mirrors/cpython
1
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-10-17 20:28:43 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 9

Thanks to Chris Herborth, the thread primitives now have proper Py*

Browse source 
names in the source code (they already had those for the linker,
through some smart macros; but the source still had the old, un-Py names).
This commit is contained in:
Guido van Rossum 1998-12-21 19:32:43 +00:00
parent 14f53a7757
commit 65d5b5763c
20 changed files with 507 additions and 548 deletions
Download patch file Download diff file Expand all files Collapse all files

84
Python/thread_solaris.h
View file

@ -40,7 +40,7 @@ PERFORMANCE OF THIS SOFTWARE.
/*
* Initialization.
*/
static void _init_thread _P0()
static void PyThread__init_thread _P0()
{
}
@ -65,15 +65,15 @@ static void *new_func _P1(funcarg, void *funcarg)
}
int start_new_thread _P2(func, void (*func) _P((void *)), arg, void *arg)
int PyThread_start_new_thread _P2(func, void (*func) _P((void *)), arg, void *arg)
{
struct func_arg *funcarg;
int success = 0; /* init not needed when SOLARIS_THREADS and */
/* C_THREADS implemented properly */
dprintf(("start_new_thread called\n"));
dprintf(("PyThread_start_new_thread called\n"));
if (!initialized)
init_thread();
PyThread_init_thread();
funcarg = (struct func_arg *) malloc(sizeof(struct func_arg));
funcarg->func = func;
funcarg->arg = arg;
@ -85,16 +85,16 @@ int start_new_thread _P2(func, void (*func) _P((void *)), arg, void *arg)
return success < 0 ? 0 : 1;
}
long get_thread_ident _P0()
long PyThread_get_thread_ident _P0()
{
if (!initialized)
init_thread();
PyThread_init_thread();
return thr_self();
}
static void do_exit_thread _P1(no_cleanup, int no_cleanup)
static void do_PyThread_exit_thread _P1(no_cleanup, int no_cleanup)
{
dprintf(("exit_thread called\n"));
dprintf(("PyThread_exit_thread called\n"));
if (!initialized)
if (no_cleanup)
_exit(0);
@ -103,20 +103,20 @@ static void do_exit_thread _P1(no_cleanup, int no_cleanup)
thr_exit(0);
}
void exit_thread _P0()
void PyThread_exit_thread _P0()
{
do_exit_thread(0);
do_PyThread_exit_thread(0);
}
void _exit_thread _P0()
void PyThread__exit_thread _P0()
{
do_exit_thread(1);
do_PyThread_exit_thread(1);
}
#ifndef NO_EXIT_PROG
static void do_exit_prog _P2(status, int status, no_cleanup, int no_cleanup)
static void do_PyThread_exit_prog _P2(status, int status, no_cleanup, int no_cleanup)
{
dprintf(("exit_prog(%d) called\n", status));
dprintf(("PyThread_exit_prog(%d) called\n", status));
if (!initialized)
if (no_cleanup)
_exit(status);
@ -128,27 +128,27 @@ static void do_exit_prog _P2(status, int status, no_cleanup, int no_cleanup)
exit(status);
}
void exit_prog _P1(status, int status)
void PyThread_exit_prog _P1(status, int status)
{
do_exit_prog(status, 0);
do_PyThread_exit_prog(status, 0);
}
void _exit_prog _P1(status, int status)
void PyThread__exit_prog _P1(status, int status)
{
do_exit_prog(status, 1);
do_PyThread_exit_prog(status, 1);
}
#endif /* NO_EXIT_PROG */
/*
* Lock support.
*/
type_lock allocate_lock _P0()
PyThread_type_lock PyThread_allocate_lock _P0()
{
mutex_t *lock;
dprintf(("allocate_lock called\n"));
dprintf(("PyThread_allocate_lock called\n"));
if (!initialized)
init_thread();
PyThread_init_thread();
lock = (mutex_t *) malloc(sizeof(mutex_t));
if (mutex_init(lock, USYNC_THREAD, 0)) {
@ -156,22 +156,22 @@ type_lock allocate_lock _P0()
free((void *) lock);
lock = 0;
}
dprintf(("allocate_lock() -> %lx\n", (long)lock));
return (type_lock) lock;
dprintf(("PyThread_allocate_lock() -> %lx\n", (long)lock));
return (PyThread_type_lock) lock;
}
void free_lock _P1(lock, type_lock lock)
void PyThread_free_lock _P1(lock, PyThread_type_lock lock)
{
dprintf(("free_lock(%lx) called\n", (long)lock));
dprintf(("PyThread_free_lock(%lx) called\n", (long)lock));
mutex_destroy((mutex_t *) lock);
free((void *) lock);
}
int acquire_lock _P2(lock, type_lock lock, waitflag, int waitflag)
int PyThread_acquire_lock _P2(lock, PyThread_type_lock lock, waitflag, int waitflag)
{
int success;
dprintf(("acquire_lock(%lx, %d) called\n", (long)lock, waitflag));
dprintf(("PyThread_acquire_lock(%lx, %d) called\n", (long)lock, waitflag));
if (waitflag)
success = mutex_lock((mutex_t *) lock);
else
@ -180,13 +180,13 @@ int acquire_lock _P2(lock, type_lock lock, waitflag, int waitflag)
perror(waitflag ? "mutex_lock" : "mutex_trylock");
else
success = !success; /* solaris does it the other way round */
dprintf(("acquire_lock(%lx, %d) -> %d\n", (long)lock, waitflag, success));
dprintf(("PyThread_acquire_lock(%lx, %d) -> %d\n", (long)lock, waitflag, success));
return success;
}
void release_lock _P1(lock, type_lock lock)
void PyThread_release_lock _P1(lock, PyThread_type_lock lock)
{
dprintf(("release_lock(%lx) called\n", (long)lock));
dprintf(("PyThread_release_lock(%lx) called\n", (long)lock));
if (mutex_unlock((mutex_t *) lock))
perror("mutex_unlock");
}
@ -194,12 +194,12 @@ void release_lock _P1(lock, type_lock lock)
/*
* Semaphore support.
*/
type_sema allocate_sema _P1(value, int value)
PyThread_type_sema PyThread_allocate_sema _P1(value, int value)
{
sema_t *sema;
dprintf(("allocate_sema called\n"));
dprintf(("PyThread_allocate_sema called\n"));
if (!initialized)
init_thread();
PyThread_init_thread();
sema = (sema_t *) malloc(sizeof(sema_t));
if (sema_init(sema, value, USYNC_THREAD, 0)) {
@ -207,23 +207,23 @@ type_sema allocate_sema _P1(value, int value)
free((void *) sema);
sema = 0;
}
dprintf(("allocate_sema() -> %lx\n", (long) sema));
return (type_sema) sema;
dprintf(("PyThread_allocate_sema() -> %lx\n", (long) sema));
return (PyThread_type_sema) sema;
}
void free_sema _P1(sema, type_sema sema)
void PyThread_free_sema _P1(sema, PyThread_type_sema sema)
{
dprintf(("free_sema(%lx) called\n", (long) sema));
dprintf(("PyThread_free_sema(%lx) called\n", (long) sema));
if (sema_destroy((sema_t *) sema))
perror("sema_destroy");
free((void *) sema);
}
int down_sema _P2(sema, type_sema sema, waitflag, int waitflag)
int PyThread_down_sema _P2(sema, PyThread_type_sema sema, waitflag, int waitflag)
{
int success;
dprintf(("down_sema(%lx) called\n", (long) sema));
dprintf(("PyThread_down_sema(%lx) called\n", (long) sema));
if (waitflag)
success = sema_wait((sema_t *) sema);
else
@ -236,13 +236,13 @@ int down_sema _P2(sema, type_sema sema, waitflag, int waitflag)
}
else
success = !success;
dprintf(("down_sema(%lx) return %d\n", (long) sema, success));
dprintf(("PyThread_down_sema(%lx) return %d\n", (long) sema, success));
return success;
}
void up_sema _P1(sema, type_sema sema)
void PyThread_up_sema _P1(sema, PyThread_type_sema sema)
{
dprintf(("up_sema(%lx)\n", (long) sema));
dprintf(("PyThread_up_sema(%lx)\n", (long) sema));
if (sema_post((sema_t *) sema))
perror("sema_post");
}