shared/tcl_base/tclthread.c

/* $Header: /cvsroot/esrg/sfesrg/esrgpcpj/shared/tcl_base/tclthread.c,v 1.1.1.1 2001/06/13 04:46:27 dtashley Exp $ */

/* 
 * tclThread.c --
 *
 *      This file implements   Platform independent thread operations.
 *      Most of the real work is done in the platform dependent files.
 *
 * Copyright (c) 1998 by Sun Microsystems, Inc.
 *
 * See the file "license.terms" for information on usage and redistribution
 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 *
 * RCS: @(#) $Id: tclthread.c,v 1.1.1.1 2001/06/13 04:46:27 dtashley Exp $
 */

#include "tclInt.h"

/*
 * There are three classes of synchronization objects:
 * mutexes, thread data keys, and condition variables.
 * The following are used to record the memory used for these
 * objects so they can be finalized.
 *
 * These statics are guarded by the mutex in the caller of
 * TclRememberThreadData, e.g., TclpThreadDataKeyInit
 */

typedef struct {
    int num;            /* Number of objects remembered */
    int max;            /* Max size of the array */
    char **list;        /* List of pointers */
} SyncObjRecord;

static SyncObjRecord keyRecord;
static SyncObjRecord mutexRecord;
static SyncObjRecord condRecord;

/*
 * Prototypes of functions used only in this file
 */
 
static void             RememberSyncObject _ANSI_ARGS_((char *objPtr,
                            SyncObjRecord *recPtr));
static void             ForgetSyncObject _ANSI_ARGS_((char *objPtr,
                            SyncObjRecord *recPtr));

/* 
 * Several functions are #defined to nothing in tcl.h if TCL_THREADS is not
 * specified.  Here we undo that so the procedures are defined in the
 * stubs table.
 */
#ifndef TCL_THREADS
#undef Tcl_MutexLock
#undef Tcl_MutexUnlock
#undef Tcl_MutexFinalize
#undef Tcl_ConditionNotify
#undef Tcl_ConditionWait
#undef Tcl_ConditionFinalize
#endif


/*
 *----------------------------------------------------------------------
 *
 * Tcl_GetThreadData --
 *
 *      This procedure allocates and initializes a chunk of thread
 *      local storage.
 *
 * Results:
 *      A thread-specific pointer to the data structure.
 *
 * Side effects:
 *      Will allocate memory the first time this thread calls for
 *      this chunk of storage.
 *
 *----------------------------------------------------------------------
 */

VOID *
Tcl_GetThreadData(keyPtr, size)
    Tcl_ThreadDataKey *keyPtr;  /* Identifier for the data chunk */
    int size;                   /* Size of storage block */
{
    VOID *result;
#ifdef TCL_THREADS

    /*
     * See if this is the first thread to init this key.
     */

    if (*keyPtr == NULL) {
        TclpThreadDataKeyInit(keyPtr);
    }

    /*
     * Initialize the key for this thread.
     */

    result = TclpThreadDataKeyGet(keyPtr);
    if (result == NULL) {
        result  = (VOID *)ckalloc((size_t)size);
        memset(result, 0, (size_t)size);
        TclpThreadDataKeySet(keyPtr, result);
    }
#else
    if (*keyPtr == NULL) {
        result = (VOID *)ckalloc((size_t)size);
        memset((char *)result, 0, (size_t)size);
        *keyPtr = (Tcl_ThreadDataKey)result;
        TclRememberDataKey(keyPtr);
    }
    result = *(VOID **)keyPtr;
#endif
    return result;
}

/*
 *----------------------------------------------------------------------
 *
 * TclThreadDataKeyGet --
 *
 *      This procedure returns a pointer to a block of thread local storage.
 *
 * Results:
 *      A thread-specific pointer to the data structure, or NULL
 *      if the memory has not been assigned to this key for this thread.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

VOID *
TclThreadDataKeyGet(keyPtr)
    Tcl_ThreadDataKey *keyPtr;  /* Identifier for the data chunk,
                                 * really (pthread_key_t **) */
{
#ifdef TCL_THREADS
    return (VOID *)TclpThreadDataKeyGet(keyPtr);
#else
    char *result = *(char **)keyPtr;
    return (VOID *)result;
#endif /* TCL_THREADS */
}


