thread_cthread.h revision a44d353e2b6d947d36ab9d36c1fc84335a0878fe 
1/***********************************************************
2Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
3The Netherlands.
4
5                        All Rights Reserved
6
7Permission to use, copy, modify, and distribute this software and its
8documentation for any purpose and without fee is hereby granted,
9provided that the above copyright notice appear in all copies and that
10both that copyright notice and this permission notice appear in
11supporting documentation, and that the names of Stichting Mathematisch
12Centrum or CWI or Corporation for National Research Initiatives or
13CNRI not be used in advertising or publicity pertaining to
14distribution of the software without specific, written prior
15permission.
16
17While CWI is the initial source for this software, a modified version
18is made available by the Corporation for National Research Initiatives
19(CNRI) at the Internet address ftp://ftp.python.org.
20
21STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
22REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
23MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
24CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
25DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
26PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
27TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
28PERFORMANCE OF THIS SOFTWARE.
29
30******************************************************************/
31
32#include <mach/cthreads.h>
33
34
35/*
36 * Initialization.
37 */
38static void PyThread__init_thread _P0()
39{
40	cthread_init();
41}
42
43/*
44 * Thread support.
45 */
46int PyThread_start_new_thread _P2(func, void (*func) _P((void *)), arg, void *arg)
47{
48	int success = 0;	/* init not needed when SOLARIS_THREADS and */
49				/* C_THREADS implemented properly */
50
51	dprintf(("PyThread_start_new_thread called\n"));
52	if (!initialized)
53		PyThread_init_thread();
54	/* looks like solaris detaches the thread to never rejoin
55	 * so well do it here
56	 */
57	cthread_detach(cthread_fork((cthread_fn_t) func, arg));
58	return success < 0 ? 0 : 1;
59}
60
61long PyThread_get_thread_ident _P0()
62{
63	if (!initialized)
64		PyThread_init_thread();
65	return (long) cthread_self();
66}
67
68static void do_PyThread_exit_thread _P1(no_cleanup, int no_cleanup)
69{
70	dprintf(("PyThread_exit_thread called\n"));
71	if (!initialized)
72		if (no_cleanup)
73			_exit(0);
74		else
75			exit(0);
76	cthread_exit(0);
77}
78
79void PyThread_exit_thread _P0()
80{
81	do_PyThread_exit_thread(0);
82}
83
84void PyThread__exit_thread _P0()
85{
86	do_PyThread_exit_thread(1);
87}
88
89#ifndef NO_EXIT_PROG
90static void do_PyThread_exit_prog _P2(status, int status, no_cleanup, int no_cleanup)
91{
92	dprintf(("PyThread_exit_prog(%d) called\n", status));
93	if (!initialized)
94		if (no_cleanup)
95			_exit(status);
96		else
97			exit(status);
98	if (no_cleanup)
99		_exit(status);
100	else
101		exit(status);
102}
103
104void PyThread_exit_prog _P1(status, int status)
105{
106	do_PyThread_exit_prog(status, 0);
107}
108
109void PyThread__exit_prog _P1(status, int status)
110{
111	do_PyThread_exit_prog(status, 1);
112}
113#endif /* NO_EXIT_PROG */
114
115/*
116 * Lock support.
117 */
118PyThread_type_lock PyThread_allocate_lock _P0()
119{
120	mutex_t lock;
121
122	dprintf(("PyThread_allocate_lock called\n"));
123	if (!initialized)
124		PyThread_init_thread();
125
126	lock = mutex_alloc();
127	if (mutex_init(lock)) {
128		perror("mutex_init");
129		free((void *) lock);
130		lock = 0;
131	}
132	dprintf(("PyThread_allocate_lock() -> %p\n", lock));
133	return (PyThread_type_lock) lock;
134}
135
136void PyThread_free_lock _P1(lock, PyThread_type_lock lock)
137{
138	dprintf(("PyThread_free_lock(%p) called\n", lock));
139	mutex_free(lock);
140}
141
142int PyThread_acquire_lock _P2(lock, PyThread_type_lock lock, waitflag, int waitflag)
143{
144	int success = FALSE;
145
146	dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
147	if (waitflag) { 	/* blocking */
148		mutex_lock(lock);
149		success = TRUE;
150	} else {		/* non blocking */
151		success = mutex_try_lock(lock);
152	}
153	dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
154	return success;
155}
156
157void PyThread_release_lock _P1(lock, PyThread_type_lock lock)
158{
159	dprintf(("PyThread_release_lock(%p) called\n", lock));
160	mutex_unlock((mutex_t )lock);
161}
162
163/*
164 * Semaphore support.
165 *
166 * This implementation is ripped directly from the pthreads implementation.
167 * Which is to say that it is 100% non-functional at this time.
168 *
169 * Assuming the page is still up, documentation can be found at:
170 *
171 * http://www.doc.ic.ac.uk/~mac/manuals/solaris-manual-pages/solaris/usr/man/man2/_lwp_sema_wait.2.html
172 *
173 * Looking at the man page, it seems that one could easily implement a
174 * semaphore using a condition.
175 *
176 */
177PyThread_type_sema PyThread_allocate_sema _P1(value, int value)
178{
179	char *sema = 0;
180	dprintf(("PyThread_allocate_sema called\n"));
181	if (!initialized)
182		PyThread_init_thread();
183
184	dprintf(("PyThread_allocate_sema() -> %p\n", sema));
185	return (PyThread_type_sema) sema;
186}
187
188void PyThread_free_sema _P1(sema, PyThread_type_sema sema)
189{
190	dprintf(("PyThread_free_sema(%p) called\n", sema));
191}
192
193int PyThread_down_sema _P2(sema, PyThread_type_sema sema, waitflag, int waitflag)
194{
195	dprintf(("PyThread_down_sema(%p, %d) called\n", sema, waitflag));
196	dprintf(("PyThread_down_sema(%p) return\n", sema));
197	return -1;
198}
199
200void PyThread_up_sema _P1(sema, PyThread_type_sema sema)
201{
202	dprintf(("PyThread_up_sema(%p)\n", sema));
203}
204