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_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_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 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_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 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,))
