@ -81,14 +81,14 @@ PyThread_init_thread(void)
or the size specified by the THREAD_STACK_SIZE macro . */
static size_t _pythread_stacksize = 0 ;
# ifdef _POSIX_THREADS
# define PYTHREAD_NAME "pthread"
# include "thread_pthread.h"
# endif
# ifdef NT_THREADS
# define PYTHREAD_NAME "nt"
# include "thread_nt.h "
# if defined(_POSIX_THREADS)
# define PYTHREAD_NAME "pthread"
# include "thread_pthread.h"
# elif defined(NT_THREADS)
# define PYTHREAD_NAME "nt"
# include "thread_nt.h"
# else
# error "Require native thread feature. See https: / / bugs.python.org / issue30832 "
# endif
@ -114,13 +114,7 @@ PyThread_set_stacksize(size_t size)
# endif
}
# ifndef Py_HAVE_NATIVE_TLS
/* If the platform has not supplied a platform specific
TLS implementation , provide our own .
This code stolen from " thread_sgi.h " , where it was the only
implementation of an existing Python TLS API .
*/
/* ------------------------------------------------------------------------
Per - thread data ( " key " ) support .
@ -157,205 +151,6 @@ any of the other functions are called. There's also a hidden assumption
that calls to PyThread_create_key ( ) are serialized externally .
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/* A singly-linked list of struct key objects remembers all the key->value
* associations . File static keyhead heads the list . keymutex is used
* to enforce exclusion internally .
*/
struct key {
/* Next record in the list, or NULL if this is the last record. */
struct key * next ;
/* The thread id, according to PyThread_get_thread_ident(). */
unsigned long id ;
/* The key and its associated value. */
int key ;
void * value ;
} ;
static struct key * keyhead = NULL ;
static PyThread_type_lock keymutex = NULL ;
static int nkeys = 0 ; /* PyThread_create_key() hands out nkeys+1 next */
/* Internal helper.
* If the current thread has a mapping for key , the appropriate struct key *
* is returned . NB : value is ignored in this case !
* If there is no mapping for key in the current thread , then :
* If value is NULL , NULL is returned .
* Else a mapping of key to value is created for the current thread ,
* and a pointer to a new struct key * is returned ; except that if
* malloc ( ) can ' t find room for a new struct key * , NULL is returned .
* So when value = = NULL , this acts like a pure lookup routine , and when
* value ! = NULL , this acts like dict . setdefault ( ) , returning an existing
* mapping if one exists , else creating a new mapping .
*
* Caution : this used to be too clever , trying to hold keymutex only
* around the " p->next = keyhead; keyhead = p " pair . That allowed
* another thread to mutate the list , via key deletion , concurrent with
* find_key ( ) crawling over the list . Hilarity ensued . For example , when
* the for - loop here does " p = p->next " , p could end up pointing at a
* record that PyThread_delete_key_value ( ) was concurrently free ( ) ' ing .
* That could lead to anything , from failing to find a key that exists , to
* segfaults . Now we lock the whole routine .
*/
static struct key *
find_key ( int set_value , int key , void * value )
{
struct key * p , * prev_p ;
unsigned long id = PyThread_get_thread_ident ( ) ;
if ( ! keymutex )
return NULL ;
PyThread_acquire_lock ( keymutex , 1 ) ;
prev_p = NULL ;
for ( p = keyhead ; p ! = NULL ; p = p - > next ) {
if ( p - > id = = id & & p - > key = = key ) {
if ( set_value )
p - > value = value ;
goto Done ;
}
/* Sanity check. These states should never happen but if
* they do we must abort . Otherwise we ' ll end up spinning
* in a tight loop with the lock held . A similar check is done
* in pystate . c tstate_delete_common ( ) . */
if ( p = = prev_p )
Py_FatalError ( " tls find_key: small circular list(!) " ) ;
prev_p = p ;
if ( p - > next = = keyhead )
Py_FatalError ( " tls find_key: circular list(!) " ) ;
}
if ( ! set_value & & value = = NULL ) {
assert ( p = = NULL ) ;
goto Done ;
}
p = ( struct key * ) PyMem_RawMalloc ( sizeof ( struct key ) ) ;
if ( p ! = NULL ) {
p - > id = id ;
p - > key = key ;
p - > value = value ;
p - > next = keyhead ;
keyhead = p ;
}
Done :
PyThread_release_lock ( keymutex ) ;
return p ;
}
/* Return a new key. This must be called before any other functions in
* this family , and callers must arrange to serialize calls to this
* function . No violations are detected .
*/
int
PyThread_create_key ( void )
{
/* All parts of this function are wrong if it's called by multiple
* threads simultaneously .
*/
if ( keymutex = = NULL )
keymutex = PyThread_allocate_lock ( ) ;
return + + nkeys ;
}
/* Forget the associations for key across *all* threads. */
void
PyThread_delete_key ( int key )
{
struct key * p , * * q ;
PyThread_acquire_lock ( keymutex , 1 ) ;
q = & keyhead ;
while ( ( p = * q ) ! = NULL ) {
if ( p - > key = = key ) {
* q = p - > next ;
PyMem_RawFree ( ( void * ) p ) ;
/* NB This does *not* free p->value! */
}
else
q = & p - > next ;
}
PyThread_release_lock ( keymutex ) ;
}
int
PyThread_set_key_value ( int key , void * value )
{
struct key * p ;
p = find_key ( 1 , key , value ) ;
if ( p = = NULL )
return - 1 ;
else
return 0 ;
}
/* Retrieve the value associated with key in the current thread, or NULL
* if the current thread doesn ' t have an association for key .
*/
void *
PyThread_get_key_value ( int key )
{
struct key * p = find_key ( 0 , key , NULL ) ;
if ( p = = NULL )
return NULL ;
else
return p - > value ;
}
/* Forget the current thread's association for key, if any. */
void
PyThread_delete_key_value ( int key )
{
unsigned long id = PyThread_get_thread_ident ( ) ;
struct key * p , * * q ;
PyThread_acquire_lock ( keymutex , 1 ) ;
q = & keyhead ;
while ( ( p = * q ) ! = NULL ) {
if ( p - > key = = key & & p - > id = = id ) {
* q = p - > next ;
PyMem_RawFree ( ( void * ) p ) ;
/* NB This does *not* free p->value! */
break ;
}
else
q = & p - > next ;
}
PyThread_release_lock ( keymutex ) ;
}
/* Forget everything not associated with the current thread id.
* This function is called from PyOS_AfterFork_Child ( ) . It is necessary
* because other thread ids which were in use at the time of the fork
* may be reused for new threads created in the forked process .
*/
void
PyThread_ReInitTLS ( void )
{
unsigned long id = PyThread_get_thread_ident ( ) ;
struct key * p , * * q ;
if ( ! keymutex )
return ;
/* As with interpreter_lock in PyEval_ReInitThreads()
we just create a new lock without freeing the old one */
keymutex = PyThread_allocate_lock ( ) ;
/* Delete all keys which do not match the current thread id */
q = & keyhead ;
while ( ( p = * q ) ! = NULL ) {
if ( p - > id ! = id ) {
* q = p - > next ;
PyMem_RawFree ( ( void * ) p ) ;
/* NB This does *not* free p->value! */
}
else
q = & p - > next ;
}
}
# endif /* Py_HAVE_NATIVE_TLS */
PyDoc_STRVAR ( threadinfo__doc__ ,
" sys.thread_info \n \
Masayuki Yamamoto
9 years ago
Victor Stinner