def apply_jit(translator, backend_name="auto", inline=False,
vec=False, enable_opts=ALL_OPTS_NAMES, **kwds):
if 'CPUClass' not in kwds:
from rpython.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)
if len(warmrunnerdesc.jitdrivers_sd) == 1:
jd = warmrunnerdesc.jitdrivers_sd[0]
jd.jitdriver.is_recursive = True
else:
count_recursive = 0
for jd in warmrunnerdesc.jitdrivers_sd:
count_recursive += jd.jitdriver.is_recursive
if count_recursive == 0:
raise Exception("if you have more than one jitdriver, at least"
" one of them has to be marked with is_recursive=True,"
" none found")
for jd in warmrunnerdesc.jitdrivers_sd:
jd.warmstate.set_param_inlining(inline)
jd.warmstate.set_param_vec(vec)
jd.warmstate.set_param_enable_opts(enable_opts)
warmrunnerdesc.finish()
translator.warmrunnerdesc = warmrunnerdesc # for later debugging
def get_cpu():
if pytest.config.option.backend == 'llgraph':
from rpython.jit.backend.llgraph.runner import LLGraphCPU
return LLGraphCPU(None)
elif pytest.config.option.backend == 'cpu':
from rpython.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 rpython.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 regalloc(request):
from rpython.jit.backend.x86.regalloc import X86FrameManager
from rpython.jit.backend.x86.regalloc import X86XMMRegisterManager
class FakeToken:
class compiled_loop_token:
asmmemmgr_blocks = None
cpu = getcpuclass()(None, None)
cpu.setup()
if cpu.HAS_CODEMAP:
cpu.codemap.setup()
looptoken = FakeToken()
asm = cpu.assembler
asm.setup_once()
asm.setup(looptoken)
regalloc = RegAlloc(asm)
regalloc.fm = fm = X86FrameManager(cpu.get_baseofs_of_frame_field())
regalloc.rm = X86RegisterManager({}, frame_manager=fm, assembler=asm)
regalloc.xrm = X86XMMRegisterManager({}, frame_manager=fm, assembler=asm)
request.cls.asm = asm
request.cls.regalloc = regalloc
from rpython.jit.metainterp.history import ResOperation, TargetToken,\
JitCellToken
from rpython.jit.metainterp.history import (BoxInt, BoxPtr, ConstInt, ConstPtr,
Box, BasicFailDescr,
BasicFinalDescr)
from rpython.jit.backend.detect_cpu import getcpuclass
from rpython.jit.backend.x86.arch import WORD
from rpython.jit.backend.x86.rx86 import fits_in_32bits
from rpython.jit.backend.llsupport import symbolic
from rpython.jit.metainterp.resoperation import rop
from rpython.jit.metainterp.executor import execute
from rpython.jit.backend.test.runner_test import LLtypeBackendTest
from rpython.jit.tool.oparser import parse
import ctypes
CPU = getcpuclass("asmjs")
class FakeStats(object):
pass
U = LLtypeBackendTest.U
S = LLtypeBackendTest.S
# ____________________________________________________________
class TestASMJSRunner(LLtypeBackendTest):
# for the individual tests see
from rpython.jit.backend.x86.regloc import *
from rpython.jit.metainterp.history import ConstFloat
from rpython.jit.metainterp.history import INT, FLOAT
from rpython.rtyper.lltypesystem import llmemory, rffi
from rpython.jit.backend.detect_cpu import getcpuclass
from rpython.jit.codewriter import longlong
import ctypes
import py
ACTUAL_CPU = getcpuclass()
if not hasattr(ACTUAL_CPU, 'NUM_REGS'):
py.test.skip('unsupported CPU')
class FakeCPU:
rtyper = None
supports_floats = True
NUM_REGS = ACTUAL_CPU.NUM_REGS
class gc_ll_descr:
kind = "boehm"
def fielddescrof(self, STRUCT, name):
return 42
def get_fail_descr_from_number(self, num):
assert num == 0x1C3
return FakeFailDescr()
class FakeMC:
def __init__(self):
self.content = []
from rpython.jit.metainterp.history import ResOperation, TargetToken,\
JitCellToken
from rpython.jit.metainterp.history import (BoxInt, BoxPtr, ConstInt,
ConstPtr, Box,
BasicFailDescr, BasicFinalDescr)
from rpython.jit.backend.detect_cpu import getcpuclass
from rpython.jit.backend.x86.arch import WORD
from rpython.jit.backend.x86.rx86 import fits_in_32bits
from rpython.jit.backend.llsupport import symbolic
from rpython.jit.metainterp.resoperation import rop
from rpython.jit.metainterp.executor import execute
from rpython.jit.backend.test.runner_test import LLtypeBackendTest
from rpython.jit.tool.oparser import parse
import ctypes
CPU = getcpuclass("asmjs")
class FakeStats(object):
pass
U = LLtypeBackendTest.U
S = LLtypeBackendTest.S
# ____________________________________________________________
class TestASMJSRunner(LLtypeBackendTest):
# for the individual tests see
# ====> ../../test/runner_test.py
def get_cpu(self):
def setup_method(self, name):
self.pool = LiteralPool()
self.asm = FakeAsm()
self.asm.mc = FakeAsm()
self.cpu = getcpuclass()(None, None)
self.cpu.setup_once()
def run_guards_translated(gcremovetypeptr):
class A(object):
pass
class B(A):
pass
class C(B):
pass
def main(argv):
A(); B().foo = len(argv); C()
return 0
t = TranslationContext()
t.config.translation.gc = "minimark"
t.config.translation.gcremovetypeptr = gcremovetypeptr
ann = t.buildannotator()
ann.build_types(main, [s_list_of_strings], main_entry_point=True)
rtyper = t.buildrtyper()
rtyper.specialize()
classdef = ann.bookkeeper.getuniqueclassdef(B)
rclass = getclassrepr(rtyper, classdef)
rinstance = getinstancerepr(rtyper, classdef)
LLB = rinstance.lowleveltype.TO
ptr_vtable_B = rclass.getvtable()
adr_vtable_B = llmemory.cast_ptr_to_adr(ptr_vtable_B)
vtable_B = llmemory.cast_adr_to_int(adr_vtable_B, mode="symbolic")
CPU = getcpuclass()
cpu = CPU(rtyper, NoStats(),
translate_support_code=True,
gcdescr=get_description(t.config))
execute_token = cpu.make_execute_token(llmemory.GCREF)
finaldescr = BasicFinalDescr()
faildescr = BasicFailDescr()
descr_B = cpu.sizeof(LLB, ptr_vtable_B)
typeid_B = descr_B.get_type_id()
fielddescr_B = cpu.fielddescrof(LLB, 'inst_foo')
LLD = lltype.GcStruct('D', ('dd', lltype.Signed))
descr_D = cpu.sizeof(LLD)
fielddescr_D = cpu.fielddescrof(LLD, 'dd')
ARRAY = lltype.GcArray(lltype.Signed)
arraydescr = cpu.arraydescrof(ARRAY)
loop1 = parse("""
[p0]
guard_class(p0, ConstInt(vtable_B), descr=faildescr) []
finish(descr=finaldescr)
""", namespace={'finaldescr': finaldescr,
'faildescr': faildescr,
'vtable_B': vtable_B})
loop2 = parse("""
[p0]
guard_gc_type(p0, ConstInt(typeid_B), descr=faildescr) []
finish(descr=finaldescr)
""", namespace={'finaldescr': finaldescr,
'faildescr': faildescr,
'typeid_B': typeid_B})
loop3 = parse("""
[p0]
guard_is_object(p0, descr=faildescr) []
finish(descr=finaldescr)
""", namespace={'finaldescr': finaldescr,
'faildescr': faildescr})
loop4 = parse("""
[p0]
guard_subclass(p0, ConstInt(vtable_B), descr=faildescr) []
finish(descr=finaldescr)
""", namespace={'finaldescr': finaldescr,
'faildescr': faildescr,
'vtable_B': vtable_B})
def g():
cpu.setup_once()
token1 = JitCellToken()
token2 = JitCellToken()
token3 = JitCellToken()
token4 = JitCellToken()
cpu.compile_loop(loop1.inputargs, loop1.operations, token1)
cpu.compile_loop(loop2.inputargs, loop2.operations, token2)
cpu.compile_loop(loop3.inputargs, loop3.operations, token3)
cpu.compile_loop(loop4.inputargs, loop4.operations, token4)
for token, p0 in [
(token1, rffi.cast(llmemory.GCREF, A())),
(token1, rffi.cast(llmemory.GCREF, B())),
(token1, rffi.cast(llmemory.GCREF, C())),
(token2, rffi.cast(llmemory.GCREF, A())),
(token2, rffi.cast(llmemory.GCREF, B())),
(token2, rffi.cast(llmemory.GCREF, C())),
(token2, rffi.cast(llmemory.GCREF, [42, 43])),
(token3, rffi.cast(llmemory.GCREF, A())),
(token3, rffi.cast(llmemory.GCREF, B())),
(token3, rffi.cast(llmemory.GCREF, [44, 45])),
(token4, rffi.cast(llmemory.GCREF, A())),
(token4, rffi.cast(llmemory.GCREF, B())),
(token4, rffi.cast(llmemory.GCREF, C())),
]:
frame = execute_token(token, p0)
descr = cpu.get_latest_descr(frame)
if descr is finaldescr:
print 'match'
elif descr is faildescr:
print 'fail'
else:
print '???'
#
if token is token2: # guard_gc_type
print int(cpu.get_actual_typeid(p0) == typeid_B)
if token is token3: # guard_is_object
print int(cpu.check_is_object(p0))
for p0 in [lltype.nullptr(llmemory.GCREF.TO),
rffi.cast(llmemory.GCREF, A()),
rffi.cast(llmemory.GCREF, B()),
rffi.cast(llmemory.GCREF, C()),
rffi.cast(llmemory.GCREF, lltype.malloc(LLD)),
rffi.cast(llmemory.GCREF, lltype.malloc(ARRAY, 5)),
rffi.cast(llmemory.GCREF, "foobar"),
rffi.cast(llmemory.GCREF, u"foobaz")]:
results = ['B', 'D', 'A', 'S', 'U']
try:
cpu.protect_speculative_field(p0, fielddescr_B)
except SpeculativeError:
results[0] = '-'
try:
cpu.protect_speculative_field(p0, fielddescr_D)
except SpeculativeError:
results[1] = '-'
try:
cpu.protect_speculative_array(p0, arraydescr)
except SpeculativeError:
results[2] = '-'
try:
cpu.protect_speculative_string(p0)
except SpeculativeError:
results[3] = '-'
try:
cpu.protect_speculative_unicode(p0)
except SpeculativeError:
results[4] = '-'
print ''.join(results)
call_initial_function(t, g)
cbuilder = genc.CStandaloneBuilder(t, main, t.config)
cbuilder.generate_source(defines=cbuilder.DEBUG_DEFINES)
cbuilder.compile()
data = cbuilder.cmdexec('')
assert data == ('fail\n'
'match\n'
'fail\n'
'fail\n' '0\n'
'match\n' '1\n'
'fail\n' '0\n'
'fail\n' '0\n'
'match\n' '1\n'
'match\n' '1\n'
'fail\n' '0\n'
'fail\n'
'match\n'
'match\n'
'-----\n' # null
'-----\n' # instance of A
'B----\n' # instance of B
'B----\n' # instance of C
'-D---\n'
'--A--\n'
'---S-\n'
'----U\n'
)
def setup_class(cls):
cls.cpu = getcpuclass()(rtyper=None, stats=FakeStats())
cls.cpu.setup_once()
class CompiledVmprofTest(CCompiledMixin):
CPUClass = getcpuclass()
def _get_TranslationContext(self):
t = TranslationContext()
t.config.translation.gc = 'incminimark'
t.config.translation.list_comprehension_operations = True
return t
def test_vmprof(self):
from rpython.rlib import rvmprof
class MyCode:
_vmprof_unique_id = 0
_vmprof_weak_list = RWeakListMixin()
_vmprof_weak_list.initialize()
def __init__(self, name):
self.name = name
def get_name(code):
return code.name
code2 = MyCode("py:y:foo:4")
rvmprof.register_code(code2, get_name)
try:
rvmprof.register_code_object_class(MyCode, get_name)
except rvmprof.VMProfPlatformUnsupported, e:
py.test.skip(str(e))
def get_unique_id(code):
return rvmprof.get_unique_id(code)
driver = JitDriver(greens=['code'],
reds=['i', 's', 'num'],
is_recursive=True,
get_unique_id=get_unique_id)
@rvmprof.vmprof_execute_code("xcode13", lambda code, num: code)
def main(code, num):
return main_jitted(code, num)
def main_jitted(code, num):
s = 0
i = 0
while i < num:
driver.jit_merge_point(code=code, i=i, s=s, num=num)
s += (i << 1)
if i % 3 == 0 and code is not code2:
main(code2, 100)
i += 1
return s
tmpfilename = str(udir.join('test_rvmprof'))
def f(num):
rthread.get_ident() # register TLOFS_thread_ident
code = MyCode("py:x:foo:3")
rvmprof.register_code(code, get_name)
fd = os.open(tmpfilename, os.O_WRONLY | os.O_CREAT, 0666)
period = 0.0001
rvmprof.enable(fd, period)
res = main(code, num)
#assert res == 499999500000
rvmprof.disable()
os.close(fd)
return 0
def check_vmprof_output():
from vmprof import read_profile
tmpfile = str(udir.join('test_rvmprof'))
stats = read_profile(tmpfile)
t = stats.get_tree()
assert t.name == 'py:x:foo:3'
assert len(t.children) == 1 # jit
self.meta_interp(f, [1000000], inline=True)
try:
import vmprof
except ImportError:
pass
else:
check_vmprof_output()
class TranslationRemoveTypePtrTest(CCompiledMixin):
CPUClass = getcpuclass()
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 as 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 (~93), 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
def setup_method(self, name):
self.pool = LiteralPool()
self.asm = FakeAsm()
self.asm.mc = FakeAsm()
self.cpu = getcpuclass()(None, None)
self.cpu.setup_once()
from rpython.jit.metainterp.history import TargetToken, BasicFinalDescr,\
JitCellToken, BasicFailDescr, AbstractDescr
from rpython.jit.backend.llsupport.gc import GcLLDescription, GcLLDescr_boehm,\
GcLLDescr_framework, GcCache, JitFrameDescrs
from rpython.jit.backend.detect_cpu import getcpuclass
from rpython.jit.backend.llsupport.symbolic import WORD
from rpython.jit.backend.llsupport import jitframe
from rpython.rtyper.lltypesystem import lltype, llmemory, rffi
from rpython.rtyper.annlowlevel import llhelper, llhelper_args
from rpython.jit.backend.llsupport.test.test_regalloc_integration import BaseTestRegalloc
from rpython.jit.codewriter.effectinfo import EffectInfo
from rpython.jit.codewriter import longlong
from rpython.rlib.objectmodel import invoke_around_extcall
CPU = getcpuclass()
def getmap(frame):
r = ''
for elem in frame.jf_gcmap:
elem = bin(elem)[2:]
elem = '0' * (WORD * 8 - len(elem)) + elem
r = elem + r
return r[r.find('1'):]
class TestRegallocGcIntegration(BaseTestRegalloc):
cpu = CPU(None, None)
cpu.gc_ll_descr = GcLLDescr_boehm(None, None, None)
cpu.setup_once()
class JitARMMixin(support.LLJitMixin):
type_system = 'lltype'
CPUClass = getcpuclass()
def check_jumps(self, maxcount):
pass
def run_guards_translated(gcremovetypeptr):
class A(object):
pass
class B(A):
pass
class C(B):
pass
def main(argv):
A(); B(); C()
return 0
t = TranslationContext()
t.config.translation.gc = "minimark"
t.config.translation.gcremovetypeptr = gcremovetypeptr
ann = t.buildannotator()
ann.build_types(main, [s_list_of_strings], main_entry_point=True)
rtyper = t.buildrtyper()
rtyper.specialize()
classdef = ann.bookkeeper.getuniqueclassdef(B)
rclass = getclassrepr(rtyper, classdef)
rinstance = getinstancerepr(rtyper, classdef)
LLB = rinstance.lowleveltype.TO
vtable_B = rclass.getvtable()
adr_vtable_B = llmemory.cast_ptr_to_adr(vtable_B)
vtable_B = llmemory.cast_adr_to_int(adr_vtable_B, mode="symbolic")
CPU = getcpuclass()
cpu = CPU(rtyper, NoStats(),
translate_support_code=True,
gcdescr=get_description(t.config))
execute_token = cpu.make_execute_token(llmemory.GCREF)
finaldescr = BasicFinalDescr()
faildescr = BasicFailDescr()
descr_B = cpu.sizeof(LLB, vtable_B)
typeid_B = descr_B.get_type_id()
loop1 = parse("""
[p0]
guard_class(p0, ConstInt(vtable_B), descr=faildescr) []
finish(descr=finaldescr)
""", namespace={'finaldescr': finaldescr,
'faildescr': faildescr,
'vtable_B': vtable_B})
loop2 = parse("""
[p0]
guard_gc_type(p0, ConstInt(typeid_B), descr=faildescr) []
finish(descr=finaldescr)
""", namespace={'finaldescr': finaldescr,
'faildescr': faildescr,
'typeid_B': typeid_B})
loop3 = parse("""
[p0]
guard_is_object(p0, descr=faildescr) []
finish(descr=finaldescr)
""", namespace={'finaldescr': finaldescr,
'faildescr': faildescr})
loop4 = parse("""
[p0]
guard_subclass(p0, ConstInt(vtable_B), descr=faildescr) []
finish(descr=finaldescr)
""", namespace={'finaldescr': finaldescr,
'faildescr': faildescr,
'vtable_B': vtable_B})
def g():
cpu.setup_once()
token1 = JitCellToken()
token2 = JitCellToken()
token3 = JitCellToken()
token4 = JitCellToken()
cpu.compile_loop(loop1.inputargs, loop1.operations, token1)
cpu.compile_loop(loop2.inputargs, loop2.operations, token2)
cpu.compile_loop(loop3.inputargs, loop3.operations, token3)
cpu.compile_loop(loop4.inputargs, loop4.operations, token4)
for token, p0 in [
(token1, rffi.cast(llmemory.GCREF, A())),
(token1, rffi.cast(llmemory.GCREF, B())),
(token1, rffi.cast(llmemory.GCREF, C())),
(token2, rffi.cast(llmemory.GCREF, A())),
(token2, rffi.cast(llmemory.GCREF, B())),
(token2, rffi.cast(llmemory.GCREF, C())),
(token2, rffi.cast(llmemory.GCREF, [42, 43])),
(token3, rffi.cast(llmemory.GCREF, A())),
(token3, rffi.cast(llmemory.GCREF, B())),
(token3, rffi.cast(llmemory.GCREF, [44, 45])),
(token4, rffi.cast(llmemory.GCREF, A())),
(token4, rffi.cast(llmemory.GCREF, B())),
(token4, rffi.cast(llmemory.GCREF, C())),
]:
frame = execute_token(token, p0)
descr = cpu.get_latest_descr(frame)
if descr is finaldescr:
print 'match'
elif descr is faildescr:
print 'fail'
else:
print '???'
#
if token is token2: # guard_gc_type
print int(cpu.get_actual_typeid(p0) == typeid_B)
if token is token3: # guard_is_object
print int(cpu.check_is_object(p0))
call_initial_function(t, g)
cbuilder = genc.CStandaloneBuilder(t, main, t.config)
cbuilder.generate_source(defines=cbuilder.DEBUG_DEFINES)
cbuilder.compile()
data = cbuilder.cmdexec('')
assert data == ('fail\n'
'match\n'
'fail\n'
'fail\n' '0\n'
'match\n' '1\n'
'fail\n' '0\n'
'fail\n' '0\n'
'match\n' '1\n'
'match\n' '1\n'
'fail\n' '0\n'
'fail\n'
'match\n'
'match\n')
class TranslationRemoveTypePtrTest(CCompiledMixin):
CPUClass = getcpuclass()
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)
except ConfigError, e:
assert str(e).startswith('invalid value asmgcc')
py.test.skip('asmgcc not supported')
class TranslationTest(CCompiledMixin):
CPUClass = getcpuclass()
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
# - two virtualizable types
# - set_param interface
# - profiler
# - full optimizer
# - floats neg and abs
# - llexternal with macro=True
class Frame(object):
_virtualizable_ = ['i']
def __init__(self, i):
self.i = i
eci = ExternalCompilationInfo(
post_include_bits=['''
#define pypy_my_fabs(x) fabs(x)
'''])
myabs1 = rffi.llexternal('pypy_my_fabs', [lltype.Float],
lltype.Float,
macro=True,
releasegil=False,
compilation_info=eci)
myabs2 = rffi.llexternal('pypy_my_fabs', [lltype.Float],
lltype.Float,
macro=True,
releasegil=True,
compilation_info=eci)
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 = myabs1(myabs2(j))
if k - abs(j): raise ValueError
if k - abs(-j): raise ValueError
return chr(total % 253)
#
class Virt2(object):
_virtualizable_ = ['i']
def __init__(self, i):
self.i = i
from rpython.rlib.libffi import types, CDLL, ArgChain
from rpython.rlib.test.test_clibffi import get_libm_name
libm_name = get_libm_name(sys.platform)
jitdriver2 = JitDriver(greens=[],
reds=['v2', 'func', 'res', 'x'],
virtualizables=['v2'])
def libffi_stuff(i, j):
lib = CDLL(libm_name)
func = lib.getpointer('fabs', [types.double], types.double)
res = 0.0
x = float(j)
v2 = Virt2(i)
while v2.i > 0:
jitdriver2.jit_merge_point(v2=v2, res=res, func=func, x=x)
promote(func)
argchain = ArgChain()
argchain.arg(x)
res = func.call(argchain, rffi.DOUBLE)
v2.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
class TranslationTestCallAssembler(CCompiledMixin):
CPUClass = getcpuclass()
def test_direct_assembler_call_translates(self):
"""Test CALL_ASSEMBLER and the recursion limit"""
# - also tests threadlocalref_get
from rpython.rlib.rstackovf import StackOverflow
class Thing(object):
def __init__(self, val):
self.val = val
class Frame(object):
_virtualizable_ = ['thing']
driver = JitDriver(greens=['codeno'],
reds=['i', 'frame'],
virtualizables=['frame'],
get_printable_location=lambda codeno: str(codeno))
class SomewhereElse(object):
pass
somewhere_else = SomewhereElse()
class Foo(object):
pass
t = ThreadLocalReference(Foo, loop_invariant=True)
tf = ThreadLocalField(lltype.Char, "test_call_assembler_")
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
if t.get().nine != 9: raise ValueError
if ord(tf.getraw()) != 0x92: raise ValueError
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 setup(value):
foo = Foo()
foo.nine = value
t.set(foo)
tf.setraw("\x92")
return foo
def mainall(codeno, bound):
foo = setup(bound + 8)
result = main(codeno) + main2(bound)
keepalive_until_here(foo)
return result
tmp_obj = setup(9)
expected_1 = main(0)
res = self.meta_interp(mainall, [0, 1],
inline=True,
policy=StopAtXPolicy(change))
print hex(res)
assert res & 255 == expected_1
bound = res & ~255
assert 1024 <= bound <= 131072
assert bound & (bound - 1) == 0 # a power of two
from rpython.rlib.objectmodel import compute_hash
from rpython.rtyper.lltypesystem import lltype, rffi
from rpython.rlib.rarithmetic import r_uint, intmask, r_int
from rpython.rlib.rawstorage import (alloc_raw_storage, raw_storage_setitem,
free_raw_storage, raw_storage_getitem)
from rpython.rlib.objectmodel import (specialize, is_annotation_constant,
always_inline)
from rpython.jit.backend.detect_cpu import getcpuclass
from rpython.jit.tool.oparser import parse
from rpython.jit.metainterp.history import (AbstractFailDescr, AbstractDescr,
BasicFailDescr, BasicFinalDescr,
JitCellToken, TargetToken,
ConstInt, ConstPtr, Const,
ConstFloat)
CPU = getcpuclass()
if sys.maxint == 2**31 - 1:
pytest.skip("32bit platforms are not supported")
@specialize.argtype(0, 1)
def malloc(T, n):
return lltype.malloc(T, n, flavor='raw', zero=True)
def free(mem):
lltype.free(mem, flavor='raw')
def isclose(a, b, rel_tol=1e-09, abs_tol=0.0):
from rpython.jit.backend.x86.regloc import *
from rpython.jit.metainterp.history import ConstFloat
from rpython.jit.metainterp.history import INT, FLOAT
from rpython.rtyper.lltypesystem import llmemory, rffi
from rpython.jit.backend.detect_cpu import getcpuclass
from rpython.jit.codewriter import longlong
import ctypes
import py
ACTUAL_CPU = getcpuclass()
if not hasattr(ACTUAL_CPU, 'NUM_REGS'):
py.test.skip('unsupported CPU')
class FakeCPU:
rtyper = None
supports_floats = True
NUM_REGS = ACTUAL_CPU.NUM_REGS
class gc_ll_descr:
kind = "boehm"
def fielddescrof(self, STRUCT, name):
return 42
def get_fail_descr_from_number(self, num):
assert num == 0x1C3
return FakeFailDescr()
def get_failargs_limit(self):
return 1000
