def start_new_thread(space, w_callable, w_args, w_kwargs=NoneNotWrapped):
"""Start a new thread and return its identifier. The thread will call the
function with positional arguments from the tuple args and keyword arguments
taken from the optional dictionary kwargs. The thread exits when the
function returns; the return value is ignored. The thread will also exit
when the function raises an unhandled exception; a stack trace will be
printed unless the exception is SystemExit."""
setup_threads(space)
if not space.is_true(space.isinstance(w_args, space.w_tuple)):
raise OperationError(space.w_TypeError,
space.wrap("2nd arg must be a tuple"))
if w_kwargs is not None and not space.is_true(space.isinstance(w_kwargs, space.w_dict)):
raise OperationError(space.w_TypeError,
space.wrap("optional 3rd arg must be a dictionary"))
if not space.is_true(space.callable(w_callable)):
raise OperationError(space.w_TypeError,
space.wrap("first arg must be callable"))
args = Arguments.frompacked(space, w_args, w_kwargs)
bootstrapper.acquire(space, w_callable, args)
try:
try:
thread.gc_thread_prepare()
ident = thread.start_new_thread(bootstrapper.bootstrap, ())
except Exception, e:
bootstrapper.release() # normally called by the new thread
raise
except thread.error:
raise wrap_thread_error(space, "can't start new thread")
return space.wrap(ident)
def start_new_thread(space, w_callable, w_args, w_kwargs=NoneNotWrapped):
"""Start a new thread and return its identifier. The thread will call the
function with positional arguments from the tuple args and keyword arguments
taken from the optional dictionary kwargs. The thread exits when the
function returns; the return value is ignored. The thread will also exit
when the function raises an unhandled exception; a stack trace will be
printed unless the exception is SystemExit."""
setup_threads(space)
if not space.is_true(space.isinstance(w_args, space.w_tuple)):
raise OperationError(space.w_TypeError,
space.wrap("2nd arg must be a tuple"))
if w_kwargs is not None and not space.is_true(
space.isinstance(w_kwargs, space.w_dict)):
raise OperationError(
space.w_TypeError,
space.wrap("optional 3rd arg must be a dictionary"))
if not space.is_true(space.callable(w_callable)):
raise OperationError(space.w_TypeError,
space.wrap("first arg must be callable"))
args = Arguments.frompacked(space, w_args, w_kwargs)
bootstrapper.acquire(space, w_callable, args)
try:
try:
thread.gc_thread_prepare() # (this has no effect any more)
ident = thread.start_new_thread(bootstrapper.bootstrap, ())
except Exception, e:
bootstrapper.release() # normally called by the new thread
raise
except thread.error:
raise wrap_thread_error(space, "can't start new thread")
return space.wrap(ident)
def f():
state.data = []
state.threadlocals = gil.GILThreadLocals()
state.threadlocals.setup_threads(space)
thread.gc_thread_prepare()
subident = thread.start_new_thread(bootstrap, ())
mainident = thread.get_ident()
runme()
still_waiting = 3000
while len(state.data) < 2*N:
if not still_waiting:
raise ValueError("time out")
still_waiting -= 1
if not we_are_translated(): gil.before_external_call()
time.sleep(0.01)
if not we_are_translated(): gil.after_external_call()
i1 = i2 = 0
for tid, i in state.data:
if tid == mainident:
assert i == i1; i1 += 1
elif tid == subident:
assert i == i2; i2 += 1
else:
assert 0
assert i1 == N
assert i2 == N
return len(state.data)
def f():
state.data = []
state.datalen1 = 0
state.datalen2 = 0
state.datalen3 = 0
state.datalen4 = 0
state.threadlocals = gil.GILThreadLocals()
state.threadlocals.setup_threads(space)
thread.gc_thread_prepare()
subident = thread.start_new_thread(bootstrap, ())
mainident = thread.get_ident()
runme(True)
still_waiting = 3000
while len(state.data) < 2*N:
debug_print(len(state.data))
if not still_waiting:
raise ValueError("time out")
still_waiting -= 1
if not we_are_translated(): gil.before_external_call()
time.sleep(0.01)
if not we_are_translated(): gil.after_external_call()
debug_print("leaving!")
i1 = i2 = 0
for tid, i in state.data:
if tid == mainident:
assert i == i1; i1 += 1
elif tid == subident:
assert i == i2; i2 += 1
else:
assert 0
assert i1 == N + skew
assert i2 == N - skew
return len(state.data)
def count(iterations=1000000):
"""Count down from a given starting point."""
ll_thread.gc_thread_prepare()
iterate = iterations
for _ in xrange(iterate):
iterations = iterations - 1
return time.time()
def new_thread():
ll_thread.gc_thread_prepare()
ident = ll_thread.start_new_thread(bootstrap, ())
time.sleep(0.5) # enough time to start, hopefully
return ident
def new_thread():
ll_thread.gc_thread_prepare()
ident = ll_thread.start_new_thread(bootstrap, ())
time.sleep(0.5) # enough time to start, hopefully
return ident
