[apple/libc.git] / threads / cthreads.h

/*
 * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * The contents of this file constitute Original Code as defined in and
 * are subject to the Apple Public Source License Version 1.1 (the
 * "License").  You may not use this file except in compliance with the
 * License.  Please obtain a copy of the License at
 * http://www.apple.com/publicsource and read it before using this file.
 * 
 * This Original Code and all software distributed under the License are
 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/*
 * Cthreads.
 */

#ifndef	_CTHREADS_
#define	_CTHREADS_ 1

#if defined(__cplusplus)
#define __DECLBEGIN extern "C" {
#define __DECLEND }
#else
#define __DECLBEGIN
#define __DECLEND
#endif

typedef void *any_t;

/*
 * Spin locks.
 */
__DECLBEGIN
extern void spin_unlock(int *p);
extern void spin_lock(int *p);
__DECLEND

#include <mach/mach_types.h>
#include <mach/boolean.h>

#ifndef MACRO_BEGIN

#define	NEVER FALSE

#define	MACRO_BEGIN	do {
#define	MACRO_END	} while (NEVER)

#endif	/* MACRO_BEGIN */

/*
 * C Threads package initialization.
 */
__DECLBEGIN
extern void cthread_init();
__DECLEND

#include <stdlib.h>

/*
 * Queues.
 */
typedef struct cthread_queue {
	struct cthread_queue_item *head;
	struct cthread_queue_item *tail;
} *cthread_queue_t;

typedef struct cthread_queue_item {
	struct cthread_queue_item *next;
} *cthread_queue_item_t;

#define	NO_QUEUE_ITEM	((cthread_queue_item_t) 0)

#define	QUEUE_INITIALIZER	{ NO_QUEUE_ITEM, NO_QUEUE_ITEM }

#define	cthread_queue_alloc()	((cthread_queue_t) calloc(1, sizeof(struct cthread_queue)))
#define	cthread_queue_init(q)	((q)->head = (q)->tail = 0)
#define	cthread_queue_free(q)	free((any_t) (q))

#define	cthread_queue_enq(q, x) \
	MACRO_BEGIN \
		(x)->next = 0; \
		if ((q)->tail == 0) \
			(q)->head = (cthread_queue_item_t) (x); \
		else \
			(q)->tail->next = (cthread_queue_item_t) (x); \
		(q)->tail = (cthread_queue_item_t) (x); \
	MACRO_END

#define	cthread_queue_preq(q, x) \
	MACRO_BEGIN \
		if ((q)->tail == 0) \
			(q)->tail = (cthread_queue_item_t) (x); \
		((cthread_queue_item_t) (x))->next = (q)->head; \
		(q)->head = (cthread_queue_item_t) (x); \
	MACRO_END

#define	cthread_queue_head(q, t)	((t) ((q)->head))

#define	cthread_queue_deq(q, t, x) \
	MACRO_BEGIN \
		if (((x) = (t) ((q)->head)) != 0 && \
		    ((q)->head = (cthread_queue_item_t) ((x)->next)) == 0) \
			(q)->tail = 0; \
	MACRO_END

#define	cthread_queue_map(q, t, f) \
	MACRO_BEGIN \
		register cthread_queue_item_t x, next; \
		for (x = (cthread_queue_item_t) ((q)->head); x != 0; x = next) { \
			next = x->next; \
			(*(f))((t) x); \
		} \
	MACRO_END


/*
 * Mutex objects.
 */
typedef struct mutex {
	int lock;
	char *name;
} *mutex_t;

#define	MUTEX_INITIALIZER	{ 0, 0 }

#define	mutex_alloc()		((mutex_t) calloc(1, sizeof(struct mutex)))
#define	mutex_init(m)		((m)->lock = 0)
#define	mutex_set_name(m, x)	((m)->name = (x))
#define	mutex_name(m)		((m)->name != 0 ? (m)->name : "?")
#define	mutex_clear(m)		/* nop */
#define	mutex_free(m)		free((any_t) (m))

#define	mutex_lock(m) \
	MACRO_BEGIN \
		if (! mutex_try_lock(m)) mutex_wait_lock(m); \
	MACRO_END

__DECLBEGIN
extern int mutex_try_lock(mutex_t m);	/* nonblocking */
extern void mutex_wait_lock(mutex_t m);	/* blocking */
extern void mutex_unlock(mutex_t m);
__DECLEND

/*
 * Condition variables.
 */
typedef struct condition {
	int lock;
	struct cthread_queue queue;
	char *name;
} *condition_t;

#define	CONDITION_INITIALIZER		{ 0, QUEUE_INITIALIZER, 0 }

