def do_random_work():
thread_index = glob.n_threads
glob.n_threads += 1
ops = ops_by_thread[thread_index]
nextop = 0
while nextop < len(ops):
op = ops[nextop]
nextop += 1
if op == OP_YIELD:
rgil.yield_thread()
check("after yield", nextop)
elif op == OP_RELEASE_AND_ACQUIRE:
rgil.release()
check("after release_gil", nextop, expected=False)
rgil.acquire()
check("after acquire_gil", nextop)
else:
arg = ops[nextop]
nextop += 1
if op == OP_BUSY:
end_time = time.time() + arg * 1e-6
while time.time() < end_time:
pass
check("after busy work", nextop)
else:
time.sleep(arg * 1e-6)
check("after time.sleep()", nextop)
finish_lock = glob.my_locks[thread_index]
finish_lock.release()
def main(argv):
rgil.release()
# don't have the GIL here
rgil.acquire()
rgil.yield_thread()
print "OK" # there is also a release/acquire pair here
return 0
def main(argv):
check('1')
rgil.release()
# don't have the GIL here
check('2', False)
rgil.acquire()
check('3')
rgil.yield_thread()
check('4')
print "OK" # there is also a release/acquire pair here
check('5')
return 0
def test_semlock_release(space):
# trigger the setup() code in time.moduledef
space.getbuiltinmodule('time')
sem_name = '/test8'
_handle = create_semaphore(space, sem_name, 1, 1)
try:
w_lock = W_SemLock(space, _handle, 0, 1)
created = []
successful = []
N_THREADS = 16
def run(space):
w_sentinel = allocate_lock(space)
yield_thread()
w_sentinel.descr_lock_acquire(space) # releases GIL
try:
yield_thread()
created.append(w_sentinel)
w_got = w_lock.acquire(
space, w_timeout=space.newfloat(5.)) # releases GIL
if space.is_true(w_got):
yield_thread()
w_lock.release(space)
successful.append(w_sentinel)
w_sentinel.descr_lock_release(space)
except:
import traceback
traceback.print_exc()
w_sentinel.descr_lock_release(space)
raise
w_run = space.wrap(interp2app(run))
w_lock.acquire(space)
for _ in range(N_THREADS):
start_new_thread(space, w_run, space.newtuple([])) # releases GIL
deadline = time.time() + 5.
while len(created) < N_THREADS:
assert time.time() < deadline
yield_thread()
w_lock.release(space)
for w_sentinel in created:
# Join thread
w_sentinel.descr_lock_acquire(space) # releases GIL
w_sentinel.descr_lock_release(space)
assert len(successful) == N_THREADS
finally:
delete_semaphore(_handle)
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 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 test_semlock_release(space):
sem_name = '/test7'
_handle = create_semaphore(space, sem_name, 1, 1)
w_lock = W_SemLock(space, _handle, 0, 1)
created = []
successful = []
N_THREADS = 16
def run(space):
w_sentinel = allocate_lock(space)
yield_thread()
w_sentinel.descr_lock_acquire(space) # releases GIL
yield_thread()
created.append(w_sentinel)
w_got = w_lock.acquire(space,
w_timeout=space.newfloat(5.)) # releases GIL
if space.is_true(w_got):
yield_thread()
w_lock.release(space)
successful.append(w_sentinel)
w_sentinel.descr_lock_release(space)
w_run = space.wrap(interp2app(run))
w_lock.acquire(space)
for _ in range(N_THREADS):
start_new_thread(space, w_run, space.newtuple([])) # releases GIL
deadline = time.time() + 5.
while len(created) < N_THREADS:
assert time.time() < deadline
yield_thread()
w_lock.release(space)
for w_sentinel in created:
# Join thread
w_sentinel.descr_lock_acquire(space) # releases GIL
w_sentinel.descr_lock_release(space)
assert len(successful) == N_THREADS
def run(space):
w_sentinel = allocate_lock(space)
yield_thread()
w_sentinel.descr_lock_acquire(space) # releases GIL
yield_thread()
created.append(w_sentinel)
w_got = w_lock.acquire(
space, w_timeout=space.newfloat(5.)) # releases GIL
if space.is_true(w_got):
yield_thread()
w_lock.release(space)
successful.append(w_sentinel)
w_sentinel.descr_lock_release(space)
def run(space):
w_sentinel = _set_sentinel(space)
yield_thread()
w_sentinel.descr_lock_acquire(space) # releases GIL
try:
yield_thread()
created.append(w_sentinel)
w_got = w_lock.acquire(
space, w_timeout=space.newfloat(5.)) # releases GIL
if space.is_true(w_got):
yield_thread()
w_lock.release(space)
successful.append(w_sentinel)
except:
import traceback
traceback.print_exc()
raise
def yield_thread():
rgil.yield_thread()
return nil
def yield_thread():
rgil.yield_thread()
return nil
def perform(self, executioncontext, frame):
rgil.yield_thread()