def get_cpu(): if pytest.config.option.backend == 'llgraph': from pypy.jit.backend.llgraph.runner import LLtypeCPU return LLtypeCPU(None) elif pytest.config.option.backend == 'cpu': from pypy.jit.backend.detect_cpu import getcpuclass return getcpuclass()(None, None) else: assert 0, "unknown backend %r" % pytest.config.option.backend
def apply_jit(translator, backend_name="auto", inline=False, enable_opts=ALL_OPTS_NAMES, **kwds): if 'CPUClass' not in kwds: from pypy.jit.backend.detect_cpu import getcpuclass kwds['CPUClass'] = getcpuclass(backend_name) ProfilerClass = Profiler # Always use Profiler here, which should have a very low impact. # Otherwise you can try with ProfilerClass = EmptyProfiler. warmrunnerdesc = WarmRunnerDesc(translator, translate_support_code=True, listops=True, no_stats = True, ProfilerClass = ProfilerClass, **kwds) for jd in warmrunnerdesc.jitdrivers_sd: jd.warmstate.set_param_inlining(inline) jd.warmstate.set_param_enable_opts(enable_opts) warmrunnerdesc.finish() translator.warmrunnerdesc = warmrunnerdesc # for later debugging
def apply_jit(translator, backend_name="auto", debug_level=DEBUG_STEPS, inline=False, **kwds): if 'CPUClass' not in kwds: from pypy.jit.backend.detect_cpu import getcpuclass kwds['CPUClass'] = getcpuclass(backend_name) if debug_level > DEBUG_OFF: ProfilerClass = Profiler else: ProfilerClass = EmptyProfiler warmrunnerdesc = WarmRunnerDesc(translator, translate_support_code=True, listops=True, no_stats = True, ProfilerClass = ProfilerClass, **kwds) warmrunnerdesc.state.set_param_inlining(inline) warmrunnerdesc.state.set_param_debug(debug_level) warmrunnerdesc.finish() translator.warmrunnerdesc = warmrunnerdesc # for later debugging
from pypy.jit.backend.llsupport.gc import GcLLDescription from pypy.jit.backend.detect_cpu import getcpuclass from pypy.jit.backend.x86.regalloc import RegAlloc from pypy.jit.backend.x86.arch import WORD, FRAME_FIXED_SIZE from pypy.jit.tool.oparser import parse from pypy.rpython.lltypesystem import lltype, llmemory, rffi from pypy.rpython.annlowlevel import llhelper from pypy.rpython.lltypesystem import rclass, rstr from pypy.jit.backend.llsupport.gc import GcLLDescr_framework, GcPtrFieldDescr from pypy.jit.backend.x86.test.test_regalloc import MockAssembler from pypy.jit.backend.x86.test.test_regalloc import BaseTestRegalloc from pypy.jit.backend.x86.regalloc import X86RegisterManager, X86FrameManager,\ X86XMMRegisterManager CPU = getcpuclass() class MockGcRootMap(object): is_shadow_stack = False def get_basic_shape(self, is_64_bit): return ['shape'] def add_frame_offset(self, shape, offset): shape.append(offset) def add_callee_save_reg(self, shape, reg_index): index_to_name = { 1: 'ebx', 2: 'esi', 3: 'edi' } shape.append(index_to_name[reg_index]) def compress_callshape(self, shape, datablockwrapper): assert datablockwrapper == 'fakedatablockwrapper' assert shape[0] == 'shape' return ['compressed'] + shape[1:]
is_comparison_or_ovf_op from pypy.jit.backend.x86.arch import IS_X86_32, IS_X86_64 from pypy.jit.tool.oparser import parse from pypy.rpython.lltypesystem import lltype, llmemory, rffi from pypy.rpython.annlowlevel import llhelper from pypy.rpython.lltypesystem import rclass, rstr from pypy.jit.codewriter import longlong from pypy.jit.codewriter.effectinfo import EffectInfo from pypy.jit.backend.x86.rx86 import * def test_is_comparison_or_ovf_op(): assert not is_comparison_or_ovf_op(rop.INT_ADD) assert is_comparison_or_ovf_op(rop.INT_ADD_OVF) assert is_comparison_or_ovf_op(rop.INT_EQ) CPU = getcpuclass() class MockGcDescr(GcCache): def get_funcptr_for_new(self): return 123 get_funcptr_for_newarray = get_funcptr_for_new get_funcptr_for_newstr = get_funcptr_for_new get_funcptr_for_newunicode = get_funcptr_for_new def rewrite_assembler(self, cpu, operations): pass class MockAssembler(object): gcrefs = None _float_constants = None def __init__(self, cpu=None, gc_ll_descr=None):
class TestTranslationRemoveTypePtrX86(CCompiledMixin): CPUClass = getcpuclass() def _get_TranslationContext(self): t = TranslationContext() t.config.translation.gc = DEFL_GC # 'hybrid' or 'minimark' t.config.translation.gcrootfinder = 'asmgcc' t.config.translation.list_comprehension_operations = True t.config.translation.gcremovetypeptr = True return t def test_external_exception_handling_translates(self): jitdriver = JitDriver(greens=[], reds=['n', 'total']) class ImDone(Exception): def __init__(self, resvalue): self.resvalue = resvalue @dont_look_inside def f(x, total): if x <= 30: raise ImDone(total * 10) if x > 200: return 2 raise ValueError @dont_look_inside def g(x): if x > 150: raise ValueError return 2 class Base: def meth(self): return 2 class Sub(Base): def meth(self): return 1 @dont_look_inside def h(x): if x < 20000: return Sub() else: return Base() def myportal(i): set_param(jitdriver, "threshold", 3) set_param(jitdriver, "trace_eagerness", 2) total = 0 n = i while True: jitdriver.can_enter_jit(n=n, total=total) jitdriver.jit_merge_point(n=n, total=total) try: total += f(n, total) except ValueError: total += 1 try: total += g(n) except ValueError: total -= 1 n -= h(n).meth() # this is to force a GUARD_CLASS def main(i): try: myportal(i) except ImDone, e: return e.resvalue # XXX custom fishing, depends on the exact env var and format logfile = udir.join('test_ztranslation.log') os.environ['PYPYLOG'] = 'jit-log-opt:%s' % (logfile, ) try: res = self.meta_interp(main, [400]) assert res == main(400) finally: del os.environ['PYPYLOG'] guard_class = 0 for line in open(str(logfile)): if 'guard_class' in line: guard_class += 1 # if we get many more guard_classes, it means that we generate # guards that always fail (the following assert's original purpose # is to catch the following case: each GUARD_CLASS is misgenerated # and always fails with "gcremovetypeptr") assert 0 < guard_class < 10
class TestTranslationX86(CCompiledMixin): CPUClass = getcpuclass() def _check_cbuilder(self, cbuilder): # We assume here that we have sse2. If not, the CPUClass # needs to be changed to CPU386_NO_SSE2, but well. assert '-msse2' in cbuilder.eci.compile_extra assert '-mfpmath=sse' in cbuilder.eci.compile_extra def test_stuff_translates(self): # this is a basic test that tries to hit a number of features and their # translation: # - jitting of loops and bridges # - virtualizables # - set_param interface # - profiler # - full optimizer # - floats neg and abs class Frame(object): _virtualizable2_ = ['i'] def __init__(self, i): self.i = i @dont_look_inside def myabs(x): return abs(x) jitdriver = JitDriver(greens=[], reds=['total', 'frame', 'j'], virtualizables=['frame']) def f(i, j): for param, _ in unroll_parameters: defl = PARAMETERS[param] set_param(jitdriver, param, defl) set_param(jitdriver, "threshold", 3) set_param(jitdriver, "trace_eagerness", 2) total = 0 frame = Frame(i) j = float(j) while frame.i > 3: jitdriver.can_enter_jit(frame=frame, total=total, j=j) jitdriver.jit_merge_point(frame=frame, total=total, j=j) total += frame.i if frame.i >= 20: frame.i -= 2 frame.i -= 1 j *= -0.712 if j + (-j): raise ValueError k = myabs(j) if k - abs(j): raise ValueError if k - abs(-j): raise ValueError return chr(total % 253) # from pypy.rpython.lltypesystem import lltype, rffi from pypy.rlib.libffi import types, CDLL, ArgChain from pypy.rlib.test.test_libffi import get_libm_name libm_name = get_libm_name(sys.platform) jitdriver2 = JitDriver(greens=[], reds=['i', 'func', 'res', 'x']) def libffi_stuff(i, j): lib = CDLL(libm_name) func = lib.getpointer('fabs', [types.double], types.double) res = 0.0 x = float(j) while i > 0: jitdriver2.jit_merge_point(i=i, res=res, func=func, x=x) promote(func) argchain = ArgChain() argchain.arg(x) res = func.call(argchain, rffi.DOUBLE) i -= 1 return res # def main(i, j): a_char = f(i, j) a_float = libffi_stuff(i, j) return ord(a_char) * 10 + int(a_float) expected = main(40, -49) res = self.meta_interp(main, [40, -49]) assert res == expected def test_direct_assembler_call_translates(self): """Test CALL_ASSEMBLER and the recursion limit""" from pypy.rlib.rstackovf import StackOverflow class Thing(object): def __init__(self, val): self.val = val class Frame(object): _virtualizable2_ = ['thing'] driver = JitDriver(greens=['codeno'], reds=['i', 'frame'], virtualizables=['frame'], get_printable_location=lambda codeno: str(codeno)) class SomewhereElse(object): pass somewhere_else = SomewhereElse() def change(newthing): somewhere_else.frame.thing = newthing def main(codeno): frame = Frame() somewhere_else.frame = frame frame.thing = Thing(0) portal(codeno, frame) return frame.thing.val def portal(codeno, frame): i = 0 while i < 10: driver.can_enter_jit(frame=frame, codeno=codeno, i=i) driver.jit_merge_point(frame=frame, codeno=codeno, i=i) nextval = frame.thing.val if codeno == 0: subframe = Frame() subframe.thing = Thing(nextval) nextval = portal(1, subframe) elif frame.thing.val > 40: change(Thing(13)) nextval = 13 frame.thing = Thing(nextval + 1) i += 1 return frame.thing.val driver2 = JitDriver(greens=[], reds=['n']) def main2(bound): try: while portal2(bound) == -bound + 1: bound *= 2 except StackOverflow: pass return bound def portal2(n): while True: driver2.jit_merge_point(n=n) n -= 1 if n <= 0: return n n = portal2(n) assert portal2(10) == -9 def mainall(codeno, bound): return main(codeno) + main2(bound) res = self.meta_interp(mainall, [0, 1], inline=True, policy=StopAtXPolicy(change)) print hex(res) assert res & 255 == main(0) bound = res & ~255 assert 1024 <= bound <= 131072 assert bound & (bound - 1) == 0 # a power of two
from pypy.jit.backend.x86.regloc import * from pypy.jit.backend.x86.assembler import Assembler386 from pypy.jit.backend.x86.regalloc import X86FrameManager, get_ebp_ofs from pypy.jit.metainterp.history import BoxInt, BoxPtr, BoxFloat, ConstFloat from pypy.jit.metainterp.history import INT, REF, FLOAT from pypy.rlib.rarithmetic import intmask from pypy.rpython.lltypesystem import lltype, llmemory, rffi from pypy.jit.backend.x86.arch import WORD, IS_X86_32, IS_X86_64 from pypy.jit.backend.detect_cpu import getcpuclass from pypy.jit.backend.x86.regalloc import X86RegisterManager, X86_64_RegisterManager, X86XMMRegisterManager, X86_64_XMMRegisterManager from pypy.jit.codewriter import longlong import ctypes ACTUAL_CPU = getcpuclass() class FakeCPU: rtyper = None supports_floats = True NUM_REGS = ACTUAL_CPU.NUM_REGS def fielddescrof(self, STRUCT, name): return 42 class FakeMC: def __init__(self): self.content = [] def writechar(self, char): self.content.append(ord(char)) def test_write_failure_recovery_description(): assembler = Assembler386(FakeCPU())
from pypy.jit.backend.x86.regloc import * from pypy.jit.backend.x86.assembler import Assembler386 from pypy.jit.backend.x86.regalloc import X86FrameManager, get_ebp_ofs from pypy.jit.metainterp.history import BoxInt, BoxPtr, BoxFloat, ConstFloat from pypy.jit.metainterp.history import INT, REF, FLOAT from pypy.rlib.rarithmetic import intmask from pypy.rpython.lltypesystem import lltype, llmemory, rffi from pypy.jit.backend.x86.arch import WORD, IS_X86_32, IS_X86_64 from pypy.jit.backend.detect_cpu import getcpuclass from pypy.jit.backend.x86.regalloc import X86RegisterManager, X86_64_RegisterManager, X86XMMRegisterManager, X86_64_XMMRegisterManager from pypy.jit.codewriter import longlong import ctypes ACTUAL_CPU = getcpuclass() class FakeCPU: rtyper = None supports_floats = True NUM_REGS = ACTUAL_CPU.NUM_REGS def fielddescrof(self, STRUCT, name): return 42 class FakeMC: def __init__(self): self.content = [] def writechar(self, char): self.content.append(ord(char))
class Jit386Mixin(support.LLJitMixin): type_system = 'lltype' CPUClass = getcpuclass() def check_jumps(self, maxcount): pass
def setup_class(cls): cls.cpu = getcpuclass()(rtyper=None, stats=FakeStats()) cls.cpu.setup_once()