cpython/Python/thread.c

245 lines
4.1 KiB
C
Raw Normal View History

1994-08-30 05:27:36 -03:00
/* Thread package.
This is intended to be usable independently from Python.
The implementation for system foobar is in a file thread_foobar.h
which is included by this file dependent on config settings.
Stuff shared by all thread_*.h files is collected here. */
#include "Python.h"
#ifndef DONT_HAVE_STDIO_H
#include <stdio.h>
#endif
1994-08-30 05:27:36 -03:00
#ifdef HAVE_STDLIB_H
1993-12-03 12:54:45 -04:00
#include <stdlib.h>
1994-08-30 05:27:36 -03:00
#else
#ifdef Py_DEBUG
extern char *getenv(const char *);
#endif
#endif
1997-05-22 17:41:59 -03:00
#ifdef __DGUX
#define _USING_POSIX4A_DRAFT6
#endif
#ifdef __sgi
#ifndef HAVE_PTHREAD_H /* XXX Need to check in configure.in */
#undef _POSIX_THREADS
#endif
#endif
1998-10-01 17:42:43 -03:00
#include "pythread.h"
1994-08-30 05:27:36 -03:00
#ifndef _POSIX_THREADS
#ifdef __sgi
#define SGI_THREADS
#endif
#ifdef HAVE_THREAD_H
#define SOLARIS_THREADS
#endif
#if defined(sun) && !defined(SOLARIS_THREADS)
#define SUN_LWP
#endif
1993-12-03 12:54:45 -04:00
#endif /* _POSIX_THREADS */
1996-12-30 12:17:54 -04:00
#ifdef Py_DEBUG
1994-08-30 05:27:36 -03:00
static int thread_debug = 0;
2002-06-25 16:26:34 -03:00
#define dprintf(args) (void)((thread_debug & 1) && printf args)
1994-08-30 05:27:36 -03:00
#define d2printf(args) ((thread_debug & 8) && printf args)
#else
#define dprintf(args)
#define d2printf(args)
1993-12-03 12:54:45 -04:00
#endif
1994-08-30 05:27:36 -03:00
static int initialized;
static void PyThread__init_thread(void); /* Forward */
void PyThread_init_thread(void)
{
1996-12-30 12:17:54 -04:00
#ifdef Py_DEBUG
1993-12-03 12:54:45 -04:00
char *p = getenv("THREADDEBUG");
if (p) {
if (*p)
thread_debug = atoi(p);
else
thread_debug = 1;
}
1996-12-30 12:17:54 -04:00
#endif /* Py_DEBUG */
if (initialized)
return;
initialized = 1;
dprintf(("PyThread_init_thread called\n"));
PyThread__init_thread();
}
1994-08-30 05:27:36 -03:00
#ifdef SGI_THREADS
#include "thread_sgi.h"
#endif
1994-08-30 05:27:36 -03:00
#ifdef SOLARIS_THREADS
#include "thread_solaris.h"
#endif
1994-08-30 05:27:36 -03:00
#ifdef SUN_LWP
#include "thread_lwp.h"
1993-12-03 12:54:45 -04:00
#endif
#ifdef HAVE_PTH
#include "thread_pth.h"
#undef _POSIX_THREADS
#endif
1994-08-30 05:27:36 -03:00
#ifdef _POSIX_THREADS
#include "thread_pthread.h"
#endif
1994-08-30 05:27:36 -03:00
#ifdef C_THREADS
#include "thread_cthread.h"
#endif
1995-01-17 12:29:31 -04:00
#ifdef NT_THREADS
#include "thread_nt.h"
#endif
1997-11-22 17:53:48 -04:00
#ifdef OS2_THREADS
#include "thread_os2.h"
#endif
#ifdef BEOS_THREADS
#include "thread_beos.h"
#endif
#ifdef WINCE_THREADS
#include "thread_wince.h"
#endif
#ifdef PLAN9_THREADS
#include "thread_plan9.h"
#endif
2002-06-11 03:22:31 -03:00
#ifdef ATHEOS_THREADS
#include "thread_atheos.h"
#endif
/*
1994-08-30 05:27:36 -03:00
#ifdef FOOBAR_THREADS
#include "thread_foobar.h"
#endif
1994-08-30 05:27:36 -03:00
*/
#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.
*/
struct key {
struct key *next;
long id;
int key;
void *value;
};
static struct key *keyhead = NULL;
static int nkeys = 0;
static PyThread_type_lock keymutex = NULL;
static struct key *find_key(int key, void *value)
{
struct key *p;
long id = PyThread_get_thread_ident();
for (p = keyhead; p != NULL; p = p->next) {
if (p->id == id && p->key == key)
return p;
}
if (value == NULL)
return NULL;
p = (struct key *)malloc(sizeof(struct key));
if (p != NULL) {
p->id = id;
p->key = key;
p->value = value;
PyThread_acquire_lock(keymutex, 1);
p->next = keyhead;
keyhead = p;
PyThread_release_lock(keymutex);
}
return p;
}
int PyThread_create_key(void)
{
if (keymutex == NULL)
keymutex = PyThread_allocate_lock();
return ++nkeys;
}
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;
free((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 = find_key(key, value);
if (p == NULL)
return -1;
else
return 0;
}
void *PyThread_get_key_value(int key)
{
struct key *p = find_key(key, NULL);
if (p == NULL)
return NULL;
else
return p->value;
}
void PyThread_delete_key_value(int key)
{
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;
free((void *)p);
/* NB This does *not* free p->value! */
break;
}
else
q = &p->next;
}
PyThread_release_lock(keymutex);
}
#endif /* Py_HAVE_NATIVE_TLS */