summaryrefslogtreecommitdiffstats
path: root/generic/tclThreadStorage.c
diff options
context:
space:
mode:
Diffstat (limited to 'generic/tclThreadStorage.c')
-rw-r--r--generic/tclThreadStorage.c860
1 files changed, 183 insertions, 677 deletions
diff --git a/generic/tclThreadStorage.c b/generic/tclThreadStorage.c
index cd49457..10093e4 100644
--- a/generic/tclThreadStorage.c
+++ b/generic/tclThreadStorage.c
@@ -8,12 +8,12 @@
* See the file "license.terms" for information on usage and redistribution of
* this file, and for a DISCLAIMER OF ALL WARRANTIES.
*
- * RCS: @(#) $Id: tclThreadStorage.c,v 1.6 2005/08/05 23:56:29 dkf Exp $
+ * RCS: @(#) $Id: tclThreadStorage.c,v 1.7 2005/08/11 22:06:47 kennykb Exp $
*/
#include "tclInt.h"
-#if defined(TCL_THREADS) && defined(USE_THREAD_STORAGE)
+#if defined(TCL_THREADS)
/*
* This is the thread storage cache array and it's accompanying mutex. The
@@ -43,13 +43,7 @@ typedef struct ThreadStorage {
static Tcl_HashEntry * AllocThreadStorageEntry(Tcl_HashTable *tablePtr,
void *keyPtr);
static void FreeThreadStorageEntry(Tcl_HashEntry *hPtr);
-static void ThreadStorageLockInit(void);
-static void ThreadStorageLock(void);
-static void ThreadStorageUnlock(void);
static Tcl_HashTable * ThreadStorageGetHashTable(Tcl_ThreadId id);
-static Tcl_HashTable * ThreadStorageInit(Tcl_ThreadId id, void *reserved);
-static void FinalizeThreadStorageThreadMushroomMushroom(
- Tcl_ThreadId id);
/*
* This is the hash key type for thread storage. We MUST use this in
@@ -59,7 +53,8 @@ static void FinalizeThreadStorageThreadMushroomMushroom(
Tcl_HashKeyType tclThreadStorageHashKeyType = {
TCL_HASH_KEY_TYPE_VERSION, /* version */
- TCL_HASH_KEY_SYSTEM_HASH, /* flags */
+ TCL_HASH_KEY_SYSTEM_HASH | TCL_HASH_KEY_RANDOMIZE_HASH,
+ /* flags */
NULL, /* hashKeyProc */
NULL, /* compareKeysProc */
AllocThreadStorageEntry, /* allocEntryProc */
@@ -83,7 +78,7 @@ Tcl_HashKeyType tclThreadStorageHashKeyType = {
* below this are RESERVED for future use.
*/
-#define STORAGE_FIRST_KEY 101
+#define STORAGE_FIRST_KEY 1
/*
* This is the default number of thread storage cache slots. This define may
@@ -98,22 +93,16 @@ Tcl_HashKeyType tclThreadStorageHashKeyType = {
* hash tables contain the actual thread storage.
*/
-static Tcl_HashTable *threadStorageHashTablePtr = NULL;
+static Tcl_HashTable threadStorageHashTable;
/*
* This is the next thread data key value to use. We increment this everytime
- * we "allocate" one. It is initially set to 1 in ThreadStorageInit.
+ * we "allocate" one. It is initially set to 1 in TclInitThreadStorage.
*/
static int nextThreadStorageKey = STORAGE_INVALID_KEY;
/*
- * Have we initialized the thread storage mutex yet?
- */
-
-static int initThreadStorage = 0;
-
-/*
* This is the master thread storage cache. Per Kevin Kenny's idea, this
* prevents unnecessary lookups for threads that use a lot of thread storage.
*/
@@ -123,88 +112,6 @@ static volatile ThreadStorage threadStorageCache[STORAGE_CACHE_SLOTS];
/*
*----------------------------------------------------------------------
*
- * ThreadStorageLockInit
- *
- * This procedure is used to initialize the lock that serializes creation
- * of thread storage.
- *
- * Results:
- * None.
- *
- * Side effects:
- * The master lock is acquired and possibly initialized for the first
- * time.
- *
- *----------------------------------------------------------------------
- */
-
-static void
-ThreadStorageLockInit()
-{
- if (!initThreadStorage) {
- /*
- * Mutexes in Tcl are self initializing, and we are taking advantage
- * of that fact since this file cannot contain platform specific
- * calls.
- */
-
- initThreadStorage = 1;
- }
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * ThreadStorageLock
- *
- * This procedure is used to grab a lock that serializes creation of
- * thread storage.
- *
- * This lock must be different than the initLock because the initLock is
- * held during creation of syncronization objects.
- *
- * Results:
- * None.
- *
- * Side effects:
- * Acquire the thread storage mutex.
- *
- *----------------------------------------------------------------------
- */
-
-static void
-ThreadStorageLock()
-{
- ThreadStorageLockInit();
- Tcl_MutexLock(&threadStorageLock);
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * ThreadStorageUnlock
- *
- * This procedure is used to release a lock that serializes creation of
- * thread storage.
- *
- * Results:
- * None.
- *
- * Side effects:
- * Release the thread storage mutex.
- *
- *----------------------------------------------------------------------
- */
-
-static void
-ThreadStorageUnlock()
-{
- Tcl_MutexUnlock(&threadStorageLock);
-}
-
-/*
- *----------------------------------------------------------------------
- *
* AllocThreadStorageEntry --
*
* Allocate space for a Tcl_HashEntry using TclpSysAlloc (not ckalloc).
@@ -258,109 +165,6 @@ FreeThreadStorageEntry(hPtr)
TclpSysFree((char *)hPtr);
}
-#ifdef TCL_THREAD_STORAGE_DEBUG
-/*
- *----------------------------------------------------------------------
- *
- * ThreadStoragePrint --
- *
- * This procedure prints out the contents of the master thread storage
- * hash table, the thread storage cache, and the next key value to the
- * specified file.
- *
- * This assumes that thread storage lock is held.
- *
- * Results:
- * None.
- *
- * Side effects:
- * The thread storage lock is acquired and released.
- *
- *----------------------------------------------------------------------
- */
-
-static void
-ThreadStoragePrint(outFile, flags)
- FILE *outFile; /* The file to print the information to. */
- int flags; /* Reserved for future use. */
-{
- Tcl_HashEntry *hPtr;
- Tcl_HashSearch search;
- int header, index;
-
- if (threadStorageHashTablePtr != NULL) {
- hPtr = Tcl_FirstHashEntry(threadStorageHashTablePtr, &search);
-
- if (hPtr != NULL) {
- fprintf(outFile, "master thread storage hash table:\n");
- for (; hPtr != NULL; hPtr = Tcl_NextHashEntry(&search)) {
- fprintf(outFile,
- "master entry ptr %p, thread %p, thread table ptr %p\n",
- hPtr, Tcl_GetHashKey(threadStorageHashTablePtr, hPtr),
- Tcl_GetHashValue(hPtr));
- }
- } else {
- fprintf(outFile,
- "master thread storage hash table has no entries\n");
- }
- } else {
- fprintf(outFile,
- "master thread storage hash table not initialized\n");
- }
-
- header = 0; /* we have not output the header yet. */
- for (index=0 ; index<STORAGE_CACHE_SLOTS ; index++) {
- if (threadStorageCache[index].id != STORAGE_INVALID_THREAD) {
- if (!header) {
- fprintf(outFile, "thread storage cache (%d total slots):\n",
- STORAGE_CACHE_SLOTS);
- header = 1;
- }
-
- fprintf(outFile, "slot %d, thread %p, thread table ptr %p\n",
- index, threadStorageCache[index].id,
- threadStorageCache[index].hashTablePtr);
-
-#ifdef VERBOSE_THREAD_STORAGE_DEBUGGING
- /*
- * Currently not enabled by default due to Tcl_HashStats use of
- * ckalloc and ckfree. Please note that this can produce a LOT of
- * output.
- */
-
- if (threadStorageCache[index].hashTablePtr != NULL) {
- CONST char *stats =
- Tcl_HashStats(threadStorageCache[index].hashTablePtr);
- if (stats != NULL) {
- fprintf(outFile, "%s\n", stats);
- ckfree((void *)stats);
- } else {
- fprintf(outFile,
- "could not get table statistics for slot %d\n",
- index);
- }
- }
-#endif
-
- } else {
- /* fprintf(outFile, "cache slot %d not used\n", index); */
- }
- }
-
- if (!header) {
- fprintf(outFile, "thread storage cache is empty (%d total slots)\n",
- STORAGE_CACHE_SLOTS);
- header = 1;
- }
-
- /*
- * Show the next data key value.
- */
-
- fprintf(outFile, "next data key value is: %d\n", nextThreadStorageKey);
-}
-#endif /* TCL_THREAD_STORAGE_DEBUG */
-
/*
*----------------------------------------------------------------------
*
@@ -399,217 +203,120 @@ ThreadStorageGetHashTable(id)
Tcl_HashTable *hashTablePtr = threadStorageCache[index].hashTablePtr;
if (threadStorageCache[index].id != id) {
- ThreadStorageLock();
+ Tcl_MutexLock(&threadStorageLock);
/*
- * Make sure the master hash table is initialized.
+ * It's not in the cache, so we look it up...
*/
-
- ThreadStorageInit(STORAGE_INVALID_THREAD, NULL);
-
- if (threadStorageHashTablePtr != NULL) {
- /*
- * It's not in the cache, so we look it up...
- */
-
- hPtr = Tcl_FindHashEntry(threadStorageHashTablePtr, (char *)id);
-
- if (hPtr != NULL) {
- /*
- * We found it, extract the hash table pointer.
- */
-
- hashTablePtr = Tcl_GetHashValue(hPtr);
- } else {
- /*
- * The thread specific hash table is not found.
- */
-
- hashTablePtr = NULL;
- }
-
- if (hashTablePtr == NULL) {
- hashTablePtr = (Tcl_HashTable *)
- TclpSysAlloc(sizeof(Tcl_HashTable), 0);
-
- if (hashTablePtr == NULL) {
- Tcl_Panic("could not allocate thread specific hash "
- "table, TclpSysAlloc failed from "
- "ThreadStorageGetHashTable!");
- }
- Tcl_InitCustomHashTable(hashTablePtr, TCL_CUSTOM_TYPE_KEYS,
- &tclThreadStorageHashKeyType);
-
- /*
- * Add new thread storage hash table to the master hash table.
- */
-
- hPtr = Tcl_CreateHashEntry(threadStorageHashTablePtr,
- (char *)id, &new);
-
- if (hPtr == NULL) {
- Tcl_Panic("Tcl_CreateHashEntry failed from "
- "ThreadStorageInit!");
- }
- Tcl_SetHashValue(hPtr, hashTablePtr);
- }
-
+
+ hPtr = Tcl_FindHashEntry(&threadStorageHashTable, (char *)id);
+
+ if (hPtr != NULL) {
/*
- * Now, we put it in the cache since it is highly likely it will
- * be needed again shortly.
+ * We found it, extract the hash table pointer.
*/
-
- threadStorageCache[index].id = id;
- threadStorageCache[index].hashTablePtr = hashTablePtr;
+
+ hashTablePtr = Tcl_GetHashValue(hPtr);
} else {
/*
- * We cannot look it up, the master hash table has not been
- * initialized.
+ * The thread specific hash table is not found.
*/
-
+
hashTablePtr = NULL;
}
- ThreadStorageUnlock();
- }
-
- return hashTablePtr;
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * ThreadStorageInit --
- *
- * This procedure initializes a thread specific hash table for the
- * current thread. It may also initialize the master hash table which
- * stores all the thread specific hash tables.
- *
- * This assumes that thread storage lock is held.
- *
- * Results:
- * A hash table pointer for the specified thread, or NULL if we are be
- * called to initialize the master hash table only.
- *
- * Side effects:
- * The thread specific hash table may be initialized and added to the
- * master hash table.
- *
- *----------------------------------------------------------------------
- */
-
-static Tcl_HashTable *
-ThreadStorageInit(id, reserved)
- Tcl_ThreadId id; /* Id of thread to get hash table for */
- void *reserved; /* reserved for future use */
-{
-#ifdef TCL_THREAD_STORAGE_DEBUG
- ThreadStoragePrint(stderr, 0);
-#endif
-
- if (threadStorageHashTablePtr == NULL) {
- /*
- * Looks like we haven't created the outer hash table yet we can just
- * do that now.
- */
- threadStorageHashTablePtr = (Tcl_HashTable *)
+ if (hashTablePtr == NULL) {
+ hashTablePtr = (Tcl_HashTable *)
TclpSysAlloc(sizeof(Tcl_HashTable), 0);
- if (threadStorageHashTablePtr == NULL) {
- Tcl_Panic("could not allocate master thread storage hash table, "
- "TclpSysAlloc failed from ThreadStorageInit!");
+
+ if (hashTablePtr == NULL) {
+ Tcl_Panic("could not allocate thread specific hash "
+ "table, TclpSysAlloc failed from "
+ "ThreadStorageGetHashTable!");
+ }
+ Tcl_InitCustomHashTable(hashTablePtr, TCL_CUSTOM_TYPE_KEYS,
+ &tclThreadStorageHashKeyType);
+
+ /*
+ * Add new thread storage hash table to the master hash table.
+ */
+
+ hPtr = Tcl_CreateHashEntry(&threadStorageHashTable,
+ (char *)id, &new);
+
+ if (hPtr == NULL) {
+ Tcl_Panic("Tcl_CreateHashEntry failed from "
+ "ThreadStorageGetHashTable!");
+ }
+ Tcl_SetHashValue(hPtr, hashTablePtr);
}
- Tcl_InitCustomHashTable(threadStorageHashTablePtr,
- TCL_CUSTOM_TYPE_KEYS, &tclThreadStorageHashKeyType);
-
- /*
- * We also initialize the cache.
- */
-
- memset((ThreadStorage *)&threadStorageCache, 0,
- sizeof(ThreadStorage) * STORAGE_CACHE_SLOTS);
/*
- * Now, we set the first value to be used for a thread data key.
+ * Now, we put it in the cache since it is highly likely it will
+ * be needed again shortly.
*/
+
+ threadStorageCache[index].id = id;
+ threadStorageCache[index].hashTablePtr = hashTablePtr;
- nextThreadStorageKey = STORAGE_FIRST_KEY;
+ Tcl_MutexUnlock(&threadStorageLock);
}
- return NULL;
+ return hashTablePtr;
}
/*
*----------------------------------------------------------------------
*
- * TclThreadStorageDataKeyInit --
+ * TclInitThreadStorage --
*
- * This procedure initializes a thread specific data block key. Each
- * thread has table of pointers to thread specific data. all threads
- * agree on which table entry is used by each module. this is remembered
- * in a "data key", that is just an index into this table. To allow self
- * initialization, the interface passes a pointer to this key and the
- * first thread to use the key fills in the pointer to the key. The key
- * should be a process-wide static.
+ * Initializes the thread storage allocator.
*
* Results:
* None.
*
* Side effects:
- * Will allocate memory the first time this process calls for this key.
- * In this case it modifies its argument to hold the pointer to
- * information about the key.
+ * This procedure initializes the master hash table that maps
+ * thread ID onto the individual index tables that map thread data
+ * key to thread data. It also creates a cache that enables
+ * fast lookup of the thread data block array for a recently
+ * executing thread without using spinlocks.
+ *
+ * This procedure is called from an extremely early point in Tcl's
+ * initialization. In particular, it may not use ckalloc/ckfree
+ * because they may depend on thread-local storage (it uses TclpSysAlloc
+ * and TclpSysFree instead). It may not depend on synchronization
+ * primitives - but no threads other than the master thread have yet
+ * been launched.
*
*----------------------------------------------------------------------
*/
void
-TclThreadStorageDataKeyInit(keyPtr)
- Tcl_ThreadDataKey *keyPtr; /* Identifier for the data chunk, really
- * (int**) */
+TclInitThreadStorage()
{
- int *indexPtr;
- int newKey;
-
- if (*keyPtr == NULL) {
- indexPtr = (int *)TclpSysAlloc(sizeof(int), 0);
- if (indexPtr == NULL) {
- Tcl_Panic("TclpSysAlloc failed from TclThreadStorageDataKeyInit!");
- }
-
- /*
- * We must call this now to make sure that nextThreadStorageKey has a
- * well defined value.
- */
-
- ThreadStorageLock();
-
- /*
- * Make sure the master hash table is initialized.
- */
-
- ThreadStorageInit(STORAGE_INVALID_THREAD, NULL);
- /*
- * These data key values are sequentially assigned and we must use the
- * storage lock to prevent serious problems here. Also note that the
- * caller should NOT make any assumptions about the provided
- * values. In particular, we may need to reserve some values in the
- * future.
- */
-
- newKey = nextThreadStorageKey++;
- ThreadStorageUnlock();
-
- *indexPtr = newKey;
- *keyPtr = (Tcl_ThreadDataKey)indexPtr;
- TclRememberDataKey(keyPtr);
- }
+ Tcl_InitCustomHashTable(&threadStorageHashTable,
+ TCL_CUSTOM_TYPE_KEYS, &tclThreadStorageHashKeyType);
+
+ /*
+ * We also initialize the cache.
+ */
+
+ memset((ThreadStorage *)&threadStorageCache, 0,
+ sizeof(ThreadStorage) * STORAGE_CACHE_SLOTS);
+
+ /*
+ * Now, we set the first value to be used for a thread data key.
+ */
+
+ nextThreadStorageKey = STORAGE_FIRST_KEY;
}
/*
*----------------------------------------------------------------------
*
- * TclThreadStorageDataKeyGet --
+ * TclpThreadDataKeyGet --
*
* This procedure returns a pointer to a block of thread local storage.
*
@@ -624,37 +331,24 @@ TclThreadStorageDataKeyInit(keyPtr)
*/
void *
-TclThreadStorageDataKeyGet(keyPtr)
+TclpThreadDataKeyGet(keyPtr)
Tcl_ThreadDataKey *keyPtr; /* Identifier for the data chunk, really
* (int**) */
{
- int *indexPtr = *(int **)keyPtr;
-
- if (indexPtr == NULL) {
+ Tcl_HashTable *hashTablePtr =
+ ThreadStorageGetHashTable(Tcl_GetCurrentThread());
+ Tcl_HashEntry *hPtr =
+ Tcl_FindHashEntry(hashTablePtr, (char *) keyPtr);
+ if (hPtr == NULL) {
return NULL;
- } else {
- Tcl_HashTable *hashTablePtr =
- ThreadStorageGetHashTable(Tcl_GetCurrentThread());
- Tcl_HashEntry *hPtr;
-
- if (hashTablePtr == NULL) {
- Tcl_Panic("ThreadStorageGetHashTable failed from "
- "ThreadStorageDataKeyGet!");
- }
-
- hPtr = Tcl_FindHashEntry(hashTablePtr, (char *) *indexPtr);
-
- if (hPtr == NULL) {
- return NULL;
- }
- return (void *) Tcl_GetHashValue(hPtr);
}
+ return (void *) Tcl_GetHashValue(hPtr);
}
/*
*----------------------------------------------------------------------
*
- * TclThreadStorageDataKeySet --
+ * TclpThreadDataKeySet --
*
* This procedure sets the pointer to a block of thread local storage.
*
@@ -662,29 +356,23 @@ TclThreadStorageDataKeyGet(keyPtr)
* None.
*
* Side effects:
- * Sets up the thread so future calls to TclThreadStorageDataKeyGet with
+ * Sets up the thread so future calls to TclpThreadDataKeyGet with
* this key will return the data pointer.
*
*----------------------------------------------------------------------
*/
void
-TclThreadStorageDataKeySet(keyPtr, data)
+TclpThreadDataKeySet(keyPtr, data)
Tcl_ThreadDataKey *keyPtr; /* Identifier for the data chunk, really
* (pthread_key_t **) */
void *data; /* Thread local storage */
{
- int *indexPtr = *(int **)keyPtr;
Tcl_HashTable *hashTablePtr;
Tcl_HashEntry *hPtr;
hashTablePtr = ThreadStorageGetHashTable(Tcl_GetCurrentThread());
- if (hashTablePtr == NULL) {
- Tcl_Panic("ThreadStorageGetHashTable failed from "
- "TclThreadStorageDataKeySet!");
- }
-
- hPtr = Tcl_FindHashEntry(hashTablePtr, (char *)*indexPtr);
+ hPtr = Tcl_FindHashEntry(hashTablePtr, (char *)keyPtr);
/*
* Does the item need to be created?
@@ -692,12 +380,7 @@ TclThreadStorageDataKeySet(keyPtr, data)
if (hPtr == NULL) {
int new;
-
- hPtr = Tcl_CreateHashEntry(hashTablePtr, (char *)*indexPtr, &new);
- if (hPtr == NULL) {
- Tcl_Panic("could not create hash entry value from "
- "TclThreadStorageDataKeySet");
- }
+ hPtr = Tcl_CreateHashEntry(hashTablePtr, (char *)keyPtr, &new);
}
Tcl_SetHashValue(hPtr, data);
@@ -706,73 +389,94 @@ TclThreadStorageDataKeySet(keyPtr, data)
/*
*----------------------------------------------------------------------
*
- * FinalizeThreadStorageThreadMushroomMushroom --
+ * TclpFinalizeThreadDataThread --
*
* This procedure cleans up the thread storage hash table for the
- * specified thread.
+ * current thread.
*
* Results:
* None.
*
* Side effects:
- * None.
+ * Frees all associated thread storage, all hash table entries for
+ * the thread's thread storage, and the hash table itself.
*
*----------------------------------------------------------------------
*/
-static void
-FinalizeThreadStorageThreadMushroomMushroom(id)
- Tcl_ThreadId id; /* Id of the thread to finalize. */
+void
+TclpFinalizeThreadDataThread()
{
+ Tcl_ThreadId id = Tcl_GetCurrentThread();
+ /* Id of the thread to finalize. */
int index = (unsigned int)id % STORAGE_CACHE_SLOTS;
- Tcl_HashTable *hashTablePtr;/* Hash table for current thread. */
Tcl_HashEntry *hPtr; /* Hash entry for current thread in master
* table. */
+ Tcl_HashTable* hashTablePtr;
+ /* Pointer to the hash table holding
+ * TSD blocks for the current thread*/
+ Tcl_HashSearch search; /* Search object to walk the TSD blocks
+ * in the designated thread */
+ Tcl_HashEntry *hPtr2; /* Hash entry for a TSD block in the
+ * designated thread. */
- ThreadStorageLock();
-
- if (threadStorageHashTablePtr != NULL) {
- hPtr = Tcl_FindHashEntry(threadStorageHashTablePtr, (char *)id);
-
- if (hPtr != NULL) {
- /*
- * We found it, extract the hash table pointer.
- */
-
- hashTablePtr = Tcl_GetHashValue(hPtr);
-
- if (hashTablePtr != NULL) {
- /*
- * Delete thread specific hash table and free the struct.
- */
-
- Tcl_DeleteHashTable(hashTablePtr);
- TclpSysFree((char *)hashTablePtr);
- }
+ Tcl_MutexLock(&threadStorageLock);
+ hPtr = Tcl_FindHashEntry(&threadStorageHashTable, (char*)id);
+ if (hPtr == NULL) {
+ hashTablePtr = NULL;
+ } else {
+ /*
+ * We found it, extract the hash table pointer.
+ */
+
+ hashTablePtr = Tcl_GetHashValue(hPtr);
+ Tcl_DeleteHashEntry(hPtr);
+ /*
+ * Make sure cache entry for this thread is NULL.
+ */
+
+ if (threadStorageCache[index].id == id) {
/*
- * Delete thread specific entry from master hash table.
+ * We do not step on another thread's cache entry. This is
+ * especially important if we are creating and exiting a lot
+ * of threads.
*/
-
- Tcl_DeleteHashEntry(hPtr);
+ threadStorageCache[index].id = STORAGE_INVALID_THREAD;
+ threadStorageCache[index].hashTablePtr = NULL;
}
}
+ Tcl_MutexUnlock(&threadStorageLock);
- /*
- * Make sure cache entry for this thread is NULL.
+ /*
+ * The thread's hash table has been extracted and removed from the master
+ * hash table. Now clean up the thread.
*/
- if (threadStorageCache[index].id == id) {
+ if (hashTablePtr != NULL) {
+
+ /* Free all TSD */
+
+ for (hPtr2 = Tcl_FirstHashEntry(hashTablePtr, &search);
+ hPtr2 != NULL;
+ hPtr2 = Tcl_NextHashEntry(&search)) {
+ void* blockPtr = Tcl_GetHashValue(hPtr2);
+ if (blockPtr != NULL) {
+ /*
+ * The block itself was allocated in Tcl_GetThreadData
+ * using ckalloc; use ckfree to dispose of it.
+ */
+ ckfree(blockPtr);
+ }
+ }
+
/*
- * We do not step on another thread's cache entry. This is especially
- * important if we are creating and exiting a lot of threads.
+ * Delete thread specific hash table and free the struct.
*/
-
- threadStorageCache[index].id = STORAGE_INVALID_THREAD;
- threadStorageCache[index].hashTablePtr = NULL;
+
+ Tcl_DeleteHashTable(hashTablePtr);
+ TclpSysFree((char *)hashTablePtr);
}
-
- ThreadStorageUnlock();
}
/*
@@ -796,51 +500,41 @@ FinalizeThreadStorageThreadMushroomMushroom(id)
void
TclFinalizeThreadStorage()
{
- ThreadStorageLock();
-
- if (threadStorageHashTablePtr != NULL) {
- Tcl_HashSearch search; /* We need to hit every thread with
+ Tcl_HashSearch search; /* We need to hit every thread with
* this search. */
- Tcl_HashEntry *hPtr; /* Hash entry for current thread in
+ Tcl_HashEntry *hPtr; /* Hash entry for current thread in
* master table. */
+ Tcl_MutexLock(&threadStorageLock);
- /*
- * We are going to delete the hash table for every thread now. This
- * hash table should be empty at this point, except for one entry for
- * the current thread.
- */
-
- for (hPtr = Tcl_FirstHashEntry(threadStorageHashTablePtr, &search);
- hPtr != NULL; hPtr = Tcl_NextHashEntry(&search)) {
- Tcl_HashTable *hashTablePtr = Tcl_GetHashValue(hPtr);
-
- if (hashTablePtr != NULL) {
- /*
- * Delete thread specific hash table for the thread in
- * question and free the struct.
- */
-
- Tcl_DeleteHashTable(hashTablePtr);
- TclpSysFree((char *)hashTablePtr);
- }
-
+ /*
+ * We are going to delete the hash table for every thread now. This
+ * hash table should be empty at this point, except for one entry for
+ * the current thread.
+ */
+
+ for (hPtr = Tcl_FirstHashEntry(&threadStorageHashTable, &search);
+ hPtr != NULL; hPtr = Tcl_NextHashEntry(&search)) {
+ Tcl_HashTable *hashTablePtr = Tcl_GetHashValue(hPtr);
+
+ if (hashTablePtr != NULL) {
/*
- * Delete thread specific entry from master hash table.
+ * Delete thread specific hash table for the thread in
+ * question and free the struct.
*/
-
- Tcl_SetHashValue(hPtr, NULL);
+
+ Tcl_DeleteHashTable(hashTablePtr);
+ TclpSysFree((char *)hashTablePtr);
}
-
- Tcl_DeleteHashTable(threadStorageHashTablePtr);
- TclpSysFree((char *)threadStorageHashTablePtr);
-
+
/*
- * Reset this so that next time around we know it's not valid.
+ * Delete thread specific entry from master hash table.
*/
-
- threadStorageHashTablePtr = NULL;
+
+ Tcl_SetHashValue(hPtr, NULL);
}
-
+
+ Tcl_DeleteHashTable(&threadStorageHashTable);
+
/*
* Clear out the thread storage cache as well.
*/
@@ -855,216 +549,28 @@ TclFinalizeThreadStorage()
nextThreadStorageKey = STORAGE_INVALID_KEY;
- ThreadStorageUnlock();
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * TclFinalizeThreadStorageData --
- *
- * This procedure cleans up the thread-local storage. This is called
- * once for each thread.
- *
- * Results:
- * None.
- *
- * Side effects:
- * Frees up the memory.
- *
- *----------------------------------------------------------------------
- */
-
-void
-TclFinalizeThreadStorageData(keyPtr)
- Tcl_ThreadDataKey *keyPtr;
-{
- if (*keyPtr != NULL) {
- Tcl_ThreadId id = Tcl_GetCurrentThread();
- Tcl_HashTable *hashTablePtr; /* Hash table for current thread. */
- Tcl_HashEntry *hPtr; /* Hash entry for data key in current
- * thread. */
- int *indexPtr = *(int **)keyPtr;
-
- hashTablePtr = ThreadStorageGetHashTable(id);
- if (hashTablePtr == NULL) {
- Tcl_Panic("ThreadStorageGetHashTable failed from "
- "TclFinalizeThreadStorageData!");
- }
-
- hPtr = Tcl_FindHashEntry(hashTablePtr, (char *)*indexPtr);
- if (hPtr != NULL) {
- void *result = Tcl_GetHashValue(hPtr);
-
- if (result != NULL) {
- /*
- * This must be ckfree because tclThread.c allocates these
- * using ckalloc.
- */
-
- ckfree((char *)result);
- }
-
- Tcl_SetHashValue(hPtr, NULL);
- }
- }
-}
-
-/*
- *----------------------------------------------------------------------
- *
- * TclFinalizeThreadStorageDataKey --
- *
- * This procedure is invoked to clean up one key. This is a process-wide
- * storage identifier. The thread finalization code cleans up the thread
- * local storage itself.
- *
- * This assumes the master lock is held.
- *
- * Results:
- * None.
- *
- * Side effects:
- * The key is deallocated.
- *
- *----------------------------------------------------------------------
- */
-
-void
-TclFinalizeThreadStorageDataKey(keyPtr)
- Tcl_ThreadDataKey *keyPtr;
-{
- int *indexPtr;
- Tcl_HashTable *hashTablePtr;/* Hash table for current thread. */
- Tcl_HashSearch search; /* Need to hit every thread with this search */
- Tcl_HashEntry *hPtr; /* Hash entry for current thread in master
- * table. */
- Tcl_HashEntry *hDataPtr; /* Hash entry for data key in current thread */
-
- if (*keyPtr != NULL) {
- indexPtr = *(int **)keyPtr;
-
- ThreadStorageLock();
-
- if (threadStorageHashTablePtr != NULL) {
- /*
- * We are going to delete the specified data key entry from every
- * thread.
- */
-
- for (hPtr = Tcl_FirstHashEntry(threadStorageHashTablePtr, &search);
- hPtr != NULL; hPtr = Tcl_NextHashEntry(&search)) {
- /*
- * Get the hash table corresponding to the thread in question.
- */
-
- hashTablePtr = Tcl_GetHashValue(hPtr);
-
- if (hashTablePtr != NULL) {
- /*
- * Now find the entry for the specified data key.
- */
-
- hDataPtr = Tcl_FindHashEntry(hashTablePtr,
- (char *)*indexPtr);
-
- if (hDataPtr != NULL) {
- /*
- * Delete the data key for this thread.
- */
-
- Tcl_DeleteHashEntry(hDataPtr);
- }
- }
- }
- }
-
- ThreadStorageUnlock();
-
- TclpSysFree((char *)indexPtr);
- *keyPtr = NULL;
- }
+ Tcl_MutexUnlock(&threadStorageLock);
}
-#else /* !defined(TCL_THREADS) || !defined(USE_THREAD_STORAGE) */
-
-static void ThreadStoragePanic(CONST char *message);
-
-/*
- *----------------------------------------------------------------------
- *
- * ThreadStoragePanic --
- *
- * Panic if Tcl was compiled without TCL_THREADS or without
- * USE_THREAD_STORAGE and a thread storage function has been called.
- *
- * Results:
- * None.
- *
- * Side effects:
- * None.
- *
- *----------------------------------------------------------------------
- */
+#else /* !defined(TCL_THREADS) */
-static void
-ThreadStoragePanic(
- CONST char *message) /* currently ignored */
-{
-#ifdef TCL_THREADS
-# ifdef USE_THREAD_STORAGE
- /*
- * Do nothing, everything is OK. However, this should never happen because
- * this function only gets called by the dummy thread storage functions
- * (used when one or both of these DEFINES are not present).
- */
-# else
- Tcl_Panic("Tcl was not compiled with thread storage enabled.");
-# endif /* USE_THREAD_STORAGE */
-#else
- Tcl_Panic("Tcl was not compiled with threads enabled.");
-#endif /* TCL_THREADS */
-}
-
/*
- * Stub functions that just call ThreadStoragePanic.
+ * Stub functions for non-threaded builds
*/
void
-TclThreadStorageDataKeyInit(Tcl_ThreadDataKey *keyPtr)
-{
- ThreadStoragePanic(NULL);
-}
-
-void *
-TclThreadStorageDataKeyGet(Tcl_ThreadDataKey *keyPtr)
+TclInitThreadStorage()
{
- ThreadStoragePanic(NULL);
- return NULL;
}
void
-TclThreadStorageDataKeySet(Tcl_ThreadDataKey *keyPtr, void *data)
+TclpFinalizeThreadDataThread()
{
- ThreadStoragePanic(NULL);
}
void
TclFinalizeThreadStorage()
{
- ThreadStoragePanic(NULL);
-}
-
-void
-TclFinalizeThreadStorageData(Tcl_ThreadDataKey *keyPtr)
-{
- ThreadStoragePanic(NULL);
-}
-
-void
-TclFinalizeThreadStorageDataKey(Tcl_ThreadDataKey *keyPtr)
-{
- ThreadStoragePanic(NULL);
}
#endif /* defined(TCL_THREADS) && defined(USE_THREAD_STORAGE) */