#define	condition_alloc()		((condition_t) calloc(1, sizeof(struct condition)))
#define	condition_init(c)		MACRO_BEGIN (c)->lock = 0; cthread_queue_init(&(c)->queue); MACRO_END
#define	condition_set_name(c, x)	((c)->name = (x))
#define	condition_name(c)		((c)->name != 0 ? (c)->name : "?")
#define	condition_clear(c)		MACRO_BEGIN condition_broadcast(c); spin_lock(&(c)->lock); MACRO_END
#define	condition_free(c)		MACRO_BEGIN condition_clear(c); free((any_t) (c)); MACRO_END

#define	condition_signal(c) \
	MACRO_BEGIN \
		if ((c)->queue.head) cond_signal(c); \
	MACRO_END

#define	condition_broadcast(c) \
	MACRO_BEGIN \
		if ((c)->queue.head) cond_broadcast(c); \
	MACRO_END

__DECLBEGIN
extern void cond_signal(condition_t c);
extern void cond_broadcast(condition_t c);
extern void condition_wait(condition_t c, mutex_t m);
__DECLEND

/*
 * Threads.
 */

typedef any_t (*cthread_fn_t)(any_t arg);

#import <setjmp.h>

typedef struct cthread {
	struct cthread *next;
	thread_port_t real_thread;
	struct mutex lock;
	struct condition done;
	int state;
#if defined(__cplusplus)
	jmp_buf catchBuf;
#else
	jmp_buf catch;
#endif
	cthread_fn_t func;
	any_t arg;
	any_t result;
	const char *name;
	any_t data;
} *cthread_t;

#define	NO_CTHREAD	((cthread_t) 0)

__DECLBEGIN
extern cthread_t cthread_fork(cthread_fn_t func, any_t arg);
extern void cthread_detach(cthread_t t);
extern any_t cthread_join(cthread_t t);
extern void cthread_yield(void);
extern void cthread_exit(any_t result);
extern kern_return_t cthread_priority(
        cthread_t	t,
        int		priority,
        boolean_t	set_max);
extern kern_return_t cthread_max_priority(
        cthread_t	t,
        mach_port_t	pset,
        int		max_priority);
extern kern_return_t cthread_abort(cthread_t t);
__DECLEND

/*
 * This structure must agree with struct cproc in cthread_internals.h
 */
typedef struct ur_cthread {
	struct ur_cthread *next;
	cthread_t incarnation;
} *ur_cthread_t;

__DECLBEGIN
extern int cthread_sp(void);

extern int cthread_stack_mask;

extern ur_cthread_t ur_cthread_self(void);
#define cthread_thread(c)	(c->real_thread)
extern void cthread_set_errno_self(int e);
extern int cthread_errno(void);
#define	cthread_assoc(id, t)	(((ur_cthread_t) (id))->incarnation = (t))
#define	cthread_self()		(ur_cthread_self()->incarnation)

extern void cthread_set_name(cthread_t t, const char *name);
extern const char *cthread_name(cthread_t t);
extern int cthread_count(void);
extern void cthread_set_limit(int n);
extern int cthread_limit(void);
__DECLEND

#define	cthread_set_data(t, x)	((t)->data = (x))
#define	cthread_data(t)		((t)->data)

/*
 * Spin locks.
 */
#define	spin_unlock(p)		(*(p) = 0)

/*
 * Mutex locks.
 */
#define	mutex_unlock(m)		((m)->lock = 0)


/*
 * Debugging support.
 */
#ifdef	CTHREADS_DEBUG

#ifndef	ASSERT
/*
 * Assertion macro, similar to <assert.h>
 */
#import <stdio.h>
#define	ASSERT(p) \
	MACRO_BEGIN \
		if (!(p)) { \
			fprintf(stderr, \
				"File %s, line %d: assertion p failed.\n", \
				__FILE__, __LINE__); \
			abort(); \
		} \
	MACRO_END

#endif	/* ASSERT */

#define	SHOULDNT_HAPPEN	0

extern int cthread_debug;

#else	/* CTHREADS_DEBUG */

#ifndef	ASSERT
#define	ASSERT(p)
#endif	/* ASSERT */

#endif	/* CTHREADS_DEBUG */

