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_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_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(
[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_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_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_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_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_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
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!)'
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!)'
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
