def test_one_thread(self, skew=+1):
from rpython.rlib.debug import debug_print
if self.bigtest:
N = 100000
skew *= 25000
else:
N = 100
skew *= 25
space = FakeSpace()
class State:
pass
state = State()
def runme(main=False):
j = 0
for i in range(N + [-skew, skew][main]):
state.datalen1 += 1 # try to crash if the GIL is not
state.datalen2 += 1 # correctly acquired
state.data.append((thread.get_ident(), i))
state.datalen3 += 1
state.datalen4 += 1
assert state.datalen1 == len(state.data)
assert state.datalen2 == len(state.data)
assert state.datalen3 == len(state.data)
assert state.datalen4 == len(state.data)
debug_print(main, i, state.datalen4)
gil.do_yield_thread()
assert i == j
j += 1
def bootstrap():
try:
runme()
except Exception, e:
assert 0
thread.gc_thread_die()
def bootstrap():
# Note that when this runs, we already hold the GIL. This is ensured
# by rffi's callback mecanism: we are a callback for the
# c_thread_start() external function.
rthread.gc_thread_start()
space = bootstrapper.space
w_callable = bootstrapper.w_callable
args = bootstrapper.args
bootstrapper.nbthreads += 1
bootstrapper.release()
# run!
try:
bootstrapper.run(space, w_callable, args)
# done
except Exception as e:
# oups! last-level attempt to recover.
try:
STDERR = 2
os.write(STDERR, "Thread exited with ")
os.write(STDERR, str(e))
os.write(STDERR, "\n")
except OSError:
pass
bootstrapper.nbthreads -= 1
rthread.gc_thread_die()
def bootstrap():
rthread.gc_thread_start()
_sleep(1)
revdb.stop_point()
_sleep(2)
revdb.stop_point()
rthread.gc_thread_die()
def bootstrap():
rthread.gc_thread_start()
_sleep(1)
print "BB"
_sleep(2)
print "BBB"
rthread.gc_thread_die()
def bootstrap():
# Note that when this runs, we already hold the GIL. This is ensured
# by rffi's callback mecanism: we are a callback for the
# c_thread_start() external function.
rthread.gc_thread_start()
space = bootstrapper.space
w_callable = bootstrapper.w_callable
args = bootstrapper.args
bootstrapper.nbthreads += 1
bootstrapper.release()
# run!
try:
bootstrapper.run(space, w_callable, args)
# done
except Exception as e:
# oups! last-level attempt to recover.
try:
STDERR = 2
os.write(STDERR, "Thread exited with ")
os.write(STDERR, str(e))
os.write(STDERR, "\n")
except OSError:
pass
bootstrapper.nbthreads -= 1
rthread.gc_thread_die()
def bootstrap():
rthread.gc_thread_start()
_sleep(1)
ec = EC(4567)
raw_thread_local.set(ec)
print raw_thread_local.get().value
assert raw_thread_local.get() is ec
rthread.gc_thread_die()
def PyThreadState_Clear(space, tstate):
"""Reset all information in a thread state object. The global
interpreter lock must be held."""
Py_DecRef(space, tstate.c_dict)
tstate.c_dict = lltype.nullptr(PyObject.TO)
space.threadlocals.leave_thread(space)
space.getexecutioncontext().cleanup_cpyext_state()
rthread.gc_thread_die()
def PyThreadState_Clear(space, tstate):
"""Reset all information in a thread state object. The global
interpreter lock must be held."""
if not space.config.translation.thread:
raise NoThreads
Py_DecRef(space, tstate.c_dict)
tstate.c_dict = lltype.nullptr(PyObject.TO)
space.threadlocals.leave_thread(space)
space.getexecutioncontext().cleanup_cpyext_state()
rthread.gc_thread_die()
def bootstrap():
rthread.gc_thread_start()
childpid = run_in_thread()
gc.collect() # collect both in the child and in the parent
gc.collect()
gc.collect()
if childpid == 0:
os.write(state.write_end, 'c') # "I did not die!" from child
else:
os.write(state.write_end, 'p') # "I did not die!" from parent
rthread.gc_thread_die()
def bootstrap():
rthread.gc_thread_start()
childpid = run_in_thread()
gc.collect() # collect both in the child and in the parent
gc.collect()
gc.collect()
if childpid == 0:
os.write(state.write_end, 'c') # "I did not die!" from child
else:
os.write(state.write_end, 'p') # "I did not die!" from parent
rthread.gc_thread_die()
class Bootstrapper(object):
"A global container used to pass information to newly starting threads."
# Passing a closure argument to rthread.start_new_thread() would be
# theoretically nicer, but comes with messy memory management issues.
# This is much more straightforward.
nbthreads = 0
# The following lock is held whenever the fields
# 'bootstrapper.w_callable' and 'bootstrapper.args' are in use.
lock = None
args = None
w_callable = None
@staticmethod
def setup(space):
if bootstrapper.lock is None:
try:
bootstrapper.lock = rthread.allocate_lock()
except rthread.error:
raise wrap_thread_error(space, "can't allocate bootstrap lock")
@staticmethod
def reinit():
bootstrapper.lock = None
bootstrapper.nbthreads = 0
bootstrapper.w_callable = None
bootstrapper.args = None
def _cleanup_(self):
self.reinit()
def bootstrap():
# Note that when this runs, we already hold the GIL. This is ensured
# by rffi's callback mecanism: we are a callback for the
# c_thread_start() external function.
rthread.gc_thread_start()
space = bootstrapper.space
w_callable = bootstrapper.w_callable
args = bootstrapper.args
bootstrapper.nbthreads += 1
bootstrapper.release()
# run!
try:
bootstrapper.run(space, w_callable, args)
# done
except Exception, e:
# oups! last-level attempt to recover.
try:
STDERR = 2
os.write(STDERR, "Thread exited with ")
os.write(STDERR, str(e))
os.write(STDERR, "\n")
except OSError:
pass
bootstrapper.nbthreads -= 1
rthread.gc_thread_die()
def test_one_thread(self, skew=+1):
from rpython.rlib.debug import debug_print
if self.bigtest:
N = 100000
skew *= 25000
else:
N = 100
skew *= 25
space = FakeSpace()
class State:
pass
state = State()
def runme(main=False):
j = 0
for i in range(N + [-skew, skew][main]):
state.datalen1 += 1 # try to crash if the GIL is not
state.datalen2 += 1 # correctly acquired
state.data.append((thread.get_ident(), i))
state.datalen3 += 1
state.datalen4 += 1
assert state.datalen1 == len(state.data)
assert state.datalen2 == len(state.data)
assert state.datalen3 == len(state.data)
assert state.datalen4 == len(state.data)
debug_print(main, i, state.datalen4)
rgil.yield_thread()
assert i == j
j += 1
def bootstrap():
try:
runme()
except Exception, e:
assert 0
thread.gc_thread_die()
def bootstrap():
try:
runme()
except Exception as e:
assert 0
thread.gc_thread_die()
def bootstrap():
rthread.gc_thread_start()
check_errno(42)
state.xlist.append(Cons(123, Cons(456, None)))
gc.collect()
rthread.gc_thread_die()
def bootstrap():
rthread.gc_thread_start()
fn = bootstrapper.fn()
bootstrapper.release()
safe_invoke(fn, [])
rthread.gc_thread_die()
def bootstrap():
try:
runme()
except Exception as e:
assert 0
thread.gc_thread_die()
def bootstrap():
rthread.gc_thread_start()
check_errno(42)
state.xlist.append(Cons(123, Cons(456, None)))
gc.collect()
rthread.gc_thread_die()
def bootstrap():
rthread.gc_thread_start()
fn = bootstrapper.fn()
bootstrapper.release()
fn.invoke([])
rthread.gc_thread_die()