|
1 |
|
2 /* Thread module */ |
|
3 /* Interface to Sjoerd's portable C thread library */ |
|
4 |
|
5 #include "Python.h" |
|
6 |
|
7 #ifndef WITH_THREAD |
|
8 #error "Error! The rest of Python is not compiled with thread support." |
|
9 #error "Rerun configure, adding a --with-threads option." |
|
10 #error "Then run `make clean' followed by `make'." |
|
11 #endif |
|
12 |
|
13 #include "pythread.h" |
|
14 |
|
15 static PyObject *ThreadError; |
|
16 |
|
17 |
|
18 /* Lock objects */ |
|
19 |
|
20 typedef struct { |
|
21 PyObject_HEAD |
|
22 PyThread_type_lock lock_lock; |
|
23 } lockobject; |
|
24 |
|
25 static void |
|
26 lock_dealloc(lockobject *self) |
|
27 { |
|
28 assert(self->lock_lock); |
|
29 /* Unlock the lock so it's safe to free it */ |
|
30 PyThread_acquire_lock(self->lock_lock, 0); |
|
31 PyThread_release_lock(self->lock_lock); |
|
32 |
|
33 PyThread_free_lock(self->lock_lock); |
|
34 PyObject_Del(self); |
|
35 } |
|
36 |
|
37 static PyObject * |
|
38 lock_PyThread_acquire_lock(lockobject *self, PyObject *args) |
|
39 { |
|
40 int i = 1; |
|
41 |
|
42 if (!PyArg_ParseTuple(args, "|i:acquire", &i)) |
|
43 return NULL; |
|
44 |
|
45 Py_BEGIN_ALLOW_THREADS |
|
46 i = PyThread_acquire_lock(self->lock_lock, i); |
|
47 Py_END_ALLOW_THREADS |
|
48 |
|
49 return PyBool_FromLong((long)i); |
|
50 } |
|
51 |
|
52 PyDoc_STRVAR(acquire_doc, |
|
53 "acquire([wait]) -> None or bool\n\ |
|
54 (acquire_lock() is an obsolete synonym)\n\ |
|
55 \n\ |
|
56 Lock the lock. Without argument, this blocks if the lock is already\n\ |
|
57 locked (even by the same thread), waiting for another thread to release\n\ |
|
58 the lock, and return None once the lock is acquired.\n\ |
|
59 With an argument, this will only block if the argument is true,\n\ |
|
60 and the return value reflects whether the lock is acquired.\n\ |
|
61 The blocking operation is not interruptible."); |
|
62 |
|
63 static PyObject * |
|
64 lock_PyThread_release_lock(lockobject *self) |
|
65 { |
|
66 /* Sanity check: the lock must be locked */ |
|
67 if (PyThread_acquire_lock(self->lock_lock, 0)) { |
|
68 PyThread_release_lock(self->lock_lock); |
|
69 PyErr_SetString(ThreadError, "release unlocked lock"); |
|
70 return NULL; |
|
71 } |
|
72 |
|
73 PyThread_release_lock(self->lock_lock); |
|
74 Py_INCREF(Py_None); |
|
75 return Py_None; |
|
76 } |
|
77 |
|
78 PyDoc_STRVAR(release_doc, |
|
79 "release()\n\ |
|
80 (release_lock() is an obsolete synonym)\n\ |
|
81 \n\ |
|
82 Release the lock, allowing another thread that is blocked waiting for\n\ |
|
83 the lock to acquire the lock. The lock must be in the locked state,\n\ |
|
84 but it needn't be locked by the same thread that unlocks it."); |
|
85 |
|
86 static PyObject * |
|
87 lock_locked_lock(lockobject *self) |
|
88 { |
|
89 if (PyThread_acquire_lock(self->lock_lock, 0)) { |
|
90 PyThread_release_lock(self->lock_lock); |
|
91 return PyBool_FromLong(0L); |
|
92 } |
|
93 return PyBool_FromLong(1L); |
|
94 } |
|
95 |
|
96 PyDoc_STRVAR(locked_doc, |
|
97 "locked() -> bool\n\ |
|
98 (locked_lock() is an obsolete synonym)\n\ |
|
99 \n\ |
|
100 Return whether the lock is in the locked state."); |
|
101 |
|
102 static PyMethodDef lock_methods[] = { |
|
103 {"acquire_lock", (PyCFunction)lock_PyThread_acquire_lock, |
|
104 METH_VARARGS, acquire_doc}, |
|
105 {"acquire", (PyCFunction)lock_PyThread_acquire_lock, |
|
106 METH_VARARGS, acquire_doc}, |
|
107 {"release_lock", (PyCFunction)lock_PyThread_release_lock, |
|
108 METH_NOARGS, release_doc}, |
|
109 {"release", (PyCFunction)lock_PyThread_release_lock, |
|
110 METH_NOARGS, release_doc}, |
|
111 {"locked_lock", (PyCFunction)lock_locked_lock, |
|
112 METH_NOARGS, locked_doc}, |
|
113 {"locked", (PyCFunction)lock_locked_lock, |
|
114 METH_NOARGS, locked_doc}, |
|
115 {"__enter__", (PyCFunction)lock_PyThread_acquire_lock, |
|
116 METH_VARARGS, acquire_doc}, |
|
117 {"__exit__", (PyCFunction)lock_PyThread_release_lock, |
|
118 METH_VARARGS, release_doc}, |
|
119 {NULL, NULL} /* sentinel */ |
|
120 }; |
|
121 |
|
122 static PyObject * |
|
123 lock_getattr(lockobject *self, char *name) |
|
124 { |
|
125 return Py_FindMethod(lock_methods, (PyObject *)self, name); |
|
126 } |
|
127 |
|
128 static PyTypeObject Locktype = { |
|
129 PyVarObject_HEAD_INIT(&PyType_Type, 0) |
|
130 "thread.lock", /*tp_name*/ |
|
131 sizeof(lockobject), /*tp_size*/ |
|
132 0, /*tp_itemsize*/ |
|
133 /* methods */ |
|
134 (destructor)lock_dealloc, /*tp_dealloc*/ |
|
135 0, /*tp_print*/ |
|
136 (getattrfunc)lock_getattr, /*tp_getattr*/ |
|
137 0, /*tp_setattr*/ |
|
138 0, /*tp_compare*/ |
|
139 0, /*tp_repr*/ |
|
140 }; |
|
141 |
|
142 static lockobject * |
|
143 newlockobject(void) |
|
144 { |
|
145 lockobject *self; |
|
146 self = PyObject_New(lockobject, &Locktype); |
|
147 if (self == NULL) |
|
148 return NULL; |
|
149 self->lock_lock = PyThread_allocate_lock(); |
|
150 if (self->lock_lock == NULL) { |
|
151 PyObject_Del(self); |
|
152 self = NULL; |
|
153 PyErr_SetString(ThreadError, "can't allocate lock"); |
|
154 } |
|
155 return self; |
|
156 } |
|
157 |
|
158 /* Thread-local objects */ |
|
159 |
|
160 #include "structmember.h" |
|
161 |
|
162 typedef struct { |
|
163 PyObject_HEAD |
|
164 PyObject *key; |
|
165 PyObject *args; |
|
166 PyObject *kw; |
|
167 PyObject *dict; |
|
168 } localobject; |
|
169 |
|
170 static PyObject * |
|
171 local_new(PyTypeObject *type, PyObject *args, PyObject *kw) |
|
172 { |
|
173 localobject *self; |
|
174 PyObject *tdict; |
|
175 |
|
176 if (type->tp_init == PyBaseObject_Type.tp_init |
|
177 && ((args && PyObject_IsTrue(args)) |
|
178 || (kw && PyObject_IsTrue(kw)))) { |
|
179 PyErr_SetString(PyExc_TypeError, |
|
180 "Initialization arguments are not supported"); |
|
181 return NULL; |
|
182 } |
|
183 |
|
184 self = (localobject *)type->tp_alloc(type, 0); |
|
185 if (self == NULL) |
|
186 return NULL; |
|
187 |
|
188 Py_XINCREF(args); |
|
189 self->args = args; |
|
190 Py_XINCREF(kw); |
|
191 self->kw = kw; |
|
192 self->dict = NULL; /* making sure */ |
|
193 self->key = PyString_FromFormat("thread.local.%p", self); |
|
194 if (self->key == NULL) |
|
195 goto err; |
|
196 |
|
197 self->dict = PyDict_New(); |
|
198 if (self->dict == NULL) |
|
199 goto err; |
|
200 |
|
201 tdict = PyThreadState_GetDict(); |
|
202 if (tdict == NULL) { |
|
203 PyErr_SetString(PyExc_SystemError, |
|
204 "Couldn't get thread-state dictionary"); |
|
205 goto err; |
|
206 } |
|
207 |
|
208 if (PyDict_SetItem(tdict, self->key, self->dict) < 0) |
|
209 goto err; |
|
210 |
|
211 return (PyObject *)self; |
|
212 |
|
213 err: |
|
214 Py_DECREF(self); |
|
215 return NULL; |
|
216 } |
|
217 |
|
218 static int |
|
219 local_traverse(localobject *self, visitproc visit, void *arg) |
|
220 { |
|
221 Py_VISIT(self->args); |
|
222 Py_VISIT(self->kw); |
|
223 Py_VISIT(self->dict); |
|
224 return 0; |
|
225 } |
|
226 |
|
227 static int |
|
228 local_clear(localobject *self) |
|
229 { |
|
230 Py_CLEAR(self->key); |
|
231 Py_CLEAR(self->args); |
|
232 Py_CLEAR(self->kw); |
|
233 Py_CLEAR(self->dict); |
|
234 return 0; |
|
235 } |
|
236 |
|
237 static void |
|
238 local_dealloc(localobject *self) |
|
239 { |
|
240 PyThreadState *tstate; |
|
241 if (self->key |
|
242 && (tstate = PyThreadState_Get()) |
|
243 && tstate->interp) { |
|
244 for(tstate = PyInterpreterState_ThreadHead(tstate->interp); |
|
245 tstate; |
|
246 tstate = PyThreadState_Next(tstate)) |
|
247 if (tstate->dict && |
|
248 PyDict_GetItem(tstate->dict, self->key)) |
|
249 PyDict_DelItem(tstate->dict, self->key); |
|
250 } |
|
251 |
|
252 local_clear(self); |
|
253 Py_TYPE(self)->tp_free((PyObject*)self); |
|
254 } |
|
255 |
|
256 static PyObject * |
|
257 _ldict(localobject *self) |
|
258 { |
|
259 PyObject *tdict, *ldict; |
|
260 |
|
261 tdict = PyThreadState_GetDict(); |
|
262 if (tdict == NULL) { |
|
263 PyErr_SetString(PyExc_SystemError, |
|
264 "Couldn't get thread-state dictionary"); |
|
265 return NULL; |
|
266 } |
|
267 |
|
268 ldict = PyDict_GetItem(tdict, self->key); |
|
269 if (ldict == NULL) { |
|
270 ldict = PyDict_New(); /* we own ldict */ |
|
271 |
|
272 if (ldict == NULL) |
|
273 return NULL; |
|
274 else { |
|
275 int i = PyDict_SetItem(tdict, self->key, ldict); |
|
276 Py_DECREF(ldict); /* now ldict is borrowed */ |
|
277 if (i < 0) |
|
278 return NULL; |
|
279 } |
|
280 |
|
281 Py_CLEAR(self->dict); |
|
282 Py_INCREF(ldict); |
|
283 self->dict = ldict; /* still borrowed */ |
|
284 |
|
285 if (Py_TYPE(self)->tp_init != PyBaseObject_Type.tp_init && |
|
286 Py_TYPE(self)->tp_init((PyObject*)self, |
|
287 self->args, self->kw) < 0) { |
|
288 /* we need to get rid of ldict from thread so |
|
289 we create a new one the next time we do an attr |
|
290 acces */ |
|
291 PyDict_DelItem(tdict, self->key); |
|
292 return NULL; |
|
293 } |
|
294 |
|
295 } |
|
296 |
|
297 /* The call to tp_init above may have caused another thread to run. |
|
298 Install our ldict again. */ |
|
299 if (self->dict != ldict) { |
|
300 Py_CLEAR(self->dict); |
|
301 Py_INCREF(ldict); |
|
302 self->dict = ldict; |
|
303 } |
|
304 |
|
305 return ldict; |
|
306 } |
|
307 |
|
308 static int |
|
309 local_setattro(localobject *self, PyObject *name, PyObject *v) |
|
310 { |
|
311 PyObject *ldict; |
|
312 |
|
313 ldict = _ldict(self); |
|
314 if (ldict == NULL) |
|
315 return -1; |
|
316 |
|
317 return PyObject_GenericSetAttr((PyObject *)self, name, v); |
|
318 } |
|
319 |
|
320 static PyObject * |
|
321 local_getdict(localobject *self, void *closure) |
|
322 { |
|
323 if (self->dict == NULL) { |
|
324 PyErr_SetString(PyExc_AttributeError, "__dict__"); |
|
325 return NULL; |
|
326 } |
|
327 |
|
328 Py_INCREF(self->dict); |
|
329 return self->dict; |
|
330 } |
|
331 |
|
332 static PyGetSetDef local_getset[] = { |
|
333 {"__dict__", (getter)local_getdict, (setter)NULL, |
|
334 "Local-data dictionary", NULL}, |
|
335 {NULL} /* Sentinel */ |
|
336 }; |
|
337 |
|
338 static PyObject *local_getattro(localobject *, PyObject *); |
|
339 |
|
340 static PyTypeObject localtype = { |
|
341 PyVarObject_HEAD_INIT(NULL, 0) |
|
342 /* tp_name */ "thread._local", |
|
343 /* tp_basicsize */ sizeof(localobject), |
|
344 /* tp_itemsize */ 0, |
|
345 /* tp_dealloc */ (destructor)local_dealloc, |
|
346 /* tp_print */ 0, |
|
347 /* tp_getattr */ 0, |
|
348 /* tp_setattr */ 0, |
|
349 /* tp_compare */ 0, |
|
350 /* tp_repr */ 0, |
|
351 /* tp_as_number */ 0, |
|
352 /* tp_as_sequence */ 0, |
|
353 /* tp_as_mapping */ 0, |
|
354 /* tp_hash */ 0, |
|
355 /* tp_call */ 0, |
|
356 /* tp_str */ 0, |
|
357 /* tp_getattro */ (getattrofunc)local_getattro, |
|
358 /* tp_setattro */ (setattrofunc)local_setattro, |
|
359 /* tp_as_buffer */ 0, |
|
360 /* tp_flags */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, |
|
361 /* tp_doc */ "Thread-local data", |
|
362 /* tp_traverse */ (traverseproc)local_traverse, |
|
363 /* tp_clear */ (inquiry)local_clear, |
|
364 /* tp_richcompare */ 0, |
|
365 /* tp_weaklistoffset */ 0, |
|
366 /* tp_iter */ 0, |
|
367 /* tp_iternext */ 0, |
|
368 /* tp_methods */ 0, |
|
369 /* tp_members */ 0, |
|
370 /* tp_getset */ local_getset, |
|
371 /* tp_base */ 0, |
|
372 /* tp_dict */ 0, /* internal use */ |
|
373 /* tp_descr_get */ 0, |
|
374 /* tp_descr_set */ 0, |
|
375 /* tp_dictoffset */ offsetof(localobject, dict), |
|
376 /* tp_init */ 0, |
|
377 /* tp_alloc */ 0, |
|
378 /* tp_new */ local_new, |
|
379 /* tp_free */ 0, /* Low-level free-mem routine */ |
|
380 /* tp_is_gc */ 0, /* For PyObject_IS_GC */ |
|
381 }; |
|
382 |
|
383 static PyObject * |
|
384 local_getattro(localobject *self, PyObject *name) |
|
385 { |
|
386 PyObject *ldict, *value; |
|
387 |
|
388 ldict = _ldict(self); |
|
389 if (ldict == NULL) |
|
390 return NULL; |
|
391 |
|
392 if (Py_TYPE(self) != &localtype) |
|
393 /* use generic lookup for subtypes */ |
|
394 return PyObject_GenericGetAttr((PyObject *)self, name); |
|
395 |
|
396 /* Optimization: just look in dict ourselves */ |
|
397 value = PyDict_GetItem(ldict, name); |
|
398 if (value == NULL) |
|
399 /* Fall back on generic to get __class__ and __dict__ */ |
|
400 return PyObject_GenericGetAttr((PyObject *)self, name); |
|
401 |
|
402 Py_INCREF(value); |
|
403 return value; |
|
404 } |
|
405 |
|
406 /* Module functions */ |
|
407 |
|
408 struct bootstate { |
|
409 PyInterpreterState *interp; |
|
410 PyObject *func; |
|
411 PyObject *args; |
|
412 PyObject *keyw; |
|
413 }; |
|
414 |
|
415 static void |
|
416 t_bootstrap(void *boot_raw) |
|
417 { |
|
418 struct bootstate *boot = (struct bootstate *) boot_raw; |
|
419 PyThreadState *tstate; |
|
420 PyObject *res; |
|
421 |
|
422 tstate = PyThreadState_New(boot->interp); |
|
423 |
|
424 PyEval_AcquireThread(tstate); |
|
425 res = PyEval_CallObjectWithKeywords( |
|
426 boot->func, boot->args, boot->keyw); |
|
427 if (res == NULL) { |
|
428 if (PyErr_ExceptionMatches(PyExc_SystemExit)) |
|
429 PyErr_Clear(); |
|
430 else { |
|
431 PyObject *file; |
|
432 PySys_WriteStderr( |
|
433 "Unhandled exception in thread started by "); |
|
434 file = PySys_GetObject("stderr"); |
|
435 if (file) |
|
436 PyFile_WriteObject(boot->func, file, 0); |
|
437 else |
|
438 PyObject_Print(boot->func, stderr, 0); |
|
439 PySys_WriteStderr("\n"); |
|
440 PyErr_PrintEx(0); |
|
441 } |
|
442 } |
|
443 else |
|
444 Py_DECREF(res); |
|
445 Py_DECREF(boot->func); |
|
446 Py_DECREF(boot->args); |
|
447 Py_XDECREF(boot->keyw); |
|
448 PyMem_DEL(boot_raw); |
|
449 PyThreadState_Clear(tstate); |
|
450 PyThreadState_DeleteCurrent(); |
|
451 PyThread_exit_thread(); |
|
452 } |
|
453 |
|
454 static PyObject * |
|
455 thread_PyThread_start_new_thread(PyObject *self, PyObject *fargs) |
|
456 { |
|
457 PyObject *func, *args, *keyw = NULL; |
|
458 struct bootstate *boot; |
|
459 long ident; |
|
460 |
|
461 if (!PyArg_UnpackTuple(fargs, "start_new_thread", 2, 3, |
|
462 &func, &args, &keyw)) |
|
463 return NULL; |
|
464 if (!PyCallable_Check(func)) { |
|
465 PyErr_SetString(PyExc_TypeError, |
|
466 "first arg must be callable"); |
|
467 return NULL; |
|
468 } |
|
469 if (!PyTuple_Check(args)) { |
|
470 PyErr_SetString(PyExc_TypeError, |
|
471 "2nd arg must be a tuple"); |
|
472 return NULL; |
|
473 } |
|
474 if (keyw != NULL && !PyDict_Check(keyw)) { |
|
475 PyErr_SetString(PyExc_TypeError, |
|
476 "optional 3rd arg must be a dictionary"); |
|
477 return NULL; |
|
478 } |
|
479 boot = PyMem_NEW(struct bootstate, 1); |
|
480 if (boot == NULL) |
|
481 return PyErr_NoMemory(); |
|
482 boot->interp = PyThreadState_GET()->interp; |
|
483 boot->func = func; |
|
484 boot->args = args; |
|
485 boot->keyw = keyw; |
|
486 Py_INCREF(func); |
|
487 Py_INCREF(args); |
|
488 Py_XINCREF(keyw); |
|
489 PyEval_InitThreads(); /* Start the interpreter's thread-awareness */ |
|
490 ident = PyThread_start_new_thread(t_bootstrap, (void*) boot); |
|
491 if (ident == -1) { |
|
492 PyErr_SetString(ThreadError, "can't start new thread"); |
|
493 Py_DECREF(func); |
|
494 Py_DECREF(args); |
|
495 Py_XDECREF(keyw); |
|
496 PyMem_DEL(boot); |
|
497 return NULL; |
|
498 } |
|
499 return PyInt_FromLong(ident); |
|
500 } |
|
501 |
|
502 PyDoc_STRVAR(start_new_doc, |
|
503 "start_new_thread(function, args[, kwargs])\n\ |
|
504 (start_new() is an obsolete synonym)\n\ |
|
505 \n\ |
|
506 Start a new thread and return its identifier. The thread will call the\n\ |
|
507 function with positional arguments from the tuple args and keyword arguments\n\ |
|
508 taken from the optional dictionary kwargs. The thread exits when the\n\ |
|
509 function returns; the return value is ignored. The thread will also exit\n\ |
|
510 when the function raises an unhandled exception; a stack trace will be\n\ |
|
511 printed unless the exception is SystemExit.\n"); |
|
512 |
|
513 static PyObject * |
|
514 thread_PyThread_exit_thread(PyObject *self) |
|
515 { |
|
516 PyErr_SetNone(PyExc_SystemExit); |
|
517 return NULL; |
|
518 } |
|
519 |
|
520 PyDoc_STRVAR(exit_doc, |
|
521 "exit()\n\ |
|
522 (PyThread_exit_thread() is an obsolete synonym)\n\ |
|
523 \n\ |
|
524 This is synonymous to ``raise SystemExit''. It will cause the current\n\ |
|
525 thread to exit silently unless the exception is caught."); |
|
526 |
|
527 static PyObject * |
|
528 thread_PyThread_interrupt_main(PyObject * self) |
|
529 { |
|
530 PyErr_SetInterrupt(); |
|
531 Py_INCREF(Py_None); |
|
532 return Py_None; |
|
533 } |
|
534 |
|
535 PyDoc_STRVAR(interrupt_doc, |
|
536 "interrupt_main()\n\ |
|
537 \n\ |
|
538 Raise a KeyboardInterrupt in the main thread.\n\ |
|
539 A subthread can use this function to interrupt the main thread." |
|
540 ); |
|
541 |
|
542 #ifndef NO_EXIT_PROG |
|
543 static PyObject * |
|
544 thread_PyThread_exit_prog(PyObject *self, PyObject *args) |
|
545 { |
|
546 int sts; |
|
547 if (!PyArg_ParseTuple(args, "i:exit_prog", &sts)) |
|
548 return NULL; |
|
549 Py_Exit(sts); /* Calls PyThread_exit_prog(sts) or _PyThread_exit_prog(sts) */ |
|
550 for (;;) { } /* Should not be reached */ |
|
551 } |
|
552 #endif |
|
553 |
|
554 static lockobject *newlockobject(void); |
|
555 |
|
556 static PyObject * |
|
557 thread_PyThread_allocate_lock(PyObject *self) |
|
558 { |
|
559 return (PyObject *) newlockobject(); |
|
560 } |
|
561 |
|
562 PyDoc_STRVAR(allocate_doc, |
|
563 "allocate_lock() -> lock object\n\ |
|
564 (allocate() is an obsolete synonym)\n\ |
|
565 \n\ |
|
566 Create a new lock object. See LockType.__doc__ for information about locks."); |
|
567 |
|
568 static PyObject * |
|
569 thread_get_ident(PyObject *self) |
|
570 { |
|
571 long ident; |
|
572 ident = PyThread_get_thread_ident(); |
|
573 if (ident == -1) { |
|
574 PyErr_SetString(ThreadError, "no current thread ident"); |
|
575 return NULL; |
|
576 } |
|
577 return PyInt_FromLong(ident); |
|
578 } |
|
579 |
|
580 PyDoc_STRVAR(get_ident_doc, |
|
581 "get_ident() -> integer\n\ |
|
582 \n\ |
|
583 Return a non-zero integer that uniquely identifies the current thread\n\ |
|
584 amongst other threads that exist simultaneously.\n\ |
|
585 This may be used to identify per-thread resources.\n\ |
|
586 Even though on some platforms threads identities may appear to be\n\ |
|
587 allocated consecutive numbers starting at 1, this behavior should not\n\ |
|
588 be relied upon, and the number should be seen purely as a magic cookie.\n\ |
|
589 A thread's identity may be reused for another thread after it exits."); |
|
590 |
|
591 static PyObject * |
|
592 thread_stack_size(PyObject *self, PyObject *args) |
|
593 { |
|
594 size_t old_size; |
|
595 Py_ssize_t new_size = 0; |
|
596 int rc; |
|
597 |
|
598 if (!PyArg_ParseTuple(args, "|n:stack_size", &new_size)) |
|
599 return NULL; |
|
600 |
|
601 if (new_size < 0) { |
|
602 PyErr_SetString(PyExc_ValueError, |
|
603 "size must be 0 or a positive value"); |
|
604 return NULL; |
|
605 } |
|
606 |
|
607 old_size = PyThread_get_stacksize(); |
|
608 |
|
609 rc = PyThread_set_stacksize((size_t) new_size); |
|
610 if (rc == -1) { |
|
611 PyErr_Format(PyExc_ValueError, |
|
612 "size not valid: %zd bytes", |
|
613 new_size); |
|
614 return NULL; |
|
615 } |
|
616 if (rc == -2) { |
|
617 PyErr_SetString(ThreadError, |
|
618 "setting stack size not supported"); |
|
619 return NULL; |
|
620 } |
|
621 |
|
622 return PyInt_FromSsize_t((Py_ssize_t) old_size); |
|
623 } |
|
624 |
|
625 PyDoc_STRVAR(stack_size_doc, |
|
626 "stack_size([size]) -> size\n\ |
|
627 \n\ |
|
628 Return the thread stack size used when creating new threads. The\n\ |
|
629 optional size argument specifies the stack size (in bytes) to be used\n\ |
|
630 for subsequently created threads, and must be 0 (use platform or\n\ |
|
631 configured default) or a positive integer value of at least 32,768 (32k).\n\ |
|
632 If changing the thread stack size is unsupported, a ThreadError\n\ |
|
633 exception is raised. If the specified size is invalid, a ValueError\n\ |
|
634 exception is raised, and the stack size is unmodified. 32k bytes\n\ |
|
635 currently the minimum supported stack size value to guarantee\n\ |
|
636 sufficient stack space for the interpreter itself.\n\ |
|
637 \n\ |
|
638 Note that some platforms may have particular restrictions on values for\n\ |
|
639 the stack size, such as requiring a minimum stack size larger than 32kB or\n\ |
|
640 requiring allocation in multiples of the system memory page size\n\ |
|
641 - platform documentation should be referred to for more information\n\ |
|
642 (4kB pages are common; using multiples of 4096 for the stack size is\n\ |
|
643 the suggested approach in the absence of more specific information)."); |
|
644 |
|
645 static PyMethodDef thread_methods[] = { |
|
646 {"start_new_thread", (PyCFunction)thread_PyThread_start_new_thread, |
|
647 METH_VARARGS, |
|
648 start_new_doc}, |
|
649 {"start_new", (PyCFunction)thread_PyThread_start_new_thread, |
|
650 METH_VARARGS, |
|
651 start_new_doc}, |
|
652 {"allocate_lock", (PyCFunction)thread_PyThread_allocate_lock, |
|
653 METH_NOARGS, allocate_doc}, |
|
654 {"allocate", (PyCFunction)thread_PyThread_allocate_lock, |
|
655 METH_NOARGS, allocate_doc}, |
|
656 {"exit_thread", (PyCFunction)thread_PyThread_exit_thread, |
|
657 METH_NOARGS, exit_doc}, |
|
658 {"exit", (PyCFunction)thread_PyThread_exit_thread, |
|
659 METH_NOARGS, exit_doc}, |
|
660 {"interrupt_main", (PyCFunction)thread_PyThread_interrupt_main, |
|
661 METH_NOARGS, interrupt_doc}, |
|
662 {"get_ident", (PyCFunction)thread_get_ident, |
|
663 METH_NOARGS, get_ident_doc}, |
|
664 {"stack_size", (PyCFunction)thread_stack_size, |
|
665 METH_VARARGS, |
|
666 stack_size_doc}, |
|
667 #ifndef NO_EXIT_PROG |
|
668 {"exit_prog", (PyCFunction)thread_PyThread_exit_prog, |
|
669 METH_VARARGS}, |
|
670 #endif |
|
671 {NULL, NULL} /* sentinel */ |
|
672 }; |
|
673 |
|
674 |
|
675 /* Initialization function */ |
|
676 |
|
677 PyDoc_STRVAR(thread_doc, |
|
678 "This module provides primitive operations to write multi-threaded programs.\n\ |
|
679 The 'threading' module provides a more convenient interface."); |
|
680 |
|
681 PyDoc_STRVAR(lock_doc, |
|
682 "A lock object is a synchronization primitive. To create a lock,\n\ |
|
683 call the PyThread_allocate_lock() function. Methods are:\n\ |
|
684 \n\ |
|
685 acquire() -- lock the lock, possibly blocking until it can be obtained\n\ |
|
686 release() -- unlock of the lock\n\ |
|
687 locked() -- test whether the lock is currently locked\n\ |
|
688 \n\ |
|
689 A lock is not owned by the thread that locked it; another thread may\n\ |
|
690 unlock it. A thread attempting to lock a lock that it has already locked\n\ |
|
691 will block until another thread unlocks it. Deadlocks may ensue."); |
|
692 |
|
693 PyMODINIT_FUNC |
|
694 initthread(void) |
|
695 { |
|
696 PyObject *m, *d; |
|
697 |
|
698 /* Initialize types: */ |
|
699 if (PyType_Ready(&localtype) < 0) |
|
700 return; |
|
701 |
|
702 /* Create the module and add the functions */ |
|
703 m = Py_InitModule3("thread", thread_methods, thread_doc); |
|
704 if (m == NULL) |
|
705 return; |
|
706 |
|
707 /* Add a symbolic constant */ |
|
708 d = PyModule_GetDict(m); |
|
709 ThreadError = PyErr_NewException("thread.error", NULL, NULL); |
|
710 PyDict_SetItemString(d, "error", ThreadError); |
|
711 Locktype.tp_doc = lock_doc; |
|
712 Py_INCREF(&Locktype); |
|
713 PyDict_SetItemString(d, "LockType", (PyObject *)&Locktype); |
|
714 |
|
715 Py_INCREF(&localtype); |
|
716 if (PyModule_AddObject(m, "_local", (PyObject *)&localtype) < 0) |
|
717 return; |
|
718 |
|
719 /* Initialize the C thread library */ |
|
720 PyThread_init_thread(); |
|
721 } |