def test_evenodd_pair_extensive(self, value):
instrs = []
failargs = []
values = []
j = 0
mapping = (('int_floordiv', lambda x, y: x // y),
('int_mod', lambda x, y: x % y), ('int_mul_ovf',
lambda x, y: x * y))
for i in range(20):
name, func = mapping[j]
instrs.append("i{d} = {i}(i0, {d})".format(d=i + 1, i=name))
values.append((name, func(value, i + 1)))
failargs.append("i" + str(i + 1))
j += 1
if j >= len(mapping):
j = 0
code = """
[i0]
{instrs}
i99 = int_add(i0, 1)
i100 = int_eq(i0,i99)
guard_true(i100) [{failargs}] # will always fail!!
finish(i0, descr=faildescr)
""".format(instrs=('\n' + ' ' * 8).join(instrs),
failargs=','.join(failargs))
# the guard forces 3 spills because after 4 divisions
# all even slots of the managed registers are full
loop = parse(code, namespace={'faildescr': BasicFinalDescr(1)})
looptoken = JitCellToken()
self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
deadframe = self.cpu.execute_token(looptoken, value)
fail = self.cpu.get_latest_descr(deadframe)
for i, (name, v) in enumerate(values):
assert self.cpu.get_int_value(deadframe, i) == v
def test_compile_more_than_32k(self):
# the guard_true needs a "b.cond" jumping forward more than 32 kb
looptoken = JitCellToken()
targettoken = TargetToken()
ops = [
'[i0]',
'label(i0, descr=targettoken)',
'i1 = int_le(i0, 9)',
'guard_true(i1, descr=faildescr) [i0]',
]
NUM = 8193
iprevious = 'i0'
for i in range(NUM):
inext = 'i%d' % (i + 2,)
ops.append('%s = int_add(%s, 1)' % (inext, iprevious))
iprevious = inext
ops.append('jump(%s, descr=targettoken)' % (iprevious,))
loop = parse('\n'.join(ops), namespace={'targettoken': targettoken,
'faildescr': BasicFailDescr(5)})
self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
deadframe = self.cpu.execute_token(looptoken, -42)
fail = self.cpu.get_latest_descr(deadframe)
assert fail.identifier == 5
res = self.cpu.get_int_value(deadframe, 0)
assert res == -42 + NUM
def test_evenodd_pair_extensive(self, value):
instrs = []
failargs = []
values = []
j = 0
mapping = (('int_floordiv',lambda x,y: x // y),
('int_mod', lambda x,y: x % y),
('int_mul_ovf', lambda x,y: x * y))
for i in range(20):
name, func = mapping[j]
instrs.append("i{d} = {i}(i0, {d})".format(d=i+1, i=name))
values.append((name, func(value, i+1)))
failargs.append("i" + str(i+1))
j += 1
if j >= len(mapping):
j = 0
code = """
[i0]
{instrs}
i99 = int_add(i0, 1)
i100 = int_eq(i0,i99)
guard_true(i100) [{failargs}] # will always fail!!
finish(i0, descr=faildescr)
""".format(instrs=('\n' +' '*8).join(instrs), failargs=','.join(failargs))
# the guard forces 3 spills because after 4 divisions
# all even slots of the managed registers are full
loop = parse(code, namespace={'faildescr': BasicFinalDescr(1)})
looptoken = JitCellToken()
self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
deadframe = self.cpu.execute_token(looptoken, value)
fail = self.cpu.get_latest_descr(deadframe)
for i,(name, v) in enumerate(values):
assert self.cpu.get_int_value(deadframe, i) == v
def test_unicodesetitem_really_needs_temploc(self):
u_box = self.alloc_unicode(u"abcdsdasdsaddefg")
targettoken = TargetToken()
finaldescr = BasicFinalDescr(1)
loop = parse('''
[i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, p10]
label(i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, p10, descr=targettoken)
unicodesetitem(p10, i6, 123)
i11 = int_add(i0, i1)
i12 = int_add(i11, i2)
i13 = int_add(i12, i3)
i14 = int_add(i13, i4)
i15 = int_add(i14, i5)
i16 = int_add(i15, i6)
i17 = int_add(i16, i7)
i18 = int_add(i17, i8)
i19 = int_add(i18, i9)
finish(i19, descr=finaldescr)
''',
namespace={
'targettoken': targettoken,
'finaldescr': finaldescr
})
looptoken = JitCellToken()
args = [(i + 1) for i in range(10)] + [u_box.getref_base()]
self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
deadframe = self.cpu.execute_token(looptoken, *args)
fail = self.cpu.get_latest_descr(deadframe)
assert fail.identifier == 1
res = self.cpu.get_int_value(deadframe, 0)
assert res == sum(args[:10])
def test_unicodesetitem_really_needs_temploc(self):
u_box = self.alloc_unicode(u"abcdsdasdsaddefg")
targettoken = TargetToken()
finaldescr = BasicFinalDescr(1)
loop = parse('''
[i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, p10]
label(i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, p10, descr=targettoken)
unicodesetitem(p10, i6, 123)
i11 = int_add(i0, i1)
i12 = int_add(i11, i2)
i13 = int_add(i12, i3)
i14 = int_add(i13, i4)
i15 = int_add(i14, i5)
i16 = int_add(i15, i6)
i17 = int_add(i16, i7)
i18 = int_add(i17, i8)
i19 = int_add(i18, i9)
finish(i19, descr=finaldescr)
''', namespace={'targettoken': targettoken,
'finaldescr': finaldescr})
looptoken = JitCellToken()
args = [(i + 1) for i in range(10)] + [u_box.getref_base()]
self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
deadframe = self.cpu.execute_token(looptoken, *args)
fail = self.cpu.get_latest_descr(deadframe)
assert fail.identifier == 1
res = self.cpu.get_int_value(deadframe, 0)
assert res == sum(args[:10])
def test_compile_more_than_32k(self):
# the guard_true needs a "b.cond" jumping forward more than 32 kb
looptoken = JitCellToken()
targettoken = TargetToken()
ops = [
'[i0]',
'label(i0, descr=targettoken)',
'i1 = int_le(i0, 9)',
'guard_true(i1, descr=faildescr) [i0]',
]
NUM = 8193
iprevious = 'i0'
for i in range(NUM):
inext = 'i%d' % (i + 2, )
ops.append('%s = int_add(%s, 1)' % (inext, iprevious))
iprevious = inext
ops.append('jump(%s, descr=targettoken)' % (iprevious, ))
loop = parse('\n'.join(ops),
namespace={
'targettoken': targettoken,
'faildescr': BasicFailDescr(5)
})
self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
deadframe = self.cpu.execute_token(looptoken, -42)
fail = self.cpu.get_latest_descr(deadframe)
assert fail.identifier == 5
res = self.cpu.get_int_value(deadframe, 0)
assert res == -42 + NUM
def test_compile_loop_many_int_args(self):
for numargs in range(2, 30):
ops = []
arglist = "[%s]\n" % ", ".join(["i%d" % i for i in range(numargs)])
ops.append(arglist)
arg1 = 0
arg2 = 1
res = numargs
for i in range(numargs - 1):
op = "i%d = int_add(i%d, i%d)\n" % (res, arg1, arg2)
arg1 = res
res += 1
arg2 += 1
ops.append(op)
ops.append("finish(i%d)" % (res - 1))
ops = "".join(ops)
loop = parse(ops)
looptoken = JitCellToken()
self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
ARGS = [lltype.Signed] * numargs
RES = lltype.Signed
args = [i + 1 for i in range(numargs)]
deadframe = self.cpu.execute_token(looptoken, *args)
assert self.cpu.get_int_value(deadframe, 0) == sum(args)
def test_compile_loop_many_int_args(self):
for numargs in range(2, 30):
ops = []
arglist = "[%s]\n" % ", ".join(["i%d" % i for i in range(numargs)])
ops.append(arglist)
arg1 = 0
arg2 = 1
res = numargs
for i in range(numargs - 1):
op = "i%d = int_add(i%d, i%d)\n" % (res, arg1, arg2)
arg1 = res
res += 1
arg2 += 1
ops.append(op)
ops.append("finish(i%d)" % (res - 1))
ops = "".join(ops)
loop = parse(ops)
looptoken = JitCellToken()
self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
ARGS = [lltype.Signed] * numargs
RES = lltype.Signed
args = [i+1 for i in range(numargs)]
deadframe = self.cpu.execute_token(looptoken, *args)
assert self.cpu.get_int_value(deadframe, 0) == sum(args)
def run(inputargs, ops):
cpu = CPU(None, None)
cpu.setup_once()
loop = parse(ops, cpu, namespace=locals())
looptoken = JitCellToken()
cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
deadframe = cpu.execute_token(looptoken, *inputargs)
return cpu, deadframe
def run(inputargs, ops):
cpu = CPU(None, None)
cpu.setup_once()
loop = parse(ops, cpu, namespace=locals())
looptoken = JitCellToken()
cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
deadframe = cpu.execute_token(looptoken, *inputargs)
return cpu, deadframe
def test_redirect_call_assembler2(self):
def assembler_helper(deadframe, virtualizable):
x = self.cpu.get_int_value(deadframe, 0)
assert x == 11
return 7
FUNCPTR = lltype.Ptr(
lltype.FuncType([llmemory.GCREF, 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)
FakeJitDriverSD.portal_calldescr = self.cpu.calldescrof(
lltype.Ptr(lltype.FuncType([lltype.Signed], lltype.Signed)),
[lltype.Signed], lltype.Signed, EffectInfo.MOST_GENERAL)
lt1, lt2, lt3 = [JitCellToken() for x in range(3)]
lt2.outermost_jitdriver_sd = FakeJitDriverSD()
loop1 = parse('''
[i0]
i1 = call_assembler_i(i0, descr=lt2)
guard_not_forced()[]
finish(i1)
''',
namespace=locals())
loop2 = parse('''
[i0]
i1 = int_add(i0, 1)
finish(i1)
''')
loop3 = parse('''
[i0]
i1 = int_sub(i0, 1)
finish(i1)
''')
self.cpu.compile_loop(loop2.inputargs, loop2.operations, lt2)
self.cpu.compile_loop(loop3.inputargs, loop3.operations, lt3)
self.cpu.compile_loop(loop1.inputargs, loop1.operations, lt1)
df = self.cpu.execute_token(lt1, 10)
assert self.cpu.get_int_value(df, 0) == 7
self.cpu.redirect_call_assembler(lt2, lt3)
df = self.cpu.execute_token(lt1, 12)
assert self.cpu.get_int_value(df, 0) == 7
def test_call_aligned_with_spilled_values(self):
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_f(ConstClass(func_ptr), %s, descr=calldescr)\n' % arguments
ops += 'i99 = same_as_i(0)\n'
ops += 'guard_true(i99) [f99, %s]\n' % arguments
ops += 'finish()\n'
loop = parse(ops, namespace=locals())
looptoken = JitCellToken()
self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
argvals, expected_result = self._prepare_args(args, floats, ints)
deadframe = self.cpu.execute_token(looptoken, *argvals)
x = longlong.getrealfloat(cpu.get_float_value(deadframe, 0))
assert abs(x - expected_result) < 0.0001
def test_call_aligned_with_spilled_values(self):
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 += 'i99 = same_as(0)\n'
ops += 'guard_true(i99) [f99, %s]\n' % arguments
ops += 'finish()\n'
loop = parse(ops, namespace=locals())
looptoken = JitCellToken()
self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
argvals, expected_result = self._prepare_args(args, floats, ints)
deadframe = self.cpu.execute_token(looptoken, *argvals)
x = longlong.getrealfloat(cpu.get_float_value(deadframe, 0))
assert abs(x - expected_result) < 0.0001
def parse(self, s, boxkinds=None, want_fail_descr=True):
if want_fail_descr:
invent_fail_descr = self.invent_fail_descr
else:
invent_fail_descr = lambda *args: None
return parse(s, self.cpu, self.namespace,
type_system=self.type_system,
boxkinds=boxkinds,
invent_fail_descr=invent_fail_descr)
def test_redirect_call_assembler2(self):
def assembler_helper(deadframe, virtualizable):
x = self.cpu.get_int_value(deadframe, 0)
assert x == 11
return 7
FUNCPTR = lltype.Ptr(lltype.FuncType([llmemory.GCREF, 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)
FakeJitDriverSD.portal_calldescr = self.cpu.calldescrof(
lltype.Ptr(lltype.FuncType([lltype.Signed], lltype.Signed)),
[lltype.Signed], lltype.Signed, EffectInfo.MOST_GENERAL)
lt1, lt2, lt3 = [JitCellToken() for x in range(3)]
lt2.outermost_jitdriver_sd = FakeJitDriverSD()
loop1 = parse('''
[i0]
i1 = call_assembler_i(i0, descr=lt2)
guard_not_forced()[]
finish(i1)
''', namespace=locals())
loop2 = parse('''
[i0]
i1 = int_add(i0, 1)
finish(i1)
''')
loop3 = parse('''
[i0]
i1 = int_sub(i0, 1)
finish(i1)
''')
self.cpu.compile_loop(loop2.inputargs, loop2.operations, lt2)
self.cpu.compile_loop(loop3.inputargs, loop3.operations, lt3)
self.cpu.compile_loop(loop1.inputargs, loop1.operations, lt1)
df = self.cpu.execute_token(lt1, 10)
assert self.cpu.get_int_value(df, 0) == 7
self.cpu.redirect_call_assembler(lt2, lt3)
df = self.cpu.execute_token(lt1, 12)
assert self.cpu.get_int_value(df, 0) == 7
def test_label_float_in_reg_and_on_stack(self):
targettoken = TargetToken()
ops = """
[i0, f3]
i2 = same_as_i(i0) # but forced to be in a register
force_spill(i2)
force_spill(f3)
f4 = float_add(f3, 5.0)
label(f3, f4, descr=targettoken)
force_spill(f3)
f5 = same_as_f(f3) # but forced to be in a register
finish(f5)
"""
faildescr = BasicFailDescr(2)
loop = parse(ops, self.cpu, namespace=locals())
looptoken = JitCellToken()
info = self.cpu.compile_loop(loop.inputargs, loop.operations,
looptoken)
ops2 = """
[i0, f1]
i1 = same_as_i(i0)
f2 = same_as_f(f1)
f3 = float_add(f1, 10.0)
force_spill(f3)
force_spill(i1)
f4 = float_add(f3, f1)
jump(f3, f4, descr=targettoken)
"""
loop2 = parse(ops2, self.cpu, namespace=locals())
looptoken2 = JitCellToken()
info = self.cpu.compile_loop(loop2.inputargs, loop2.operations,
looptoken2)
deadframe = self.cpu.execute_token(looptoken, -9,
longlong.getfloatstorage(-13.5))
res = longlong.getrealfloat(self.cpu.get_float_value(deadframe, 0))
assert res == -13.5
#
deadframe = self.cpu.execute_token(looptoken2, -9,
longlong.getfloatstorage(-13.5))
res = longlong.getrealfloat(self.cpu.get_float_value(deadframe, 0))
assert res == -3.5
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_subi_range(self):
for i in [-32769, -32768, -32767, 32767, 32768, 32769]:
ops = '''
[i0]
i1 = int_sub(i0, %d)
i2 = int_sub_ovf(i1, %d)
finish(i2)
''' % (i, i)
loop = parse(ops, self.cpu, namespace=locals())
looptoken = JitCellToken()
self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
deadframe = self.cpu.execute_token(looptoken, 10000000)
assert self.cpu.get_int_value(deadframe, 0) == 10000000 - 2 * i
def test_subi_range(self):
for i in [-32769, -32768, -32767, 32767, 32768, 32769]:
ops = '''
[i0]
i1 = int_sub(i0, %d)
i2 = int_sub_ovf(i1, %d)
finish(i2)
''' % (i, i)
loop = parse(ops, self.cpu, namespace=locals())
looptoken = JitCellToken()
self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
deadframe = self.cpu.execute_token(looptoken, 10000000)
assert self.cpu.get_int_value(deadframe, 0) == 10000000 - 2 * i
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_label_float_in_reg_and_on_stack(self):
targettoken = TargetToken()
ops = """
[i0, f3]
i2 = same_as_i(i0) # but forced to be in a register
force_spill(i2)
force_spill(f3)
f4 = float_add(f3, 5.0)
label(f3, f4, descr=targettoken)
force_spill(f3)
f5 = same_as_f(f3) # but forced to be in a register
finish(f5)
"""
faildescr = BasicFailDescr(2)
loop = parse(ops, self.cpu, namespace=locals())
looptoken = JitCellToken()
info = self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
ops2 = """
[i0, f1]
i1 = same_as_i(i0)
f2 = same_as_f(f1)
f3 = float_add(f1, 10.0)
force_spill(f3)
force_spill(i1)
f4 = float_add(f3, f1)
jump(f3, f4, descr=targettoken)
"""
loop2 = parse(ops2, self.cpu, namespace=locals())
looptoken2 = JitCellToken()
info = self.cpu.compile_loop(loop2.inputargs, loop2.operations, looptoken2)
deadframe = self.cpu.execute_token(looptoken, -9, longlong.getfloatstorage(-13.5))
res = longlong.getrealfloat(self.cpu.get_float_value(deadframe, 0))
assert res == -13.5
#
deadframe = self.cpu.execute_token(looptoken2, -9, longlong.getfloatstorage(-13.5))
res = longlong.getrealfloat(self.cpu.get_float_value(deadframe, 0))
assert res == -3.5
def _compile_and_run(self, source, args_values, float=True, ns={}):
loop = parse(source, namespace=ns)
cpu = self.CPUClass(rtyper=None, stats=None)
cpu.setup_once()
#
looptoken = JitCellToken()
cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
#import pdb; pdb.set_trace()
deadframe = cpu.execute_token(looptoken, *args_values)
print(source)
if float:
return cpu.get_float_value(deadframe, 0)
else:
return cpu.get_int_value(deadframe, 0)
def _compile_and_run(self, source, args_values, float=True, ns={}):
loop = parse(source, namespace=ns)
cpu = self.CPUClass(rtyper=None, stats=None)
cpu.setup_once()
#
looptoken = JitCellToken()
cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
#import pdb; pdb.set_trace()
deadframe = cpu.execute_token(looptoken, *args_values)
print(source)
if float:
return cpu.get_float_value(deadframe, 0)
else:
return cpu.get_int_value(deadframe, 0)
def test_return_spilled_args(self):
numargs = 50
ops = []
arglist = "[%s]\n" % ", ".join(["i%d" % i for i in range(numargs)])
ops.append(arglist)
# spill every inputarg
for i in range(numargs):
ops.append("force_spill(i%d)\n" % i)
ops.append("guard_value(i0, -1) %s" % arglist)
ops = "".join(ops)
loop = parse(ops)
looptoken = JitCellToken()
faildescr = loop.operations[-1].getdescr()
self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
ARGS = [lltype.Signed] * numargs
RES = lltype.Signed
args = [i + 1 for i in range(numargs)]
deadframe = self.cpu.execute_token(looptoken, *args)
fail = self.cpu.get_latest_descr(deadframe)
assert fail is faildescr
for i in range(numargs):
assert self.cpu.get_int_value(deadframe, i) == i + 1
bridgeops = [arglist]
bridgeops.append("guard_value(i1, -5) %s" % arglist)
bridgeops = "".join(bridgeops)
bridge = parse(bridgeops)
faildescr2 = bridge.operations[-1].getdescr()
self.cpu.compile_bridge(faildescr, bridge.inputargs, bridge.operations,
looptoken)
deadframe = self.cpu.execute_token(looptoken, *args)
fail = self.cpu.get_latest_descr(deadframe)
assert fail is faildescr2
for i in range(numargs):
assert self.cpu.get_int_value(deadframe, i) == i + 1
def test_call_aligned_explicit_check(self):
if (not platform.machine().startswith('arm') and
sys.maxint == 2 ** 31 - 1): # XXX is still necessary on x86?
py.test.skip("libffi on 32bit is broken")
cpu = self.cpu
if not cpu.supports_floats:
py.test.skip('requires floats')
func_addr = self.make_function_returning_stack_pointer()
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):
args = []
funcargs = []
float_count = 0
int_count = 0
for i in range(8):
if case & (1<<i):
args.append('f%d' % float_count)
float_count += 1
funcargs.append(F)
else:
args.append('i%d' % int_count)
int_count += 1
funcargs.append(I)
arguments = ', '.join(args)
FUNC = self.FuncType(funcargs, I)
calldescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
EffectInfo.MOST_GENERAL)
ops = '[%s]\n' % arguments
ops += 'i99 = call_i(%d, %s, descr=calldescr)\n' % (func_addr,
arguments)
ops += 'finish(i99)\n'
loop = parse(ops, namespace=locals())
looptoken = JitCellToken()
self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
argvals, expected_result = self._prepare_args(args, floats, ints)
deadframe = self.cpu.execute_token(looptoken, *argvals)
x = cpu.get_int_value(deadframe, 0)
align_req = self.get_alignment_requirements()
assert x % align_req == 0
def test_call_aligned_explicit_check(self):
if (not platform.machine().startswith('arm')
and sys.maxint == 2**31 - 1): # XXX is still necessary on x86?
py.test.skip("libffi on 32bit is broken")
cpu = self.cpu
if not cpu.supports_floats:
py.test.skip('requires floats')
func_addr = self.make_function_returning_stack_pointer()
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):
args = []
funcargs = []
float_count = 0
int_count = 0
for i in range(8):
if case & (1 << i):
args.append('f%d' % float_count)
float_count += 1
funcargs.append(F)
else:
args.append('i%d' % int_count)
int_count += 1
funcargs.append(I)
arguments = ', '.join(args)
FUNC = self.FuncType(funcargs, I)
calldescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
EffectInfo.MOST_GENERAL)
ops = '[%s]\n' % arguments
ops += 'i99 = call(%d, %s, descr=calldescr)\n' % (func_addr,
arguments)
ops += 'finish(i99)\n'
loop = parse(ops, namespace=locals())
looptoken = JitCellToken()
self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
argvals, expected_result = self._prepare_args(args, floats, ints)
deadframe = self.cpu.execute_token(looptoken, *argvals)
x = cpu.get_int_value(deadframe, 0)
align_req = self.get_alignment_requirements()
assert x % align_req == 0
def test_return_spilled_args(self):
numargs = 50
ops = []
arglist = "[%s]\n" % ", ".join(["i%d" % i for i in range(numargs)])
ops.append(arglist)
# spill every inputarg
for i in range(numargs):
ops.append("force_spill(i%d)\n" % i)
ops.append("guard_value(i0, -1) %s" % arglist)
ops = "".join(ops)
loop = parse(ops)
looptoken = JitCellToken()
faildescr = loop.operations[-1].getdescr()
self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
ARGS = [lltype.Signed] * numargs
RES = lltype.Signed
args = [i+1 for i in range(numargs)]
deadframe = self.cpu.execute_token(looptoken, *args)
fail = self.cpu.get_latest_descr(deadframe)
assert fail is faildescr
for i in range(numargs):
assert self.cpu.get_int_value(deadframe, i) == i + 1
bridgeops = [arglist]
bridgeops.append("guard_value(i1, -5) %s" % arglist)
bridgeops = "".join(bridgeops)
bridge = parse(bridgeops)
faildescr2 = bridge.operations[-1].getdescr()
self.cpu.compile_bridge(faildescr, bridge.inputargs, bridge.operations, looptoken)
deadframe = self.cpu.execute_token(looptoken, *args)
fail = self.cpu.get_latest_descr(deadframe)
assert fail is faildescr2
for i in range(numargs):
assert self.cpu.get_int_value(deadframe, i) == i + 1
def test_int_mul_no_overflow_var_var(self, v1, v2):
try:
result = v1*v2
except OverflowError:
py.test.skip("this test is not made to check the overflow!")
code = """
[i0,i2]
i1 = int_mul_ovf(i0,i2)
finish(i1, descr=faildescr)
""".format()
loop = parse(code, namespace={"faildescr": BasicFinalDescr(1)})
looptoken = JitCellToken()
self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
deadframe = self.cpu.execute_token(looptoken, v1, v2)
fail = self.cpu.get_latest_descr(deadframe)
assert self.cpu.get_int_value(deadframe, 0) == result
def test_int_mul_no_overflow_var_var(self, v1, v2):
try:
result = v1 * v2
except OverflowError:
py.test.skip("this test is not made to check the overflow!")
code = """
[i0,i2]
i1 = int_mul_ovf(i0,i2)
finish(i1, descr=faildescr)
""".format()
loop = parse(code, namespace={"faildescr": BasicFinalDescr(1)})
looptoken = JitCellToken()
self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
deadframe = self.cpu.execute_token(looptoken, v1, v2)
fail = self.cpu.get_latest_descr(deadframe)
assert self.cpu.get_int_value(deadframe, 0) == result
def test_uint_rshift(self):
code = """
[i1]
i11 = int_and(i1, 63)
i10 = uint_rshift(18, i11)
i1402 = int_is_true(i10)
guard_false(i1402, descr=faildescr) [] # must NEVER exit with i1 == 0
finish(i1402, descr=finishdescr)
"""
finishdescr = BasicFinalDescr(1)
faildescr = BasicFailDescr(2)
loop = parse(code, namespace={"faildescr": faildescr, "finishdescr": finishdescr})
looptoken = JitCellToken()
self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
deadframe = self.cpu.execute_token(looptoken, 19)
fail = self.cpu.get_latest_descr(deadframe)
assert fail == finishdescr # ensures that guard is not taken!
def test_debugger_on(self):
from rpython.tool.logparser import parse_log_file, extract_category
from rpython.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.get_loop_run_counters(0)
assert struct.i == 1
struct = self.cpu.assembler.get_loop_run_counters(1)
assert struct.i == 1
struct = self.cpu.assembler.get_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.all_descrs = LLtypeMixin.cpu.setup_descrs()
staticdata.cpu = cpu
staticdata.jitlog = jl.JitLogger(cpu)
staticdata.jitlog.trace_id = 1
#
loop = parse('''
[p1]
i1 = getfield_gc_i(p1, descr=valuedescr)
i2 = int_add(i1, 1)
p2 = new_with_vtable(descr=nodesize)
setfield_gc(p2, i2, descr=valuedescr)
jump(p2)
''',
namespace=LLtypeMixin.__dict__.copy())
#
metainterp = FakeMetaInterp()
metainterp.staticdata = staticdata
metainterp.cpu = cpu
metainterp.history = History()
t = convert_loop_to_trace(loop, staticdata)
metainterp.history.inputargs = t.inputargs
metainterp.history.trace = t
#
greenkey = 'faked'
target_token = compile_loop(
metainterp,
greenkey, (0, 0, 0),
t.inputargs, [t._mapping[x] for x in loop.operations[-1].getarglist()],
use_unroll=False)
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 == 2
#
assert len(cpu.seen) == 1
assert cpu.seen[0][2] == jitcell_token
#
del cpu.seen[:]
def test_debugger_on(self):
py.test.skip("I don't care for now")
from rpython.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_uint_rshift(self):
code = """
[i1]
i11 = int_and(i1, 63)
i10 = uint_rshift(18, i11)
i1402 = int_is_true(i10)
guard_false(i1402, descr=faildescr) [] # must NEVER exit with i1 == 0
finish(i1402, descr=finishdescr)
"""
finishdescr = BasicFinalDescr(1)
faildescr = BasicFailDescr(2)
loop = parse(code,
namespace={
'faildescr': faildescr,
'finishdescr': finishdescr
})
looptoken = JitCellToken()
self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
deadframe = self.cpu.execute_token(looptoken, 19)
fail = self.cpu.get_latest_descr(deadframe)
assert fail == finishdescr # ensures that guard is not taken!
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.tracker._all_size_descrs_with_vtable = (
LLtypeMixin.cpu.tracker._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_i(p1, descr=valuedescr)
i2 = int_add(i1, 1)
p2 = new_with_vtable(descr=nodesize)
setfield_gc(p2, i2, descr=valuedescr)
jump(p2)
''', namespace=LLtypeMixin.__dict__.copy())
#
metainterp = FakeMetaInterp()
metainterp.staticdata = staticdata
metainterp.cpu = cpu
metainterp.history = History()
t = convert_loop_to_trace(loop, staticdata)
metainterp.history.inputargs = t.inputargs
metainterp.history.trace = t
#
greenkey = 'faked'
target_token = compile_loop(metainterp, greenkey, (0, 0, 0),
t.inputargs,
[t._mapping[x] for x in 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_double_evenodd_pair(self):
code = """
[i0]
i1 = int_floordiv(i0, 2)
i2 = int_floordiv(i0, 3)
i3 = int_floordiv(i0, 4)
i4 = int_floordiv(i0, 5)
i5 = int_floordiv(i0, 6)
i6 = int_floordiv(i0, 7)
i7 = int_floordiv(i0, 8)
i8 = int_le(i1, 0)
guard_true(i8) [i1,i2,i3,i4,i5,i6,i7]
finish(i0, descr=faildescr)
"""
# the guard forces 3 spills because after 4 divisions
# all even slots of the managed registers are full
loop = parse(code, namespace={'faildescr': BasicFinalDescr(1)})
looptoken = JitCellToken()
self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
deadframe = self.cpu.execute_token(looptoken, 100)
fail = self.cpu.get_latest_descr(deadframe)
for i in range(2, 9):
assert self.cpu.get_int_value(deadframe, i - 2) == 100 // i
def test_ops_offset(self):
from rpython.rlib import debug
looptoken = JitCellToken()
targettoken = TargetToken()
loop = parse("""
[i0]
label(i0, descr=targettoken)
i1 = int_add(i0, 1)
i2 = int_le(i1, 9)
jump(i1, descr=targettoken)
""", namespace=locals())
debug._log = dlog = debug.DebugLog()
info = self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
ops_offset = info.ops_offset
debug._log = None
#
assert ops_offset is looptoken._x86_ops_offset
# 2*increment_debug_counter + ops + None
assert len(ops_offset) == 2 + len(loop.operations) + 1
assert (ops_offset[loop.operations[0]] <=
ops_offset[loop.operations[1]] <=
ops_offset[loop.operations[2]] <=
ops_offset[None])
def test_ops_offset(self):
from rpython.rlib import debug
looptoken = JitCellToken()
targettoken = TargetToken()
loop = parse("""
[i0]
label(i0, descr=targettoken)
i1 = int_add(i0, 1)
i2 = int_le(i1, 9)
jump(i1, descr=targettoken)
""", namespace=locals())
debug._log = dlog = debug.DebugLog()
info = self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
ops_offset = info.ops_offset
debug._log = None
#
assert ops_offset is looptoken._x86_ops_offset
# 2*increment_debug_counter + ops + None
assert len(ops_offset) == 2 + len(loop.operations) + 1
assert (ops_offset[loop.operations[0]] <=
ops_offset[loop.operations[1]] <=
ops_offset[loop.operations[2]] <=
ops_offset[None])
def test_double_evenodd_pair(self):
code = """
[i0]
i1 = int_floordiv(i0, 2)
i2 = int_floordiv(i0, 3)
i3 = int_floordiv(i0, 4)
i4 = int_floordiv(i0, 5)
i5 = int_floordiv(i0, 6)
i6 = int_floordiv(i0, 7)
i7 = int_floordiv(i0, 8)
i8 = int_le(i1, 0)
guard_true(i8) [i1,i2,i3,i4,i5,i6,i7]
finish(i0, descr=faildescr)
"""
# the guard forces 3 spills because after 4 divisions
# all even slots of the managed registers are full
loop = parse(code, namespace={'faildescr': BasicFinalDescr(1)})
looptoken = JitCellToken()
self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
deadframe = self.cpu.execute_token(looptoken, 100)
fail = self.cpu.get_latest_descr(deadframe)
for i in range(2,9):
assert self.cpu.get_int_value(deadframe, i-2) == 100//i
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_descr = self.cpu.sizeof(O, True)
o_vtable = globals()['o_vtable']
#
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
strhashdescr = self.gc_ll_descr.str_hash_descr
unicodehashdescr = self.gc_ll_descr.unicode_hash_descr
casmdescr = JitCellToken()
clt = FakeLoopToken()
clt._ll_initial_locs = [0, 8]
frame_info = lltype.malloc(jitframe.JITFRAMEINFO, flavor='raw')
clt.frame_info = frame_info
frame_info.jfi_frame_depth = 13
frame_info.jfi_frame_size = 255
framedescrs = self.gc_ll_descr.getframedescrs(self.cpu)
framelendescr = framedescrs.arraydescr.lendescr
jfi_frame_depth = framedescrs.jfi_frame_depth
jfi_frame_size = framedescrs.jfi_frame_size
jf_frame_info = framedescrs.jf_frame_info
jf_savedata = framedescrs.jf_savedata
jf_force_descr = framedescrs.jf_force_descr
jf_descr = framedescrs.jf_descr
jf_guard_exc = framedescrs.jf_guard_exc
jf_forward = framedescrs.jf_forward
jf_extra_stack_depth = framedescrs.jf_extra_stack_depth
signedframedescr = self.cpu.signedframedescr
floatframedescr = self.cpu.floatframedescr
casmdescr.compiled_loop_token = clt
#
guarddescr = AbstractFailDescr()
#
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,
[])
remap = {}
for a, b in zip(ops.inputargs, expected.inputargs):
remap[b] = a
equaloplists(operations, expected.operations, remap=remap)
lltype.free(frame_info, flavor='raw')
def check_rewrite(self, frm_operations, to_operations, **namespace):
# objects to use inside the test
A = lltype.GcArray(lltype.Signed)
adescr = get_array_descr(self.gc_ll_descr, A)
adescr.tid = 4321
alendescr = adescr.lendescr
#
pinned_obj_type = lltype.GcStruct('PINNED_STRUCT', ('my_int', lltype.Signed))
pinned_obj_my_int_descr = get_field_descr(self.gc_ll_descr, pinned_obj_type, 'my_int')
pinned_obj_ptr = lltype.malloc(pinned_obj_type)
pinned_obj_gcref = lltype.cast_opaque_ptr(llmemory.GCREF, pinned_obj_ptr)
assert rgc.pin(pinned_obj_gcref)
#
notpinned_obj_type = lltype.GcStruct('NOT_PINNED_STRUCT', ('my_int', lltype.Signed))
notpinned_obj_my_int_descr = get_field_descr(self.gc_ll_descr, notpinned_obj_type, 'my_int')
notpinned_obj_ptr = lltype.malloc(notpinned_obj_type)
notpinned_obj_gcref = lltype.cast_opaque_ptr(llmemory.GCREF, notpinned_obj_ptr)
#
ptr_array_descr = self.cpu.arraydescrof(MovableObjectTracker.ptr_array_type)
#
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
casmdescr = JitCellToken()
clt = FakeLoopToken()
clt._ll_initial_locs = [0, 8]
frame_info = lltype.malloc(jitframe.JITFRAMEINFO, flavor='raw')
clt.frame_info = frame_info
frame_info.jfi_frame_depth = 13
frame_info.jfi_frame_size = 255
framedescrs = self.gc_ll_descr.getframedescrs(self.cpu)
framelendescr = framedescrs.arraydescr.lendescr
jfi_frame_depth = framedescrs.jfi_frame_depth
jfi_frame_size = framedescrs.jfi_frame_size
jf_frame_info = framedescrs.jf_frame_info
signedframedescr = self.cpu.signedframedescr
floatframedescr = self.cpu.floatframedescr
casmdescr.compiled_loop_token = clt
tzdescr = None # noone cares
#
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)
operations = self.gc_ll_descr.rewrite_assembler(self.cpu,
ops.operations,
[])
# make the array containing the GCREF's accessible inside the tests.
# This must be done after we call 'rewrite_assembler'. Before that
# call 'last_moving_obj_tracker' is None or filled with some old
# value.
namespace['ptr_array_gcref'] = self.gc_ll_descr.last_moving_obj_tracker.ptr_array_gcref
expected = parse(to_operations % Evaluator(namespace),
namespace=namespace)
equaloplists(operations, expected.operations)
lltype.free(frame_info, flavor='raw')
def parse(self, s, boxkinds=None, namespace=None):
return parse(s,
self.cpu,
namespace or self.namespace,
type_system=self.type_system,
boxkinds=boxkinds)
def parse(self, s, boxkinds=None, namespace=None):
return parse(s, self.cpu, namespace or self.namespace,
type_system=self.type_system,
boxkinds=boxkinds)
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 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 parse(self, *args, **kwds):
kwds['OpParser'] = self.OpParser
return parse(*args, **kwds)
def setup_class(cls):
if cls.runappdirect:
py.test.skip("Can't run this test with -A")
w_f = cls.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
token = JitCellToken()
token.number = 0
di_loop = JitDebugInfo(MockJitDriverSD, logger, token, oplist, 'loop',
greenkey)
di_loop_optimize = JitDebugInfo(MockJitDriverSD, logger, JitCellToken(),
oplist, 'loop', greenkey)
di_loop.asminfo = AsmInfo(offset, 0x42, 12)
di_bridge = JitDebugInfo(MockJitDriverSD, logger, JitCellToken(),
oplist, 'bridge', fail_descr=BasicFailDescr())
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(Counters.ABORT_TOO_LONG, pypyjitdriver,
greenkey, 'blah', Logger(MockSD), [])
space = cls.space
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
cls.w_sorted_keys = space.wrap(sorted(Counters.counter_names))
def check_rewrite(self, frm_operations, to_operations, **namespace):
# objects to use inside the test
A = lltype.GcArray(lltype.Signed)
adescr = get_array_descr(self.gc_ll_descr, A)
adescr.tid = 4321
alendescr = adescr.lendescr
#
pinned_obj_type = lltype.GcStruct('PINNED_STRUCT', ('my_int', lltype.Signed))
pinned_obj_my_int_descr = get_field_descr(self.gc_ll_descr, pinned_obj_type, 'my_int')
pinned_obj_ptr = lltype.malloc(pinned_obj_type)
pinned_obj_gcref = lltype.cast_opaque_ptr(llmemory.GCREF, pinned_obj_ptr)
assert rgc.pin(pinned_obj_gcref)
#
notpinned_obj_type = lltype.GcStruct('NOT_PINNED_STRUCT', ('my_int', lltype.Signed))
notpinned_obj_my_int_descr = get_field_descr(self.gc_ll_descr, notpinned_obj_type, 'my_int')
notpinned_obj_ptr = lltype.malloc(notpinned_obj_type)
notpinned_obj_gcref = lltype.cast_opaque_ptr(llmemory.GCREF, notpinned_obj_ptr)
#
ptr_array_descr = self.cpu.arraydescrof(MovableObjectTracker.ptr_array_type)
#
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)
#
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
casmdescr = JitCellToken()
clt = FakeLoopToken()
clt._ll_initial_locs = [0, 8]
frame_info = lltype.malloc(jitframe.JITFRAMEINFO, flavor='raw')
clt.frame_info = frame_info
frame_info.jfi_frame_depth = 13
frame_info.jfi_frame_size = 255
framedescrs = self.gc_ll_descr.getframedescrs(self.cpu)
framelendescr = framedescrs.arraydescr.lendescr
jfi_frame_depth = framedescrs.jfi_frame_depth
jfi_frame_size = framedescrs.jfi_frame_size
jf_frame_info = framedescrs.jf_frame_info
signedframedescr = self.cpu.signedframedescr
floatframedescr = self.cpu.floatframedescr
casmdescr.compiled_loop_token = clt
tzdescr = None # noone cares
#
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)
operations = self.gc_ll_descr.rewrite_assembler(self.cpu,
ops.operations,
[])
# make the array containing the GCREF's accessible inside the tests.
# This must be done after we call 'rewrite_assembler'. Before that
# call 'last_moving_obj_tracker' is None or filled with some old
# value.
namespace['ptr_array_gcref'] = self.gc_ll_descr.last_moving_obj_tracker.ptr_array_gcref
expected = parse(to_operations % Evaluator(namespace),
namespace=namespace)
equaloplists(operations, expected.operations)
lltype.free(frame_info, flavor='raw')
def parse(self, s, boxkinds=None, namespace=None):
return parse(s,
self.cpu,
namespace or self.namespace,
boxkinds=boxkinds)
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
casmdescr = JitCellToken()
clt = FakeLoopToken()
clt._ll_initial_locs = [0, 8]
frame_info = lltype.malloc(jitframe.JITFRAMEINFO, flavor='raw')
clt.frame_info = frame_info
frame_info.jfi_frame_depth = 13
frame_info.jfi_frame_size = 255
framedescrs = self.gc_ll_descr.getframedescrs(self.cpu)
framelendescr = framedescrs.arraydescr.lendescr
jfi_frame_depth = framedescrs.jfi_frame_depth
jfi_frame_size = framedescrs.jfi_frame_size
jf_frame_info = framedescrs.jf_frame_info
signedframedescr = self.cpu.signedframedescr
floatframedescr = self.cpu.floatframedescr
casmdescr.compiled_loop_token = clt
tzdescr = None # noone cares
#
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)
lltype.free(frame_info, flavor='raw')
def test_call_alignment_call_assembler(self):
cpu = self.cpu
if not cpu.supports_floats:
py.test.skip('requires floats')
fdescr3 = BasicFinalDescr(3)
fdescr4 = BasicFinalDescr(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_descr = 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)
deadframe = cpu.execute_token(called_looptoken, *argvals)
assert cpu.get_latest_descr(deadframe) == fdescr3
t = longlong.getrealfloat(cpu.get_float_value(deadframe, 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_descr_float = done_descr
try:
othertoken = JitCellToken()
self.cpu.compile_loop(loop.inputargs, loop.operations,
othertoken)
# prepare call to called_loop
argvals, _ = self._prepare_args(args, floats, ints)
deadframe = cpu.execute_token(othertoken, *argvals)
x = longlong.getrealfloat(cpu.get_float_value(deadframe, 0))
assert cpu.get_latest_descr(deadframe) == fdescr4
assert abs(x - expected_result) < 0.0001
finally:
del self.cpu.done_with_this_frame_descr_float
def setup_class(cls):
if cls.runappdirect:
py.test.skip("Can't run this test with -A")
w_f = cls.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
class FailDescr(BasicFailDescr):
def get_jitcounter_hash(self):
from rpython.rlib.rarithmetic import r_uint
return r_uint(13)
oplist[-1].setdescr(FailDescr())
oplist[-2].setdescr(FailDescr())
token = JitCellToken()
token.number = 0
di_loop = JitDebugInfo(MockJitDriverSD, logger, token, oplist, 'loop',
greenkey)
di_loop_optimize = JitDebugInfo(MockJitDriverSD, logger,
JitCellToken(), oplist, 'loop',
greenkey)
di_loop.asminfo = AsmInfo(offset, 0x42, 12)
di_bridge = JitDebugInfo(MockJitDriverSD,
logger,
JitCellToken(),
oplist,
'bridge',
fail_descr=FailDescr())
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(Counters.ABORT_TOO_LONG, pypyjitdriver,
greenkey, 'blah', Logger(MockSD), [])
space = cls.space
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
cls.w_sorted_keys = space.wrap(sorted(Counters.counter_names))
def parse(self, *args, **kwds):
kwds['OpParser'] = self.OpParser
return parse(*args, **kwds)
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
strhashdescr = self.gc_ll_descr.str_hash_descr
unicodehashdescr = self.gc_ll_descr.unicode_hash_descr
casmdescr = JitCellToken()
clt = FakeLoopToken()
clt._ll_initial_locs = [0, 8]
frame_info = lltype.malloc(jitframe.JITFRAMEINFO, flavor='raw')
clt.frame_info = frame_info
frame_info.jfi_frame_depth = 13
frame_info.jfi_frame_size = 255
framedescrs = self.gc_ll_descr.getframedescrs(self.cpu)
framelendescr = framedescrs.arraydescr.lendescr
jfi_frame_depth = framedescrs.jfi_frame_depth
jfi_frame_size = framedescrs.jfi_frame_size
jf_frame_info = framedescrs.jf_frame_info
jf_savedata = framedescrs.jf_savedata
jf_force_descr = framedescrs.jf_force_descr
jf_descr = framedescrs.jf_descr
jf_guard_exc = framedescrs.jf_guard_exc
jf_forward = framedescrs.jf_forward
jf_extra_stack_depth = framedescrs.jf_extra_stack_depth
signedframedescr = self.cpu.signedframedescr
floatframedescr = self.cpu.floatframedescr
casmdescr.compiled_loop_token = clt
#
guarddescr = AbstractFailDescr()
#
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)
lltype.free(frame_info, flavor='raw')
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
})
loop1a = parse("""
[p0]
guard_nonnull_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()
token1a = JitCellToken()
token2 = JitCellToken()
token3 = JitCellToken()
token4 = JitCellToken()
cpu.compile_loop(loop1.inputargs, loop1.operations, token1)
cpu.compile_loop(loop1a.inputargs, loop1a.operations, token1a)
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())),
(token1a, rffi.cast(llmemory.GCREF, A())),
(token1a, lltype.nullptr(llmemory.GCREF.TO)),
(token1a, rffi.cast(llmemory.GCREF, B())),
(token1a, 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'
'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')
