def entry_point(argv): os.write(1, "hello world\n") error = rthread.set_stacksize(int(argv[1])) if error != 0: os.write( 2, "set_stacksize(%d) returned %d\n" % (int(argv[1]), error)) raise AssertionError # malloc a bit s1 = State() s2 = State() s3 = State() s1.x = 0x11111111 s2.x = 0x22222222 s3.x = 0x33333333 # start 3 new threads state.ll_lock = rthread.allocate_ll_lock() after() state.count = 0 invoke_around_extcall(before, after) ident1 = rthread.start_new_thread(bootstrap, ()) ident2 = rthread.start_new_thread(bootstrap, ()) ident3 = rthread.start_new_thread(bootstrap, ()) # wait for the 3 threads to finish while True: if state.count == 3: break time.sleep(0.1) # invokes before/after # check that the malloced structures were not overwritten assert s1.x == 0x11111111 assert s2.x == 0x22222222 assert s3.x == 0x33333333 os.write(1, "done\n") return 0
def test_simple_tcp(): from rpython.rlib import rthread sock = RSocket() try_ports = [1023] + range(20000, 30000, 437) for port in try_ports: print 'binding to port %d:' % (port,), try: sock.bind(INETAddress('127.0.0.1', port)) print 'works' break except SocketError as e: # should get a "Permission denied" print e else: raise e addr = INETAddress('127.0.0.1', port) assert addr.eq(sock.getsockname()) sock.listen(1) s2 = RSocket(AF_INET, SOCK_STREAM) s2.settimeout(10.0) # test one side with timeouts so select is used, shouldn't affect test connected = [False] #thread-mutable list def connecting(): try: s2.connect(addr) connected[0] = True finally: lock.release() lock = rthread.allocate_lock() lock.acquire(True) rthread.start_new_thread(connecting, ()) print 'waiting for connection' fd1, addr2 = sock.accept() s1 = RSocket(fd=fd1) print 'connection accepted' lock.acquire(True) assert connected[0] print 'connecting side knows that the connection was accepted too' assert addr.eq(s2.getpeername()) #assert addr2.eq(s2.getsockname()) assert addr2.eq(s1.getpeername()) s1.send('?') print 'sent one character' buf = s2.recv(100) assert buf == '?' print 'received ok' def sendstuff(): s2.sendall('x'*50000) rthread.start_new_thread(sendstuff, ()) buf = '' while len(buf) < 50000: data = s1.recv(50100) print 'recv returned %d bytes' % (len(data,)) assert data buf += data assert buf == 'x'*50000 print 'data received ok' s1.shutdown(SHUT_RDWR) s1.close() s2.close()
def entry_point(argv): os.write(1, "hello world\n") error = rthread.set_stacksize(int(argv[1])) if error != 0: os.write(2, "set_stacksize(%d) returned %d\n" % ( int(argv[1]), error)) raise AssertionError # malloc a bit s1 = State(); s2 = State(); s3 = State() s1.x = 0x11111111; s2.x = 0x22222222; s3.x = 0x33333333 # start 3 new threads state.ll_lock = rthread.allocate_ll_lock() after() state.count = 0 invoke_around_extcall(before, after) ident1 = rthread.start_new_thread(bootstrap, ()) ident2 = rthread.start_new_thread(bootstrap, ()) ident3 = rthread.start_new_thread(bootstrap, ()) # wait for the 3 threads to finish while True: if state.count == 3: break time.sleep(0.1) # invokes before/after # check that the malloced structures were not overwritten assert s1.x == 0x11111111 assert s2.x == 0x22222222 assert s3.x == 0x33333333 os.write(1, "done\n") return 0
def main(argv): print "A" rthread.start_new_thread(bootstrap, ()) for i in range(2): _sleep(2) print "AAAA" return 9
def main(argv): ec = EC(12) raw_thread_local.set(ec) rthread.start_new_thread(bootstrap, ()) _sleep(2) print raw_thread_local.get().value assert raw_thread_local.get() is ec return 9
def main(argv): revdb.stop_point() rthread.start_new_thread(bootstrap, ()) for i in range(2): _sleep(2) revdb.stop_point() print "ok" return 9
def main(argv): for j in range(N_THREADS): lock = rthread.allocate_lock() lock.acquire(True) glob.my_locks.append(lock) for j in range(N_THREADS): rthread.start_new_thread(do_random_work, ()) for j in range(N_THREADS): glob.my_locks[j].acquire(True) print "OK" return 0
def f(): state.data = [] state.datalen1 = 0 state.datalen2 = 0 state.datalen3 = 0 state.datalen4 = 0 state.threadlocals = my_gil_threadlocals state.threadlocals.setup_threads(space) 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: llop.debug_print(lltype.Void, "timeout. progress: " "%d of 2*N (= %f%%)" % \ (len(state.data), 2*N, 100*len(state.data)/(2.0*N))) raise ValueError("time out") still_waiting -= 1 if not we_are_translated(): rgil.release() time.sleep(0.1) if not we_are_translated(): rgil.acquire() 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 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 f(): state.data = [] state.datalen1 = 0 state.datalen2 = 0 state.datalen3 = 0 state.datalen4 = 0 state.threadlocals = my_gil_threadlocals state.threadlocals.setup_threads(space) 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 start_new_thread(space, w_callable, w_args, w_kwargs=None): """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.isinstance_w(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.isinstance_w(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: ident = rthread.start_new_thread(bootstrapper.bootstrap, ()) except Exception: bootstrapper.release() # normally called by the new thread raise except rthread.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=None): """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.isinstance_w(w_args, space.w_tuple): raise oefmt(space.w_TypeError, "2nd arg must be a tuple") if w_kwargs is not None and not space.isinstance_w(w_kwargs, space.w_dict): raise oefmt(space.w_TypeError, "optional 3rd arg must be a dictionary") if not space.is_true(space.callable(w_callable)): raise oefmt(space.w_TypeError, "first arg must be callable") args = Arguments.frompacked(space, w_args, w_kwargs) bootstrapper.acquire(space, w_callable, args) try: try: ident = rthread.start_new_thread(bootstrapper.bootstrap, ()) except Exception: bootstrapper.release() # normally called by the new thread raise except rthread.error: raise wrap_thread_error(space, "can't start new thread") return space.newint(ident)
def new_thread(): ident = rthread.start_new_thread(bootstrap, ()) time.sleep(0.5) # enough time to start, hopefully return ident
def new_thread(fn): bootstrapper.aquire(fn) ident = rthread.start_new_thread(bootstrap, ()) return nil
addr = INETAddress('127.0.0.1', port) assert addr.eq(sock.getsockname()) sock.listen(1) s2 = RSocket(AF_INET, SOCK_STREAM) s2.settimeout(10.0) # test one side with timeouts so select is used, shouldn't affect test connected = [False] #thread-mutable list def connecting(): try: s2.connect(addr) connected[0] = True finally: lock.release() lock = rthread.allocate_lock() lock.acquire(True) rthread.start_new_thread(connecting, ()) print 'waiting for connection' fd1, addr2 = sock.accept() s1 = RSocket(fd=fd1) print 'connection accepted' lock.acquire(True) assert connected[0] print 'connecting side knows that the connection was accepted too' assert addr.eq(s2.getpeername()) #assert addr2.eq(s2.getsockname()) assert addr2.eq(s1.getpeername()) s1.send('?') print 'sent one character' buf = s2.recv(100) assert buf == '?'
s2 = RSocket(AF_INET, SOCK_STREAM) s2.settimeout( 10.0 ) # test one side with timeouts so select is used, shouldn't affect test connected = [False] #thread-mutable list def connecting(): try: s2.connect(addr) connected[0] = True finally: lock.release() lock = rthread.allocate_lock() lock.acquire(True) rthread.start_new_thread(connecting, ()) print 'waiting for connection' fd1, addr2 = sock.accept() s1 = RSocket(fd=fd1) print 'connection accepted' lock.acquire(True) assert connected[0] print 'connecting side knows that the connection was accepted too' assert addr.eq(s2.getpeername()) #assert addr2.eq(s2.getsockname()) assert addr2.eq(s1.getpeername()) s1.send('?') print 'sent one character' buf = s2.recv(100) assert buf == '?'