#endif	/* _CTHREADS_ */
Commit	Line	Data
e9ce8d39 A	1	/*
	2	* Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
	6	* The contents of this file constitute Original Code as defined in and
	7	* are subject to the Apple Public Source License Version 1.1 (the
	8	* "License"). You may not use this file except in compliance with the
	9	* License. Please obtain a copy of the License at
	10	* http://www.apple.com/publicsource and read it before using this file.
	11	*
	12	* This Original Code and all software distributed under the License are
	13	* distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	14	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	15	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	16	* FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
	17	* License for the specific language governing rights and limitations
	18	* under the License.
	19	*
	20	* @APPLE_LICENSE_HEADER_END@
	21	*/
	22	/*
	23	* Cthreads.
	24	*/
	25
	26	#ifndef _CTHREADS_
	27	#define _CTHREADS_ 1
	28
	29	#if defined(__cplusplus)
	30	#define __DECLBEGIN extern "C" {
	31	#define __DECLEND }
	32	#else
	33	#define __DECLBEGIN
	34	#define __DECLEND
	35	#endif
	36
	37	typedef void *any_t;
	38
	39	/*
	40	* Spin locks.
	41	*/
	42	__DECLBEGIN
	43	extern void spin_unlock(int *p);
	44	extern void spin_lock(int *p);
	45	__DECLEND
	46
	47	#include <mach/mach_types.h>
	48	#include <mach/boolean.h>
	49
	50	#ifndef MACRO_BEGIN
	51
	52	#define NEVER FALSE
	53
	54	#define MACRO_BEGIN do {
	55	#define MACRO_END } while (NEVER)
	56
	57	#endif /* MACRO_BEGIN */
	58
	59	/*
	60	* C Threads package initialization.
	61	*/
	62	__DECLBEGIN
	63	extern void cthread_init();
	64	__DECLEND
