def test_without_floats(): graph = support.getgraph(lambda x: x + 3.2, [5.4]) policy = JitPolicy() policy.set_supports_floats(True) assert policy.look_inside_graph(graph) policy = JitPolicy() policy.set_supports_floats(False) assert not policy.look_inside_graph(graph)
def __init__(self, translator, policy=None, backendopt=True, CPUClass=None, ProfilerClass=EmptyProfiler, **kwds): pyjitpl._warmrunnerdesc = self # this is a global for debugging only! self.set_translator(translator) self.memory_manager = memmgr.MemoryManager() self.build_cpu(CPUClass, **kwds) self.find_portals() self.codewriter = codewriter.CodeWriter(self.cpu, self.jitdrivers_sd) if policy is None: policy = JitPolicy() policy.set_supports_floats(self.cpu.supports_floats) policy.set_supports_longlong(self.cpu.supports_longlong) policy.set_supports_singlefloats(self.cpu.supports_singlefloats) graphs = self.codewriter.find_all_graphs(policy) policy.dump_unsafe_loops() self.check_access_directly_sanity(graphs) if backendopt: self.prejit_optimizations(policy, graphs) elif self.opt.listops: self.prejit_optimizations_minimal_inline(policy, graphs) self.build_meta_interp(ProfilerClass) self.make_args_specifications() # from pypy.jit.metainterp.virtualref import VirtualRefInfo vrefinfo = VirtualRefInfo(self) self.codewriter.setup_vrefinfo(vrefinfo) # self.hooks = policy.jithookiface self.make_virtualizable_infos() self.make_exception_classes() self.make_driverhook_graphs() self.make_enter_functions() self.rewrite_jit_merge_points(policy) verbose = False # not self.cpu.translate_support_code self.rewrite_access_helpers() self.codewriter.make_jitcodes(verbose=verbose) self.rewrite_can_enter_jits() self.rewrite_set_param() self.rewrite_force_virtual(vrefinfo) self.rewrite_force_quasi_immutable() self.add_finish() self.metainterp_sd.finish_setup(self.codewriter)
def test_without_floats(): graph = support.getgraph(lambda x: x+3.2, [5.4]) policy = JitPolicy() policy.set_supports_floats(True) assert policy.look_inside_graph(graph) policy = JitPolicy() policy.set_supports_floats(False) assert not policy.look_inside_graph(graph)
def test_on_compile_bridge(self): called = [] class MyJitIface(JitHookInterface): def after_compile(self, di): called.append("compile") def after_compile_bridge(self, di): called.append("compile_bridge") def before_compile_bridge(self, di): called.append("before_compile_bridge") driver = JitDriver(greens=['n', 'm'], reds=['i']) def loop(n, m): i = 0 while i < n + m: driver.can_enter_jit(n=n, m=m, i=i) driver.jit_merge_point(n=n, m=m, i=i) if i >= 4: i += 2 i += 1 self.meta_interp(loop, [1, 10], policy=JitPolicy(MyJitIface())) assert called == ["compile", "before_compile_bridge", "compile_bridge"]
def test_dont_look_inside(): @jit.dont_look_inside def h(x): return x + 3 graph = support.getgraph(h, [5]) assert not JitPolicy().look_inside_graph(graph)
def test_elidable(): @jit.elidable def g(x): return x + 2 graph = support.getgraph(g, [5]) assert not JitPolicy().look_inside_graph(graph)
def test_loops(): def g(x): i = 0 while i < x: i += 1 return i graph = support.getgraph(g, [5]) assert not JitPolicy().look_inside_graph(graph)
def test_unroll_safe(): @jit.unroll_safe def h(x): i = 0 while i < x: i += 1 return i graph = support.getgraph(h, [5]) assert JitPolicy().look_inside_graph(graph)
def test_on_compile(self): called = [] class MyJitIface(JitHookInterface): def after_compile(self, di): called.append(("compile", di.greenkey[1].getint(), di.greenkey[0].getint(), di.type)) def before_compile(self, di): called.append(("optimize", di.greenkey[1].getint(), di.greenkey[0].getint(), di.type)) #def before_optimize(self, jitdriver, logger, looptoken, oeprations, # type, greenkey): # called.append(("trace", greenkey[1].getint(), # greenkey[0].getint(), type)) iface = MyJitIface() driver = JitDriver(greens=['n', 'm'], reds=['i']) def loop(n, m): i = 0 while i < n + m: driver.can_enter_jit(n=n, m=m, i=i) driver.jit_merge_point(n=n, m=m, i=i) i += 1 self.meta_interp(loop, [1, 4], policy=JitPolicy(iface)) assert called == [ #("trace", 4, 1, "loop"), ("optimize", 4, 1, "loop"), ("compile", 4, 1, "loop") ] self.meta_interp(loop, [2, 4], policy=JitPolicy(iface)) assert called == [ #("trace", 4, 1, "loop"), ("optimize", 4, 1, "loop"), ("compile", 4, 1, "loop"), #("trace", 4, 2, "loop"), ("optimize", 4, 2, "loop"), ("compile", 4, 2, "loop") ]
def test_str_join(): def f(x, y): return "hello".join([str(x), str(y), "bye"]) graph = support.getgraph(f, [5, 83]) for block in graph.iterblocks(): for op in block.operations: if op.opname == 'direct_call': funcptr = op.args[0].value called_graph = funcptr._obj.graph if JitPolicy().look_inside_graph(called_graph): # the calls to join() and str() should be residual mod = called_graph.func.__module__ assert (mod == 'pypy.rpython.rlist' or mod == 'pypy.rpython.lltypesystem.rlist')
def test_unroll_safe_and_inline(): @jit.unroll_safe def h(x): i = 0 while i < x: i += 1 return i h._always_inline_ = True def g(x): return h(x) graph = support.getgraph(h, [5]) assert JitPolicy().look_inside_graph(graph)
def test_access_directly_but_not_seen(): class X: _virtualizable2_ = ["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_abort_quasi_immut(self): reasons = [] class MyJitIface(JitHookInterface): def on_abort(self, reason, jitdriver, greenkey, greenkey_repr): assert jitdriver is myjitdriver assert len(greenkey) == 1 reasons.append(reason) assert greenkey_repr == 'blah' iface = MyJitIface() myjitdriver = JitDriver(greens=['foo'], reds=['x', 'total'], get_printable_location=lambda *args: 'blah') class Foo: _immutable_fields_ = ['a?'] def __init__(self, a): self.a = a def f(a, x): foo = Foo(a) total = 0 while x > 0: myjitdriver.jit_merge_point(foo=foo, x=x, total=total) # read a quasi-immutable field out of a Constant total += foo.a foo.a += 1 x -= 1 return total # assert f(100, 7) == 721 res = self.meta_interp(f, [100, 7], policy=JitPolicy(iface)) assert res == 721 assert reasons == [ABORT_FORCE_QUASIIMMUT] * 2
def jitpolicy(driver): from pypy.jit.codewriter.policy import JitPolicy return JitPolicy()
def jitpolicy(driver): """Returns the JIT policy to use when translating.""" from pypy.jit.codewriter.policy import JitPolicy return JitPolicy()
def jitpolicy(driver): """Returns the JIT policy to use when translating.""" return JitPolicy()
def _get_jitcodes(testself, CPUClass, func, values, type_system, supports_longlong=False, translationoptions={}, **kwds): from pypy.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): cell = self.jit_cell_at_key(greenkey) cell.set_procedure_token(procedure_token) def helper_func(self, FUNCPTR, func): from pypy.rpython.annlowlevel import llhelper return llhelper(FUNCPTR, func) def get_location_str(self, args): return 'location' def jit_cell_at_key(self, greenkey): assert greenkey == [] return self._cell _cell = FakeJitCell() trace_limit = sys.maxint enable_opts = ALL_OPTS_DICT func._jit_unroll_safe_ = True rtyper = support.annotate(func, values, type_system=type_system, 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 = "???" stats = history.Stats() cpu = CPUClass(rtyper, stats, None, False) cw = codewriter.CodeWriter(cpu, [FakeJitDriverSD()]) cw.debug = True testself.cw = cw policy = JitPolicy() policy.set_supports_floats(True) policy.set_supports_longlong(supports_longlong) cw.find_all_graphs(policy) # 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)
def _get_jitcodes(testself, CPUClass, func, values, type_system, supports_longlong=False, **kwds): from pypy.jit.codewriter import support class FakeJitCell(object): __compiled_merge_points = [] def get_compiled_merge_points(self): return self.__compiled_merge_points[:] def set_compiled_merge_points(self, lst): self.__compiled_merge_points = lst class FakeWarmRunnerState(object): def attach_unoptimized_bridge_from_interp(self, greenkey, newloop): pass def helper_func(self, FUNCPTR, func): from pypy.rpython.annlowlevel import llhelper return llhelper(FUNCPTR, func) def get_location_str(self, args): return 'location' def jit_cell_at_key(self, greenkey): assert greenkey == [] return self._cell _cell = FakeJitCell() trace_limit = sys.maxint enable_opts = ALL_OPTS_DICT func._jit_unroll_safe_ = True rtyper = support.annotate(func, values, type_system=type_system) 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 = "???" on_compile = lambda *args: None on_compile_bridge = lambda *args: None stats = history.Stats() cpu = CPUClass(rtyper, stats, None, False) cw = codewriter.CodeWriter(cpu, [FakeJitDriverSD()]) cw.debug = True testself.cw = cw policy = JitPolicy() policy.set_supports_floats(True) policy.set_supports_longlong(supports_longlong) cw.find_all_graphs(policy) # 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)
def jitpolicy(driver): return JitPolicy()
def test_regular_function(): graph = support.getgraph(lambda x: x + 3, [5]) assert JitPolicy().look_inside_graph(graph)