/*
 *----------------------------------------------------------------------
 *
 * TclThreadDataKeySet --
 *
 *      This procedure sets a thread local storage pointer.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      The assigned value will be returned by TclpThreadDataKeyGet.
 *
 *----------------------------------------------------------------------
 */

void
TclThreadDataKeySet(keyPtr, data)
    Tcl_ThreadDataKey *keyPtr;  /* Identifier for the data chunk,
                                 * really (pthread_key_t **) */
    VOID *data;                 /* Thread local storage */
{
#ifdef TCL_THREADS
    if (*keyPtr == NULL) {
        TclpThreadDataKeyInit(keyPtr);
    }
    TclpThreadDataKeySet(keyPtr, data);
#else
    *keyPtr = (Tcl_ThreadDataKey)data;
#endif /* TCL_THREADS */
}


/*
 *----------------------------------------------------------------------
 *
 * RememberSyncObject
 *
 *      Keep a list of (mutexes/condition variable/data key)
 *      used during finalization.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Add to the appropriate list.
 *
 *----------------------------------------------------------------------
 */

static void
RememberSyncObject(objPtr, recPtr)
    char *objPtr;               /* Pointer to sync object */
    SyncObjRecord *recPtr;      /* Record of sync objects */
{
    char **newList;
    int i, j;

    /*
     * Save the pointer to the allocated object so it can be finalized.
     * Grow the list of pointers if necessary, copying only non-NULL
     * pointers to the new list.
     */

    if (recPtr->num >= recPtr->max) {
        recPtr->max += 8;
        newList = (char **)ckalloc(recPtr->max * sizeof(char *));
        for (i=0,j=0 ; i<recPtr->num ; i++) {
            if (recPtr->list[i] != NULL) {
                newList[j++] = recPtr->list[i];
            }
        }
        if (recPtr->list != NULL) {
            ckfree((char *)recPtr->list);
        }
        recPtr->list = newList;
        recPtr->num = j;
    }
    recPtr->list[recPtr->num] = objPtr;
    recPtr->num++;
}

/*
 *----------------------------------------------------------------------
 *
 * ForgetSyncObject
 *
 *      Remove a single object from the list.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Remove from the appropriate list.
 *
 *----------------------------------------------------------------------
 */

static void
ForgetSyncObject(objPtr, recPtr)
    char *objPtr;               /* Pointer to sync object */
    SyncObjRecord *recPtr;      /* Record of sync objects */
{
    int i;

    for (i=0 ; i<recPtr->num ; i++) {
        if (objPtr == recPtr->list[i]) {
            recPtr->list[i] = NULL;
            return;
        }
    }
}

/*
 *----------------------------------------------------------------------
 *
 * TclRememberMutex
 *
 *      Keep a list of mutexes used during finalization.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Add to the mutex list.
 *
 *----------------------------------------------------------------------
 */

