|
1 |
|
2 #ifdef MACH_C_THREADS |
|
3 #include <mach/cthreads.h> |
|
4 #endif |
|
5 |
|
6 #ifdef HURD_C_THREADS |
|
7 #include <cthreads.h> |
|
8 #endif |
|
9 |
|
10 /* |
|
11 * Initialization. |
|
12 */ |
|
13 static void |
|
14 PyThread__init_thread(void) |
|
15 { |
|
16 #ifndef HURD_C_THREADS |
|
17 /* Roland McGrath said this should not be used since this is |
|
18 done while linking to threads */ |
|
19 cthread_init(); |
|
20 #else |
|
21 /* do nothing */ |
|
22 ; |
|
23 #endif |
|
24 } |
|
25 |
|
26 /* |
|
27 * Thread support. |
|
28 */ |
|
29 long |
|
30 PyThread_start_new_thread(void (*func)(void *), void *arg) |
|
31 { |
|
32 int success = 0; /* init not needed when SOLARIS_THREADS and */ |
|
33 /* C_THREADS implemented properly */ |
|
34 |
|
35 dprintf(("PyThread_start_new_thread called\n")); |
|
36 if (!initialized) |
|
37 PyThread_init_thread(); |
|
38 /* looks like solaris detaches the thread to never rejoin |
|
39 * so well do it here |
|
40 */ |
|
41 cthread_detach(cthread_fork((cthread_fn_t) func, arg)); |
|
42 return success < 0 ? -1 : 0; |
|
43 } |
|
44 |
|
45 long |
|
46 PyThread_get_thread_ident(void) |
|
47 { |
|
48 if (!initialized) |
|
49 PyThread_init_thread(); |
|
50 return (long) cthread_self(); |
|
51 } |
|
52 |
|
53 static void |
|
54 do_PyThread_exit_thread(int no_cleanup) |
|
55 { |
|
56 dprintf(("PyThread_exit_thread called\n")); |
|
57 if (!initialized) |
|
58 if (no_cleanup) |
|
59 _exit(0); |
|
60 else |
|
61 exit(0); |
|
62 cthread_exit(0); |
|
63 } |
|
64 |
|
65 void |
|
66 PyThread_exit_thread(void) |
|
67 { |
|
68 do_PyThread_exit_thread(0); |
|
69 } |
|
70 |
|
71 void |
|
72 PyThread__exit_thread(void) |
|
73 { |
|
74 do_PyThread_exit_thread(1); |
|
75 } |
|
76 |
|
77 #ifndef NO_EXIT_PROG |
|
78 static |
|
79 void do_PyThread_exit_prog(int status, int no_cleanup) |
|
80 { |
|
81 dprintf(("PyThread_exit_prog(%d) called\n", status)); |
|
82 if (!initialized) |
|
83 if (no_cleanup) |
|
84 _exit(status); |
|
85 else |
|
86 exit(status); |
|
87 if (no_cleanup) |
|
88 _exit(status); |
|
89 else |
|
90 exit(status); |
|
91 } |
|
92 |
|
93 void |
|
94 PyThread_exit_prog(int status) |
|
95 { |
|
96 do_PyThread_exit_prog(status, 0); |
|
97 } |
|
98 |
|
99 void |
|
100 PyThread__exit_prog(int status) |
|
101 { |
|
102 do_PyThread_exit_prog(status, 1); |
|
103 } |
|
104 #endif /* NO_EXIT_PROG */ |
|
105 |
|
106 /* |
|
107 * Lock support. |
|
108 */ |
|
109 PyThread_type_lock |
|
110 PyThread_allocate_lock(void) |
|
111 { |
|
112 mutex_t lock; |
|
113 |
|
114 dprintf(("PyThread_allocate_lock called\n")); |
|
115 if (!initialized) |
|
116 PyThread_init_thread(); |
|
117 |
|
118 lock = mutex_alloc(); |
|
119 if (mutex_init(lock)) { |
|
120 perror("mutex_init"); |
|
121 free((void *) lock); |
|
122 lock = 0; |
|
123 } |
|
124 dprintf(("PyThread_allocate_lock() -> %p\n", lock)); |
|
125 return (PyThread_type_lock) lock; |
|
126 } |
|
127 |
|
128 void |
|
129 PyThread_free_lock(PyThread_type_lock lock) |
|
130 { |
|
131 dprintf(("PyThread_free_lock(%p) called\n", lock)); |
|
132 mutex_free(lock); |
|
133 } |
|
134 |
|
135 int |
|
136 PyThread_acquire_lock(PyThread_type_lock lock, int waitflag) |
|
137 { |
|
138 int success = FALSE; |
|
139 |
|
140 dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag)); |
|
141 if (waitflag) { /* blocking */ |
|
142 mutex_lock((mutex_t)lock); |
|
143 success = TRUE; |
|
144 } else { /* non blocking */ |
|
145 success = mutex_try_lock((mutex_t)lock); |
|
146 } |
|
147 dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success)); |
|
148 return success; |
|
149 } |
|
150 |
|
151 void |
|
152 PyThread_release_lock(PyThread_type_lock lock) |
|
153 { |
|
154 dprintf(("PyThread_release_lock(%p) called\n", lock)); |
|
155 mutex_unlock((mutex_t )lock); |
|
156 } |