History

add hg and python

cinap_lenrek committed 15 years ago

Commit 4bb9e221 parent 987265c3706 files · +1228772 −-233Browse files

Showing the changes to sys/src/cmd/python/Python/thread_atheos.h (1 of 3706 files). Show all

Unified · Split

sys/src/cmd/python/Python/thread_atheos.h+300−0
@@ -0,0 +1,300 @@
1+/* Threading for AtheOS.
2+ Based on thread_beos.h. */
3+
4+#include <atheos/threads.h>
5+#include <atheos/semaphore.h>
6+#include <atheos/atomic.h>
7+#include <errno.h>
8+#include <string.h>
9+
10+/* Missing decl from threads.h */
11+extern int exit_thread(int);
12+
13+
14+/* Undefine FASTLOCK to play with simple semaphores. */
15+#define FASTLOCK
16+
17+
18+#ifdef FASTLOCK
19+
20+/* Use an atomic counter and a semaphore for maximum speed. */
21+typedef struct fastmutex {
22+ sem_id sem;
23+ atomic_t count;
24+} fastmutex_t;
25+
26+
27+static int fastmutex_create(const char *name, fastmutex_t * mutex);
28+static int fastmutex_destroy(fastmutex_t * mutex);
29+static int fastmutex_lock(fastmutex_t * mutex);
30+static int fastmutex_timedlock(fastmutex_t * mutex, bigtime_t timeout);
31+static int fastmutex_unlock(fastmutex_t * mutex);
32+
33+
34+static int fastmutex_create(const char *name, fastmutex_t * mutex)
35+{
36+ mutex->count = 0;
37+ mutex->sem = create_semaphore(name, 0, 0);
38+ return (mutex->sem < 0) ? -1 : 0;
39+}
40+
41+
42+static int fastmutex_destroy(fastmutex_t * mutex)
43+{
44+ if (fastmutex_timedlock(mutex, 0) == 0 || errno == EWOULDBLOCK) {
45+ return delete_semaphore(mutex->sem);
46+ }
47+ return 0;
48+}
49+
50+
51+static int fastmutex_lock(fastmutex_t * mutex)
52+{
53+ atomic_t prev = atomic_add(&mutex->count, 1);
54+ if (prev > 0)
55+ return lock_semaphore(mutex->sem);
56+ return 0;
57+}
58+
59+
60+static int fastmutex_timedlock(fastmutex_t * mutex, bigtime_t timeout)
61+{
62+ atomic_t prev = atomic_add(&mutex->count, 1);
63+ if (prev > 0)
64+ return lock_semaphore_x(mutex->sem, 1, 0, timeout);
65+ return 0;
66+}
67+
68+
69+static int fastmutex_unlock(fastmutex_t * mutex)
70+{
71+ atomic_t prev = atomic_add(&mutex->count, -1);
72+ if (prev > 1)
73+ return unlock_semaphore(mutex->sem);
74+ return 0;
75+}
76+
77+
78+#endif /* FASTLOCK */
79+
80+
81+/*
82+ * Initialization.
83+ *
84+ */
85+static void PyThread__init_thread(void)
86+{
87+ /* Do nothing. */
88+ return;
89+}
90+
91+
92+/*
93+ * Thread support.
94+ *
95+ */
96+
97+static atomic_t thread_count = 0;
98+
99+long PyThread_start_new_thread(void (*func) (void *), void *arg)
100+{
101+ status_t success = -1;
102+ thread_id tid;
103+ char name[OS_NAME_LENGTH];
104+ atomic_t this_thread;
105+
106+ dprintf(("PyThread_start_new_thread called\n"));
107+
108+ this_thread = atomic_add(&thread_count, 1);
109+ PyOS_snprintf(name, sizeof(name), "python thread (%d)", this_thread);
110+
111+ tid = spawn_thread(name, func, NORMAL_PRIORITY, 0, arg);
112+ if (tid < 0) {
113+ dprintf(("PyThread_start_new_thread spawn_thread failed: %s\n", strerror(errno)));
114+ } else {
115+ success = resume_thread(tid);
116+ if (success < 0) {
117+ dprintf(("PyThread_start_new_thread resume_thread failed: %s\n", strerror(errno)));
118+ }
119+ }
120+
121+ return (success < 0 ? -1 : tid);
122+}
123+
124+
125+long PyThread_get_thread_ident(void)
126+{
127+ return get_thread_id(NULL);
128+}
129+
130+
131+static void do_PyThread_exit_thread(int no_cleanup)
132+{
133+ dprintf(("PyThread_exit_thread called\n"));
134+
135+ /* Thread-safe way to read a variable without a mutex: */
136+ if (atomic_add(&thread_count, 0) == 0) {
137+ /* No threads around, so exit main(). */
138+ if (no_cleanup)
139+ _exit(0);
140+ else
141+ exit(0);
142+ } else {
143+ /* We're a thread */
144+ exit_thread(0);
145+ }
146+}
147+
148+
149+void PyThread_exit_thread(void)
150+{
151+ do_PyThread_exit_thread(0);
152+}
153+
154+
155+void PyThread__exit_thread(void)
156+{
157+ do_PyThread_exit_thread(1);
158+}
159+
160+
161+#ifndef NO_EXIT_PROG
162+static void do_PyThread_exit_prog(int status, int no_cleanup)
163+{
164+ dprintf(("PyThread_exit_prog(%d) called\n", status));
165+
166+ /* No need to do anything, the threads get torn down if main()exits. */
167+ if (no_cleanup)
168+ _exit(status);
169+ else
170+ exit(status);
171+}
172+
173+
174+void PyThread_exit_prog(int status)
175+{
176+ do_PyThread_exit_prog(status, 0);
177+}
178+
179+
180+void PyThread__exit_prog(int status)
181+{
182+ do_PyThread_exit_prog(status, 1);
183+}
184+#endif /* NO_EXIT_PROG */
185+
186+
187+/*
188+ * Lock support.
189+ *
190+ */
191+
192+static atomic_t lock_count = 0;
193+
194+PyThread_type_lock PyThread_allocate_lock(void)
195+{
196+#ifdef FASTLOCK
197+ fastmutex_t *lock;
198+#else
199+ sem_id sema;
200+#endif
201+ char name[OS_NAME_LENGTH];
202+ atomic_t this_lock;
203+
204+ dprintf(("PyThread_allocate_lock called\n"));
205+
206+#ifdef FASTLOCK
207+ lock = (fastmutex_t *) malloc(sizeof(fastmutex_t));
208+ if (lock == NULL) {
209+ dprintf(("PyThread_allocate_lock failed: out of memory\n"));
210+ return (PyThread_type_lock) NULL;
211+ }
212+#endif
213+ this_lock = atomic_add(&lock_count, 1);
214+ PyOS_snprintf(name, sizeof(name), "python lock (%d)", this_lock);
215+
216+#ifdef FASTLOCK
217+ if (fastmutex_create(name, lock) < 0) {
218+ dprintf(("PyThread_allocate_lock failed: %s\n",
219+ strerror(errno)));
220+ free(lock);
221+ lock = NULL;
222+ }
223+ dprintf(("PyThread_allocate_lock()-> %p\n", lock));
224+ return (PyThread_type_lock) lock;
225+#else
226+ sema = create_semaphore(name, 1, 0);
227+ if (sema < 0) {
228+ dprintf(("PyThread_allocate_lock failed: %s\n",
229+ strerror(errno)));
230+ sema = 0;
231+ }
232+ dprintf(("PyThread_allocate_lock()-> %p\n", sema));
233+ return (PyThread_type_lock) sema;
234+#endif
235+}
236+
237+
238+void PyThread_free_lock(PyThread_type_lock lock)
239+{
240+ dprintf(("PyThread_free_lock(%p) called\n", lock));
241+
242+#ifdef FASTLOCK
243+ if (fastmutex_destroy((fastmutex_t *) lock) < 0) {
244+ dprintf(("PyThread_free_lock(%p) failed: %s\n", lock,
245+ strerror(errno)));
246+ }
247+ free(lock);
248+#else
249+ if (delete_semaphore((sem_id) lock) < 0) {
250+ dprintf(("PyThread_free_lock(%p) failed: %s\n", lock,
251+ strerror(errno)));
252+ }
253+#endif
254+}
255+
256+
257+int PyThread_acquire_lock(PyThread_type_lock lock, int waitflag)
258+{
259+ int retval;
260+
261+ dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock,
262+ waitflag));
263+
264+#ifdef FASTLOCK
265+ if (waitflag)
266+ retval = fastmutex_lock((fastmutex_t *) lock);
267+ else
268+ retval = fastmutex_timedlock((fastmutex_t *) lock, 0);
269+#else
270+ if (waitflag)
271+ retval = lock_semaphore((sem_id) lock);
272+ else
273+ retval = lock_semaphore_x((sem_id) lock, 1, 0, 0);
274+#endif
275+ if (retval < 0) {
276+ dprintf(("PyThread_acquire_lock(%p, %d) failed: %s\n",
277+ lock, waitflag, strerror(errno)));
278+ }
279+ dprintf(("PyThread_acquire_lock(%p, %d)-> %d\n", lock, waitflag,
280+ retval));
281+ return retval < 0 ? 0 : 1;
282+}
283+
284+
285+void PyThread_release_lock(PyThread_type_lock lock)
286+{
287+ dprintf(("PyThread_release_lock(%p) called\n", lock));
288+
289+#ifdef FASTLOCK
290+ if (fastmutex_unlock((fastmutex_t *) lock) < 0) {
291+ dprintf(("PyThread_release_lock(%p) failed: %s\n", lock,
292+ strerror(errno)));
293+ }
294+#else
295+ if (unlock_semaphore((sem_id) lock) < 0) {
296+ dprintf(("PyThread_release_lock(%p) failed: %s\n", lock,
297+ strerror(errno)));
298+ }
299+#endif
300+}

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t