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 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", 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()
def setup_class(cls):
cls.cpu = getcpuclass()(rtyper=None, stats=FakeStats())
cls.cpu.setup_once()