def test_make_jitcell_getter_custom(): from pypy.rpython.typesystem import LowLevelTypeSystem class FakeRTyper: type_system = LowLevelTypeSystem.instance class FakeJitCell(BaseJitCell): pass celldict = {} def getter(x, y): return celldict.get((x, y)) def setter(newcell, x, y): newcell.x = x newcell.y = y celldict[x, y] = newcell GETTER = lltype.Ptr(lltype.FuncType([lltype.Signed, lltype.Float], llmemory.GCREF)) SETTER = lltype.Ptr(lltype.FuncType([llmemory.GCREF, lltype.Signed, lltype.Float], lltype.Void)) class FakeWarmRunnerDesc: rtyper = FakeRTyper() cpu = None get_jitcell_at_ptr = llhelper(GETTER, getter) set_jitcell_at_ptr = llhelper(SETTER, setter) # state = WarmEnterState(FakeWarmRunnerDesc()) get_jitcell = state._make_jitcell_getter_custom(FakeJitCell) cell1 = get_jitcell(5, 42.5) assert isinstance(cell1, FakeJitCell) assert cell1.x == 5 assert cell1.y == 42.5 cell2 = get_jitcell(5, 42.5) assert cell2 is cell1 cell3 = get_jitcell(41, 42.5) cell4 = get_jitcell(42, 0.25) assert cell1 is not cell3 is not cell4 is not cell1
def make_enter_function(self, jd): from pypy.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 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 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 = llhelper(CAN_NEVER_INLINE, can_never_inline) _get_jitcell_at_ptr = None _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_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 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_jitcell_at_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 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 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 _get_jitcell_at_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_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 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 _get_jitcell_at_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_jitdriver_callbacks_1(): class FakeWarmRunnerDesc: cpu = None memory_manager = None 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 == "(no jitdriver.get_printable_location!)"
def make_enter_function(self): from pypy.jit.metainterp.warmstate import WarmEnterState state = WarmEnterState(self) maybe_compile_and_run = state.make_entry_point() self.state = state def crash_in_jit(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(sys.exc_info()[2]) raise fatalerror('~~~ Crash in JIT! %s' % (e,), traceback=True) crash_in_jit._dont_inline_ = True if self.translator.rtyper.type_system.name == 'lltypesystem': def maybe_enter_jit(*args): try: maybe_compile_and_run(*args) except JitException: raise # go through except Exception, e: crash_in_jit(e) maybe_enter_jit._always_inline_ = True
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 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 = llhelper(CAN_NEVER_INLINE, can_never_inline) _get_jitcell_at_ptr = None _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_set_future_values(): future_values = {} class FakeCPU: def set_future_value_int(self, j, value): future_values[j] = "int", value def set_future_value_float(self, j, value): future_values[j] = "float", value class FakeWarmRunnerDesc: cpu = FakeCPU() red_args_types = ["int", "float"] class metainterp_sd: virtualizable_info = None # state = WarmEnterState(FakeWarmRunnerDesc()) set_future_values = state.make_set_future_values() set_future_values(5, 42.5) assert future_values == { 0: ("int", 5), 1: ("float", 42.5), } assert set_future_values is state.make_set_future_values()
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 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_jitcell_at_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 test_make_unwrap_greenkey(): class FakeWarmRunnerDesc: green_args_spec = [lltype.Signed, lltype.Float] state = WarmEnterState(FakeWarmRunnerDesc()) 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_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: can_inline_ptr = None get_printable_location_ptr = None state = WarmEnterState(FakeWarmRunnerDesc()) state.make_jitdriver_callbacks() res = state.can_inline_callable([BoxInt(5), BoxFloat(42.5)]) assert res is True res = state.get_location_str([BoxInt(5), BoxFloat(42.5)]) assert res == '(no jitdriver.get_printable_location!)'
def test_make_jitcell_getter(): class FakeJitDriverSD: _green_args_spec = [lltype.Float] _get_jitcell_at_ptr = None state = WarmEnterState(None, FakeJitDriverSD()) get_jitcell = state.make_jitcell_getter() cell1 = get_jitcell(True, 1.75) cell2 = get_jitcell(True, 1.75) assert cell1 is cell2 assert get_jitcell is state.make_jitcell_getter()
def test_make_jitcell_getter(): class FakeWarmRunnerDesc: green_args_spec = [lltype.Float] get_jitcell_at_ptr = None state = WarmEnterState(FakeWarmRunnerDesc()) get_jitcell = state.make_jitcell_getter() cell1 = get_jitcell(1.75) cell2 = get_jitcell(1.75) assert cell1 is cell2 assert get_jitcell is state.make_jitcell_getter()
def test_attach_unoptimized_bridge_from_interp(): class FakeWarmRunnerDesc: green_args_spec = [lltype.Signed, lltype.Float] get_jitcell_at_ptr = None state = WarmEnterState(FakeWarmRunnerDesc()) get_jitcell = state.make_jitcell_getter() state.attach_unoptimized_bridge_from_interp([BoxInt(5), BoxFloat(2.25)], "entry loop token") cell1 = get_jitcell(5, 2.25) assert cell1.counter < 0 assert cell1.entry_loop_token == "entry loop token"
def test_attach_unoptimized_bridge_from_interp(): class FakeWarmRunnerDesc: green_args_spec = [lltype.Signed, lltype.Float] get_jitcell_at_ptr = None state = WarmEnterState(FakeWarmRunnerDesc()) get_jitcell = state.make_jitcell_getter() state.attach_unoptimized_bridge_from_interp( [ConstInt(5), ConstFloat(2.25)], "entry loop token") cell1 = get_jitcell(5, 2.25) assert cell1.counter < 0 assert cell1.entry_loop_token == "entry loop token"
def test_make_jitcell_getter_default(): class FakeJitDriverSD: _green_args_spec = [lltype.Signed, lltype.Float] state = WarmEnterState(None, FakeJitDriverSD()) get_jitcell = state._make_jitcell_getter_default() cell1 = get_jitcell(True, 42, 42.5) assert isinstance(cell1, JitCell) cell2 = get_jitcell(True, 42, 42.5) assert cell1 is cell2 cell3 = get_jitcell(True, 41, 42.5) assert get_jitcell(False, 42, 0.25) is None cell4 = get_jitcell(True, 42, 0.25) assert get_jitcell(False, 42, 0.25) is cell4 assert cell1 is not cell3 is not cell4 is not cell1
def test_make_jitcell_getter_default(): class FakeWarmRunnerDesc: green_args_spec = [lltype.Signed, lltype.Float] class FakeJitCell(BaseJitCell): pass state = WarmEnterState(FakeWarmRunnerDesc()) get_jitcell = state._make_jitcell_getter_default(FakeJitCell) cell1 = get_jitcell(42, 42.5) assert isinstance(cell1, FakeJitCell) cell2 = get_jitcell(42, 42.5) assert cell1 is cell2 cell3 = get_jitcell(41, 42.5) cell4 = get_jitcell(42, 0.25) assert cell1 is not cell3 is not cell4 is not cell1
def test_attach_unoptimized_bridge_from_interp(): class FakeJitDriverSD: _green_args_spec = [lltype.Signed, lltype.Float] _get_jitcell_at_ptr = None state = WarmEnterState(None, FakeJitDriverSD()) get_jitcell = state.make_jitcell_getter() class FakeLoopToken(object): pass looptoken = FakeLoopToken() state.attach_unoptimized_bridge_from_interp([ConstInt(5), constfloat(2.25)], looptoken) cell1 = get_jitcell(True, 5, 2.25) assert cell1.counter < 0 assert cell1.get_entry_loop_token() is looptoken
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 green_args_spec = [lltype.Signed, lltype.Float] can_inline_ptr = None get_printable_location_ptr = llhelper(GET_LOCATION, get_location) state = WarmEnterState(FakeWarmRunnerDesc()) state.make_jitdriver_callbacks() res = state.get_location_str([BoxInt(5), BoxFloat(42.5)]) assert res == "hi there"
def test_make_jitdriver_callbacks_2(): def can_inline(x, y): assert x == 5 assert y == 42.5 return False CAN_INLINE = lltype.Ptr(lltype.FuncType([lltype.Signed, lltype.Float], lltype.Bool)) class FakeWarmRunnerDesc: rtyper = None green_args_spec = [lltype.Signed, lltype.Float] can_inline_ptr = llhelper(CAN_INLINE, can_inline) get_printable_location_ptr = None state = WarmEnterState(FakeWarmRunnerDesc()) state.make_jitdriver_callbacks() res = state.can_inline_callable([BoxInt(5), BoxFloat(42.5)]) assert res is False
def test_attach_unoptimized_bridge_from_interp(): class FakeJitDriverSD: _green_args_spec = [lltype.Signed, lltype.Float] _get_jitcell_at_ptr = None state = WarmEnterState(None, FakeJitDriverSD()) get_jitcell = state.make_jitcell_getter() class FakeLoopToken(object): invalidated = False looptoken = FakeLoopToken() state.attach_procedure_to_interp( [ConstInt(5), constfloat(2.25)], looptoken) cell1 = get_jitcell(True, 5, 2.25) assert cell1.counter < 0 assert cell1.get_procedure_token() is looptoken
def test_make_jitcell_getter_custom(): from pypy.rpython.typesystem import LowLevelTypeSystem class FakeRTyper: type_system = LowLevelTypeSystem.instance celldict = {} def getter(x, y): return celldict.get((x, y)) def setter(newcell, x, y): newcell.x = x newcell.y = y celldict[x, y] = newcell GETTER = lltype.Ptr( lltype.FuncType([lltype.Signed, lltype.Float], llmemory.GCREF)) SETTER = lltype.Ptr( lltype.FuncType([llmemory.GCREF, lltype.Signed, lltype.Float], lltype.Void)) class FakeWarmRunnerDesc: rtyper = FakeRTyper() cpu = None memory_manager = None class FakeJitDriverSD: _get_jitcell_at_ptr = llhelper(GETTER, getter) _set_jitcell_at_ptr = llhelper(SETTER, setter) # state = WarmEnterState(FakeWarmRunnerDesc(), FakeJitDriverSD()) get_jitcell = state._make_jitcell_getter_custom() cell1 = get_jitcell(True, 5, 42.5) assert isinstance(cell1, JitCell) assert cell1.x == 5 assert cell1.y == 42.5 cell2 = get_jitcell(True, 5, 42.5) assert cell2 is cell1 cell3 = get_jitcell(True, 41, 42.5) assert get_jitcell(False, 42, 0.25) is None cell4 = get_jitcell(True, 42, 0.25) assert get_jitcell(False, 42, 0.25) is cell4 assert cell1 is not cell3 is not cell4 is not cell1
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 green_args_spec = [lltype.Signed, lltype.Float] can_inline_ptr = None get_printable_location_ptr = None confirm_enter_jit_ptr = llhelper(ENTER_JIT, confirm_enter_jit) get_jitcell_at_ptr = None state = WarmEnterState(FakeWarmRunnerDesc()) state.make_jitdriver_callbacks() res = state.confirm_enter_jit(5, 42.5, 3) assert res is True
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 green_args_spec = [lltype.Signed, lltype.Float] can_inline_ptr = None get_printable_location_ptr = llhelper(GET_LOCATION, get_location) confirm_enter_jit_ptr = None get_jitcell_at_ptr = None state = WarmEnterState(FakeWarmRunnerDesc()) state.make_jitdriver_callbacks() res = state.get_location_str([ConstInt(5), ConstFloat(42.5)]) assert res == "hi there"
def test_make_jitdriver_callbacks_2(): def can_inline(x, y): assert x == 5 assert y == 42.5 return False CAN_INLINE = lltype.Ptr( lltype.FuncType([lltype.Signed, lltype.Float], lltype.Bool)) class FakeCell: dont_trace_here = False class FakeWarmRunnerDesc: rtyper = None green_args_spec = [lltype.Signed, lltype.Float] can_inline_ptr = llhelper(CAN_INLINE, can_inline) get_printable_location_ptr = None confirm_enter_jit_ptr = None state = WarmEnterState(FakeWarmRunnerDesc()) def jit_getter(*args): return FakeCell() state.jit_getter = jit_getter state.make_jitdriver_callbacks() res = state.can_inline_callable([ConstInt(5), ConstFloat(42.5)]) assert res is False
def test_make_jitdriver_callbacks_1(): class FakeWarmRunnerDesc: cpu = None memory_manager = None 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 == '(no jitdriver.get_printable_location!)'
def test_make_set_future_values(): future_values = {} class FakeCPU: def set_future_value_int(self, j, value): future_values[j] = "int", value def set_future_value_float(self, j, value): future_values[j] = "float", value class FakeWarmRunnerDesc: cpu = FakeCPU() memory_manager = None class FakeJitDriverSD: _red_args_types = ["int", "float"] virtualizable_info = None # state = WarmEnterState(FakeWarmRunnerDesc(), FakeJitDriverSD()) set_future_values = state.make_set_future_values() set_future_values(5, 42.5) assert future_values == { 0: ("int", 5), 1: ("float", longlong.getfloatstorage(42.5)), } assert set_future_values is state.make_set_future_values()
def test_cleanup_jitcell_dict(): class FakeJitDriverSD: _green_args_spec = [lltype.Signed] # # Test creating tons of jitcells that remain at 0 warmstate = WarmEnterState(None, FakeJitDriverSD()) get_jitcell = warmstate._make_jitcell_getter_default() cell1 = get_jitcell(True, -1) assert len(warmstate._jitcell_dict) == 1 # for i in range(1, 20005): get_jitcell(True, i) # should trigger a clean-up at 20001 assert len(warmstate._jitcell_dict) == (i % 20000) + 1 # # Same test, with one jitcell that has a counter of BASE instead of 0 warmstate = WarmEnterState(None, FakeJitDriverSD()) get_jitcell = warmstate._make_jitcell_getter_default() cell2 = get_jitcell(True, -2) cell2.counter = BASE = warmstate.THRESHOLD_LIMIT // 2 # 50% # for i in range(0, 20005): get_jitcell(True, i) assert len(warmstate._jitcell_dict) == (i % 19999) + 2 # assert cell2 in warmstate._jitcell_dict.values() assert cell2.counter == int(BASE * 0.92) # decayed once # # Same test, with jitcells that are compiled and freed by the memmgr warmstate = WarmEnterState(None, FakeJitDriverSD()) get_jitcell = warmstate._make_jitcell_getter_default() get_jitcell(True, -1) # for i in range(1, 20005): cell = get_jitcell(True, i) cell.counter = -1 cell.wref_procedure_token = None # or a dead weakref, equivalently assert len(warmstate._jitcell_dict) == (i % 20000) + 1 # # Same test, with counter == -2 (rare case, kept alive) warmstate = WarmEnterState(None, FakeJitDriverSD()) get_jitcell = warmstate._make_jitcell_getter_default() cell = get_jitcell(True, -1) cell.counter = -2 # for i in range(1, 20005): cell = get_jitcell(True, i) cell.counter = -2 assert len(warmstate._jitcell_dict) == i + 1
def test_make_jitdriver_callbacks_2(): def can_inline(x, y): assert x == 5 assert y == 42.5 return False CAN_INLINE = lltype.Ptr(lltype.FuncType([lltype.Signed, lltype.Float], lltype.Bool)) class FakeCell: dont_trace_here = False class FakeWarmRunnerDesc: rtyper = None green_args_spec = [lltype.Signed, lltype.Float] can_inline_ptr = llhelper(CAN_INLINE, can_inline) get_printable_location_ptr = None confirm_enter_jit_ptr = None state = WarmEnterState(FakeWarmRunnerDesc()) def jit_getter(*args): return FakeCell() state.jit_getter = jit_getter state.make_jitdriver_callbacks() res = state.can_inline_callable([ConstInt(5), ConstFloat(42.5)]) assert res is False
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 green_args_spec = [lltype.Signed, lltype.Float] can_inline_ptr = None get_printable_location_ptr = None confirm_enter_jit_ptr = llhelper(ENTER_JIT, confirm_enter_jit) get_jitcell_at_ptr = None state = WarmEnterState(FakeWarmRunnerDesc()) state.make_jitdriver_callbacks() res = state.confirm_enter_jit(5, 42.5, 3) assert res is True
def make_enter_function(self, jd): from pypy.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 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,), traceback=True)
def test_make_jitdriver_callbacks_1(): class FakeWarmRunnerDesc: can_inline_ptr = None get_printable_location_ptr = None confirm_enter_jit_ptr = None green_args_spec = [lltype.Signed, lltype.Float] class FakeCell: dont_trace_here = False state = WarmEnterState(FakeWarmRunnerDesc()) def jit_getter(*args): return FakeCell() state.jit_getter = jit_getter state.make_jitdriver_callbacks() res = state.can_inline_callable([ConstInt(5), ConstFloat(42.5)]) assert res is True res = state.get_location_str([ConstInt(5), ConstFloat(42.5)]) assert res == '(no jitdriver.get_printable_location!)'