/* * tclThreadStorage.c -- * * This file implements platform independent thread storage operations. * * Copyright (c) 2003-2004 by Joe Mistachkin * * 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.1 2004/06/24 01:29:02 mistachkin Exp $ */ #include "tclInt.h" #if defined(TCL_THREADS) && defined(USE_THREAD_STORAGE) /* * This is the thread storage cache array and it's accompanying mutex. * The elements are pairs of thread Id and an associated hash table * pointer; the hash table being pointed to contains the thread storage * for it's associated thread. The purpose of this cache is to minimize * the number of hash table lookups in the master thread storage hash * table. */ static Tcl_Mutex threadStorageLock; /* * This is the struct used for a thread storage cache slot. It contains * the owning thread Id and the associated hash table pointer. */ typedef struct ThreadStorage { Tcl_ThreadId id; /* the owning thread id */ Tcl_HashTable *hashTablePtr; /* the hash table for the thread */ } ThreadStorage; /* * These are the prototypes for the custom hash table allocation * functions used by the thread storage subsystem. */ static Tcl_HashEntry * AllocThreadStorageEntry _ANSI_ARGS_(( Tcl_HashTable *tablePtr, void *keyPtr)); static void FreeThreadStorageEntry _ANSI_ARGS_(( Tcl_HashEntry *hPtr)); /* * This is the hash key type for thread storage. We MUST use this in * combination with the new hash key type flag TCL_HASH_KEY_SYSTEM_HASH * because these hash tables MAY be used by the threaded memory allocator. */ Tcl_HashKeyType tclThreadStorageHashKeyType = { TCL_HASH_KEY_TYPE_VERSION, /* version */ TCL_HASH_KEY_SYSTEM_HASH, /* flags */ NULL, /* hashKeyProc */ NULL, /* compareKeysProc */ AllocThreadStorageEntry, /* allocEntryProc */ FreeThreadStorageEntry /* freeEntryProc */ }; /* * This is an invalid thread value. */ #define STORAGE_INVALID_THREAD (Tcl_ThreadId)0 /* * This is the value for an invalid thread storage key. */ #define STORAGE_INVALID_KEY 0 /* * This is the first valid key for use by external callers. * All the values below this are RESERVED for future use. */ #define STORAGE_FIRST_KEY 101 /* * This is the default number of thread storage cache slots. * This define may need to be fine tuned for maximum performance. */ #define STORAGE_CACHE_SLOTS 97 /* * This is the master thread storage hash table. It is keyed on * thread Id and contains values that are hash tables for each thread. * The thread specific hash tables contain the actual thread storage. */ static Tcl_HashTable *threadStorageHashTablePtr = NULL; /* * This is the next thread data key value to use. We increment this * everytime we "allocate" one. It is initially set to 1 in * TclThreadStorageInit. */ 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 kennykb's idea, this * prevents unnecessary lookups for threads that use a lot of thread * storage. */ static volatile ThreadStorage threadStorageCache[STORAGE_CACHE_SLOTS]; /* *---------------------------------------------------------------------- * * TclThreadStorageLockInit * * 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. * *---------------------------------------------------------------------- */ void TclThreadStorageLockInit() { 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; } } /* *---------------------------------------------------------------------- * * TclThreadStorageLock * * 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. * *---------------------------------------------------------------------- */ void TclThreadStorageLock() { TclThreadStorageLockInit(); Tcl_MutexLock(&threadStorageLock); } /* *---------------------------------------------------------------------- * * TclThreadStorageUnlock * * This procedure is used to release a lock that serializes creation * of thread storage. * * Results: * None. * * Side effects: * Release the thread storage mutex. * *---------------------------------------------------------------------- */ void TclThreadStorageUnlock() { Tcl_MutexUnlock(&threadStorageLock); } /* *---------------------------------------------------------------------- * * AllocThreadStorageEntry -- * * Allocate space for a Tcl_HashEntry using TclpSysAlloc (not * ckalloc). We do this because the threaded memory allocator MAY * use the thread storage hash tables. * * Results: * The return value is a pointer to the created entry. * * Side effects: * None. * *---------------------------------------------------------------------- */ static Tcl_HashEntry * AllocThreadStorageEntry(tablePtr, keyPtr) Tcl_HashTable *tablePtr; /* Hash table. */ void *keyPtr; /* Key to store in the hash table entry. */ { Tcl_HashEntry *hPtr; hPtr = (Tcl_HashEntry *)TclpSysAlloc(sizeof(Tcl_HashEntry), 0); hPtr->key.oneWordValue = (char *)keyPtr; return hPtr; } /* *---------------------------------------------------------------------- * * FreeThreadStorageEntry -- * * Frees space for a Tcl_HashEntry using TclpSysFree (not ckfree). * We do this because the threaded memory allocator MAY use the * thread storage hash tables. * * Results: * None. * * Side effects: * None. * *---------------------------------------------------------------------- */ static void FreeThreadStorageEntry(hPtr) Tcl_HashEntry *hPtr; /* Hash entry to free. */ { TclpSysFree((char *)hPtr); } /* *---------------------------------------------------------------------- * * TclThreadStoragePrint -- * * 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. * *---------------------------------------------------------------------- */ void TclThreadStoragePrint(outFile, flags) FILE *outFile; /* The file to print the information to. */ int flags; /* Reserved for future use. */ { Tcl_HashEntry *hPtr; Tcl_HashSearch search; #if 0 /* Please see comment regarding Tcl_HashStats below. */ CONST char *stats; #endif int header; int 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); #if 0 /* * Currently disabled due to Tcl_HashStats use of ckalloc and ckfree. * Please note that this can produce a LOT of output. */ if (threadStorageCache[index].hashTablePtr != NULL) { 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); } /* *---------------------------------------------------------------------- * * TclThreadStorageGetHashTable -- * * This procedure returns a hash table pointer to be used for thread * storage for the specified thread. * * Results: * A hash table pointer for the specified thread, or NULL * if the hash table has not been created yet. * * This assumes that thread storage lock is held. * * Side effects: * May change an entry in the master thread storage cache to point * to the specified thread and it's associated hash table. * *---------------------------------------------------------------------- */ Tcl_HashTable * TclThreadStorageGetHashTable(id) Tcl_ThreadId id; /* Id of the thread to get the hash table for */ { int index = (int)id % STORAGE_CACHE_SLOTS; Tcl_HashEntry *hPtr; int new; /* * It's important that we pick up the hash table pointer BEFORE * comparing thread Id in case another thread is in the critical * region changing things out from under you. */ Tcl_HashTable *hashTablePtr = threadStorageCache[index].hashTablePtr; if (threadStorageCache[index].id != id) { TclThreadStorageLock(); /* make sure the master hash table is initialized. */ TclThreadStorageInit(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_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_SetHashValue(hPtr, hashTablePtr); } else { Tcl_Panic("Tcl_CreateHashEntry failed from TclThreadStorageInit!"); } } else { Tcl_Panic("could not allocate thread specific hash table, TclpSysAlloc failed from TclThreadStorageGetHashTable!"); } } /* 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; } else { /* we cannot look it up, the master hash table has not been initialized. */ hashTablePtr = NULL; } TclThreadStorageUnlock(); } return hashTablePtr; } /* *---------------------------------------------------------------------- * * TclThreadStorageInit -- * * 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. * *---------------------------------------------------------------------- */ Tcl_HashTable * TclThreadStorageInit(id, reserved) Tcl_ThreadId id; /* Id of the thread to get the hash table for */ void *reserved; /* reserved for future use */ { #if 0 /* #ifdef TCL_THREAD_STORAGE_DEBUG */ TclThreadStoragePrint(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 *)TclpSysAlloc(sizeof(Tcl_HashTable), 0); if (threadStorageHashTablePtr != NULL) { /* initialize the hash table */ Tcl_InitCustomHashTable(threadStorageHashTablePtr, TCL_CUSTOM_TYPE_KEYS, &tclThreadStorageHashKeyType); } else { Tcl_Panic("could not allocate master thread storage hash table, TclpSysAlloc failed from TclThreadStorageInit!"); } /* 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; } return NULL; } /* *---------------------------------------------------------------------- * * TclThreadStorageDataKeyInit -- * * 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. * * 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. * *---------------------------------------------------------------------- */ void TclThreadStorageDataKeyInit(keyPtr) Tcl_ThreadDataKey *keyPtr; /* Identifier for the data chunk, * really (int **) */ { int *indexPtr; int newKey; if (*keyPtr == NULL) { indexPtr = (int *)TclpSysAlloc(sizeof(int), 0); if (indexPtr != NULL) { /* * We must call this now to make sure * that nextThreadStorageKey has a well defined * value. */ TclThreadStorageLock(); /* make sure the master hash table is initialized. */ TclThreadStorageInit(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++; TclThreadStorageUnlock(); *indexPtr = newKey; *keyPtr = (Tcl_ThreadDataKey)indexPtr; TclRememberDataKey(keyPtr); } else { Tcl_Panic("TclpSysAlloc failed from TclThreadStorageDataKeyInit!"); /* this should also be a fatal error */ } } } /* *---------------------------------------------------------------------- * * TclThreadStorageDataKeyGet -- * * 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 * TclThreadStorageDataKeyGet(keyPtr) Tcl_ThreadDataKey *keyPtr; /* Identifier for the data chunk, * really (int **) */ { int *indexPtr = *(int **)keyPtr; void *result; Tcl_ThreadId id = Tcl_GetCurrentThread(); Tcl_HashTable *hashTablePtr; Tcl_HashEntry *hPtr; if (indexPtr == NULL) { result = NULL; } else { hashTablePtr = TclThreadStorageGetHashTable(id); if (hashTablePtr != NULL) { hPtr = Tcl_FindHashEntry(hashTablePtr, (char *)*indexPtr); if (hPtr != NULL) { result = (void *)Tcl_GetHashValue(hPtr); } else { result = NULL; } } else { Tcl_Panic("TclThreadStorageGetHashTable failed from TclThreadStorageDataKeyGet!"); result = NULL; } } return result; } /* *---------------------------------------------------------------------- * * TclThreadStorageDataKeySet -- * * This procedure sets the pointer to a block of thread local storage. * * Results: * None. * * Side effects: * Sets up the thread so future calls to TclThreadStorageDataKeyGet * with this key will return the data pointer. * *---------------------------------------------------------------------- */ void TclThreadStorageDataKeySet(keyPtr, data) Tcl_ThreadDataKey *keyPtr; /* Identifier for the data chunk, * really (pthread_key_t **) */ void *data; /* Thread local storage */ { int *indexPtr = *(int **)keyPtr; Tcl_ThreadId id = Tcl_GetCurrentThread(); Tcl_HashTable *hashTablePtr; Tcl_HashEntry *hPtr; int new; hashTablePtr = TclThreadStorageGetHashTable(id); if (hashTablePtr != NULL) { hPtr = Tcl_FindHashEntry(hashTablePtr, (char *)*indexPtr); /* does the item need to be created? */ if (hPtr == NULL) { hPtr = Tcl_CreateHashEntry(hashTablePtr, (char *)*indexPtr, &new); } if (hPtr != NULL) { Tcl_SetHashValue(hPtr, data); } else { Tcl_Panic("could not set hash entry value from TclThreadStorageDataKeySet"); } } else { Tcl_Panic("TclThreadStorageGetHashTable failed from TclThreadStorageDataKeySet!"); } } /* *---------------------------------------------------------------------- * * TclFinalizeThreadStorageThread -- * * This procedure cleans up the thread storage hash table for the * specified thread. * * Results: * None. * * Side effects: * None. * *---------------------------------------------------------------------- */ void TclFinalizeThreadStorageThread(id) Tcl_ThreadId id; /* Id of the thread to finalize */ { int index = (int)id % STORAGE_CACHE_SLOTS; Tcl_HashTable *hashTablePtr; /* hash table for current thread */ Tcl_HashEntry *hPtr; /* hash entry for current thread in master table */ TclThreadStorageLock(); 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); } /* delete thread specific entry from master hash table. */ Tcl_DeleteHashEntry(hPtr); } } /* * Make sure cache entry for this thread is NULL. */ if (threadStorageCache[index].id == id) { /* * We do not step on another thread's cache entry. * This is especially important if we are creating * and exiting a lot of threads. */ threadStorageCache[index].id = STORAGE_INVALID_THREAD; threadStorageCache[index].hashTablePtr = NULL; } TclThreadStorageUnlock(); } /* *---------------------------------------------------------------------- * * TclFinalizeThreadStorage -- * * This procedure cleans up the master thread storage hash table, * all thread specific hash tables, and the thread storage cache. * * Results: * None. * * Side effects: * The master thread storage hash table and thread storage cache are * reset to their initial (empty) state. * *---------------------------------------------------------------------- */ void TclFinalizeThreadStorage() { Tcl_HashTable *hashTablePtr; /* hash table for current thread */ Tcl_HashSearch search; /* we need to hit every thread with this search */ Tcl_HashEntry *hPtr; /* hash entry for current thread in master table */ TclThreadStorageLock(); if (threadStorageHashTablePtr != NULL) { /* * 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)) { /* get the hash table corresponding to the thread in question. */ hashTablePtr = Tcl_GetHashValue(hPtr); if (hashTablePtr != NULL) { /* delete thread specific hash table and free the struct. */ Tcl_DeleteHashTable(hashTablePtr); TclpSysFree((char *)hashTablePtr); } /* delete thread specific entry from master hash table. */ Tcl_SetHashValue(hPtr, NULL); } Tcl_DeleteHashTable(threadStorageHashTablePtr); TclpSysFree((char *)threadStorageHashTablePtr); /* reset this so that next time around we know it's not valid. */ threadStorageHashTablePtr = NULL; } /* clear out the thread storage cache as well */ memset((ThreadStorage *)&threadStorageCache, 0, sizeof(ThreadStorage) * STORAGE_CACHE_SLOTS); /* reset this to zero, it will be set to STORAGE_FIRST_KEY if the thread storage subsystem gets reinitialized */ nextThreadStorageKey = STORAGE_INVALID_KEY; TclThreadStorageUnlock(); } /* *---------------------------------------------------------------------- * * 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; { void *result; int *indexPtr; Tcl_ThreadId id = Tcl_GetCurrentThread(); Tcl_HashTable *hashTablePtr; /* hash table for current thread */ Tcl_HashEntry *hPtr; /* hash entry for data key in current thread */ if (*keyPtr != NULL) { indexPtr = *(int **)keyPtr; hashTablePtr = TclThreadStorageGetHashTable(id); if (hashTablePtr != NULL) { hPtr = Tcl_FindHashEntry(hashTablePtr, (char *)*indexPtr); if (hPtr != NULL) { 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); } } else { Tcl_Panic("TclThreadStorageGetHashTable failed from TclFinalizeThreadStorageData!"); } } } /* *---------------------------------------------------------------------- * * 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; /* we 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; TclThreadStorageLock(); 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); } } } } TclThreadStorageUnlock(); TclpSysFree((char *)indexPtr); *keyPtr = NULL; } } #else /* !defined(TCL_THREADS) || !defined(USE_THREAD_STORAGE) */ static void ThreadStoragePanic _ANSI_ARGS_(( 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. * *---------------------------------------------------------------------- */ static void ThreadStoragePanic(message) 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 #else Tcl_Panic("Tcl was not compiled with threads enabled."); #endif } void TclThreadStorageLockInit() { ThreadStoragePanic(NULL); } void TclThreadStorageLock() { ThreadStoragePanic(NULL); } void TclThreadStorageUnlock() { ThreadStoragePanic(NULL); } void TclThreadStoragePrint(outFile, flags) FILE *outFile; int flags; { ThreadStoragePanic(NULL); } Tcl_HashTable * TclThreadStorageGetHashTable(id) Tcl_ThreadId id; { ThreadStoragePanic(NULL); return NULL; } Tcl_HashTable * TclThreadStorageInit(id, reserved) Tcl_ThreadId id; void *reserved; { ThreadStoragePanic(NULL); return NULL; } void TclThreadStorageDataKeyInit(keyPtr) Tcl_ThreadDataKey *keyPtr; { ThreadStoragePanic(NULL); } void * TclThreadStorageDataKeyGet(keyPtr) Tcl_ThreadDataKey *keyPtr; { ThreadStoragePanic(NULL); return NULL; } void TclThreadStorageDataKeySet(keyPtr, data) Tcl_ThreadDataKey *keyPtr; void *data; { ThreadStoragePanic(NULL); } void TclFinalizeThreadStorageThread(id) Tcl_ThreadId id; { ThreadStoragePanic(NULL); } void TclFinalizeThreadStorage() { ThreadStoragePanic(NULL); } void TclFinalizeThreadStorageData(keyPtr) Tcl_ThreadDataKey *keyPtr; { ThreadStoragePanic(NULL); } void TclFinalizeThreadStorageDataKey(keyPtr) Tcl_ThreadDataKey *keyPtr; { ThreadStoragePanic(NULL); } #endif /* defined(TCL_THREADS) && defined(USE_THREAD_STORAGE) */