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_New(space, interp): """Create a new thread state object belonging to the given interpreter object. The global interpreter lock need not be held, but may be held if it is necessary to serialize calls to this function.""" if not space.config.translation.thread: raise NoThreads # PyThreadState_Get will allocate a new execution context, # we need to protect gc and other globals with the GIL. rthread.gc_thread_start() return PyThreadState_Get(space)
def pypy_thread_attach(): if not space.config.objspace.usemodules.thread: return os_thread.setup_threads(space) os_thread.bootstrapper.acquire(space, None, None) rthread.gc_thread_start() os_thread.bootstrapper.nbthreads += 1 os_thread.bootstrapper.release() before = rffi.aroundstate.before if before: before()
def pypy_thread_attach(): if not space.config.objspace.usemodules.thread: return os_thread.setup_threads(space) os_thread.bootstrapper.acquire(space, None, None) # XXX this doesn't really work. Don't use os.fork(), and # if your embedder program uses fork(), don't use any PyPy # code in the fork rthread.gc_thread_start() os_thread.bootstrapper.nbthreads += 1 os_thread.bootstrapper.release()
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 PyThreadState_New(space, interp): """Create a new thread state object belonging to the given interpreter object. The global interpreter lock need not be held, but may be held if it is necessary to serialize calls to this function.""" rthread.gc_thread_prepare() # PyThreadState_Get will allocate a new execution context, # we need to protect gc and other globals with the GIL. rffi.aroundstate.after() try: rthread.gc_thread_start() return PyThreadState_Get(space) finally: rffi.aroundstate.before()
def bootstrap(): rthread.gc_thread_start() fn = bootstrapper.fn() bootstrapper.release() fn.invoke([]) rthread.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()