mirrors/cpython
1
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-08-31 14:07:50 +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

86
Python/thread_lwp.h
View file

@ -46,7 +46,7 @@ struct lock {
/*
* Initialization.
*/
static void _init_thread _P0()
static void PyThread__init_thread _P0()
{
lwp_setstkcache(STACKSIZE, NSTACKS);
}
@ -56,30 +56,30 @@ static void _init_thread _P0()
*/
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)
{
thread_t tid;
int success;
dprintf(("start_new_thread called\n"));
dprintf(("PyThread_start_new_thread called\n"));
if (!initialized)
init_thread();
PyThread_init_thread();
success = lwp_create(&tid, func, MINPRIO, 0, lwp_newstk(), 1, arg);
return success < 0 ? 0 : 1;
}
long get_thread_ident _P0()
long PyThread_get_thread_ident _P0()
{
thread_t tid;
if (!initialized)
init_thread();
PyThread_init_thread();
if (lwp_self(&tid) < 0)
return -1;
return tid.thread_id;
}
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);
@ -88,20 +88,20 @@ static void do_exit_thread _P1(no_cleanup, int no_cleanup)
lwp_destroy(SELF);
}
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);
@ -110,49 +110,49 @@ static void do_exit_prog _P2(status, int status, no_cleanup, int no_cleanup)
pod_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()
{
struct lock *lock;
extern char *malloc();
dprintf(("allocate_lock called\n"));
dprintf(("PyThread_allocate_lock called\n"));
if (!initialized)
init_thread();
PyThread_init_thread();
lock = (struct lock *) malloc(sizeof(struct lock));
lock->lock_locked = 0;
(void) mon_create(&lock->lock_monitor);
(void) cv_create(&lock->lock_condvar, lock->lock_monitor);
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));
mon_destroy(((struct lock *) lock)->lock_monitor);
free((char *) 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));
success = 0;
(void) mon_enter(((struct lock *) lock)->lock_monitor);
@ -165,13 +165,13 @@ int acquire_lock _P2(lock, type_lock lock, waitflag, int waitflag)
}
cv_broadcast(((struct lock *) lock)->lock_condvar);
mon_exit(((struct lock *) lock)->lock_monitor);
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));
(void) mon_enter(((struct lock *) lock)->lock_monitor);
((struct lock *) lock)->lock_locked = 0;
cv_broadcast(((struct lock *) lock)->lock_condvar);
@ -181,30 +181,30 @@ 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)
{
type_sema sema = 0;
dprintf(("allocate_sema called\n"));
PyThread_type_sema sema = 0;
dprintf(("PyThread_allocate_sema called\n"));
if (!initialized)
init_thread();
PyThread_init_thread();
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));
}
int down_sema _P2(sema, type_sema sema, waitflag, int waitflag)
int PyThread_down_sema _P2(sema, PyThread_type_sema sema, waitflag, int waitflag)
{
dprintf(("down_sema(%lx, %d) called\n", (long) sema, waitflag));
dprintf(("down_sema(%lx) return\n", (long) sema));
dprintf(("PyThread_down_sema(%lx, %d) called\n", (long) sema, waitflag));
dprintf(("PyThread_down_sema(%lx) return\n", (long) sema));
return -1;
}
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));
}