def test_elidable_kinds():
from rpython.jit.backend.llgraph.runner import LLGraphCPU
@jit.elidable
def f1(n, m):
return n + m
@jit.elidable
def f2(n, m):
return [n, m] # may raise MemoryError
@jit.elidable
def f3(n, m):
if n > m:
raise ValueError
return n + m
def f(n, m):
a = f1(n, m)
b = f2(n, m)
c = f3(n, m)
return a + len(b) + c
rtyper = support.annotate(f, [7, 9])
jitdriver_sd = FakeJitDriverSD(rtyper.annotator.translator.graphs[0])
cc = CallControl(LLGraphCPU(rtyper), jitdrivers_sd=[jitdriver_sd])
res = cc.find_all_graphs(FakePolicy())
[f_graph] = [x for x in res if x.func is f]
for index, expected in [
(0, EffectInfo.EF_ELIDABLE_CANNOT_RAISE),
(1, EffectInfo.EF_ELIDABLE_OR_MEMORYERROR),
(2, EffectInfo.EF_ELIDABLE_CAN_RAISE)]:
call_op = f_graph.startblock.operations[index]
assert call_op.opname == 'direct_call'
call_descr = cc.getcalldescr(call_op)
assert call_descr.extrainfo.extraeffect == expected
def test_random_effects_on_stacklet_switch():
from rpython.jit.backend.llgraph.runner import LLGraphCPU
from rpython.translator.platform import CompilationError
try:
from rpython.rlib._rffi_stacklet import switch, handle
except CompilationError as e:
if "Unsupported platform!" in e.out:
py.test.skip("Unsupported platform!")
else:
raise e
@jit.dont_look_inside
def f():
switch(rffi.cast(handle, 0))
rtyper = support.annotate(f, [])
jitdriver_sd = FakeJitDriverSD(rtyper.annotator.translator.graphs[0])
cc = CallControl(LLGraphCPU(rtyper), jitdrivers_sd=[jitdriver_sd])
res = cc.find_all_graphs(FakePolicy())
[f_graph] = [x for x in res if x.func is f]
[block, _] = list(f_graph.iterblocks())
op = block.operations[-1]
call_descr = cc.getcalldescr(op)
assert call_descr.extrainfo.has_random_effects()
def test_can_or_cannot_collect():
from rpython.jit.backend.llgraph.runner import LLGraphCPU
prebuilts = [[5], [6]]
l = []
def f1(n):
if n > 1:
raise IndexError
return prebuilts[n] # cannot collect
f1._dont_inline_ = True
def f2(n):
return [n] # can collect
f2._dont_inline_ = True
def f(n):
a = f1(n)
b = f2(n)
return len(a) + len(b)
rtyper = support.annotate(f, [1])
jitdriver_sd = FakeJitDriverSD(rtyper.annotator.translator.graphs[0])
cc = CallControl(LLGraphCPU(rtyper), jitdrivers_sd=[jitdriver_sd])
res = cc.find_all_graphs(FakePolicy())
[f_graph] = [x for x in res if x.func is f]
for index, expected in [(0, False), (1, True), (2, False), (3, False)]: # f1() # f2() # len() # len()
call_op = f_graph.startblock.operations[index]
assert call_op.opname == "direct_call"
call_descr = cc.getcalldescr(call_op)
assert call_descr.extrainfo.check_can_collect() == expected
def test_instantiate_with_unreasonable_attr():
# It is possible to have in real code the instantiate() function for
# a class be dont-look-inside. This is caused by the code that
# initialize the instance attributes: if one attribute has a strange
# type, the whole function is disabled. Check that it still works.
class MyFakePolicy:
def look_inside_graph(self, graph):
name = graph.name
return not (name.startswith('instantiate_') and
name.endswith('A2'))
class A1:
pass
class A2(A1):
pass
classes = [A1, A2]
def f(n):
x = classes[n]
x()
rtyper = support.annotate(f, [1])
maingraph = rtyper.annotator.translator.graphs[0]
cw = CodeWriter(FakeCPU(rtyper), [FakeJitDriverSD(maingraph)])
cw.find_all_graphs(MyFakePolicy())
cw.make_jitcodes(verbose=True)
#
names = [jitcode.name for jitcode in cw.assembler.indirectcalltargets]
assert len(names) == 1
assert names[0].startswith('instantiate_') and names[0].endswith('A1')
def transform_func_to_jitcode(self, func, values):
"""For testing."""
rtyper = support.annotate(func, values)
graph = rtyper.annotator.translator.graphs[0]
jitcode = JitCode("test")
self.transform_graph_to_jitcode(graph, jitcode, True)
return jitcode
def test_call_release_gil():
from rpython.jit.backend.llgraph.runner import LLGraphCPU
T = rffi.CArrayPtr(rffi.TIME_T)
external = rffi.llexternal("time", [T], rffi.TIME_T, releasegil=True,
save_err=rffi.RFFI_SAVE_ERRNO)
# no jit.dont_look_inside in this test
def f():
return external(lltype.nullptr(T.TO))
rtyper = support.annotate(f, [])
jitdriver_sd = FakeJitDriverSD(rtyper.annotator.translator.graphs[0])
cc = CallControl(LLGraphCPU(rtyper), jitdrivers_sd=[jitdriver_sd])
res = cc.find_all_graphs(FakePolicy())
[llext_graph] = [x for x in res if x.func is external]
[block, _] = list(llext_graph.iterblocks())
[op] = block.operations
tgt_tuple = op.args[0].value._obj.graph.func._call_aroundstate_target_
assert type(tgt_tuple) is tuple and len(tgt_tuple) == 2
call_target, saveerr = tgt_tuple
assert saveerr == rffi.RFFI_SAVE_ERRNO
call_target = llmemory.cast_ptr_to_adr(call_target)
call_descr = cc.getcalldescr(op)
assert call_descr.extrainfo.has_random_effects()
assert call_descr.extrainfo.is_call_release_gil() is True
assert call_descr.extrainfo.call_release_gil_target == (
call_target, rffi.RFFI_SAVE_ERRNO)
def test_find_all_graphs():
def g(x):
return x + 2
def f(x):
return g(x) + 1
rtyper = support.annotate(f, [7])
jitdriver_sd = FakeJitDriverSD(rtyper.annotator.translator.graphs[0])
cc = CallControl(jitdrivers_sd=[jitdriver_sd])
res = cc.find_all_graphs(FakePolicy())
funcs = set([graph.func for graph in res])
assert funcs == set([f, g])
def test_int_abs():
def f(n):
return abs(n)
rtyper = support.annotate(f, [35])
jitdriver_sd = FakeJitDriverSD(rtyper.annotator.translator.graphs[0])
cw = CodeWriter(FakeCPU(rtyper), [jitdriver_sd])
cw.find_all_graphs(FakePolicy())
cw.make_jitcodes(verbose=True)
#
s = jitdriver_sd.mainjitcode.dump()
assert "inline_call_ir_i <JitCode '_ll_1_int_abs__Signed'>" in s
def test_find_all_graphs():
def g(x):
return x + 2
def f(x):
return g(x) + 1
rtyper = support.annotate(f, [7])
jitdriver_sd = FakeJitDriverSD(rtyper.annotator.translator.graphs[0])
cc = CallControl(jitdrivers_sd=[jitdriver_sd])
res = cc.find_all_graphs(FakePolicy())
funcs = set([graph.func for graph in res])
assert funcs == set([f, g])
def test_newlist_negativ():
def f(n):
l = [0] * n
return len(l)
rtyper = support.annotate(f, [-1])
jitdriver_sd = FakeJitDriverSD(rtyper.annotator.translator.graphs[0])
cw = CodeWriter(FakeCPU(rtyper), [jitdriver_sd])
graphs = cw.find_all_graphs(FakePolicy())
backend_optimizations(rtyper.annotator.translator, graphs=graphs)
cw.make_jitcodes(verbose=True)
s = jitdriver_sd.mainjitcode.dump()
assert 'int_force_ge_zero' in s
assert 'new_array' in s
def test_find_all_graphs_without_g():
def g(x):
return x + 2
def f(x):
return g(x) + 1
rtyper = support.annotate(f, [7])
jitdriver_sd = FakeJitDriverSD(rtyper.annotator.translator.graphs[0])
cc = CallControl(jitdrivers_sd=[jitdriver_sd])
class CustomFakePolicy:
def look_inside_graph(self, graph):
assert graph.name == 'g'
return False
res = cc.find_all_graphs(CustomFakePolicy())
funcs = [graph.func for graph in res]
assert funcs == [f]
def test_access_directly_but_not_seen():
class X:
_virtualizable_ = ["a"]
def h(x, y):
w = 0
for i in range(y):
w += 4
return w
def f(y):
x = jit.hint(X(), access_directly=True)
h(x, y)
rtyper = support.annotate(f, [3])
h_graph = rtyper.annotator.translator.graphs[1]
assert h_graph.func is h
py.test.raises(ValueError, JitPolicy().look_inside_graph, h_graph)
def test_elidable_kinds():
from rpython.jit.backend.llgraph.runner import LLGraphCPU
from rpython.rlib.objectmodel import compute_hash
from rpython.rlib.rsiphash import enable_siphash24
@jit.elidable
def f1(n, m):
return n + m
@jit.elidable
def f2(n, m):
return [n, m] # may raise MemoryError
@jit.elidable
def f3(n, m):
if n > m:
raise ValueError
return n + m
@jit.elidable
def f4(n, m):
return compute_hash(str(n) + str(m))
def f(n, m):
a = f1(n, m)
b = f2(n, m)
c = f3(n, m)
d = f4(n, m)
enable_siphash24()
return a + len(b) + c + d
rtyper = support.annotate(f, [7, 9])
jitdriver_sd = FakeJitDriverSD(rtyper.annotator.translator.graphs[0])
cc = CallControl(LLGraphCPU(rtyper), jitdrivers_sd=[jitdriver_sd])
res = cc.find_all_graphs(FakePolicy())
[f_graph] = [x for x in res if x.func is f]
for index, expected in [(0, EffectInfo.EF_ELIDABLE_CANNOT_RAISE),
(1, EffectInfo.EF_ELIDABLE_OR_MEMORYERROR),
(2, EffectInfo.EF_ELIDABLE_CAN_RAISE),
(3, EffectInfo.EF_ELIDABLE_OR_MEMORYERROR)]:
call_op = f_graph.startblock.operations[index]
assert call_op.opname == 'direct_call'
call_descr = cc.getcalldescr(call_op)
assert call_descr.extrainfo.extraeffect == expected
def test_access_directly_but_not_seen():
class X:
_virtualizable_ = ["a"]
def h(x, y):
w = 0
for i in range(y):
w += 4
return w
def f(y):
x = jit.hint(X(), access_directly=True)
h(x, y)
rtyper = support.annotate(f, [3])
h_graph = rtyper.annotator.translator.graphs[1]
assert h_graph.func is h
py.test.raises(ValueError, JitPolicy().look_inside_graph, h_graph)
def test_raise_elidable_no_result():
from rpython.jit.backend.llgraph.runner import LLGraphCPU
l = []
@jit.elidable
def f1(n, m):
l.append(n)
def f(n, m):
f1(n, m)
return n + m
rtyper = support.annotate(f, [7, 9])
jitdriver_sd = FakeJitDriverSD(rtyper.annotator.translator.graphs[0])
cc = CallControl(LLGraphCPU(rtyper), jitdrivers_sd=[jitdriver_sd])
res = cc.find_all_graphs(FakePolicy())
[f_graph] = [x for x in res if x.func is f]
call_op = f_graph.startblock.operations[0]
assert call_op.opname == 'direct_call'
with py.test.raises(Exception):
call_descr = cc.getcalldescr(call_op)
def test_find_all_graphs_without_g():
def g(x):
return x + 2
def f(x):
return g(x) + 1
rtyper = support.annotate(f, [7])
jitdriver_sd = FakeJitDriverSD(rtyper.annotator.translator.graphs[0])
cc = CallControl(jitdrivers_sd=[jitdriver_sd])
class CustomFakePolicy:
def look_inside_graph(self, graph):
assert graph.name == 'g'
return False
res = cc.find_all_graphs(CustomFakePolicy())
funcs = [graph.func for graph in res]
assert funcs == [f]
def test_call():
def ggg(x):
return x * 2
def fff(a, b):
return ggg(b) - ggg(a)
rtyper = support.annotate(fff, [35, 42])
jitdriver_sd = FakeJitDriverSD(rtyper.annotator.translator.graphs[0])
cw = CodeWriter(FakeCPU(rtyper), [jitdriver_sd])
cw.find_all_graphs(FakePolicy())
cw.make_jitcodes(verbose=True)
jitcode = jitdriver_sd.mainjitcode
print jitcode.dump()
[jitcode2] = cw.assembler.descrs
print jitcode2.dump()
assert jitcode is not jitcode2
assert jitcode.name == 'fff'
assert jitcode2.name == 'ggg'
assert 'ggg' in jitcode.dump()
assert lltype.typeOf(jitcode2.fnaddr) == llmemory.Address
assert isinstance(jitcode2.calldescr, FakeCallDescr)
def test_call():
def ggg(x):
return x * 2
def fff(a, b):
return ggg(b) - ggg(a)
rtyper = support.annotate(fff, [35, 42])
jitdriver_sd = FakeJitDriverSD(rtyper.annotator.translator.graphs[0])
cw = CodeWriter(FakeCPU(rtyper), [jitdriver_sd])
cw.find_all_graphs(FakePolicy())
cw.make_jitcodes(verbose=True)
jitcode = jitdriver_sd.mainjitcode
print jitcode.dump()
[jitcode2] = cw.assembler.descrs
print jitcode2.dump()
assert jitcode is not jitcode2
assert jitcode.name == 'fff'
assert jitcode2.name == 'ggg'
assert 'ggg' in jitcode.dump()
assert lltype.typeOf(jitcode2.fnaddr) == llmemory.Address
assert isinstance(jitcode2.calldescr, FakeCallDescr)
def test_instantiate():
class A1:
id = 651
class A2(A1):
id = 652
class B1:
id = 661
class B2(B1):
id = 662
def dont_look(n):
return n + 1
classes = [
(A1, B1),
(A2, B2)
]
def f(n):
x, y = classes[n]
return x().id + y().id + dont_look(n)
rtyper = support.annotate(f, [0])
maingraph = rtyper.annotator.translator.graphs[0]
cw = CodeWriter(FakeCPU(rtyper), [FakeJitDriverSD(maingraph)])
cw.find_all_graphs(FakePolicy())
cw.make_jitcodes(verbose=True)
#
assert len(cw.assembler.indirectcalltargets) == 4
names = [jitcode.name for jitcode in cw.assembler.indirectcalltargets]
for expected in ['A1', 'A2', 'B1', 'B2']:
for name in names:
if name.startswith('instantiate_') and name.endswith(expected):
break
else:
assert 0, "missing instantiate_*_%s in:\n%r" % (expected,
names)
names = set([value for key, value in cw.assembler.list_of_addr2name])
assert 'dont_look' in names
def test_instantiate():
class A1:
id = 651
class A2(A1):
id = 652
class B1:
id = 661
class B2(B1):
id = 662
def dont_look(n):
return n + 1
classes = [
(A1, B1),
(A2, B2)
]
def f(n):
x, y = classes[n]
return x().id + y().id + dont_look(n)
rtyper = support.annotate(f, [0])
maingraph = rtyper.annotator.translator.graphs[0]
cw = CodeWriter(FakeCPU(rtyper), [FakeJitDriverSD(maingraph)])
cw.find_all_graphs(FakePolicy())
cw.make_jitcodes(verbose=True)
#
assert len(cw.assembler.indirectcalltargets) == 4
names = [jitcode.name for jitcode in cw.assembler.indirectcalltargets]
for expected in ['A1', 'A2', 'B1', 'B2']:
for name in names:
if name.startswith('instantiate_') and name.endswith(expected):
break
else:
assert 0, "missing instantiate_*_%s in:\n%r" % (expected,
names)
names = set([value for key, value in cw.assembler.list_of_addr2name])
assert 'dont_look' in names
def test_raise_elidable_no_result():
from rpython.jit.backend.llgraph.runner import LLGraphCPU
l = []
@jit.elidable
def f1(n, m):
l.append(n)
def f(n, m):
f1(n, m)
return n + m
rtyper = support.annotate(f, [7, 9])
jitdriver_sd = FakeJitDriverSD(rtyper.annotator.translator.graphs[0])
cc = CallControl(LLGraphCPU(rtyper), jitdrivers_sd=[jitdriver_sd])
res = cc.find_all_graphs(FakePolicy())
[f_graph] = [x for x in res if x.func is f]
call_op = f_graph.startblock.operations[0]
assert call_op.opname == 'direct_call'
with py.test.raises(Exception):
call_descr = cc.getcalldescr(call_op)
def test_raw_malloc_and_access():
TP = rffi.CArray(lltype.Signed)
def f(n):
a = lltype.malloc(TP, n, flavor='raw')
a[0] = n
res = a[0]
lltype.free(a, flavor='raw')
return res
rtyper = support.annotate(f, [35])
jitdriver_sd = FakeJitDriverSD(rtyper.annotator.translator.graphs[0])
cw = CodeWriter(FakeCPU(rtyper), [jitdriver_sd])
cw.find_all_graphs(FakePolicy())
cw.make_jitcodes(verbose=True)
#
s = jitdriver_sd.mainjitcode.dump()
assert 'residual_call_ir_i $<* fn _ll_1_raw_malloc_varsize__Signed>' in s
assert 'setarrayitem_raw_i' in s
assert 'getarrayitem_raw_i' in s
assert 'residual_call_ir_v $<* fn _ll_1_raw_free__arrayPtr>' in s
def test_raw_malloc_and_access():
TP = rffi.CArray(lltype.Signed)
def f(n):
a = lltype.malloc(TP, n, flavor='raw')
a[0] = n
res = a[0]
lltype.free(a, flavor='raw')
return res
rtyper = support.annotate(f, [35])
jitdriver_sd = FakeJitDriverSD(rtyper.annotator.translator.graphs[0])
cw = CodeWriter(FakeCPU(rtyper), [jitdriver_sd])
cw.find_all_graphs(FakePolicy())
cw.make_jitcodes(verbose=True)
#
s = jitdriver_sd.mainjitcode.dump()
assert 'residual_call_ir_i $<* fn _ll_1_raw_malloc_varsize__Signed>' in s
assert 'setarrayitem_raw_i' in s
assert 'getarrayitem_raw_i' in s
assert 'residual_call_ir_v $<* fn _ll_1_raw_free__arrayPtr>' in s
def test_releases_gil_analyzer():
from rpython.jit.backend.llgraph.runner import LLGraphCPU
T = rffi.CArrayPtr(rffi.TIME_T)
external = rffi.llexternal("time", [T], rffi.TIME_T, releasegil=True)
@jit.dont_look_inside
def f():
return external(lltype.nullptr(T.TO))
rtyper = support.annotate(f, [])
jitdriver_sd = FakeJitDriverSD(rtyper.annotator.translator.graphs[0])
cc = CallControl(LLGraphCPU(rtyper), jitdrivers_sd=[jitdriver_sd])
res = cc.find_all_graphs(FakePolicy())
[f_graph] = [x for x in res if x.func is f]
[block, _] = list(f_graph.iterblocks())
[op] = block.operations
call_descr = cc.getcalldescr(op)
assert call_descr.extrainfo.has_random_effects()
assert call_descr.extrainfo.is_call_release_gil() is False
def test_releases_gil_analyzer():
from rpython.jit.backend.llgraph.runner import LLGraphCPU
T = rffi.CArrayPtr(rffi.TIME_T)
external = rffi.llexternal("time", [T], rffi.TIME_T, releasegil=True)
@jit.dont_look_inside
def f():
return external(lltype.nullptr(T.TO))
rtyper = support.annotate(f, [])
jitdriver_sd = FakeJitDriverSD(rtyper.annotator.translator.graphs[0])
cc = CallControl(LLGraphCPU(rtyper), jitdrivers_sd=[jitdriver_sd])
res = cc.find_all_graphs(FakePolicy())
[f_graph] = [x for x in res if x.func is f]
[block, _] = list(f_graph.iterblocks())
[op] = block.operations
call_descr = cc.getcalldescr(op)
assert call_descr.extrainfo.has_random_effects()
assert call_descr.extrainfo.is_call_release_gil() is False
def test_no_random_effects_for_rotateLeft():
from rpython.jit.backend.llgraph.runner import LLGraphCPU
from rpython.rlib.rarithmetic import r_uint
if r_uint.BITS == 32:
py.test.skip("64-bit only")
from rpython.rlib.rmd5 import _rotateLeft
def f(n, m):
return _rotateLeft(r_uint(n), m)
rtyper = support.annotate(f, [7, 9])
jitdriver_sd = FakeJitDriverSD(rtyper.annotator.translator.graphs[0])
cc = CallControl(LLGraphCPU(rtyper), jitdrivers_sd=[jitdriver_sd])
res = cc.find_all_graphs(FakePolicy())
[f_graph] = [x for x in res if x.func is f]
[block, _] = list(f_graph.iterblocks())
op = block.operations[-1]
call_descr = cc.getcalldescr(op)
assert not call_descr.extrainfo.has_random_effects()
assert call_descr.extrainfo.check_is_elidable()
def test_no_random_effects_for_rotateLeft():
from rpython.jit.backend.llgraph.runner import LLGraphCPU
from rpython.rlib.rarithmetic import r_uint
if r_uint.BITS == 32:
py.test.skip("64-bit only")
from rpython.rlib.rmd5 import _rotateLeft
def f(n, m):
return _rotateLeft(r_uint(n), m)
rtyper = support.annotate(f, [7, 9])
jitdriver_sd = FakeJitDriverSD(rtyper.annotator.translator.graphs[0])
cc = CallControl(LLGraphCPU(rtyper), jitdrivers_sd=[jitdriver_sd])
res = cc.find_all_graphs(FakePolicy())
[f_graph] = [x for x in res if x.func is f]
[block, _] = list(f_graph.iterblocks())
op = block.operations[-1]
call_descr = cc.getcalldescr(op)
assert not call_descr.extrainfo.has_random_effects()
assert call_descr.extrainfo.check_is_elidable()
def test_can_or_cannot_collect():
from rpython.jit.backend.llgraph.runner import LLGraphCPU
prebuilts = [[5], [6]]
l = []
def f1(n):
if n > 1:
raise IndexError
return prebuilts[n] # cannot collect
f1._dont_inline_ = True
def f2(n):
return [n] # can collect
f2._dont_inline_ = True
def f(n):
a = f1(n)
b = f2(n)
return len(a) + len(b)
rtyper = support.annotate(f, [1])
jitdriver_sd = FakeJitDriverSD(rtyper.annotator.translator.graphs[0])
cc = CallControl(LLGraphCPU(rtyper), jitdrivers_sd=[jitdriver_sd])
res = cc.find_all_graphs(FakePolicy())
[f_graph] = [x for x in res if x.func is f]
for index, expected in [
(0, False), # f1()
(1, True), # f2()
(2, False), # len()
(3, False)
]: # len()
call_op = f_graph.startblock.operations[index]
assert call_op.opname == 'direct_call'
call_descr = cc.getcalldescr(call_op)
assert call_descr.extrainfo.check_can_collect() == expected
def setup_class(cls):
from rpython.jit.metainterp.typesystem import llhelper
from rpython.jit.codewriter.support import annotate
from rpython.jit.metainterp.warmspot import WarmRunnerDesc
from rpython.rtyper.rclass import OBJECT, OBJECT_VTABLE
from rpython.rtyper.lltypesystem import lltype, llmemory
exc_vtable = lltype.malloc(OBJECT_VTABLE, immortal=True)
cls.exc_vtable = exc_vtable
class FakeFailDescr(object):
def __init__(self, no):
self.no = no
def handle_fail(self, deadframe, metainterp_sd, jitdrivers_sd):
no = self.no
assert deadframe._no == no
if no == 0:
raise jitexc.DoneWithThisFrameInt(3)
if no == 1:
raise jitexc.ContinueRunningNormally(
[0], [], [], [1], [], [])
if no == 3:
exc = lltype.malloc(OBJECT)
exc.typeptr = exc_vtable
raise jitexc.ExitFrameWithExceptionRef(
metainterp_sd.cpu,
lltype.cast_opaque_ptr(llmemory.GCREF, exc))
assert 0
class FakeDeadFrame:
def __init__(self, no):
self._no = no
class FakeDescr:
pass
class FakeCPU(object):
supports_floats = False
supports_longlong = False
supports_singlefloats = False
ts = llhelper
translate_support_code = False
stats = "stats"
class tracker:
pass
def setup_descrs(self):
return []
def get_latest_descr(self, deadframe):
assert isinstance(deadframe, FakeDeadFrame)
return self.get_fail_descr_from_number(deadframe._no)
def get_fail_descr_number(self, d):
return -1
def __init__(self, *args, **kwds):
pass
def nodescr(self, *args, **kwds):
return FakeDescr()
fielddescrof = nodescr
calldescrof = nodescr
sizeof = nodescr
def get_fail_descr_from_number(self, no):
return FakeFailDescr(no)
def make_execute_token(self, *ARGS):
return "not callable"
driver = JitDriver(reds = ['red'], greens = ['green'])
def f(green):
red = 0
while red < 10:
driver.can_enter_jit(red=red, green=green)
driver.jit_merge_point(red=red, green=green)
red += 1
return red
rtyper = annotate(f, [0])
FakeCPU.rtyper = rtyper
translator = rtyper.annotator.translator
translator.config.translation.gc = 'hybrid'
cls.desc = WarmRunnerDesc(translator, CPUClass=FakeCPU)
cls.FakeDeadFrame = FakeDeadFrame
def test_elidable_kinds():
from rpython.jit.backend.llgraph.runner import LLGraphCPU
from rpython.rlib.objectmodel import compute_hash
from rpython.rlib.rsiphash import enable_siphash24
@jit.elidable
def f1(n, m):
return n + m
@jit.elidable
def f2(n, m):
return [n, m] # may raise MemoryError
@jit.elidable
def f3(n, m):
if n > m:
raise ValueError
return n + m
@jit.elidable
def f4(n, m):
return compute_hash(str(n) + str(m))
T = rffi.CArrayPtr(rffi.TIME_T)
external = rffi.llexternal("time", [T], rffi.TIME_T, releasegil=True)
def effect():
return external(lltype.nullptr(T.TO))
@jit.elidable
def f5(n, m):
effect()
return 1
def f(n, m):
a = f1(n, m)
b = f2(n, m)
c = f3(n, m)
d = f4(n, m)
f5(n, m)
enable_siphash24()
return a + len(b) + c + d
rtyper = support.annotate(f, [7, 9])
jitdriver_sd = FakeJitDriverSD(rtyper.annotator.translator.graphs[0])
cc = CallControl(LLGraphCPU(rtyper), jitdrivers_sd=[jitdriver_sd])
res = cc.find_all_graphs(FakePolicy())
[f_graph] = [x for x in res if x.func is f]
for index, expected in [(0, EffectInfo.EF_ELIDABLE_CANNOT_RAISE),
(1, EffectInfo.EF_ELIDABLE_OR_MEMORYERROR),
(2, EffectInfo.EF_ELIDABLE_CAN_RAISE),
(3, EffectInfo.EF_ELIDABLE_OR_MEMORYERROR)]:
call_op = f_graph.startblock.operations[index]
assert call_op.opname == 'direct_call'
call_descr = cc.getcalldescr(call_op)
assert call_descr.extrainfo.extraeffect == expected
call_op = f_graph.startblock.operations[4]
assert call_op.opname == 'direct_call'
excinfo = py.test.raises(Exception, cc.getcalldescr, call_op)
lines = excinfo.value.args[0].splitlines()
assert "f5" in lines[2]
assert "effect" in lines[3]
assert "random effects" in lines[-1]
def make_graphs(self, func, values, type_system='lltype'):
self.rtyper = support.annotate(func, values, type_system=type_system)
return self.rtyper.annotator.translator.graphs
def _get_jitcodes(testself, CPUClass, func, values,
supports_floats=True,
supports_longlong=False,
supports_singlefloats=False,
translationoptions={}, **kwds):
from rpython.jit.codewriter import support
class FakeJitCell(object):
__product_token = None
def get_procedure_token(self):
return self.__product_token
def set_procedure_token(self, token):
self.__product_token = token
class FakeWarmRunnerState(object):
def attach_procedure_to_interp(self, greenkey, procedure_token):
assert greenkey == []
self._cell.set_procedure_token(procedure_token)
def helper_func(self, FUNCPTR, func):
from rpython.rtyper.annlowlevel import llhelper
return llhelper(FUNCPTR, func)
def get_unique_id(self, *args):
return 0
def get_location_str(self, args):
return 'location'
class JitCell:
@staticmethod
def get_jit_cell_at_key(greenkey):
assert greenkey == []
return FakeWarmRunnerState._cell
_cell = FakeJitCell()
trace_limit = sys.maxint
enable_opts = ALL_OPTS_DICT
vec = True
if kwds.pop('disable_optimizations', False):
FakeWarmRunnerState.enable_opts = {}
func._jit_unroll_safe_ = True
rtyper = support.annotate(func, values,
translationoptions=translationoptions)
graphs = rtyper.annotator.translator.graphs
testself.all_graphs = graphs
result_kind = history.getkind(graphs[0].getreturnvar().concretetype)[0]
class FakeJitDriver:
name = 'fakejitdriver'
class FakeJitDriverSD:
num_green_args = 0
portal_graph = graphs[0]
virtualizable_info = None
greenfield_info = None
result_type = result_kind
portal_runner_ptr = "???"
vec = False
jitdriver = FakeJitDriver()
stats = history.Stats(None)
cpu = CPUClass(rtyper, stats, None, False)
cw = codewriter.CodeWriter(cpu, [FakeJitDriverSD()])
cw.debug = True
testself.cw = cw
if supports_floats and not cpu.supports_floats:
py.test.skip("this test requires supports_floats=True")
if supports_longlong and not cpu.supports_longlong:
py.test.skip("this test requires supports_longlong=True")
if supports_singlefloats and not cpu.supports_singlefloats:
py.test.skip("this test requires supports_singlefloats=True")
policy = JitPolicy()
policy.set_supports_floats(supports_floats)
policy.set_supports_longlong(supports_longlong)
policy.set_supports_singlefloats(supports_singlefloats)
graphs = cw.find_all_graphs(policy)
if kwds.get("backendopt"):
backend_optimizations(rtyper.annotator.translator, graphs=graphs)
#
testself.warmrunnerstate = FakeWarmRunnerState()
testself.warmrunnerstate.cpu = cpu
FakeJitDriverSD.warmstate = testself.warmrunnerstate
if hasattr(testself, 'finish_setup_for_interp_operations'):
testself.finish_setup_for_interp_operations()
#
cw.make_jitcodes(verbose=True)
return stats
def _get_jitcodes(testself,
CPUClass,
func,
values,
supports_floats=True,
supports_longlong=False,
supports_singlefloats=False,
translationoptions={},
**kwds):
from rpython.jit.codewriter import support
class FakeJitCell(object):
__product_token = None
def get_procedure_token(self):
return self.__product_token
def set_procedure_token(self, token):
self.__product_token = token
class FakeWarmRunnerState(object):
def attach_procedure_to_interp(self, greenkey, procedure_token):
assert greenkey == []
self._cell.set_procedure_token(procedure_token)
def helper_func(self, FUNCPTR, func):
from rpython.rtyper.annlowlevel import llhelper
return llhelper(FUNCPTR, func)
def get_unique_id(self, *args):
return 0
def get_location_str(self, args):
return 'location'
class JitCell:
@staticmethod
def get_jit_cell_at_key(greenkey):
assert greenkey == []
return FakeWarmRunnerState._cell
_cell = FakeJitCell()
trace_limit = sys.maxint
enable_opts = ALL_OPTS_DICT
vec = True
if kwds.pop('disable_optimizations', False):
FakeWarmRunnerState.enable_opts = {}
func._jit_unroll_safe_ = True
rtyper = support.annotate(func,
values,
translationoptions=translationoptions)
graphs = rtyper.annotator.translator.graphs
testself.all_graphs = graphs
result_kind = history.getkind(graphs[0].getreturnvar().concretetype)[0]
class FakeJitDriverSD:
num_green_args = 0
portal_graph = graphs[0]
virtualizable_info = None
greenfield_info = None
result_type = result_kind
portal_runner_ptr = "???"
vec = False
stats = history.Stats(None)
cpu = CPUClass(rtyper, stats, None, False)
cw = codewriter.CodeWriter(cpu, [FakeJitDriverSD()])
cw.debug = True
testself.cw = cw
if supports_floats and not cpu.supports_floats:
py.test.skip("this test requires supports_floats=True")
if supports_longlong and not cpu.supports_longlong:
py.test.skip("this test requires supports_longlong=True")
if supports_singlefloats and not cpu.supports_singlefloats:
py.test.skip("this test requires supports_singlefloats=True")
policy = JitPolicy()
policy.set_supports_floats(supports_floats)
policy.set_supports_longlong(supports_longlong)
policy.set_supports_singlefloats(supports_singlefloats)
graphs = cw.find_all_graphs(policy)
if kwds.get("backendopt"):
backend_optimizations(rtyper.annotator.translator, graphs=graphs)
#
testself.warmrunnerstate = FakeWarmRunnerState()
testself.warmrunnerstate.cpu = cpu
FakeJitDriverSD.warmstate = testself.warmrunnerstate
if hasattr(testself, 'finish_setup_for_interp_operations'):
testself.finish_setup_for_interp_operations()
#
cw.make_jitcodes(verbose=True)
return stats
def setup_class(cls):
from rpython.jit.metainterp.typesystem import llhelper
from rpython.jit.codewriter.support import annotate
from rpython.jit.metainterp.warmspot import WarmRunnerDesc
from rpython.rtyper.rclass import OBJECT, OBJECT_VTABLE
from rpython.rtyper.lltypesystem import lltype, llmemory
exc_vtable = lltype.malloc(OBJECT_VTABLE, immortal=True)
cls.exc_vtable = exc_vtable
class FakeFailDescr(object):
def __init__(self, no):
self.no = no
def handle_fail(self, deadframe, metainterp_sd, jitdrivers_sd):
no = self.no
assert deadframe._no == no
if no == 0:
raise jitexc.DoneWithThisFrameInt(3)
if no == 1:
raise jitexc.ContinueRunningNormally(
[0], [], [], [1], [], [])
if no == 3:
exc = lltype.malloc(OBJECT)
exc.typeptr = exc_vtable
raise jitexc.ExitFrameWithExceptionRef(
metainterp_sd.cpu,
lltype.cast_opaque_ptr(llmemory.GCREF, exc))
assert 0
class FakeDeadFrame:
def __init__(self, no):
self._no = no
class FakeDescr:
pass
class FakeCPU(object):
supports_floats = False
supports_longlong = False
supports_singlefloats = False
ts = llhelper
translate_support_code = False
stats = "stats"
class tracker:
pass
def get_latest_descr(self, deadframe):
assert isinstance(deadframe, FakeDeadFrame)
return self.get_fail_descr_from_number(deadframe._no)
def get_fail_descr_number(self, d):
return -1
def __init__(self, *args, **kwds):
pass
def nodescr(self, *args, **kwds):
return FakeDescr()
fielddescrof = nodescr
calldescrof = nodescr
sizeof = nodescr
def get_fail_descr_from_number(self, no):
return FakeFailDescr(no)
def make_execute_token(self, *ARGS):
return "not callable"
driver = JitDriver(reds = ['red'], greens = ['green'])
def f(green):
red = 0
while red < 10:
driver.can_enter_jit(red=red, green=green)
driver.jit_merge_point(red=red, green=green)
red += 1
return red
rtyper = annotate(f, [0])
FakeCPU.rtyper = rtyper
translator = rtyper.annotator.translator
translator.config.translation.gc = 'hybrid'
cls.desc = WarmRunnerDesc(translator, CPUClass=FakeCPU)
cls.FakeDeadFrame = FakeDeadFrame
def make_graphs(self, func, values):
self.rtyper = support.annotate(func, values)
return self.rtyper.annotator.translator.graphs
