def test_rewrite_assembler_initialization_store_2(self):
S = lltype.GcStruct('S', ('parent', OBJECT),
('x', lltype.Signed))
s_vtable = lltype.malloc(OBJECT_VTABLE, immortal=True)
wbdescr = self.gc_ll_descr.write_barrier_descr
xdescr = get_field_descr(self.gc_ll_descr, S, 'x')
ops = parse("""
[p1]
p0 = new_with_vtable(ConstClass(s_vtable))
p3 = new_with_vtable(ConstClass(s_vtable))
setfield_gc(p0, p1, descr=xdescr)
jump()
""", namespace=locals())
expected = parse("""
[p1]
p0 = new_with_vtable(ConstClass(s_vtable))
p3 = new_with_vtable(ConstClass(s_vtable))
cond_call_gc_wb(p0, p1, descr=wbdescr)
setfield_raw(p0, p1, descr=xdescr)
jump()
""", namespace=locals())
operations = get_deep_immutable_oplist(ops.operations)
operations = self.gc_ll_descr.rewrite_assembler(self.fake_cpu,
operations, [])
equaloplists(operations, expected.operations)
def check_rewrite(self, frm_operations, to_operations, **namespace):
S = lltype.GcStruct('S', ('x', lltype.Signed), ('y', lltype.Signed))
sdescr = get_size_descr(self.gc_ll_descr, S)
sdescr.tid = 1234
#
T = lltype.GcStruct('T', ('y', lltype.Signed), ('z', lltype.Ptr(S)),
('t', lltype.Signed))
tdescr = get_size_descr(self.gc_ll_descr, T)
tdescr.tid = 5678
tzdescr = get_field_descr(self.gc_ll_descr, T, 'z')
#
A = lltype.GcArray(lltype.Signed)
adescr = get_array_descr(self.gc_ll_descr, A)
adescr.tid = 4321
alendescr = adescr.lendescr
#
B = lltype.GcArray(lltype.Char)
bdescr = get_array_descr(self.gc_ll_descr, B)
bdescr.tid = 8765
blendescr = bdescr.lendescr
#
C = lltype.GcArray(lltype.Ptr(S))
cdescr = get_array_descr(self.gc_ll_descr, C)
cdescr.tid = 8111
clendescr = cdescr.lendescr
#
E = lltype.GcStruct('Empty')
edescr = get_size_descr(self.gc_ll_descr, E)
edescr.tid = 9000
#
vtable_descr = self.gc_ll_descr.fielddescr_vtable
O = lltype.GcStruct('O', ('parent', rclass.OBJECT),
('x', lltype.Signed))
o_vtable = lltype.malloc(rclass.OBJECT_VTABLE, immortal=True)
register_known_gctype(self.cpu, o_vtable, O)
#
tiddescr = self.gc_ll_descr.fielddescr_tid
wbdescr = self.gc_ll_descr.write_barrier_descr
WORD = globals()['WORD']
#
strdescr = self.gc_ll_descr.str_descr
unicodedescr = self.gc_ll_descr.unicode_descr
strlendescr = strdescr.lendescr
unicodelendescr = unicodedescr.lendescr
#
namespace.update(locals())
#
for funcname in self.gc_ll_descr._generated_functions:
namespace[funcname] = self.gc_ll_descr.get_malloc_fn(funcname)
namespace[funcname + '_descr'] = getattr(self.gc_ll_descr,
'%s_descr' % funcname)
#
ops = parse(frm_operations, namespace=namespace)
expected = parse(to_operations % Evaluator(namespace),
namespace=namespace)
operations = self.gc_ll_descr.rewrite_assembler(
self.cpu, ops.operations, [])
equaloplists(operations, expected.operations)
def parse(self, s, boxkinds=None):
return parse(s,
self.cpu,
self.namespace,
type_system=self.type_system,
boxkinds=boxkinds,
invent_fail_descr=self.invent_fail_descr)
def setup_class(cls):
if option.runappdirect:
py.test.skip("Can't run this test with -A")
space = gettestobjspace(usemodules=('pypyjit',))
cls.space = space
w_f = space.appexec([], """():
def f():
pass
return f
""")
ll_code = cast_instance_to_base_ptr(w_f.code)
logger = Logger(MockSD())
oplist = parse("""
[i1, i2]
i3 = int_add(i1, i2)
guard_true(i3) []
""", namespace={'ptr0': 3}).operations
def interp_on_compile():
pypyjitdriver.on_compile(logger, LoopToken(), oplist, 'loop',
0, False, ll_code)
def interp_on_compile_bridge():
pypyjitdriver.on_compile_bridge(logger, LoopToken(), oplist, 0)
cls.w_on_compile = space.wrap(interp2app(interp_on_compile))
cls.w_on_compile_bridge = space.wrap(interp2app(interp_on_compile_bridge))
def test_debugger_on(self):
from pypy.tool.logparser import parse_log_file, extract_category
from pypy.rlib import debug
loop = """
[i0]
debug_merge_point('xyz', 0)
i1 = int_add(i0, 1)
i2 = int_ge(i1, 10)
guard_false(i2) []
jump(i1)
"""
ops = parse(loop)
debug._log = dlog = debug.DebugLog()
try:
self.cpu.assembler.set_debug(True)
self.cpu.compile_loop(ops.inputargs, ops.operations, ops.token)
self.cpu.set_future_value_int(0, 0)
self.cpu.execute_token(ops.token)
# check debugging info
struct = self.cpu.assembler.loop_run_counters[0]
assert struct.i == 10
self.cpu.finish_once()
finally:
debug._log = None
assert ('jit-backend-counts', [('debug_print', 'loop -1:10')]) in dlog
def setup_class(cls):
if option.runappdirect:
py.test.skip("Can't run this test with -A")
space = gettestobjspace(usemodules=('pypyjit',))
cls.space = space
w_f = space.appexec([], """():
def function():
pass
return function
""")
cls.w_f = w_f
ll_code = cast_instance_to_base_ptr(w_f.code)
code_gcref = lltype.cast_opaque_ptr(llmemory.GCREF, ll_code)
logger = Logger(MockSD())
oplist = parse("""
[i1, i2, p2]
i3 = int_add(i1, i2)
debug_merge_point(0, 0, 0, 0, 0, ConstPtr(ptr0))
guard_nonnull(p2) []
guard_true(i3) []
""", namespace={'ptr0': code_gcref}).operations
greenkey = [ConstInt(0), ConstInt(0), ConstPtr(code_gcref)]
offset = {}
for i, op in enumerate(oplist):
if i != 1:
offset[op] = i
di_loop = JitDebugInfo(MockJitDriverSD, logger, JitCellToken(),
oplist, 'loop', greenkey)
di_loop_optimize = JitDebugInfo(MockJitDriverSD, logger, JitCellToken(),
oplist, 'loop', greenkey)
di_loop.asminfo = AsmInfo(offset, 0, 0)
di_bridge = JitDebugInfo(MockJitDriverSD, logger, JitCellToken(),
oplist, 'bridge', fail_descr_no=0)
di_bridge.asminfo = AsmInfo(offset, 0, 0)
def interp_on_compile():
di_loop.oplist = cls.oplist
pypy_hooks.after_compile(di_loop)
def interp_on_compile_bridge():
pypy_hooks.after_compile_bridge(di_bridge)
def interp_on_optimize():
di_loop_optimize.oplist = cls.oplist
pypy_hooks.before_compile(di_loop_optimize)
def interp_on_abort():
pypy_hooks.on_abort(ABORT_TOO_LONG, pypyjitdriver, greenkey,
'blah')
cls.w_on_compile = space.wrap(interp2app(interp_on_compile))
cls.w_on_compile_bridge = space.wrap(interp2app(interp_on_compile_bridge))
cls.w_on_abort = space.wrap(interp2app(interp_on_abort))
cls.w_int_add_num = space.wrap(rop.INT_ADD)
cls.w_dmp_num = space.wrap(rop.DEBUG_MERGE_POINT)
cls.w_on_optimize = space.wrap(interp2app(interp_on_optimize))
cls.orig_oplist = oplist
def test_call_aligned_with_spilled_values(self):
from pypy.rlib.libffi import types
cpu = self.cpu
if not cpu.supports_floats:
py.test.skip('requires floats')
def func(*args):
return float(sum(args))
F = lltype.Float
I = lltype.Signed
floats = [0.7, 5.8, 0.1, 0.3, 0.9, -2.34, -3.45, -4.56]
ints = [7, 11, 23, 13, -42, 1111, 95, 1]
for case in range(256):
local_floats = list(floats)
local_ints = list(ints)
args = []
spills = []
funcargs = []
float_count = 0
int_count = 0
for i in range(8):
if case & (1<<i):
args.append('f%d' % float_count)
spills.append('force_spill(f%d)' % float_count)
float_count += 1
funcargs.append(F)
else:
args.append('i%d' % int_count)
spills.append('force_spill(i%d)' % int_count)
int_count += 1
funcargs.append(I)
arguments = ', '.join(args)
spill_ops = '\n'.join(spills)
FUNC = self.FuncType(funcargs, F)
FPTR = self.Ptr(FUNC)
func_ptr = llhelper(FPTR, func)
calldescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
EffectInfo.MOST_GENERAL)
funcbox = self.get_funcbox(cpu, func_ptr)
ops = '[%s]\n' % arguments
ops += '%s\n' % spill_ops
ops += 'f99 = call(ConstClass(func_ptr), %s, descr=calldescr)\n' % arguments
ops += 'finish(f99, %s)\n' % arguments
loop = parse(ops, namespace=locals())
looptoken = JitCellToken()
done_number = self.cpu.get_fail_descr_number(loop.operations[-1].getdescr())
self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
argvals, expected_result = self._prepare_args(args, floats, ints)
res = self.cpu.execute_token(looptoken, *argvals)
x = longlong.getrealfloat(cpu.get_latest_value_float(0))
assert abs(x - expected_result) < 0.0001
def test_call_aligned_with_spilled_values(self):
from pypy.rlib.libffi import types
cpu = self.cpu
if not cpu.supports_floats:
py.test.skip('requires floats')
def func(*args):
return float(sum(args))
F = lltype.Float
I = lltype.Signed
floats = [0.7, 5.8, 0.1, 0.3, 0.9, -2.34, -3.45, -4.56]
ints = [7, 11, 23, 13, -42, 1111, 95, 1]
for case in range(256):
local_floats = list(floats)
local_ints = list(ints)
args = []
spills = []
funcargs = []
float_count = 0
int_count = 0
for i in range(8):
if case & (1 << i):
args.append('f%d' % float_count)
spills.append('force_spill(f%d)' % float_count)
float_count += 1
funcargs.append(F)
else:
args.append('i%d' % int_count)
spills.append('force_spill(i%d)' % int_count)
int_count += 1
funcargs.append(I)
arguments = ', '.join(args)
spill_ops = '\n'.join(spills)
FUNC = self.FuncType(funcargs, F)
FPTR = self.Ptr(FUNC)
func_ptr = llhelper(FPTR, func)
calldescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
EffectInfo.MOST_GENERAL)
funcbox = self.get_funcbox(cpu, func_ptr)
ops = '[%s]\n' % arguments
ops += '%s\n' % spill_ops
ops += 'f99 = call(ConstClass(func_ptr), %s, descr=calldescr)\n' % arguments
ops += 'finish(f99, %s)\n' % arguments
loop = parse(ops, namespace=locals())
looptoken = JitCellToken()
done_number = self.cpu.get_fail_descr_number(
loop.operations[-1].getdescr())
self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
argvals, expected_result = self._prepare_args(args, floats, ints)
res = self.cpu.execute_token(looptoken, *argvals)
x = longlong.getrealfloat(cpu.get_latest_value_float(0))
assert abs(x - expected_result) < 0.0001
def parse(self, s, boxkinds=None):
return parse(
s,
self.cpu,
self.namespace,
type_system=self.type_system,
boxkinds=boxkinds,
invent_fail_descr=self.invent_fail_descr,
)
def test_rewrite_assembler_initialization_store_3(self):
A = lltype.GcArray(lltype.Ptr(lltype.GcStruct('S')))
arraydescr = get_array_descr(self.gc_ll_descr, A)
ops = parse("""
[p1]
p0 = new_array(3, descr=arraydescr)
setarrayitem_gc(p0, 0, p1, descr=arraydescr)
jump()
""", namespace=locals())
expected = parse("""
[p1]
p0 = new_array(3, descr=arraydescr)
setarrayitem_gc(p0, 0, p1, descr=arraydescr)
jump()
""", namespace=locals())
operations = get_deep_immutable_oplist(ops.operations)
operations = self.gc_ll_descr.rewrite_assembler(self.fake_cpu,
operations, [])
equaloplists(operations, expected.operations)
def consider_category(log, options, category):
loops = logparser.extract_category(log, category)
if options.loopnum is None:
input_loops = loops
else:
input_loops = [loops[options.loopnum]]
loops = [parse(inp, no_namespace=True, nonstrict=True)
for inp in input_loops]
summary = {}
for loop in loops:
summary = loop.summary(summary)
return loops, summary
def consider_category(log, options, category):
loops = logparser.extract_category(log, category)
if options.loopnum is None:
input_loops = loops
else:
input_loops = [loops[options.loopnum]]
loops = [
parse(inp, no_namespace=True, nonstrict=True) for inp in input_loops
]
summary = {}
for loop in loops:
summary = loop.summary(summary)
return loops, summary
def test_compile_new_loop():
cpu = FakeCPU()
staticdata = FakeMetaInterpStaticData()
staticdata.cpu = cpu
staticdata.globaldata = FakeGlobalData()
staticdata.globaldata.loopnumbering = 1
#
loop = parse(
"""
[p1]
i1 = getfield_gc(p1, descr=valuedescr)
i2 = int_add(i1, 1)
p2 = new_with_vtable(ConstClass(node_vtable))
setfield_gc(p2, i2, descr=valuedescr)
jump(p2)
""",
namespace=LLtypeMixin.__dict__.copy(),
)
#
metainterp = FakeMetaInterp()
metainterp.staticdata = staticdata
metainterp.cpu = cpu
metainterp.history = History()
metainterp.history.operations = loop.operations[:]
metainterp.history.inputargs = loop.inputargs[:]
cpu._all_size_descrs_with_vtable = LLtypeMixin.cpu._all_size_descrs_with_vtable
#
loop_tokens = []
loop_token = compile_new_loop(metainterp, loop_tokens, [], 0, None)
assert loop_tokens == [loop_token]
assert loop_token.number == 1
assert staticdata.globaldata.loopnumbering == 2
#
assert len(cpu.seen) == 1
assert cpu.seen[0][2] == loop_token
#
del cpu.seen[:]
metainterp = FakeMetaInterp()
metainterp.staticdata = staticdata
metainterp.cpu = cpu
metainterp.history = History()
metainterp.history.operations = loop.operations[:]
metainterp.history.inputargs = loop.inputargs[:]
#
loop_token_2 = compile_new_loop(metainterp, loop_tokens, [], 0, None)
assert loop_token_2 is loop_token
assert loop_tokens == [loop_token]
assert len(cpu.seen) == 0
assert staticdata.globaldata.loopnumbering == 2
def test_debugger_checksum(self):
loop = """
[i0]
debug_merge_point('xyz', 0)
i1 = int_add(i0, 1)
i2 = int_ge(i1, 10)
guard_false(i2) []
jump(i1)
"""
ops = parse(loop)
self.cpu.assembler.set_debug(True)
self.cpu.compile_loop(ops.inputargs, ops.operations, ops.token)
self.cpu.set_future_value_int(0, 0)
self.cpu.execute_token(ops.token)
assert ops.token._x86_debug_checksum == sum([op.getopnum() for op in ops.operations])
def test_debugger_checksum(self):
loop = """
[i0]
label(i0, descr=targettoken)
debug_merge_point('xyz', 0, 0)
i1 = int_add(i0, 1)
i2 = int_ge(i1, 10)
guard_false(i2) []
jump(i1, descr=targettoken)
"""
ops = parse(loop, namespace={"targettoken": TargetToken()})
self.cpu.assembler.set_debug(True)
looptoken = JitCellToken()
self.cpu.compile_loop(ops.inputargs, ops.operations, looptoken)
self.cpu.execute_token(looptoken, 0)
assert looptoken._x86_debug_checksum == sum([op.getopnum() for op in ops.operations])
def test_debugger_checksum(self):
loop = """
[i0]
label(i0, descr=targettoken)
debug_merge_point('xyz', 0)
i1 = int_add(i0, 1)
i2 = int_ge(i1, 10)
guard_false(i2) []
jump(i1, descr=targettoken)
"""
ops = parse(loop, namespace={'targettoken': TargetToken()})
self.cpu.assembler.set_debug(True)
looptoken = JitCellToken()
self.cpu.compile_loop(ops.inputargs, ops.operations, looptoken)
self.cpu.execute_token(looptoken, 0)
assert looptoken._x86_debug_checksum == sum([op.getopnum()
for op in ops.operations])
def test_debugger_on(self):
from pypy.tool.logparser import parse_log_file, extract_category
from pypy.rlib import debug
targettoken, preambletoken = TargetToken(), TargetToken()
loop = """
[i0]
label(i0, descr=preambletoken)
debug_merge_point('xyz', 0, 0)
i1 = int_add(i0, 1)
i2 = int_ge(i1, 10)
guard_false(i2) []
label(i1, descr=targettoken)
debug_merge_point('xyz', 0, 0)
i11 = int_add(i1, 1)
i12 = int_ge(i11, 10)
guard_false(i12) []
jump(i11, descr=targettoken)
"""
ops = parse(loop,
namespace={
'targettoken': targettoken,
'preambletoken': preambletoken
})
debug._log = dlog = debug.DebugLog()
try:
self.cpu.assembler.set_debug(True)
looptoken = JitCellToken()
self.cpu.compile_loop(ops.inputargs, ops.operations, looptoken)
self.cpu.execute_token(looptoken, 0)
# check debugging info
struct = self.cpu.assembler.loop_run_counters[0]
assert struct.i == 1
struct = self.cpu.assembler.loop_run_counters[1]
assert struct.i == 1
struct = self.cpu.assembler.loop_run_counters[2]
assert struct.i == 9
self.cpu.finish_once()
finally:
debug._log = None
l0 = ('debug_print', 'entry -1:1')
l1 = ('debug_print', preambletoken.repr_of_descr() + ':1')
l2 = ('debug_print', targettoken.repr_of_descr() + ':9')
assert ('jit-backend-counts', [l0, l1, l2]) in dlog
def main(argv):
log = logparser.parse_log_file(argv[0])
parts = logparser.extract_category(log, "jit-log-opt-")
for i, oplist in enumerate(parts):
loop = parse(oplist, no_namespace=True, nonstrict=True)
num_ops = 0
num_dmp = 0
num_guards = 0
for op in loop.operations:
if op.getopnum() == rop.DEBUG_MERGE_POINT:
num_dmp += 1
else:
num_ops += 1
if op.is_guard():
num_guards += 1
if num_dmp == 0:
print "Loop #%d, length: %d, opcodes: %d, guards: %d" % (i, num_ops, num_dmp, num_guards)
else:
print "Loop #%d, length: %d, opcodes: %d, guards: %d, %f" % (i, num_ops, num_dmp, num_guards, num_ops/num_dmp)
def test_debugger_on(self):
from pypy.tool.logparser import parse_log_file, extract_category
from pypy.rlib import debug
targettoken, preambletoken = TargetToken(), TargetToken()
loop = """
[i0]
label(i0, descr=preambletoken)
debug_merge_point('xyz', 0)
i1 = int_add(i0, 1)
i2 = int_ge(i1, 10)
guard_false(i2) []
label(i1, descr=targettoken)
debug_merge_point('xyz', 0)
i11 = int_add(i1, 1)
i12 = int_ge(i11, 10)
guard_false(i12) []
jump(i11, descr=targettoken)
"""
ops = parse(loop, namespace={'targettoken': targettoken,
'preambletoken': preambletoken})
debug._log = dlog = debug.DebugLog()
try:
self.cpu.assembler.set_debug(True)
looptoken = JitCellToken()
self.cpu.compile_loop(ops.inputargs, ops.operations, looptoken)
self.cpu.execute_token(looptoken, 0)
# check debugging info
struct = self.cpu.assembler.loop_run_counters[0]
assert struct.i == 1
struct = self.cpu.assembler.loop_run_counters[1]
assert struct.i == 1
struct = self.cpu.assembler.loop_run_counters[2]
assert struct.i == 9
self.cpu.finish_once()
finally:
debug._log = None
l0 = ('debug_print', 'entry -1:1')
l1 = ('debug_print', preambletoken.repr_of_descr() + ':1')
l2 = ('debug_print', targettoken.repr_of_descr() + ':9')
assert ('jit-backend-counts', [l0, l1, l2]) in dlog
def main(argv):
log = logparser.parse_log_file(argv[0])
parts = logparser.extract_category(log, "jit-log-opt-")
for i, oplist in enumerate(parts):
loop = parse(oplist, no_namespace=True, nonstrict=True)
num_ops = 0
num_dmp = 0
num_guards = 0
for op in loop.operations:
if op.getopnum() == rop.DEBUG_MERGE_POINT:
num_dmp += 1
else:
num_ops += 1
if op.is_guard():
num_guards += 1
if num_dmp == 0:
print "Loop #%d, length: %d, opcodes: %d, guards: %d" % (
i, num_ops, num_dmp, num_guards)
else:
print "Loop #%d, length: %d, opcodes: %d, guards: %d, %f" % (
i, num_ops, num_dmp, num_guards, num_ops / num_dmp)
def test_compile_loop():
cpu = FakeCPU()
staticdata = FakeMetaInterpStaticData()
staticdata.cpu = cpu
staticdata.globaldata = FakeGlobalData()
staticdata.globaldata.loopnumbering = 1
#
loop = parse('''
[p1]
i1 = getfield_gc(p1, descr=valuedescr)
i2 = int_add(i1, 1)
p2 = new_with_vtable(ConstClass(node_vtable))
setfield_gc(p2, i2, descr=valuedescr)
jump(p2)
''', namespace=LLtypeMixin.__dict__.copy())
#
metainterp = FakeMetaInterp()
metainterp.staticdata = staticdata
metainterp.cpu = cpu
metainterp.history = History()
metainterp.history.operations = loop.operations[:-1]
metainterp.history.inputargs = loop.inputargs[:]
cpu._all_size_descrs_with_vtable = (
LLtypeMixin.cpu._all_size_descrs_with_vtable)
#
greenkey = 'faked'
target_token = compile_loop(metainterp, greenkey, 0,
loop.inputargs,
loop.operations[-1].getarglist(),
None)
jitcell_token = target_token.targeting_jitcell_token
assert jitcell_token == target_token.original_jitcell_token
assert jitcell_token.target_tokens == [target_token]
assert jitcell_token.number == 1
assert staticdata.globaldata.loopnumbering == 2
#
assert len(cpu.seen) == 1
assert cpu.seen[0][2] == jitcell_token
#
del cpu.seen[:]
def test_compile_loop():
cpu = FakeCPU()
staticdata = FakeMetaInterpStaticData()
staticdata.cpu = cpu
staticdata.globaldata = FakeGlobalData()
staticdata.globaldata.loopnumbering = 1
#
loop = parse('''
[p1]
i1 = getfield_gc(p1, descr=valuedescr)
i2 = int_add(i1, 1)
p2 = new_with_vtable(ConstClass(node_vtable))
setfield_gc(p2, i2, descr=valuedescr)
jump(p2)
''',
namespace=LLtypeMixin.__dict__.copy())
#
metainterp = FakeMetaInterp()
metainterp.staticdata = staticdata
metainterp.cpu = cpu
metainterp.history = History()
metainterp.history.operations = loop.operations[:-1]
metainterp.history.inputargs = loop.inputargs[:]
cpu._all_size_descrs_with_vtable = (
LLtypeMixin.cpu._all_size_descrs_with_vtable)
#
greenkey = 'faked'
target_token = compile_loop(metainterp, greenkey, 0, loop.inputargs,
loop.operations[-1].getarglist(), None)
jitcell_token = target_token.targeting_jitcell_token
assert jitcell_token == target_token.original_jitcell_token
assert jitcell_token.target_tokens == [target_token]
assert jitcell_token.number == 1
assert staticdata.globaldata.loopnumbering == 2
#
assert len(cpu.seen) == 1
assert cpu.seen[0][2] == jitcell_token
#
del cpu.seen[:]
def parse(self, *args, **kwds):
kwds['OpParser'] = self.OpParser
return parse(*args, **kwds)
def setup_class(cls):
if option.runappdirect:
py.test.skip("Can't run this test with -A")
space = gettestobjspace(usemodules=('pypyjit', ))
cls.space = space
w_f = space.appexec([], """():
def function():
pass
return function
""")
cls.w_f = w_f
ll_code = cast_instance_to_base_ptr(w_f.code)
code_gcref = lltype.cast_opaque_ptr(llmemory.GCREF, ll_code)
logger = Logger(MockSD())
oplist = parse("""
[i1, i2, p2]
i3 = int_add(i1, i2)
debug_merge_point(0, 0, 0, 0, ConstPtr(ptr0))
guard_nonnull(p2) []
guard_true(i3) []
""",
namespace={
'ptr0': code_gcref
}).operations
greenkey = [ConstInt(0), ConstInt(0), ConstPtr(code_gcref)]
offset = {}
for i, op in enumerate(oplist):
if i != 1:
offset[op] = i
di_loop = JitDebugInfo(MockJitDriverSD, logger, JitCellToken(), oplist,
'loop', greenkey)
di_loop_optimize = JitDebugInfo(MockJitDriverSD, logger,
JitCellToken(), oplist, 'loop',
greenkey)
di_loop.asminfo = AsmInfo(offset, 0, 0)
di_bridge = JitDebugInfo(MockJitDriverSD,
logger,
JitCellToken(),
oplist,
'bridge',
fail_descr_no=0)
di_bridge.asminfo = AsmInfo(offset, 0, 0)
def interp_on_compile():
di_loop.oplist = cls.oplist
pypy_hooks.after_compile(di_loop)
def interp_on_compile_bridge():
pypy_hooks.after_compile_bridge(di_bridge)
def interp_on_optimize():
di_loop_optimize.oplist = cls.oplist
pypy_hooks.before_compile(di_loop_optimize)
def interp_on_abort():
pypy_hooks.on_abort(ABORT_TOO_LONG, pypyjitdriver, greenkey,
'blah')
cls.w_on_compile = space.wrap(interp2app(interp_on_compile))
cls.w_on_compile_bridge = space.wrap(
interp2app(interp_on_compile_bridge))
cls.w_on_abort = space.wrap(interp2app(interp_on_abort))
cls.w_int_add_num = space.wrap(rop.INT_ADD)
cls.w_on_optimize = space.wrap(interp2app(interp_on_optimize))
cls.orig_oplist = oplist
def test_call_alignment_call_assembler(self):
from pypy.rlib.libffi import types
cpu = self.cpu
if not cpu.supports_floats:
py.test.skip('requires floats')
fdescr3 = BasicFailDescr(3)
fdescr4 = BasicFailDescr(4)
def assembler_helper(failindex, virtualizable):
assert 0, 'should not be called, but was with failindex (%d)' % failindex
return 13
FUNCPTR = lltype.Ptr(lltype.FuncType([lltype.Signed, llmemory.GCREF],
lltype.Signed))
class FakeJitDriverSD:
index_of_virtualizable = -1
_assembler_helper_ptr = llhelper(FUNCPTR, assembler_helper)
assembler_helper_adr = llmemory.cast_ptr_to_adr(
_assembler_helper_ptr)
floats = [0.7, 5.8, 0.1, 0.3, 0.9, -2.34, -3.45, -4.56]
ints = [7, 11, 23, 42, -42, 1111, 95, 1]
for case in range(256):
float_count = 0
int_count = 0
args = []
called_ops = ''
total_index = -1
for i in range(8):
if case & (1<<i):
args.append('f%d' % float_count)
else:
args.append('i%d' % int_count)
called_ops += 'f%d = cast_int_to_float(i%d)\n' % (
float_count, int_count)
int_count += 1
if total_index == -1:
total_index = float_count
float_count += 1
else:
called_ops += 'f%d = float_add(f%d, f%d)\n' % (
float_count + 1, total_index, float_count)
total_index = float_count + 1
float_count += 2
arguments = ', '.join(args)
called_ops = '[%s]\n' % arguments + called_ops
called_ops += 'finish(f%d, descr=fdescr3)\n' % total_index
# compile called loop
called_loop = parse(called_ops, namespace=locals())
called_looptoken = LoopToken()
called_looptoken.outermost_jitdriver_sd = FakeJitDriverSD()
done_number = self.cpu.get_fail_descr_number(called_loop.operations[-1].getdescr())
self.cpu.compile_loop(called_loop.inputargs, called_loop.operations, called_looptoken)
expected_result = self._prepare_args(args, floats, ints)
res = cpu.execute_token(called_looptoken)
assert res.identifier == 3
t = longlong.getrealfloat(cpu.get_latest_value_float(0))
assert abs(t - expected_result) < 0.0001
ARGS = []
RES = lltype.Float
for x in args:
if x[0] == 'f':
ARGS.append(lltype.Float)
else:
ARGS.append(lltype.Signed)
FakeJitDriverSD.portal_calldescr = self.cpu.calldescrof(
lltype.Ptr(lltype.FuncType(ARGS, RES)), ARGS, RES)
ops = '''
[%s]
f99 = call_assembler(%s, descr=called_looptoken)
guard_not_forced()[]
finish(f99, descr=fdescr4)
''' % (arguments, arguments)
loop = parse(ops, namespace=locals())
# we want to take the fast path
self.cpu.done_with_this_frame_float_v = done_number
try:
othertoken = LoopToken()
self.cpu.compile_loop(loop.inputargs, loop.operations, othertoken)
# prepare call to called_loop
self._prepare_args(args, floats, ints)
res = cpu.execute_token(othertoken)
x = longlong.getrealfloat(cpu.get_latest_value_float(0))
assert res.identifier == 4
assert abs(x - expected_result) < 0.0001
finally:
del self.cpu.done_with_this_frame_float_v
def parse(self, s, boxkinds=None):
return parse(s, self.cpu, self.namespace,
type_system=self.type_system,
boxkinds=boxkinds)
def test_call_alignment_call_assembler(self):
from pypy.rlib.libffi import types
cpu = self.cpu
if not cpu.supports_floats:
py.test.skip('requires floats')
fdescr3 = BasicFailDescr(3)
fdescr4 = BasicFailDescr(4)
def assembler_helper(failindex, virtualizable):
assert 0, 'should not be called, but was with failindex (%d)' % failindex
return 13
FUNCPTR = lltype.Ptr(
lltype.FuncType([lltype.Signed, llmemory.GCREF], lltype.Signed))
class FakeJitDriverSD:
index_of_virtualizable = -1
_assembler_helper_ptr = llhelper(FUNCPTR, assembler_helper)
assembler_helper_adr = llmemory.cast_ptr_to_adr(
_assembler_helper_ptr)
floats = [0.7, 5.8, 0.1, 0.3, 0.9, -2.34, -3.45, -4.56]
ints = [7, 11, 23, 42, -42, 1111, 95, 1]
for case in range(256):
float_count = 0
int_count = 0
args = []
called_ops = ''
total_index = -1
for i in range(8):
if case & (1 << i):
args.append('f%d' % float_count)
else:
args.append('i%d' % int_count)
called_ops += 'f%d = cast_int_to_float(i%d)\n' % (
float_count, int_count)
int_count += 1
if total_index == -1:
total_index = float_count
float_count += 1
else:
called_ops += 'f%d = float_add(f%d, f%d)\n' % (
float_count + 1, total_index, float_count)
total_index = float_count + 1
float_count += 2
arguments = ', '.join(args)
called_ops = '[%s]\n' % arguments + called_ops
called_ops += 'finish(f%d, descr=fdescr3)\n' % total_index
# compile called loop
called_loop = parse(called_ops, namespace=locals())
called_looptoken = JitCellToken()
called_looptoken.outermost_jitdriver_sd = FakeJitDriverSD()
done_number = self.cpu.get_fail_descr_number(
called_loop.operations[-1].getdescr())
self.cpu.compile_loop(called_loop.inputargs,
called_loop.operations, called_looptoken)
argvals, expected_result = self._prepare_args(args, floats, ints)
res = cpu.execute_token(called_looptoken, *argvals)
assert res.identifier == 3
t = longlong.getrealfloat(cpu.get_latest_value_float(0))
assert abs(t - expected_result) < 0.0001
ARGS = []
RES = lltype.Float
for x in args:
if x[0] == 'f':
ARGS.append(lltype.Float)
else:
ARGS.append(lltype.Signed)
FakeJitDriverSD.portal_calldescr = self.cpu.calldescrof(
lltype.Ptr(lltype.FuncType(ARGS, RES)), ARGS, RES,
EffectInfo.MOST_GENERAL)
ops = '''
[%s]
f99 = call_assembler(%s, descr=called_looptoken)
guard_not_forced()[]
finish(f99, descr=fdescr4)
''' % (arguments, arguments)
loop = parse(ops, namespace=locals())
# we want to take the fast path
self.cpu.done_with_this_frame_float_v = done_number
try:
othertoken = JitCellToken()
self.cpu.compile_loop(loop.inputargs, loop.operations,
othertoken)
# prepare call to called_loop
argvals, _ = self._prepare_args(args, floats, ints)
res = cpu.execute_token(othertoken, *argvals)
x = longlong.getrealfloat(cpu.get_latest_value_float(0))
assert res.identifier == 4
assert abs(x - expected_result) < 0.0001
finally:
del self.cpu.done_with_this_frame_float_v
def check_rewrite(self, frm_operations, to_operations, **namespace):
S = lltype.GcStruct('S', ('x', lltype.Signed),
('y', lltype.Signed))
sdescr = get_size_descr(self.gc_ll_descr, S)
sdescr.tid = 1234
#
T = lltype.GcStruct('T', ('y', lltype.Signed),
('z', lltype.Ptr(S)),
('t', lltype.Signed))
tdescr = get_size_descr(self.gc_ll_descr, T)
tdescr.tid = 5678
tzdescr = get_field_descr(self.gc_ll_descr, T, 'z')
#
A = lltype.GcArray(lltype.Signed)
adescr = get_array_descr(self.gc_ll_descr, A)
adescr.tid = 4321
alendescr = adescr.lendescr
#
B = lltype.GcArray(lltype.Char)
bdescr = get_array_descr(self.gc_ll_descr, B)
bdescr.tid = 8765
blendescr = bdescr.lendescr
#
C = lltype.GcArray(lltype.Ptr(S))
cdescr = get_array_descr(self.gc_ll_descr, C)
cdescr.tid = 8111
clendescr = cdescr.lendescr
#
E = lltype.GcStruct('Empty')
edescr = get_size_descr(self.gc_ll_descr, E)
edescr.tid = 9000
#
vtable_descr = self.gc_ll_descr.fielddescr_vtable
O = lltype.GcStruct('O', ('parent', rclass.OBJECT),
('x', lltype.Signed))
o_vtable = lltype.malloc(rclass.OBJECT_VTABLE, immortal=True)
register_known_gctype(self.cpu, o_vtable, O)
#
tiddescr = self.gc_ll_descr.fielddescr_tid
wbdescr = self.gc_ll_descr.write_barrier_descr
WORD = globals()['WORD']
#
strdescr = self.gc_ll_descr.str_descr
unicodedescr = self.gc_ll_descr.unicode_descr
strlendescr = strdescr.lendescr
unicodelendescr = unicodedescr.lendescr
#
namespace.update(locals())
#
for funcname in self.gc_ll_descr._generated_functions:
namespace[funcname] = self.gc_ll_descr.get_malloc_fn(funcname)
namespace[funcname + '_descr'] = getattr(self.gc_ll_descr,
'%s_descr' % funcname)
#
ops = parse(frm_operations, namespace=namespace)
expected = parse(to_operations % Evaluator(namespace),
namespace=namespace)
operations = self.gc_ll_descr.rewrite_assembler(self.cpu,
ops.operations,
[])
equaloplists(operations, expected.operations)
def parse(self, *args, **kwds):
kwds['OpParser'] = self.OpParser
return parse(*args, **kwds)
