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_lwp.h (1 of 3706 files). Show all

Unified · Split

sys/src/cmd/python/Python/thread_lwp.h+149−0
@@ -0,0 +1,149 @@
1+
2+#include <stdlib.h>
3+#include <lwp/lwp.h>
4+#include <lwp/stackdep.h>
5+
6+#define STACKSIZE 1000 /* stacksize for a thread */
7+#define NSTACKS 2 /* # stacks to be put in cache initially */
8+
9+struct lock {
10+ int lock_locked;
11+ cv_t lock_condvar;
12+ mon_t lock_monitor;
13+};
14+
15+
16+/*
17+ * Initialization.
18+ */
19+static void PyThread__init_thread(void)
20+{
21+ lwp_setstkcache(STACKSIZE, NSTACKS);
22+}
23+
24+/*
25+ * Thread support.
26+ */
27+
28+
29+long PyThread_start_new_thread(void (*func)(void *), void *arg)
30+{
31+ thread_t tid;
32+ int success;
33+ dprintf(("PyThread_start_new_thread called\n"));
34+ if (!initialized)
35+ PyThread_init_thread();
36+ success = lwp_create(&tid, func, MINPRIO, 0, lwp_newstk(), 1, arg);
37+ return success < 0 ? -1 : 0;
38+}
39+
40+long PyThread_get_thread_ident(void)
41+{
42+ thread_t tid;
43+ if (!initialized)
44+ PyThread_init_thread();
45+ if (lwp_self(&tid) < 0)
46+ return -1;
47+ return tid.thread_id;
48+}
49+
50+static void do_PyThread_exit_thread(int no_cleanup)
51+{
52+ dprintf(("PyThread_exit_thread called\n"));
53+ if (!initialized)
54+ if (no_cleanup)
55+ _exit(0);
56+ else
57+ exit(0);
58+ lwp_destroy(SELF);
59+}
60+
61+void PyThread_exit_thread(void)
62+{
63+ do_PyThread_exit_thread(0);
64+}
65+
66+void PyThread__exit_thread(void)
67+{
68+ do_PyThread_exit_thread(1);
69+}
70+
71+#ifndef NO_EXIT_PROG
72+static void do_PyThread_exit_prog(int status, int no_cleanup)
73+{
74+ dprintf(("PyThread_exit_prog(%d) called\n", status));
75+ if (!initialized)
76+ if (no_cleanup)
77+ _exit(status);
78+ else
79+ exit(status);
80+ pod_exit(status);
81+}
82+
83+void PyThread_exit_prog(int status)
84+{
85+ do_PyThread_exit_prog(status, 0);
86+}
87+
88+void PyThread__exit_prog(int status)
89+{
90+ do_PyThread_exit_prog(status, 1);
91+}
92+#endif /* NO_EXIT_PROG */
93+
94+/*
95+ * Lock support.
96+ */
97+PyThread_type_lock PyThread_allocate_lock(void)
98+{
99+ struct lock *lock;
100+ extern char *malloc(size_t);
101+
102+ dprintf(("PyThread_allocate_lock called\n"));
103+ if (!initialized)
104+ PyThread_init_thread();
105+
106+ lock = (struct lock *) malloc(sizeof(struct lock));
107+ lock->lock_locked = 0;
108+ (void) mon_create(&lock->lock_monitor);
109+ (void) cv_create(&lock->lock_condvar, lock->lock_monitor);
110+ dprintf(("PyThread_allocate_lock() -> %p\n", lock));
111+ return (PyThread_type_lock) lock;
112+}
113+
114+void PyThread_free_lock(PyThread_type_lock lock)
115+{
116+ dprintf(("PyThread_free_lock(%p) called\n", lock));
117+ mon_destroy(((struct lock *) lock)->lock_monitor);
118+ free((char *) lock);
119+}
120+
121+int PyThread_acquire_lock(PyThread_type_lock lock, int waitflag)
122+{
123+ int success;
124+
125+ dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
126+ success = 0;
127+
128+ (void) mon_enter(((struct lock *) lock)->lock_monitor);
129+ if (waitflag)
130+ while (((struct lock *) lock)->lock_locked)
131+ cv_wait(((struct lock *) lock)->lock_condvar);
132+ if (!((struct lock *) lock)->lock_locked) {
133+ success = 1;
134+ ((struct lock *) lock)->lock_locked = 1;
135+ }
136+ cv_broadcast(((struct lock *) lock)->lock_condvar);
137+ mon_exit(((struct lock *) lock)->lock_monitor);
138+ dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
139+ return success;
140+}
141+
142+void PyThread_release_lock(PyThread_type_lock lock)
143+{
144+ dprintf(("PyThread_release_lock(%p) called\n", lock));
145+ (void) mon_enter(((struct lock *) lock)->lock_monitor);
146+ ((struct lock *) lock)->lock_locked = 0;
147+ cv_broadcast(((struct lock *) lock)->lock_condvar);
148+ mon_exit(((struct lock *) lock)->lock_monitor);
149+}