1 

     2 #include <stdlib.h>

     3 #include <lwp/lwp.h>

     4 #include <lwp/stackdep.h>

     5 

     6 #define STACKSIZE	1000	/* stacksize for a thread */

     7 #define NSTACKS		2	/* # stacks to be put in cache initially */

     8 

     9 struct lock {

    10 	int lock_locked;

    11 	cv_t lock_condvar;

    12 	mon_t lock_monitor;

    13 };

    14 

    15 

    16 /*

    17  * Initialization.

    18  */

    19 static void PyThread__init_thread(void)

    20 {

    21 	lwp_setstkcache(STACKSIZE, NSTACKS);

    22 }

    23 

    24 /*

    25  * Thread support.

    26  */

    27 

    28 

    29 long PyThread_start_new_thread(void (*func)(void *), void *arg)

    30 {

    31 	thread_t tid;

    32 	int success;

    33 	dprintf(("PyThread_start_new_thread called\n"));

    34 	if (!initialized)

    35 		PyThread_init_thread();

    36 	success = lwp_create(&tid, func, MINPRIO, 0, lwp_newstk(), 1, arg);

    37 	return success < 0 ? -1 : 0;

    38 }

    39 

    40 long PyThread_get_thread_ident(void)

    41 {

    42 	thread_t tid;

    43 	if (!initialized)

    44 		PyThread_init_thread();

    45 	if (lwp_self(&tid) < 0)

    46 		return -1;

    47 	return tid.thread_id;

    48 }

    49 

    50 static void do_PyThread_exit_thread(int no_cleanup)

    51 {

    52 	dprintf(("PyThread_exit_thread called\n"));

    53 	if (!initialized)

    54 		if (no_cleanup)

    55 			_exit(0);

    56 		else

    57 			exit(0);

    58 	lwp_destroy(SELF);

    59 }

    60 

    61 void PyThread_exit_thread(void)

    62 {

    63 	do_PyThread_exit_thread(0);

    64 }

    65 

    66 void PyThread__exit_thread(void)

    67 {

    68 	do_PyThread_exit_thread(1);

    69 }

    70 

    71 #ifndef NO_EXIT_PROG

    72 static void do_PyThread_exit_prog(int status, int no_cleanup)

    73 {

    74 	dprintf(("PyThread_exit_prog(%d) called\n", status));

    75 	if (!initialized)

    76 		if (no_cleanup)

    77 			_exit(status);

    78 		else

    79 			exit(status);

    80 	pod_exit(status);

    81 }

    82 

    83 void PyThread_exit_prog(int status)

    84 {

    85 	do_PyThread_exit_prog(status, 0);

    86 }

    87 

    88 void PyThread__exit_prog(int status)

    89 {

    90 	do_PyThread_exit_prog(status, 1);

    91 }

    92 #endif /* NO_EXIT_PROG */

    93 

    94 /*

    95  * Lock support.

    96  */

    97 PyThread_type_lock PyThread_allocate_lock(void)

    98 {

    99 	struct lock *lock;

   100 	extern char *malloc(size_t);

   101 

   102 	dprintf(("PyThread_allocate_lock called\n"));

   103 	if (!initialized)

   104 		PyThread_init_thread();

   105 

   106 	lock = (struct lock *) malloc(sizeof(struct lock));

   107 	lock->lock_locked = 0;

   108 	(void) mon_create(&lock->lock_monitor);

   109 	(void) cv_create(&lock->lock_condvar, lock->lock_monitor);

   110 	dprintf(("PyThread_allocate_lock() -> %p\n", lock));

   111 	return (PyThread_type_lock) lock;

   112 }

   113 

   114 void PyThread_free_lock(PyThread_type_lock lock)

   115 {

   116 	dprintf(("PyThread_free_lock(%p) called\n", lock));

   117 	mon_destroy(((struct lock *) lock)->lock_monitor);

   118 	free((char *) lock);

   119 }

   120 

   121 int PyThread_acquire_lock(PyThread_type_lock lock, int waitflag)

   122 {

   123 	int success;

   124 

   125 	dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));

   126 	success = 0;

   127 

   128 	(void) mon_enter(((struct lock *) lock)->lock_monitor);

   129 	if (waitflag)

   130 		while (((struct lock *) lock)->lock_locked)

   131 			cv_wait(((struct lock *) lock)->lock_condvar);

   132 	if (!((struct lock *) lock)->lock_locked) {

   133 		success = 1;

   134 		((struct lock *) lock)->lock_locked = 1;

   135 	}

   136 	cv_broadcast(((struct lock *) lock)->lock_condvar);

   137 	mon_exit(((struct lock *) lock)->lock_monitor);

   138 	dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));

   139 	return success;

   140 }

   141 

   142 void PyThread_release_lock(PyThread_type_lock lock)

   143 {

   144 	dprintf(("PyThread_release_lock(%p) called\n", lock));

   145 	(void) mon_enter(((struct lock *) lock)->lock_monitor);

   146 	((struct lock *) lock)->lock_locked = 0;

   147 	cv_broadcast(((struct lock *) lock)->lock_condvar);

   148 	mon_exit(((struct lock *) lock)->lock_monitor);

   149 }