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