65
66	#include <stdlib.h>
67
68	/*
69	* Queues.
70	*/
71	typedef struct cthread_queue {
72	struct cthread_queue_item *head;
73	struct cthread_queue_item *tail;
74	} *cthread_queue_t;
75
76	typedef struct cthread_queue_item {
77	struct cthread_queue_item *next;
78	} *cthread_queue_item_t;
79
80	#define NO_QUEUE_ITEM ((cthread_queue_item_t) 0)
81
82	#define QUEUE_INITIALIZER { NO_QUEUE_ITEM, NO_QUEUE_ITEM }
83
84	#define cthread_queue_alloc() ((cthread_queue_t) calloc(1, sizeof(struct cthread_queue)))
85	#define cthread_queue_init(q) ((q)->head = (q)->tail = 0)
86	#define cthread_queue_free(q) free((any_t) (q))
87
88	#define cthread_queue_enq(q, x) \
89	MACRO_BEGIN \
90	(x)->next = 0; \
91	if ((q)->tail == 0) \
92	(q)->head = (cthread_queue_item_t) (x); \
93	else \
94	(q)->tail->next = (cthread_queue_item_t) (x); \
95	(q)->tail = (cthread_queue_item_t) (x); \
96	MACRO_END
97
98	#define cthread_queue_preq(q, x) \
99	MACRO_BEGIN \
100	if ((q)->tail == 0) \
101	(q)->tail = (cthread_queue_item_t) (x); \
102	((cthread_queue_item_t) (x))->next = (q)->head; \
103	(q)->head = (cthread_queue_item_t) (x); \
104	MACRO_END
105
106	#define cthread_queue_head(q, t) ((t) ((q)->head))
107
108	#define cthread_queue_deq(q, t, x) \
109	MACRO_BEGIN \
110	if (((x) = (t) ((q)->head)) != 0 && \
111	((q)->head = (cthread_queue_item_t) ((x)->next)) == 0) \
112	(q)->tail = 0; \
113	MACRO_END
114
115	#define cthread_queue_map(q, t, f) \
116	MACRO_BEGIN \
117	register cthread_queue_item_t x, next; \
118	for (x = (cthread_queue_item_t) ((q)->head); x != 0; x = next) { \
119	next = x->next; \
120	(*(f))((t) x); \
121	} \
122	MACRO_END
123
124
125	/*
126	* Mutex objects.
127	*/
128	typedef struct mutex {
129	int lock;
130	char *name;
131	} *mutex_t;
132
133	#define MUTEX_INITIALIZER { 0, 0 }
134
135	#define mutex_alloc() ((mutex_t) calloc(1, sizeof(struct mutex)))
136	#define mutex_init(m) ((m)->lock = 0)
137	#define mutex_set_name(m, x) ((m)->name = (x))
138	#define mutex_name(m) ((m)->name != 0 ? (m)->name : "?")
139	#define mutex_clear(m) /* nop */
140	#define mutex_free(m) free((any_t) (m))
141
142	#define mutex_lock(m) \
143	MACRO_BEGIN \
144	if (! mutex_try_lock(m)) mutex_wait_lock(m); \
145	MACRO_END
146
147	__DECLBEGIN
148	extern int mutex_try_lock(mutex_t m); /* nonblocking */
149	extern void mutex_wait_lock(mutex_t m); /* blocking */
150	extern void mutex_unlock(mutex_t m);
151	__DECLEND
152
153	/*
154	* Condition variables.
155	*/
156	typedef struct condition {
157	int lock;
158	struct cthread_queue queue;
159	char *name;
160	} *condition_t;
161
162	#define CONDITION_INITIALIZER { 0, QUEUE_INITIALIZER, 0 }
163
164	#define condition_alloc() ((condition_t) calloc(1, sizeof(struct condition)))
165	#define condition_init(c) MACRO_BEGIN (c)->lock = 0; cthread_queue_init(&(c)->queue); MACRO_END
166	#define condition_set_name(c, x) ((c)->name = (x))
167	#define condition_name(c) ((c)->name != 0 ? (c)->name : "?")
168	#define condition_clear(c) MACRO_BEGIN condition_broadcast(c); spin_lock(&(c)->lock); MACRO_END
169	#define condition_free(c) MACRO_BEGIN condition_clear(c); free((any_t) (c)); MACRO_END
170
171	#define condition_signal(c) \
172	MACRO_BEGIN \
173	if ((c)->queue.head) cond_signal(c); \
174	MACRO_END
175
176	#define condition_broadcast(c) \
177	MACRO_BEGIN \
178	if ((c)->queue.head) cond_broadcast(c); \
179	MACRO_END
180
181	__DECLBEGIN
182	extern void cond_signal(condition_t c);
183	extern void cond_broadcast(condition_t c);
184	extern void condition_wait(condition_t c, mutex_t m);
185	__DECLEND
186
187	/*
188	* Threads.
189	*/
190
191	typedef any_t (*cthread_fn_t)(any_t arg);
192
193	#import <setjmp.h>
194
195	typedef struct cthread {
196	struct cthread *next;
197	thread_port_t real_thread;
198	struct mutex lock;
199	struct condition done;
200	int state;
201	#if defined(__cplusplus)
202	jmp_buf catchBuf;
203	#else
204	jmp_buf catch;
205	#endif
206	cthread_fn_t func;
207	any_t arg;
208	any_t result;
209	const char *name;
210	any_t data;
211	} *cthread_t;
212
213	#define NO_CTHREAD ((cthread_t) 0)
214
215	__DECLBEGIN
216	extern cthread_t cthread_fork(cthread_fn_t func, any_t arg);
217	extern void cthread_detach(cthread_t t);
218	extern any_t cthread_join(cthread_t t);
219	extern void cthread_yield(void);
220	extern void cthread_exit(any_t result);
221	extern kern_return_t cthread_priority(
222	cthread_t t,
223	int priority,
224	boolean_t set_max);
225	extern kern_return_t cthread_max_priority(
226	cthread_t t,
227	mach_port_t pset,
228	int max_priority);
229	extern kern_return_t cthread_abort(cthread_t t);
230	__DECLEND
231
232	/*
233	* This structure must agree with struct cproc in cthread_internals.h
234	*/
235	typedef struct ur_cthread {
236	struct ur_cthread *next;
237	cthread_t incarnation;
238	} *ur_cthread_t;
239
240	__DECLBEGIN
241	extern int cthread_sp(void);
242
243	extern int cthread_stack_mask;
244
245	extern ur_cthread_t ur_cthread_self(void);
246	#define cthread_thread(c) (c->real_thread)
247	extern void cthread_set_errno_self(int e);
248	extern int cthread_errno(void);
249	#define cthread_assoc(id, t) (((ur_cthread_t) (id))->incarnation = (t))
250	#define cthread_self() (ur_cthread_self()->incarnation)
251
252	extern void cthread_set_name(cthread_t t, const char *name);
253	extern const char *cthread_name(cthread_t t);
254	extern int cthread_count(void);
255	extern void cthread_set_limit(int n);
256	extern int cthread_limit(void);
257	__DECLEND
258
259	#define cthread_set_data(t, x) ((t)->data = (x))
260	#define cthread_data(t) ((t)->data)
261
262	/*
263	* Spin locks.
264	*/
265	#define spin_unlock(p) (*(p) = 0)
266
267	/*
268	* Mutex locks.
269	*/
270	#define mutex_unlock(m) ((m)->lock = 0)
271
272
273	/*
274	* Debugging support.
275	*/
276	#ifdef CTHREADS_DEBUG
277
278	#ifndef ASSERT
279	/*
280	* Assertion macro, similar to <assert.h>
281	*/
282	#import <stdio.h>
283	#define ASSERT(p) \
284	MACRO_BEGIN \
285	if (!(p)) { \
286	fprintf(stderr, \
287	"File %s, line %d: assertion p failed.\n", \
288	__FILE__, __LINE__); \
289	abort(); \
290	} \
291	MACRO_END
292
293	#endif /* ASSERT */
294
295	#define SHOULDNT_HAPPEN 0
296
297	extern int cthread_debug;
298
299	#else /* CTHREADS_DEBUG */
300
301	#ifndef ASSERT
302	#define ASSERT(p)
303	#endif /* ASSERT */
304
305	#endif /* CTHREADS_DEBUG */
306
307	#endif /* _CTHREADS_ */