void
TclRememberMutex(mutexPtr)
    Tcl_Mutex *mutexPtr;
{
    RememberSyncObject((char *)mutexPtr, &mutexRecord);
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_MutexFinalize
 *
 *      Finalize a single mutex and remove it from the
 *      list of remembered objects.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Remove the mutex from the list.
 *
 *----------------------------------------------------------------------
 */

void
Tcl_MutexFinalize(mutexPtr)
    Tcl_Mutex *mutexPtr;
{
#ifdef TCL_THREADS
    TclpFinalizeMutex(mutexPtr);
#endif
    ForgetSyncObject((char *)mutexPtr, &mutexRecord);
}

/*
 *----------------------------------------------------------------------
 *
 * TclRememberDataKey
 *
 *      Keep a list of thread data keys used during finalization.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Add to the key list.
 *
 *----------------------------------------------------------------------
 */

void
TclRememberDataKey(keyPtr)
    Tcl_ThreadDataKey *keyPtr;
{
    RememberSyncObject((char *)keyPtr, &keyRecord);
}

/*
 *----------------------------------------------------------------------
 *
 * TclRememberCondition
 *
 *      Keep a list of condition variables used during finalization.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Add to the condition variable list.
 *
 *----------------------------------------------------------------------
 */

void
TclRememberCondition(condPtr)
    Tcl_Condition *condPtr;
{
    RememberSyncObject((char *)condPtr, &condRecord);
}

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ConditionFinalize
 *
 *      Finalize a single condition variable and remove it from the
 *      list of remembered objects.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Remove the condition variable from the list.
 *
 *----------------------------------------------------------------------
 */

void
Tcl_ConditionFinalize(condPtr)
    Tcl_Condition *condPtr;
{
#ifdef TCL_THREADS
    TclpFinalizeCondition(condPtr);
#endif
    ForgetSyncObject((char *)condPtr, &condRecord);
}

/*
 *----------------------------------------------------------------------
 *
 * TclFinalizeThreadData --
 *
 *      This procedure cleans up the thread-local storage.  This is
 *      called once for each thread.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Frees up all thread local storage.
 *
 *----------------------------------------------------------------------
 */

void
TclFinalizeThreadData()
{
    int i;
    Tcl_ThreadDataKey *keyPtr;

    TclpMasterLock();
    for (i=0 ; i<keyRecord.num ; i++) {
        keyPtr = (Tcl_ThreadDataKey *) keyRecord.list[i];
#ifdef TCL_THREADS
        TclpFinalizeThreadData(keyPtr);
#else
        if (*keyPtr != NULL) {
            ckfree((char *)*keyPtr);
            *keyPtr = NULL;
        }
#endif
    }
#ifdef TCL_THREADS
    TclpMasterUnlock();
#endif
}

/*
 *----------------------------------------------------------------------
 *
 * TclFinalizeSynchronization --
 *
 *      This procedure cleans up all synchronization objects:
 *      mutexes, condition variables, and thread-local storage.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Frees up the memory.
 *
 *----------------------------------------------------------------------
 */

void
TclFinalizeSynchronization()
{
#ifdef TCL_THREADS
    Tcl_ThreadDataKey *keyPtr;
    Tcl_Mutex *mutexPtr;
    Tcl_Condition *condPtr;
    int i;

    TclpMasterLock();
    for (i=0 ; i<keyRecord.num ; i++) {
        keyPtr = (Tcl_ThreadDataKey *)keyRecord.list[i];
        TclpFinalizeThreadDataKey(keyPtr);
    }
    if (keyRecord.list != NULL) {
        ckfree((char *)keyRecord.list);
        keyRecord.list = NULL;
    }
    keyRecord.max = 0;
    keyRecord.num = 0;

    for (i=0 ; i<mutexRecord.num ; i++) {
        mutexPtr = (Tcl_Mutex *)mutexRecord.list[i];
        if (mutexPtr != NULL) {
            TclpFinalizeMutex(mutexPtr);
        }
    }
    if (mutexRecord.list != NULL) {
        ckfree((char *)mutexRecord.list);
        mutexRecord.list = NULL;
    }
    mutexRecord.max = 0;
    mutexRecord.num = 0;

    for (i=0 ; i<condRecord.num ; i++) {
        condPtr = (Tcl_Condition *)condRecord.list[i];
        if (condPtr != NULL) {
            TclpFinalizeCondition(condPtr);
        }
    }
    if (condRecord.list != NULL) {
        ckfree((char *)condRecord.list);
        condRecord.list = NULL;
    }
    condRecord.max = 0;
    condRecord.num = 0;

    TclpMasterUnlock();
#else
    if (keyRecord.list != NULL) {
        ckfree((char *)keyRecord.list);
        keyRecord.list = NULL;
    }
    keyRecord.max = 0;
    keyRecord.num = 0;
#endif
}


/*
 *----------------------------------------------------------------------
 *
 * Tcl_ExitThread --
 *
 *      This procedure is called to terminate the current thread.
 *      This should be used by extensions that create threads with
 *      additional interpreters in them.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      All thread exit handlers are invoked, then the thread dies.
 *
 *----------------------------------------------------------------------
 */

void
Tcl_ExitThread(status)
    int status;
{
    Tcl_FinalizeThread();
#ifdef TCL_THREADS
    TclpThreadExit(status);
#endif
}

#ifndef TCL_THREADS

/*
 *----------------------------------------------------------------------
 *
 * Tcl_ConditionWait, et al. --
 *
 *      These noop procedures are provided so the stub table does
 *      not have to be conditionalized for threads.  The real
 *      implementations of these functions live in the platform
 *      specific files.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

#undef Tcl_ConditionWait
void
Tcl_ConditionWait(condPtr, mutexPtr, timePtr)
    Tcl_Condition *condPtr;     /* Really (pthread_cond_t **) */
    Tcl_Mutex *mutexPtr;        /* Really (pthread_mutex_t **) */
    Tcl_Time *timePtr;          /* Timeout on waiting period */
{
}

#undef Tcl_ConditionNotify
void
Tcl_ConditionNotify(condPtr)
    Tcl_Condition *condPtr;
{
}

#undef Tcl_MutexLock
void
Tcl_MutexLock(mutexPtr)
    Tcl_Mutex *mutexPtr;
{
}

#undef Tcl_MutexUnlock
void
Tcl_MutexUnlock(mutexPtr)
    Tcl_Mutex *mutexPtr;
{
}
#endif


/* $History: tclthread.c $
 * 
 * *****************  Version 1  *****************
 * User: Dtashley     Date: 1/02/01    Time: 1:06a
 * Created in $/IjuScripter, IjuConsole/Source/Tcl Base
 * Initial check-in.
 */ 

/* End of TCLTHREAD.C */
1	dashley	25	/* $Header: /cvsroot/esrg/sfesrg/esrgpcpj/shared/tcl_base/tclthread.c,v 1.1.1.1 2001/06/13 04:46:27 dtashley Exp $ */
2
3			/*
4			* tclThread.c --
5			*
6			* This file implements Platform independent thread operations.
7			* Most of the real work is done in the platform dependent files.
8			*
9			* Copyright (c) 1998 by Sun Microsystems, Inc.
10			*
11			* See the file "license.terms" for information on usage and redistribution
12			* of this file, and for a DISCLAIMER OF ALL WARRANTIES.
13			*
14			* RCS: @(#) $Id: tclthread.c,v 1.1.1.1 2001/06/13 04:46:27 dtashley Exp $
15			*/
16
17			#include "tclInt.h"
18
19			/*
20			* There are three classes of synchronization objects:
21			* mutexes, thread data keys, and condition variables.
22			* The following are used to record the memory used for these
23			* objects so they can be finalized.
24			*
25			* These statics are guarded by the mutex in the caller of
26			* TclRememberThreadData, e.g., TclpThreadDataKeyInit
27			*/
28
29			typedef struct {
30			int num; /* Number of objects remembered */
31			int max; /* Max size of the array */
32			char *list; / List of pointers */
33			} SyncObjRecord;
34
35			static SyncObjRecord keyRecord;
36			static SyncObjRecord mutexRecord;
37			static SyncObjRecord condRecord;
38
39			/*
40			* Prototypes of functions used only in this file
41			*/
42
43			static void RememberSyncObject _ANSI_ARGS_((char *objPtr,
44			SyncObjRecord *recPtr));
45			static void ForgetSyncObject _ANSI_ARGS_((char *objPtr,
46			SyncObjRecord *recPtr));
47
48			/*
49			* Several functions are #defined to nothing in tcl.h if TCL_THREADS is not
50			* specified. Here we undo that so the procedures are defined in the
51			* stubs table.
52			*/
53			#ifndef TCL_THREADS
54			#undef Tcl_MutexLock
55			#undef Tcl_MutexUnlock
56			#undef Tcl_MutexFinalize
57			#undef Tcl_ConditionNotify
58			#undef Tcl_ConditionWait
59			#undef Tcl_ConditionFinalize
60			#endif
61
62
63			/*
64			*----------------------------------------------------------------------
65			*
66			* Tcl_GetThreadData --
67			*
68			* This procedure allocates and initializes a chunk of thread
69			* local storage.
70			*
71			* Results:
72			* A thread-specific pointer to the data structure.
73			*
74			* Side effects:
75			* Will allocate memory the first time this thread calls for
76			* this chunk of storage.
77			*
78			*----------------------------------------------------------------------
79			*/
80
81			VOID *
82			Tcl_GetThreadData(keyPtr, size)
83			Tcl_ThreadDataKey keyPtr; / Identifier for the data chunk */
84			int size; /* Size of storage block */
85			{
86			VOID *result;
87			#ifdef TCL_THREADS
88
89			/*
90			* See if this is the first thread to init this key.
91			*/
92
93			if (*keyPtr == NULL) {
94			TclpThreadDataKeyInit(keyPtr);
95			}
96
97			/*
98			* Initialize the key for this thread.
99			*/
100
101			result = TclpThreadDataKeyGet(keyPtr);
102			if (result == NULL) {
103			result = (VOID *)ckalloc((size_t)size);
104			memset(result, 0, (size_t)size);
105			TclpThreadDataKeySet(keyPtr, result);
106			}
107			#else
108			if (*keyPtr == NULL) {
109			result = (VOID *)ckalloc((size_t)size);
110			memset((char *)result, 0, (size_t)size);
111			*keyPtr = (Tcl_ThreadDataKey)result;
112			TclRememberDataKey(keyPtr);
113			}
114			result = (VOID *)keyPtr;
115			#endif
116			return result;
117			}
118
119			/*
120			*----------------------------------------------------------------------
121			*
122			* TclThreadDataKeyGet --
123			*
124			* This procedure returns a pointer to a block of thread local storage.
125			*
126			* Results:
127			* A thread-specific pointer to the data structure, or NULL
128			* if the memory has not been assigned to this key for this thread.
129			*
130			* Side effects:
131			* None.
132			*
133			*----------------------------------------------------------------------
134			*/
135
136			VOID *
137			TclThreadDataKeyGet(keyPtr)
138			Tcl_ThreadDataKey keyPtr; / Identifier for the data chunk,
139			* really (pthread_key_t *) /
140			{
141			#ifdef TCL_THREADS
142			return (VOID *)TclpThreadDataKeyGet(keyPtr);
143			#else
144			char result = (char **)keyPtr;
145			return (VOID *)result;
146			#endif /* TCL_THREADS */
147			}
148
149
150			/*
151			*----------------------------------------------------------------------
152			*
153			* TclThreadDataKeySet --
154			*
155			* This procedure sets a thread local storage pointer.
156			*
157			* Results:
158			* None.
159			*
160			* Side effects:
161			* The assigned value will be returned by TclpThreadDataKeyGet.
162			*
163			*----------------------------------------------------------------------
164			*/
165
166			void
167			TclThreadDataKeySet(keyPtr, data)
168			Tcl_ThreadDataKey keyPtr; / Identifier for the data chunk,
169			* really (pthread_key_t *) /
170			VOID data; / Thread local storage */
171			{
172			#ifdef TCL_THREADS
173			if (*keyPtr == NULL) {
174			TclpThreadDataKeyInit(keyPtr);
175			}
176			TclpThreadDataKeySet(keyPtr, data);
177			#else
178			*keyPtr = (Tcl_ThreadDataKey)data;
179			#endif /* TCL_THREADS */
180			}
181
182
183
184			/*
185			*----------------------------------------------------------------------
186			*
187			* RememberSyncObject
188			*
189			* Keep a list of (mutexes/condition variable/data key)
190			* used during finalization.
191			*
192			* Results:
193			* None.
194			*
195			* Side effects:
196			* Add to the appropriate list.
197			*
198			*----------------------------------------------------------------------
199			*/
200
201			static void
202			RememberSyncObject(objPtr, recPtr)
203			char objPtr; / Pointer to sync object */
204			SyncObjRecord recPtr; / Record of sync objects */
205			{
206			char **newList;
207			int i, j;
208
209			/*
210			* Save the pointer to the allocated object so it can be finalized.
211			* Grow the list of pointers if necessary, copying only non-NULL
212			* pointers to the new list.
213			*/
214
215			if (recPtr->num >= recPtr->max) {
216			recPtr->max += 8;
217			newList = (char *)ckalloc(recPtr->max sizeof(char *));
218			for (i=0,j=0 ; i<recPtr->num ; i++) {
219			if (recPtr->list[i] != NULL) {
220			newList[j++] = recPtr->list[i];
221			}
222			}
223			if (recPtr->list != NULL) {
224			ckfree((char *)recPtr->list);
225			}
226			recPtr->list = newList;
227			recPtr->num = j;
228			}
229			recPtr->list[recPtr->num] = objPtr;
230			recPtr->num++;
231			}
232
233			/*
234			*----------------------------------------------------------------------
235			*
236			* ForgetSyncObject
237			*
238			* Remove a single object from the list.
239			*
240			* Results:
241			* None.
242			*
243			* Side effects:
244			* Remove from the appropriate list.
245			*
246			*----------------------------------------------------------------------
247			*/
248
249			static void
250			ForgetSyncObject(objPtr, recPtr)
251			char objPtr; / Pointer to sync object */
252			SyncObjRecord recPtr; / Record of sync objects */
253			{
254			int i;
255
256			for (i=0 ; i<recPtr->num ; i++) {
257			if (objPtr == recPtr->list[i]) {
258			recPtr->list[i] = NULL;
259			return;
260			}
261			}
262			}
263
264			/*
265			*----------------------------------------------------------------------
266			*
267			* TclRememberMutex
268			*
269			* Keep a list of mutexes used during finalization.
270			*
271			* Results:
272			* None.
273			*
274			* Side effects:
275			* Add to the mutex list.
276			*
277			*----------------------------------------------------------------------
278			*/
279
280			void
281			TclRememberMutex(mutexPtr)
282			Tcl_Mutex *mutexPtr;
283			{
284			RememberSyncObject((char *)mutexPtr, &mutexRecord);
285			}
286
287			/*
288			*----------------------------------------------------------------------
289			*
290			* Tcl_MutexFinalize
291			*
292			* Finalize a single mutex and remove it from the
293			* list of remembered objects.
294			*
295			* Results:
296			* None.
297			*
298			* Side effects:
299			* Remove the mutex from the list.
300			*
301			*----------------------------------------------------------------------
302			*/
303
304			void
305			Tcl_MutexFinalize(mutexPtr)
306			Tcl_Mutex *mutexPtr;
307			{
308			#ifdef TCL_THREADS
309			TclpFinalizeMutex(mutexPtr);
310			#endif
311			ForgetSyncObject((char *)mutexPtr, &mutexRecord);
312			}
313
314			/*
315			*----------------------------------------------------------------------
316			*
317			* TclRememberDataKey
318			*
319			* Keep a list of thread data keys used during finalization.
320			*
321			* Results:
322			* None.
323			*
324			* Side effects:
325			* Add to the key list.
326			*
327			*----------------------------------------------------------------------
328			*/
329
330			void
331			TclRememberDataKey(keyPtr)
332			Tcl_ThreadDataKey *keyPtr;
333			{
334			RememberSyncObject((char *)keyPtr, &keyRecord);
335			}
336
337			/*
338			*----------------------------------------------------------------------
339			*
340			* TclRememberCondition
341			*
342			* Keep a list of condition variables used during finalization.
343			*
344			* Results:
345			* None.
346			*
347			* Side effects:
348			* Add to the condition variable list.
349			*
350			*----------------------------------------------------------------------
351			*/
352
353			void
354			TclRememberCondition(condPtr)
355			Tcl_Condition *condPtr;
356			{
357			RememberSyncObject((char *)condPtr, &condRecord);
358			}
359
360			/*
361			*----------------------------------------------------------------------
362			*
363			* Tcl_ConditionFinalize
364			*
365			* Finalize a single condition variable and remove it from the
366			* list of remembered objects.
367			*
368			* Results:
369			* None.
370			*
371			* Side effects:
372			* Remove the condition variable from the list.
373			*
374			*----------------------------------------------------------------------
375			*/
376
377			void
378			Tcl_ConditionFinalize(condPtr)
379			Tcl_Condition *condPtr;
380			{
381			#ifdef TCL_THREADS
382			TclpFinalizeCondition(condPtr);
383			#endif
384			ForgetSyncObject((char *)condPtr, &condRecord);
385			}
386
387			/*
388			*----------------------------------------------------------------------
389			*
390			* TclFinalizeThreadData --
391			*
392			* This procedure cleans up the thread-local storage. This is
393			* called once for each thread.
394			*
395			* Results:
396			* None.
397			*
398			* Side effects:
399			* Frees up all thread local storage.
400			*
401			*----------------------------------------------------------------------
402			*/
403
404			void
405			TclFinalizeThreadData()
406			{
407			int i;
408			Tcl_ThreadDataKey *keyPtr;
409
410			TclpMasterLock();
411			for (i=0 ; i<keyRecord.num ; i++) {
412			keyPtr = (Tcl_ThreadDataKey *) keyRecord.list[i];
413			#ifdef TCL_THREADS
414			TclpFinalizeThreadData(keyPtr);
415			#else
416			if (*keyPtr != NULL) {
417			ckfree((char )keyPtr);
418			*keyPtr = NULL;
419			}
420			#endif
421			}
422			#ifdef TCL_THREADS
423			TclpMasterUnlock();
424			#endif
425			}
426
427			/*
428			*----------------------------------------------------------------------
429			*
430			* TclFinalizeSynchronization --
431			*
432			* This procedure cleans up all synchronization objects:
433			* mutexes, condition variables, and thread-local storage.
434			*
435			* Results:
436			* None.
437			*
438			* Side effects:
439			* Frees up the memory.
440			*
441			*----------------------------------------------------------------------
442			*/
443
444			void
445			TclFinalizeSynchronization()
446			{
447			#ifdef TCL_THREADS
448			Tcl_ThreadDataKey *keyPtr;
449			Tcl_Mutex *mutexPtr;
450			Tcl_Condition *condPtr;
451			int i;
452
453			TclpMasterLock();
454			for (i=0 ; i<keyRecord.num ; i++) {
455			keyPtr = (Tcl_ThreadDataKey *)keyRecord.list[i];
456			TclpFinalizeThreadDataKey(keyPtr);
457			}
458			if (keyRecord.list != NULL) {
459			ckfree((char *)keyRecord.list);
460			keyRecord.list = NULL;
461			}
462			keyRecord.max = 0;
463			keyRecord.num = 0;
464
465			for (i=0 ; i<mutexRecord.num ; i++) {
466			mutexPtr = (Tcl_Mutex *)mutexRecord.list[i];
467			if (mutexPtr != NULL) {
468			TclpFinalizeMutex(mutexPtr);
469			}
470			}
471			if (mutexRecord.list != NULL) {
472			ckfree((char *)mutexRecord.list);
473			mutexRecord.list = NULL;
474			}
475			mutexRecord.max = 0;
476			mutexRecord.num = 0;
477
478			for (i=0 ; i<condRecord.num ; i++) {
479			condPtr = (Tcl_Condition *)condRecord.list[i];
480			if (condPtr != NULL) {
481			TclpFinalizeCondition(condPtr);
482			}
483			}
484			if (condRecord.list != NULL) {
485			ckfree((char *)condRecord.list);
486			condRecord.list = NULL;
487			}
488			condRecord.max = 0;
489			condRecord.num = 0;
490
491			TclpMasterUnlock();
492			#else
493			if (keyRecord.list != NULL) {
494			ckfree((char *)keyRecord.list);
495			keyRecord.list = NULL;
496			}
497			keyRecord.max = 0;
498			keyRecord.num = 0;
499			#endif
500			}
501
502
503			/*
504			*----------------------------------------------------------------------
505			*
506			* Tcl_ExitThread --
507			*
508			* This procedure is called to terminate the current thread.
509			* This should be used by extensions that create threads with
510			* additional interpreters in them.
511			*
512			* Results:
513			* None.
514			*
515			* Side effects:
516			* All thread exit handlers are invoked, then the thread dies.
517			*
518			*----------------------------------------------------------------------
519			*/
520
521			void
522			Tcl_ExitThread(status)
523			int status;
524			{
525			Tcl_FinalizeThread();
526			#ifdef TCL_THREADS
527			TclpThreadExit(status);
528			#endif
529			}
530
531			#ifndef TCL_THREADS
532
533			/*
534			*----------------------------------------------------------------------
535			*
536			* Tcl_ConditionWait, et al. --
537			*
538			* These noop procedures are provided so the stub table does
539			* not have to be conditionalized for threads. The real
540			* implementations of these functions live in the platform
541			* specific files.
542			*
543			* Results:
544			* None.
545			*
546			* Side effects:
547			* None.
548			*
549			*----------------------------------------------------------------------
550			*/
551
552			#undef Tcl_ConditionWait
553			void
554			Tcl_ConditionWait(condPtr, mutexPtr, timePtr)
555			Tcl_Condition condPtr; / Really (pthread_cond_t *) /
556			Tcl_Mutex mutexPtr; / Really (pthread_mutex_t *) /
557			Tcl_Time timePtr; / Timeout on waiting period */
558			{
559			}
560
561			#undef Tcl_ConditionNotify
562			void
563			Tcl_ConditionNotify(condPtr)
564			Tcl_Condition *condPtr;
565			{
566			}
567
568			#undef Tcl_MutexLock
569			void
570			Tcl_MutexLock(mutexPtr)
571			Tcl_Mutex *mutexPtr;
572			{
573			}
574
575			#undef Tcl_MutexUnlock
576			void
577			Tcl_MutexUnlock(mutexPtr)
578			Tcl_Mutex *mutexPtr;
579			{
580			}
581			#endif
582
583
584			/* $History: tclthread.c $
585			*
586			* *************** Version 1 ***************
587			* User: Dtashley Date: 1/02/01 Time: 1:06a
588			* Created in $/IjuScripter, IjuConsole/Source/Tcl Base
589			* Initial check-in.
590			*/
591
592			/* End of TCLTHREAD.C */