def test_make_jitdriver_callbacks_3(): def get_location(x, y): assert x == 5 assert y == 42.5 return "hi there" # abuse the return type, but nobody checks it GET_LOCATION = lltype.Ptr(lltype.FuncType([lltype.Signed, lltype.Float], lltype.Ptr(rstr.STR))) class FakeWarmRunnerDesc: rtyper = None cpu = None memory_manager = None jitcounter = DeterministicJitCounter() class FakeJitDriverSD: jitdriver = None _green_args_spec = [lltype.Signed, lltype.Float] _get_printable_location_ptr = llhelper(GET_LOCATION, get_location) _confirm_enter_jit_ptr = None _can_never_inline_ptr = None _get_unique_id_ptr = None _should_unroll_one_iteration_ptr = None red_args_types = [] state = WarmEnterState(FakeWarmRunnerDesc(), FakeJitDriverSD()) state.make_jitdriver_callbacks() res = state.get_location_str([ConstInt(5), constfloat(42.5)]) assert res == "hi there"
def make_enter_function(self, jd): from rpython.jit.metainterp.warmstate import WarmEnterState state = WarmEnterState(self, jd) maybe_compile_and_run = state.make_entry_point() jd.warmstate = state def crash_in_jit(e): tb = not we_are_translated() and sys.exc_info()[2] try: raise e except jitexc.JitException: raise # go through except MemoryError: raise # go through except StackOverflow: raise # go through except Exception, e: if not we_are_translated(): print "~~~ Crash in JIT!" print '~~~ %s: %s' % (e.__class__, e) if sys.stdout == sys.__stdout__: import pdb pdb.post_mortem(tb) raise e.__class__, e, tb fatalerror('~~~ Crash in JIT! %s' % (e, ))
def test_make_jitdriver_callbacks_5(): def can_never_inline(x, y): assert x == 5 assert y == 42.5 return True CAN_NEVER_INLINE = lltype.Ptr(lltype.FuncType( [lltype.Signed, lltype.Float], lltype.Bool)) class FakeWarmRunnerDesc: rtyper = None cpu = None memory_manager = None jitcounter = DeterministicJitCounter() class FakeJitDriverSD: jitdriver = None _green_args_spec = [lltype.Signed, lltype.Float] _get_printable_location_ptr = None _confirm_enter_jit_ptr = None _get_unique_id_ptr = None _can_never_inline_ptr = llhelper(CAN_NEVER_INLINE, can_never_inline) _should_unroll_one_iteration_ptr = None red_args_types = [] state = WarmEnterState(FakeWarmRunnerDesc(), FakeJitDriverSD()) state.make_jitdriver_callbacks() res = state.can_never_inline(5, 42.5) assert res is True
def test_make_jitdriver_callbacks_4(): def confirm_enter_jit(x, y, z): assert x == 5 assert y == 42.5 assert z == 3 return True ENTER_JIT = lltype.Ptr(lltype.FuncType([lltype.Signed, lltype.Float, lltype.Signed], lltype.Bool)) class FakeWarmRunnerDesc: rtyper = None cpu = None memory_manager = None jitcounter = DeterministicJitCounter() class FakeJitDriverSD: jitdriver = None _green_args_spec = [lltype.Signed, lltype.Float] _get_printable_location_ptr = None _confirm_enter_jit_ptr = llhelper(ENTER_JIT, confirm_enter_jit) _can_never_inline_ptr = None _should_unroll_one_iteration_ptr = None red_args_types = [] state = WarmEnterState(FakeWarmRunnerDesc(), FakeJitDriverSD()) state.make_jitdriver_callbacks() res = state.confirm_enter_jit(5, 42.5, 3) assert res is True
def make_enter_function(self, jd): from rpython.jit.metainterp.warmstate import WarmEnterState state = WarmEnterState(self, jd) maybe_compile_and_run, EnterJitAssembler = state.make_entry_point() jd.warmstate = state def crash_in_jit(e): tb = not we_are_translated() and sys.exc_info()[2] try: raise e except jitexc.JitException: raise # go through except MemoryError: raise # go through except StackOverflow: raise # go through except Exception as e: if not we_are_translated(): print "~~~ Crash in JIT!" print '~~~ %s: %s' % (e.__class__, e) if sys.stdout == sys.__stdout__: import pdb; pdb.post_mortem(tb) raise e.__class__, e, tb fatalerror('~~~ Crash in JIT! %s' % (e,)) crash_in_jit._dont_inline_ = True def maybe_enter_jit(*args): try: maybe_compile_and_run(state.increment_threshold, *args) except Exception as e: crash_in_jit(e) maybe_enter_jit._always_inline_ = True jd._maybe_enter_jit_fn = maybe_enter_jit jd._maybe_compile_and_run_fn = maybe_compile_and_run jd._EnterJitAssembler = EnterJitAssembler
def test_make_jitdriver_callbacks_4(): def confirm_enter_jit(x, y, z): assert x == 5 assert y == 42.5 assert z == 3 return True ENTER_JIT = lltype.Ptr( lltype.FuncType([lltype.Signed, lltype.Float, lltype.Signed], lltype.Bool)) class FakeWarmRunnerDesc: rtyper = None cpu = None memory_manager = None jitcounter = DeterministicJitCounter() class FakeJitDriverSD: jitdriver = None _green_args_spec = [lltype.Signed, lltype.Float] _get_printable_location_ptr = None _confirm_enter_jit_ptr = llhelper(ENTER_JIT, confirm_enter_jit) _can_never_inline_ptr = None _should_unroll_one_iteration_ptr = None red_args_types = [] state = WarmEnterState(FakeWarmRunnerDesc(), FakeJitDriverSD()) state.make_jitdriver_callbacks() res = state.confirm_enter_jit(5, 42.5, 3) assert res is True
def test_make_unwrap_greenkey(): class FakeJitDriverSD: _green_args_spec = [lltype.Signed, lltype.Float] state = WarmEnterState(None, FakeJitDriverSD()) unwrap_greenkey = state.make_unwrap_greenkey() greenargs = unwrap_greenkey([ConstInt(42), constfloat(42.5)]) assert greenargs == (42, 42.5) assert type(greenargs[0]) is int
def test_make_jitdriver_callbacks_1(): class FakeWarmRunnerDesc: cpu = None memory_manager = None jitcounter = DeterministicJitCounter() class FakeJitDriverSD: jitdriver = None _green_args_spec = [lltype.Signed, lltype.Float] _get_printable_location_ptr = None _confirm_enter_jit_ptr = None _can_never_inline_ptr = None _should_unroll_one_iteration_ptr = None red_args_types = [] class FakeCell: dont_trace_here = False state = WarmEnterState(FakeWarmRunnerDesc(), FakeJitDriverSD()) def jit_getter(build, *args): return FakeCell() state.jit_getter = jit_getter state.make_jitdriver_callbacks() res = state.get_location_str([ConstInt(5), constfloat(42.5)]) assert res == '(<unknown jitdriver>: no get_printable_location)'
def make_enter_function(self, jd): from rpython.jit.metainterp.warmstate import WarmEnterState state = WarmEnterState(self, jd) maybe_compile_and_run, EnterJitAssembler = state.make_entry_point() jd.warmstate = state def crash_in_jit(e): tb = not we_are_translated() and sys.exc_info()[2] try: raise e except jitexc.JitException: raise # go through except MemoryError: raise # go through except StackOverflow: raise # go through except Exception as e: if not we_are_translated(): print "~~~ Crash in JIT!" print '~~~ %s: %s' % (e.__class__, e) if sys.stdout == sys.__stdout__: import pdb pdb.post_mortem(tb) raise e.__class__, e, tb fatalerror('~~~ Crash in JIT! %s' % (e, )) crash_in_jit._dont_inline_ = True def maybe_enter_jit(*args): try: maybe_compile_and_run(state.increment_threshold, *args) except Exception as e: crash_in_jit(e) maybe_enter_jit._always_inline_ = True jd._maybe_enter_jit_fn = maybe_enter_jit jd._maybe_compile_and_run_fn = maybe_compile_and_run jd._EnterJitAssembler = EnterJitAssembler
def make_enter_function(self, jd): from rpython.jit.metainterp.warmstate import WarmEnterState state = WarmEnterState(self, jd) maybe_compile_and_run = state.make_entry_point() jd.warmstate = state def crash_in_jit(e): tb = not we_are_translated() and sys.exc_info()[2] try: raise e except jitexc.JitException: raise # go through except MemoryError: raise # go through except StackOverflow: raise # go through except Exception, e: if not we_are_translated(): print "~~~ Crash in JIT!" print '~~~ %s: %s' % (e.__class__, e) if sys.stdout == sys.__stdout__: import pdb; pdb.post_mortem(tb) raise e.__class__, e, tb fatalerror('~~~ Crash in JIT! %s' % (e,))