[pypy-commit] pypy default: Implement thread state manipulation APIs with behavior more closely resembling CPython's
exarkun
noreply at buildbot.pypy.org
Fri Mar 16 21:39:18 CET 2012
Author: Jean-Paul Calderone <exarkun at twistedmatrix.com>
Branch:
Changeset: r53728:660149ad1d19
Date: 2012-03-16 16:38 -0400
http://bitbucket.org/pypy/pypy/changeset/660149ad1d19/
Log: Implement thread state manipulation APIs with behavior more closely
resembling CPython's
diff --git a/pypy/module/cpyext/pystate.py b/pypy/module/cpyext/pystate.py
--- a/pypy/module/cpyext/pystate.py
+++ b/pypy/module/cpyext/pystate.py
@@ -10,7 +10,7 @@
[('next', PyInterpreterState)],
PyInterpreterStateStruct)
PyThreadState = lltype.Ptr(cpython_struct(
- "PyThreadState",
+ "PyThreadState",
[('interp', PyInterpreterState),
('dict', PyObject),
]))
@@ -19,12 +19,15 @@
def PyEval_SaveThread(space):
"""Release the global interpreter lock (if it has been created and thread
support is enabled) and reset the thread state to NULL, returning the
- previous thread state (which is not NULL except in PyPy). If the lock has been created,
+ previous thread state. If the lock has been created,
the current thread must have acquired it. (This function is available even
when thread support is disabled at compile time.)"""
+ state = space.fromcache(InterpreterState)
if rffi.aroundstate.before:
rffi.aroundstate.before()
- return lltype.nullptr(PyThreadState.TO)
+ tstate = state.swap_thread_state(
+ space, lltype.nullptr(PyThreadState.TO))
+ return tstate
@cpython_api([PyThreadState], lltype.Void)
def PyEval_RestoreThread(space, tstate):
@@ -35,6 +38,8 @@
when thread support is disabled at compile time.)"""
if rffi.aroundstate.after:
rffi.aroundstate.after()
+ state = space.fromcache(InterpreterState)
+ state.swap_thread_state(space, tstate)
@cpython_api([], lltype.Void)
def PyEval_InitThreads(space):
@@ -67,28 +72,91 @@
dealloc=ThreadState_dealloc)
from pypy.interpreter.executioncontext import ExecutionContext
+
+# Keep track of the ThreadStateCapsule for a particular execution context. The
+# default is for new execution contexts not to have one; it is allocated on the
+# first cpyext-based request for it.
ExecutionContext.cpyext_threadstate = ThreadStateCapsule(None)
+# Also keep track of whether it has been initialized yet or not (None is a valid
+# PyThreadState for an execution context to have, when the GIL has been
+# released, so a check against that can't be used to determine the need for
+# initialization).
+ExecutionContext.cpyext_initialized_threadstate = False
+
+def cleanup_cpyext_state(self):
+ try:
+ del self.cpyext_threadstate
+ except AttributeError:
+ pass
+ self.cpyext_initialized_threadstate = False
+ExecutionContext.cleanup_cpyext_state = cleanup_cpyext_state
+
class InterpreterState(object):
def __init__(self, space):
self.interpreter_state = lltype.malloc(
PyInterpreterState.TO, flavor='raw', zero=True, immortal=True)
def new_thread_state(self, space):
+ """
+ Create a new ThreadStateCapsule to hold the PyThreadState for a
+ particular execution context.
+
+ :param space: A space.
+
+ :returns: A new ThreadStateCapsule holding a newly allocated
+ PyThreadState and referring to this interpreter state.
+ """
capsule = ThreadStateCapsule(space)
ts = capsule.memory
ts.c_interp = self.interpreter_state
ts.c_dict = make_ref(space, space.newdict())
return capsule
+
def get_thread_state(self, space):
+ """
+ Get the current PyThreadState for the current execution context.
+
+ :param space: A space.
+
+ :returns: The current PyThreadState for the current execution context,
+ or None if it does not have one.
+ """
ec = space.getexecutioncontext()
return self._get_thread_state(space, ec).memory
+
+ def swap_thread_state(self, space, tstate):
+ """
+ Replace the current thread state of the current execution context with a
+ new thread state.
+
+ :param space: The space.
+
+ :param tstate: The new PyThreadState for the current execution context.
+
+ :returns: The old thread state for the current execution context, either
+ None or a PyThreadState.
+ """
+ ec = space.getexecutioncontext()
+ capsule = self._get_thread_state(space, ec)
+ old_tstate = capsule.memory
+ capsule.memory = tstate
+ return old_tstate
+
def _get_thread_state(self, space, ec):
- if ec.cpyext_threadstate.memory == lltype.nullptr(PyThreadState.TO):
+ """
+ Get the ThreadStateCapsule for the given execution context, possibly
+ creating a new one if it does not already have one.
+
+ :param space: The space.
+ :param ec: The ExecutionContext of which to get the thread state.
+ :returns: The ThreadStateCapsule for the given execution context.
+ """
+ if not ec.cpyext_initialized_threadstate:
ec.cpyext_threadstate = self.new_thread_state(space)
-
+ ec.cpyext_initialized_threadstate = True
return ec.cpyext_threadstate
@cpython_api([], PyThreadState, error=CANNOT_FAIL)
@@ -105,13 +173,8 @@
def PyThreadState_Swap(space, tstate):
"""Swap the current thread state with the thread state given by the argument
tstate, which may be NULL. The global interpreter lock must be held."""
- # All cpyext calls release and acquire the GIL, so this function has no
- # side-effects
- if tstate:
- return lltype.nullptr(PyThreadState.TO)
- else:
- state = space.fromcache(InterpreterState)
- return state.get_thread_state(space)
+ state = space.fromcache(InterpreterState)
+ return state.swap_thread_state(space, tstate)
@cpython_api([PyThreadState], lltype.Void)
def PyEval_AcquireThread(space, tstate):
diff --git a/pypy/module/cpyext/test/test_cpyext.py b/pypy/module/cpyext/test/test_cpyext.py
--- a/pypy/module/cpyext/test/test_cpyext.py
+++ b/pypy/module/cpyext/test/test_cpyext.py
@@ -106,10 +106,7 @@
del obj
import gc; gc.collect()
- try:
- del space.getexecutioncontext().cpyext_threadstate
- except AttributeError:
- pass
+ space.getexecutioncontext().cleanup_cpyext_state()
for w_obj in state.non_heaptypes_w:
Py_DecRef(space, w_obj)
diff --git a/pypy/module/cpyext/test/test_pystate.py b/pypy/module/cpyext/test/test_pystate.py
--- a/pypy/module/cpyext/test/test_pystate.py
+++ b/pypy/module/cpyext/test/test_pystate.py
@@ -3,6 +3,10 @@
from pypy.rpython.lltypesystem.lltype import nullptr
from pypy.module.cpyext.pystate import PyInterpreterState, PyThreadState
from pypy.module.cpyext.pyobject import from_ref
+from pypy.rpython.lltypesystem import lltype
+from pypy.module.cpyext.test.test_cpyext import LeakCheckingTest, freeze_refcnts
+from pypy.module.cpyext.pystate import PyThreadState_Get, PyInterpreterState_Head
+from pypy.tool import leakfinder
class AppTestThreads(AppTestCpythonExtensionBase):
def test_allow_threads(self):
@@ -21,6 +25,93 @@
# Should compile at least
module.test()
+
+ def test_thread_state_get(self):
+ module = self.import_extension('foo', [
+ ("get", "METH_NOARGS",
+ """
+ PyThreadState *tstate = PyThreadState_Get();
+ if (tstate == NULL) {
+ return PyLong_FromLong(0);
+ }
+ if (tstate->interp != PyInterpreterState_Head()) {
+ return PyLong_FromLong(1);
+ }
+ if (tstate->interp->next != NULL) {
+ return PyLong_FromLong(2);
+ }
+ return PyLong_FromLong(3);
+ """),
+ ])
+ assert module.get() == 3
+
+ def test_basic_threadstate_dance(self):
+ module = self.import_extension('foo', [
+ ("dance", "METH_NOARGS",
+ """
+ PyThreadState *old_tstate, *new_tstate;
+
+ old_tstate = PyThreadState_Swap(NULL);
+ if (old_tstate == NULL) {
+ return PyLong_FromLong(0);
+ }
+
+ new_tstate = PyThreadState_Get();
+ if (new_tstate != NULL) {
+ return PyLong_FromLong(1);
+ }
+
+ new_tstate = PyThreadState_Swap(old_tstate);
+ if (new_tstate != NULL) {
+ return PyLong_FromLong(2);
+ }
+
+ new_tstate = PyThreadState_Get();
+ if (new_tstate != old_tstate) {
+ return PyLong_FromLong(3);
+ }
+
+ return PyLong_FromLong(4);
+ """),
+ ])
+ assert module.dance() == 4
+
+ def test_threadstate_dict(self):
+ module = self.import_extension('foo', [
+ ("getdict", "METH_NOARGS",
+ """
+ PyObject *dict = PyThreadState_GetDict();
+ Py_INCREF(dict);
+ return dict;
+ """),
+ ])
+ assert isinstance(module.getdict(), dict)
+
+ def test_savethread(self):
+ module = self.import_extension('foo', [
+ ("bounce", "METH_NOARGS",
+ """
+ PyThreadState *tstate = PyEval_SaveThread();
+ if (tstate == NULL) {
+ return PyLong_FromLong(0);
+ }
+
+ if (PyThreadState_Get() != NULL) {
+ return PyLong_FromLong(1);
+ }
+
+ PyEval_RestoreThread(tstate);
+
+ if (PyThreadState_Get() != tstate) {
+ return PyLong_FromLong(2);
+ }
+
+ return PyLong_FromLong(3);
+ """),
+ ])
+
+
+
class TestInterpreterState(BaseApiTest):
def test_interpreter_head(self, space, api):
state = api.PyInterpreterState_Head()
@@ -29,31 +120,3 @@
def test_interpreter_next(self, space, api):
state = api.PyInterpreterState_Head()
assert nullptr(PyInterpreterState.TO) == api.PyInterpreterState_Next(state)
-
-class TestThreadState(BaseApiTest):
- def test_thread_state_get(self, space, api):
- ts = api.PyThreadState_Get()
- assert ts != nullptr(PyThreadState.TO)
-
- def test_thread_state_interp(self, space, api):
- ts = api.PyThreadState_Get()
- assert ts.c_interp == api.PyInterpreterState_Head()
- assert ts.c_interp.c_next == nullptr(PyInterpreterState.TO)
-
- def test_basic_threadstate_dance(self, space, api):
- # Let extension modules call these functions,
- # Not sure of the semantics in pypy though.
- # (cpyext always acquires and releases the GIL around calls)
- tstate = api.PyThreadState_Swap(None)
- assert tstate is not None
- assert not api.PyThreadState_Swap(tstate)
-
- api.PyEval_AcquireThread(tstate)
- api.PyEval_ReleaseThread(tstate)
-
- def test_threadstate_dict(self, space, api):
- ts = api.PyThreadState_Get()
- ref = ts.c_dict
- assert ref == api.PyThreadState_GetDict()
- w_obj = from_ref(space, ref)
- assert space.isinstance_w(w_obj, space.w_dict)
More information about the pypy-commit
mailing list