thread_cthread.h 3.56 KB
Newer Older
1

2
#include <mach/cthreads.h>
3 4 5 6 7


/*
 * Initialization.
 */
8 9
static void
PyThread__init_thread(void)
10 11 12 13 14 15 16
{
	cthread_init();
}

/*
 * Thread support.
 */
17
int
18
PyThread_start_new_thread(void (*func)(void *), void *arg)
19 20 21 22
{
	int success = 0;	/* init not needed when SOLARIS_THREADS and */
				/* C_THREADS implemented properly */

23
	dprintf(("PyThread_start_new_thread called\n"));
24
	if (!initialized)
25
		PyThread_init_thread();
26 27 28 29
	/* looks like solaris detaches the thread to never rejoin
	 * so well do it here
	 */
	cthread_detach(cthread_fork((cthread_fn_t) func, arg));
30 31 32
	return success < 0 ? 0 : 1;
}

33 34
long
PyThread_get_thread_ident(void)
35 36
{
	if (!initialized)
37
		PyThread_init_thread();
38
	return (long) cthread_self();
39 40
}

41 42
static void
do_PyThread_exit_thread(int no_cleanup)
43
{
44
	dprintf(("PyThread_exit_thread called\n"));
45 46 47 48 49 50 51 52
	if (!initialized)
		if (no_cleanup)
			_exit(0);
		else
			exit(0);
	cthread_exit(0);
}

53 54
void
PyThread_exit_thread(void)
55
{
56
	do_PyThread_exit_thread(0);
57 58
}

59 60
void
PyThread__exit_thread(void)
61
{
62
	do_PyThread_exit_thread(1);
63 64 65
}

#ifndef NO_EXIT_PROG
66 67
static
void do_PyThread_exit_prog(int status, int no_cleanup)
68
{
69
	dprintf(("PyThread_exit_prog(%d) called\n", status));
70 71 72 73 74
	if (!initialized)
		if (no_cleanup)
			_exit(status);
		else
			exit(status);
75 76 77 78
	if (no_cleanup)
		_exit(status);
	else
		exit(status);
79 80
}

81 82
void
PyThread_exit_prog(int status)
83
{
84
	do_PyThread_exit_prog(status, 0);
85 86
}

87 88
void
PyThread__exit_prog(int status)
89
{
90
	do_PyThread_exit_prog(status, 1);
91 92 93 94 95 96
}
#endif /* NO_EXIT_PROG */

/*
 * Lock support.
 */
97 98
PyThread_type_lock
PyThread_allocate_lock(void)
99
{
100
	mutex_t lock;
101

102
	dprintf(("PyThread_allocate_lock called\n"));
103
	if (!initialized)
104
		PyThread_init_thread();
105

106 107 108 109 110 111
	lock = mutex_alloc();
	if (mutex_init(lock)) {
		perror("mutex_init");
		free((void *) lock);
		lock = 0;
	}
112
	dprintf(("PyThread_allocate_lock() -> %p\n", lock));
113
	return (PyThread_type_lock) lock;
114 115
}

116 117
void
PyThread_free_lock(PyThread_type_lock lock)
118
{
119
	dprintf(("PyThread_free_lock(%p) called\n", lock));
120
	mutex_free(lock);
121 122
}

123 124
int
PyThread_acquire_lock(PyThread_type_lock lock, int waitflag)
125
{
126
	int success = FALSE;
127

128
	dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
129 130 131 132 133 134
	if (waitflag) { 	/* blocking */
		mutex_lock(lock);
		success = TRUE;
	} else {		/* non blocking */
		success = mutex_try_lock(lock);
	}
135
	dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
136 137 138
	return success;
}

139 140
void
PyThread_release_lock(PyThread_type_lock lock)
141
{
142
	dprintf(("PyThread_release_lock(%p) called\n", lock));
143
	mutex_unlock((mutex_t )lock);
144 145 146 147
}

/*
 * Semaphore support.
148 149 150 151 152 153 154 155 156 157 158
 *
 * This implementation is ripped directly from the pthreads implementation.
 * Which is to say that it is 100% non-functional at this time.
 *
 * Assuming the page is still up, documentation can be found at:
 *
 * http://www.doc.ic.ac.uk/~mac/manuals/solaris-manual-pages/solaris/usr/man/man2/_lwp_sema_wait.2.html
 *
 * Looking at the man page, it seems that one could easily implement a
 * semaphore using a condition.
 *
159
 */
160 161
PyThread_type_sema
PyThread_allocate_sema(int value)
162
{
163
	char *sema = 0;
164
	dprintf(("PyThread_allocate_sema called\n"));
165
	if (!initialized)
166
		PyThread_init_thread();
167

168
	dprintf(("PyThread_allocate_sema() -> %p\n", sema));
169
	return (PyThread_type_sema) sema;
170 171
}

172 173
void
PyThread_free_sema(PyThread_type_sema sema)
174
{
175
	dprintf(("PyThread_free_sema(%p) called\n", sema));
176 177
}

178 179
int
PyThread_down_sema(PyThread_type_sema sema, int waitflag)
180
{
181 182
	dprintf(("PyThread_down_sema(%p, %d) called\n", sema, waitflag));
	dprintf(("PyThread_down_sema(%p) return\n", sema));
183
	return -1;
184 185
}

186 187
void
PyThread_up_sema(PyThread_type_sema sema)
188
{
189
	dprintf(("PyThread_up_sema(%p)\n", sema));
190
}