Modules/threadmodule.c

   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 }