[pypy-svn] r76978 - in pypy/trunk: . pypy/jit/metainterp pypy/jit/metainterp/optimizeopt pypy/jit/metainterp/test pypy/module/array/benchmark pypy/module/array/test pypy/module/pypyjit/test pypy/rlib/rsre pypy/rlib/rsre/test
hakanardo at codespeak.net
hakanardo at codespeak.net
Thu Sep 9 18:23:44 CEST 2010
Author: hakanardo
Date: Thu Sep 9 18:23:42 2010
New Revision: 76978
Added:
pypy/trunk/pypy/jit/metainterp/optimizeopt/
- copied from r76976, pypy/branch/jit-bounds/pypy/jit/metainterp/optimizeopt/
pypy/trunk/pypy/jit/metainterp/test/test_intbound.py
- copied unchanged from r76976, pypy/branch/jit-bounds/pypy/jit/metainterp/test/test_intbound.py
pypy/trunk/pypy/module/pypyjit/test/randomized.py
- copied unchanged from r76976, pypy/branch/jit-bounds/pypy/module/pypyjit/test/randomized.py
pypy/trunk/pypy/rlib/rsre/ (props changed)
- copied from r76976, pypy/branch/jit-bounds/pypy/rlib/rsre/
pypy/trunk/pypy/rlib/rsre/__init__.py
- copied unchanged from r76976, pypy/branch/jit-bounds/pypy/rlib/rsre/__init__.py
pypy/trunk/pypy/rlib/rsre/rsre_char.py
- copied unchanged from r76976, pypy/branch/jit-bounds/pypy/rlib/rsre/rsre_char.py
pypy/trunk/pypy/rlib/rsre/rsre_core.py
- copied unchanged from r76976, pypy/branch/jit-bounds/pypy/rlib/rsre/rsre_core.py
pypy/trunk/pypy/rlib/rsre/rsre_re.py
- copied unchanged from r76976, pypy/branch/jit-bounds/pypy/rlib/rsre/rsre_re.py
pypy/trunk/pypy/rlib/rsre/test/ (props changed)
- copied from r76976, pypy/branch/jit-bounds/pypy/rlib/rsre/test/
pypy/trunk/pypy/rlib/rsre/test/__init__.py
- copied unchanged from r76976, pypy/branch/jit-bounds/pypy/rlib/rsre/test/__init__.py
pypy/trunk/pypy/rlib/rsre/test/re_tests.py
- copied unchanged from r76976, pypy/branch/jit-bounds/pypy/rlib/rsre/test/re_tests.py
pypy/trunk/pypy/rlib/rsre/test/targetrsre.py
- copied unchanged from r76976, pypy/branch/jit-bounds/pypy/rlib/rsre/test/targetrsre.py
pypy/trunk/pypy/rlib/rsre/test/test_char.py
- copied unchanged from r76976, pypy/branch/jit-bounds/pypy/rlib/rsre/test/test_char.py
pypy/trunk/pypy/rlib/rsre/test/test_match.py
- copied unchanged from r76976, pypy/branch/jit-bounds/pypy/rlib/rsre/test/test_match.py
pypy/trunk/pypy/rlib/rsre/test/test_re.py
- copied unchanged from r76976, pypy/branch/jit-bounds/pypy/rlib/rsre/test/test_re.py
pypy/trunk/pypy/rlib/rsre/test/test_search.py
- copied unchanged from r76976, pypy/branch/jit-bounds/pypy/rlib/rsre/test/test_search.py
pypy/trunk/pypy/rlib/rsre/test/test_zexternal.py
- copied unchanged from r76976, pypy/branch/jit-bounds/pypy/rlib/rsre/test/test_zexternal.py
pypy/trunk/pypy/rlib/rsre/test/test_zinterp.py
- copied unchanged from r76976, pypy/branch/jit-bounds/pypy/rlib/rsre/test/test_zinterp.py
Removed:
pypy/trunk/pypy/jit/metainterp/optimizeopt.py
Modified:
pypy/trunk/ (props changed)
pypy/trunk/pypy/jit/metainterp/test/test_basic.py
pypy/trunk/pypy/jit/metainterp/test/test_optimizeopt.py
pypy/trunk/pypy/jit/metainterp/test/test_resume.py
pypy/trunk/pypy/module/array/benchmark/Makefile (props changed)
pypy/trunk/pypy/module/array/benchmark/intimg.c (props changed)
pypy/trunk/pypy/module/array/benchmark/intimgtst.c (props changed)
pypy/trunk/pypy/module/array/benchmark/intimgtst.py (props changed)
pypy/trunk/pypy/module/array/benchmark/loop.c (props changed)
pypy/trunk/pypy/module/array/benchmark/sum.c (props changed)
pypy/trunk/pypy/module/array/benchmark/sumtst.c (props changed)
pypy/trunk/pypy/module/array/benchmark/sumtst.py (props changed)
pypy/trunk/pypy/module/array/test/test_array_old.py (props changed)
pypy/trunk/pypy/module/pypyjit/test/test_pypy_c.py
Log:
Merged jit-bounds, which splits jit/metainterp/optimizeopt into separate optimizations steps and adds one additional step keeping bounds on integers and removes guards when they are not needed.
Modified: pypy/trunk/pypy/jit/metainterp/test/test_basic.py
==============================================================================
--- pypy/trunk/pypy/jit/metainterp/test/test_basic.py (original)
+++ pypy/trunk/pypy/jit/metainterp/test/test_basic.py Thu Sep 9 18:23:42 2010
@@ -455,6 +455,31 @@
# the CALL_PURE is constant-folded away by optimizeopt.py
self.check_loops(int_sub=1, call=0, call_pure=0)
+ def test_pure_function_returning_object(self):
+ myjitdriver = JitDriver(greens = ['m'], reds = ['n'])
+ class V:
+ def __init__(self, x):
+ self.x = x
+ v1 = V(1)
+ v2 = V(2)
+ def externfn(x):
+ if x:
+ return v1
+ else:
+ return v2
+ externfn._pure_function_ = True
+ def f(n, m):
+ while n > 0:
+ myjitdriver.can_enter_jit(n=n, m=m)
+ myjitdriver.jit_merge_point(n=n, m=m)
+ m = V(m).x
+ n -= externfn(m).x + externfn(m + m - m).x
+ return n
+ res = self.meta_interp(f, [21, 5])
+ assert res == -1
+ # the CALL_PURE is constant-folded away by optimizeopt.py
+ self.check_loops(int_sub=1, call=0, call_pure=0, getfield_gc=1)
+
def test_constant_across_mp(self):
myjitdriver = JitDriver(greens = [], reds = ['n'])
class X(object):
Modified: pypy/trunk/pypy/jit/metainterp/test/test_optimizeopt.py
==============================================================================
--- pypy/trunk/pypy/jit/metainterp/test/test_optimizeopt.py (original)
+++ pypy/trunk/pypy/jit/metainterp/test/test_optimizeopt.py Thu Sep 9 18:23:42 2010
@@ -4,7 +4,8 @@
#OOtypeMixin,
BaseTest)
from pypy.jit.metainterp.optimizefindnode import PerfectSpecializationFinder
-from pypy.jit.metainterp import optimizeopt
+import pypy.jit.metainterp.optimizeopt.optimizer as optimizeopt
+import pypy.jit.metainterp.optimizeopt.virtualize as virtualize
from pypy.jit.metainterp.optimizeopt import optimize_loop_1
from pypy.jit.metainterp.optimizeutil import InvalidLoop
from pypy.jit.metainterp.history import AbstractDescr, ConstInt, BoxInt
@@ -64,7 +65,7 @@
class cpu(object):
pass
opt = FakeOptimizer()
- virt1 = optimizeopt.AbstractVirtualStructValue(opt, None)
+ virt1 = virtualize.AbstractVirtualStructValue(opt, None)
lst1 = virt1._get_field_descr_list()
assert lst1 == []
lst2 = virt1._get_field_descr_list()
@@ -75,7 +76,7 @@
lst4 = virt1._get_field_descr_list()
assert lst3 is lst4
- virt2 = optimizeopt.AbstractVirtualStructValue(opt, None)
+ virt2 = virtualize.AbstractVirtualStructValue(opt, None)
lst5 = virt2._get_field_descr_list()
assert lst5 is lst1
virt2.setfield(LLtypeMixin.valuedescr, optimizeopt.OptValue(None))
@@ -88,7 +89,7 @@
self.fieldnums = fieldnums
def equals(self, fieldnums):
return self.fieldnums == fieldnums
- class FakeVirtualValue(optimizeopt.AbstractVirtualValue):
+ class FakeVirtualValue(virtualize.AbstractVirtualValue):
def _make_virtual(self, *args):
return FakeVInfo()
v1 = FakeVirtualValue(None, None, None)
@@ -257,6 +258,7 @@
optimize_loop_1(metainterp_sd, loop)
#
expected = self.parse(optops)
+ print '\n'.join([str(o) for o in loop.operations])
self.assert_equal(loop, expected)
def test_simple(self):
@@ -266,7 +268,13 @@
guard_value(i0, 0) [i0]
jump(i)
"""
- self.optimize_loop(ops, 'Not', ops)
+ expected = """
+ [i]
+ i0 = int_sub(i, 1)
+ guard_value(i0, 0) [i0]
+ jump(1)
+ """
+ self.optimize_loop(ops, 'Not', expected)
def test_constant_propagate(self):
ops = """
@@ -680,7 +688,13 @@
guard_value(i1, 0) [i]
jump(i)
"""
- self.optimize_loop(ops, 'Not', ops)
+ expected = """
+ [i]
+ i1 = int_add(i, 3)
+ guard_value(i1, 0) [i]
+ jump(-3)
+ """
+ self.optimize_loop(ops, 'Not', expected)
def test_int_is_true_of_bool(self):
ops = """
@@ -3089,6 +3103,724 @@
'''
self.optimize_loop(ops, 'Not', expected)
+ def test_bound_lt(self):
+ ops = """
+ [i0]
+ i1 = int_lt(i0, 4)
+ guard_true(i1) []
+ i2 = int_lt(i0, 5)
+ guard_true(i2) []
+ jump(i0)
+ """
+ expected = """
+ [i0]
+ i1 = int_lt(i0, 4)
+ guard_true(i1) []
+ jump(i0)
+ """
+ self.optimize_loop(ops, 'Not', expected)
+
+ def test_bound_lt_noguard(self):
+ ops = """
+ [i0]
+ i1 = int_lt(i0, 4)
+ i2 = int_lt(i0, 5)
+ jump(i2)
+ """
+ expected = """
+ [i0]
+ i1 = int_lt(i0, 4)
+ i2 = int_lt(i0, 5)
+ jump(i2)
+ """
+ self.optimize_loop(ops, 'Not', expected)
+
+ def test_bound_lt_noopt(self):
+ ops = """
+ [i0]
+ i1 = int_lt(i0, 4)
+ guard_false(i1) []
+ i2 = int_lt(i0, 5)
+ guard_true(i2) []
+ jump(i0)
+ """
+ expected = """
+ [i0]
+ i1 = int_lt(i0, 4)
+ guard_false(i1) []
+ i2 = int_lt(i0, 5)
+ guard_true(i2) []
+ jump(4)
+ """
+ self.optimize_loop(ops, 'Not', expected)
+
+ def test_bound_lt_rev(self):
+ ops = """
+ [i0]
+ i1 = int_lt(i0, 4)
+ guard_false(i1) []
+ i2 = int_gt(i0, 3)
+ guard_true(i2) []
+ jump(i0)
+ """
+ expected = """
+ [i0]
+ i1 = int_lt(i0, 4)
+ guard_false(i1) []
+ jump(i0)
+ """
+ self.optimize_loop(ops, 'Not', expected)
+
+ def test_bound_lt_tripple(self):
+ ops = """
+ [i0]
+ i1 = int_lt(i0, 0)
+ guard_true(i1) []
+ i2 = int_lt(i0, 7)
+ guard_true(i2) []
+ i3 = int_lt(i0, 5)
+ guard_true(i3) []
+ jump(i0)
+ """
+ expected = """
+ [i0]
+ i1 = int_lt(i0, 0)
+ guard_true(i1) []
+ jump(i0)
+ """
+ self.optimize_loop(ops, 'Not', expected)
+
+ def test_bound_lt_add(self):
+ ops = """
+ [i0]
+ i1 = int_lt(i0, 4)
+ guard_true(i1) []
+ i2 = int_add(i0, 10)
+ i3 = int_lt(i2, 15)
+ guard_true(i3) []
+ jump(i0)
+ """
+ expected = """
+ [i0]
+ i1 = int_lt(i0, 4)
+ guard_true(i1) []
+ i2 = int_add(i0, 10)
+ jump(i0)
+ """
+ self.optimize_loop(ops, 'Not', expected)
+
+ def test_bound_lt_add_before(self):
+ ops = """
+ [i0]
+ i2 = int_add(i0, 10)
+ i3 = int_lt(i2, 15)
+ guard_true(i3) []
+ i1 = int_lt(i0, 6)
+ guard_true(i1) []
+ jump(i0)
+ """
+ expected = """
+ [i0]
+ i2 = int_add(i0, 10)
+ i3 = int_lt(i2, 15)
+ guard_true(i3) []
+ jump(i0)
+ """
+ self.optimize_loop(ops, 'Not', expected)
+
+ def test_bound_lt_add_ovf(self):
+ ops = """
+ [i0]
+ i1 = int_lt(i0, 4)
+ guard_true(i1) []
+ i2 = int_add_ovf(i0, 10)
+ guard_no_overflow() []
+ i3 = int_lt(i2, 15)
+ guard_true(i3) []
+ jump(i0)
+ """
+ expected = """
+ [i0]
+ i1 = int_lt(i0, 4)
+ guard_true(i1) []
+ i2 = int_add(i0, 10)
+ jump(i0)
+ """
+ self.optimize_loop(ops, 'Not', expected)
+
+ def test_bound_lt_add_ovf_before(self):
+ ops = """
+ [i0]
+ i2 = int_add_ovf(i0, 10)
+ guard_no_overflow() []
+ i3 = int_lt(i2, 15)
+ guard_true(i3) []
+ i1 = int_lt(i0, 6)
+ guard_true(i1) []
+ jump(i0)
+ """
+ expected = """
+ [i0]
+ i2 = int_add_ovf(i0, 10)
+ guard_no_overflow() []
+ i3 = int_lt(i2, 15)
+ guard_true(i3) []
+ jump(i0)
+ """
+ self.optimize_loop(ops, 'Not', expected)
+
+ def test_bound_lt_sub(self):
+ ops = """
+ [i0]
+ i1 = int_lt(i0, 4)
+ guard_true(i1) []
+ i2 = int_sub(i0, 10)
+ i3 = int_lt(i2, -5)
+ guard_true(i3) []
+ jump(i0)
+ """
+ expected = """
+ [i0]
+ i1 = int_lt(i0, 4)
+ guard_true(i1) []
+ i2 = int_sub(i0, 10)
+ jump(i0)
+ """
+ self.optimize_loop(ops, 'Not', expected)
+
+ def test_bound_lt_sub_before(self):
+ ops = """
+ [i0]
+ i2 = int_sub(i0, 10)
+ i3 = int_lt(i2, -5)
+ guard_true(i3) []
+ i1 = int_lt(i0, 5)
+ guard_true(i1) []
+ jump(i0)
+ """
+ expected = """
+ [i0]
+ i2 = int_sub(i0, 10)
+ i3 = int_lt(i2, -5)
+ guard_true(i3) []
+ jump(i0)
+ """
+ self.optimize_loop(ops, 'Not', expected)
+
+ def test_bound_ltle(self):
+ ops = """
+ [i0]
+ i1 = int_lt(i0, 4)
+ guard_true(i1) []
+ i2 = int_le(i0, 3)
+ guard_true(i2) []
+ jump(i0)
+ """
+ expected = """
+ [i0]
+ i1 = int_lt(i0, 4)
+ guard_true(i1) []
+ jump(i0)
+ """
+ self.optimize_loop(ops, 'Not', expected)
+
+ def test_bound_lelt(self):
+ ops = """
+ [i0]
+ i1 = int_le(i0, 4)
+ guard_true(i1) []
+ i2 = int_lt(i0, 5)
+ guard_true(i2) []
+ jump(i0)
+ """
+ expected = """
+ [i0]
+ i1 = int_le(i0, 4)
+ guard_true(i1) []
+ jump(i0)
+ """
+ self.optimize_loop(ops, 'Not', expected)
+
+ def test_bound_gt(self):
+ ops = """
+ [i0]
+ i1 = int_gt(i0, 5)
+ guard_true(i1) []
+ i2 = int_gt(i0, 4)
+ guard_true(i2) []
+ jump(i0)
+ """
+ expected = """
+ [i0]
+ i1 = int_gt(i0, 5)
+ guard_true(i1) []
+ jump(i0)
+ """
+ self.optimize_loop(ops, 'Not', expected)
+
+ def test_bound_gtge(self):
+ ops = """
+ [i0]
+ i1 = int_gt(i0, 5)
+ guard_true(i1) []
+ i2 = int_ge(i0, 6)
+ guard_true(i2) []
+ jump(i0)
+ """
+ expected = """
+ [i0]
+ i1 = int_gt(i0, 5)
+ guard_true(i1) []
+ jump(i0)
+ """
+ self.optimize_loop(ops, 'Not', expected)
+
+ def test_bound_gegt(self):
+ ops = """
+ [i0]
+ i1 = int_ge(i0, 5)
+ guard_true(i1) []
+ i2 = int_gt(i0, 4)
+ guard_true(i2) []
+ jump(i0)
+ """
+ expected = """
+ [i0]
+ i1 = int_ge(i0, 5)
+ guard_true(i1) []
+ jump(i0)
+ """
+ self.optimize_loop(ops, 'Not', expected)
+
+ def test_bound_ovf(self):
+ ops = """
+ [i0]
+ i1 = int_ge(i0, 0)
+ guard_true(i1) []
+ i2 = int_lt(i0, 10)
+ guard_true(i2) []
+ i3 = int_add_ovf(i0, 1)
+ guard_no_overflow() []
+ jump(i3)
+ """
+ expected = """
+ [i0]
+ i1 = int_ge(i0, 0)
+ guard_true(i1) []
+ i2 = int_lt(i0, 10)
+ guard_true(i2) []
+ i3 = int_add(i0, 1)
+ jump(i3)
+ """
+ self.optimize_loop(ops, 'Not', expected)
+
+ def test_addsub_const(self):
+ ops = """
+ [i0]
+ i1 = int_add(i0, 1)
+ i2 = int_sub(i1, 1)
+ i3 = int_add(i2, 1)
+ i4 = int_mul(i2, i3)
+ jump(i4)
+ """
+ expected = """
+ [i0]
+ i1 = int_add(i0, 1)
+ i4 = int_mul(i0, i1)
+ jump(i4)
+ """
+ self.optimize_loop(ops, 'Not', expected)
+
+ def test_addsub_int(self):
+ ops = """
+ [i0, i10]
+ i1 = int_add(i0, i10)
+ i2 = int_sub(i1, i10)
+ i3 = int_add(i2, i10)
+ i4 = int_add(i2, i3)
+ jump(i4, i10)
+ """
+ expected = """
+ [i0, i10]
+ i1 = int_add(i0, i10)
+ i4 = int_add(i0, i1)
+ jump(i4, i10)
+ """
+ self.optimize_loop(ops, 'Not, Not', expected)
+
+ def test_addsub_int2(self):
+ ops = """
+ [i0, i10]
+ i1 = int_add(i10, i0)
+ i2 = int_sub(i1, i10)
+ i3 = int_add(i10, i2)
+ i4 = int_add(i2, i3)
+ jump(i4, i10)
+ """
+ expected = """
+ [i0, i10]
+ i1 = int_add(i10, i0)
+ i4 = int_add(i0, i1)
+ jump(i4, i10)
+ """
+ self.optimize_loop(ops, 'Not, Not', expected)
+
+ def test_framestackdepth_overhead(self):
+ ops = """
+ [p0, i22]
+ i1 = getfield_gc(p0, descr=valuedescr)
+ i2 = int_gt(i1, i22)
+ guard_false(i2) []
+ i3 = int_add(i1, 1)
+ setfield_gc(p0, i3, descr=valuedescr)
+ i4 = int_sub(i3, 1)
+ setfield_gc(p0, i4, descr=valuedescr)
+ i5 = int_gt(i4, i22)
+ guard_false(i5) []
+ i6 = int_add(i4, 1)
+ i331 = force_token()
+ i7 = int_sub(i6, 1)
+ setfield_gc(p0, i7, descr=valuedescr)
+ jump(p0, i22)
+ """
+ expected = """
+ [p0, i22]
+ i1 = getfield_gc(p0, descr=valuedescr)
+ i2 = int_gt(i1, i22)
+ guard_false(i2) []
+ i3 = int_add(i1, 1)
+ i331 = force_token()
+ setfield_gc(p0, i1, descr=valuedescr)
+ jump(p0, i22)
+ """
+ self.optimize_loop(ops, 'Not, Not', expected)
+
+ def test_addsub_ovf(self):
+ ops = """
+ [i0]
+ i1 = int_add_ovf(i0, 10)
+ guard_no_overflow() []
+ i2 = int_sub_ovf(i1, 5)
+ guard_no_overflow() []
+ jump(i2)
+ """
+ expected = """
+ [i0]
+ i1 = int_add_ovf(i0, 10)
+ guard_no_overflow() []
+ i2 = int_sub(i1, 5)
+ jump(i2)
+ """
+ self.optimize_loop(ops, 'Not', expected)
+
+ def test_subadd_ovf(self):
+ ops = """
+ [i0]
+ i1 = int_sub_ovf(i0, 10)
+ guard_no_overflow() []
+ i2 = int_add_ovf(i1, 5)
+ guard_no_overflow() []
+ jump(i2)
+ """
+ expected = """
+ [i0]
+ i1 = int_sub_ovf(i0, 10)
+ guard_no_overflow() []
+ i2 = int_add(i1, 5)
+ jump(i2)
+ """
+ self.optimize_loop(ops, 'Not', expected)
+
+ def test_bound_and(self):
+ ops = """
+ [i0]
+ i1 = int_and(i0, 255)
+ i2 = int_lt(i1, 500)
+ guard_true(i2) []
+ i3 = int_le(i1, 255)
+ guard_true(i3) []
+ i4 = int_gt(i1, -1)
+ guard_true(i4) []
+ i5 = int_ge(i1, 0)
+ guard_true(i5) []
+ i6 = int_lt(i1, 0)
+ guard_false(i6) []
+ i7 = int_le(i1, -1)
+ guard_false(i7) []
+ i8 = int_gt(i1, 255)
+ guard_false(i8) []
+ i9 = int_ge(i1, 500)
+ guard_false(i9) []
+ i12 = int_lt(i1, 100)
+ guard_true(i12) []
+ i13 = int_le(i1, 90)
+ guard_true(i13) []
+ i14 = int_gt(i1, 10)
+ guard_true(i14) []
+ i15 = int_ge(i1, 20)
+ guard_true(i15) []
+ jump(i1)
+ """
+ expected = """
+ [i0]
+ i1 = int_and(i0, 255)
+ i12 = int_lt(i1, 100)
+ guard_true(i12) []
+ i13 = int_le(i1, 90)
+ guard_true(i13) []
+ i14 = int_gt(i1, 10)
+ guard_true(i14) []
+ i15 = int_ge(i1, 20)
+ guard_true(i15) []
+ jump(i1)
+ """
+ self.optimize_loop(ops, 'Not', expected)
+
+ def test_subsub_ovf(self):
+ ops = """
+ [i0]
+ i1 = int_sub_ovf(1, i0)
+ guard_no_overflow() []
+ i2 = int_gt(i1, 1)
+ guard_true(i2) []
+ i3 = int_sub_ovf(1, i0)
+ guard_no_overflow() []
+ i4 = int_gt(i3, 1)
+ guard_true(i4) []
+ jump(i0)
+ """
+ expected = """
+ [i0]
+ i1 = int_sub_ovf(1, i0)
+ guard_no_overflow() []
+ i2 = int_gt(i1, 1)
+ guard_true(i2) []
+ i3 = int_sub(1, i0)
+ jump(i0)
+ """
+ self.optimize_loop(ops, 'Not', expected)
+
+ def test_bound_eq(self):
+ ops = """
+ [i0, i1]
+ i2 = int_le(i0, 4)
+ guard_true(i2) []
+ i3 = int_eq(i0, i1)
+ guard_true(i3) []
+ i4 = int_lt(i1, 5)
+ guard_true(i4) []
+ jump(i0, i1)
+ """
+ expected = """
+ [i0, i1]
+ i2 = int_le(i0, 4)
+ guard_true(i2) []
+ i3 = int_eq(i0, i1)
+ guard_true(i3) []
+ jump(i0, i1)
+ """
+ self.optimize_loop(ops, 'Not, Not', expected)
+
+ def test_bound_eq_const(self):
+ ops = """
+ [i0]
+ i1 = int_eq(i0, 7)
+ guard_true(i1) []
+ i2 = int_add(i0, 3)
+ jump(i2)
+ """
+ expected = """
+ [i0]
+ i1 = int_eq(i0, 7)
+ guard_true(i1) []
+ jump(10)
+
+ """
+ self.optimize_loop(ops, 'Not', expected)
+
+ def test_bound_eq_const_not(self):
+ ops = """
+ [i0]
+ i1 = int_eq(i0, 7)
+ guard_false(i1) []
+ i2 = int_add(i0, 3)
+ jump(i2)
+ """
+ expected = """
+ [i0]
+ i1 = int_eq(i0, 7)
+ guard_false(i1) []
+ i2 = int_add(i0, 3)
+ jump(i2)
+
+ """
+ self.optimize_loop(ops, 'Not', expected)
+
+ def test_bound_ne_const(self):
+ ops = """
+ [i0]
+ i1 = int_ne(i0, 7)
+ guard_false(i1) []
+ i2 = int_add(i0, 3)
+ jump(i2)
+ """
+ expected = """
+ [i0]
+ i1 = int_ne(i0, 7)
+ guard_false(i1) []
+ jump(10)
+
+ """
+ self.optimize_loop(ops, 'Not', expected)
+
+ def test_bound_ne_const_not(self):
+ ops = """
+ [i0]
+ i1 = int_ne(i0, 7)
+ guard_true(i1) []
+ i2 = int_add(i0, 3)
+ jump(i2)
+ """
+ expected = """
+ [i0]
+ i1 = int_ne(i0, 7)
+ guard_true(i1) []
+ i2 = int_add(i0, 3)
+ jump(i2)
+ """
+ self.optimize_loop(ops, 'Not', expected)
+
+ def test_bound_ltne(self):
+ ops = """
+ [i0, i1]
+ i2 = int_lt(i0, 7)
+ guard_true(i2) []
+ i3 = int_ne(i0, 10)
+ guard_true(i2) []
+ jump(i0, i1)
+ """
+ expected = """
+ [i0, i1]
+ i2 = int_lt(i0, 7)
+ guard_true(i2) []
+ jump(i0, i1)
+ """
+ self.optimize_loop(ops, 'Not, Not', expected)
+
+ def test_bound_lege_const(self):
+ ops = """
+ [i0]
+ i1 = int_ge(i0, 7)
+ guard_true(i1) []
+ i2 = int_le(i0, 7)
+ guard_true(i2) []
+ i3 = int_add(i0, 3)
+ jump(i3)
+ """
+ expected = """
+ [i0]
+ i1 = int_ge(i0, 7)
+ guard_true(i1) []
+ i2 = int_le(i0, 7)
+ guard_true(i2) []
+ jump(10)
+
+ """
+ self.optimize_loop(ops, 'Not', expected)
+
+ def test_mul_ovf(self):
+ ops = """
+ [i0, i1]
+ i2 = int_and(i0, 255)
+ i3 = int_lt(i1, 5)
+ guard_true(i3) []
+ i4 = int_gt(i1, -10)
+ guard_true(i4) []
+ i5 = int_mul_ovf(i2, i1)
+ guard_no_overflow() []
+ i6 = int_lt(i5, -2550)
+ guard_false(i6) []
+ i7 = int_ge(i5, 1276)
+ guard_false(i7) []
+ i8 = int_gt(i5, 126)
+ guard_true(i8) []
+ jump(i0, i1)
+ """
+ expected = """
+ [i0, i1]
+ i2 = int_and(i0, 255)
+ i3 = int_lt(i1, 5)
+ guard_true(i3) []
+ i4 = int_gt(i1, -10)
+ guard_true(i4) []
+ i5 = int_mul(i2, i1)
+ i8 = int_gt(i5, 126)
+ guard_true(i8) []
+ jump(i0, i1)
+ """
+ self.optimize_loop(ops, 'Not, Not', expected)
+
+ def test_mul_ovf_before(self):
+ ops = """
+ [i0, i1]
+ i2 = int_and(i0, 255)
+ i22 = int_add(i2, 1)
+ i3 = int_mul_ovf(i22, i1)
+ guard_no_overflow() []
+ i4 = int_lt(i3, 10)
+ guard_true(i4) []
+ i5 = int_gt(i3, 2)
+ guard_true(i5) []
+ i6 = int_lt(i1, 0)
+ guard_false(i6) []
+ jump(i0, i1)
+ """
+ expected = """
+ [i0, i1]
+ i2 = int_and(i0, 255)
+ i22 = int_add(i2, 1)
+ i3 = int_mul_ovf(i22, i1)
+ guard_no_overflow() []
+ i4 = int_lt(i3, 10)
+ guard_true(i4) []
+ i5 = int_gt(i3, 2)
+ guard_true(i5) []
+ jump(i0, i1)
+ """
+ self.optimize_loop(ops, 'Not, Not', expected)
+
+ def test_sub_ovf_before(self):
+ ops = """
+ [i0, i1]
+ i2 = int_and(i0, 255)
+ i3 = int_sub_ovf(i2, i1)
+ guard_no_overflow() []
+ i4 = int_le(i3, 10)
+ guard_true(i4) []
+ i5 = int_ge(i3, 2)
+ guard_true(i5) []
+ i6 = int_lt(i1, -10)
+ guard_false(i6) []
+ i7 = int_gt(i1, 253)
+ guard_false(i7) []
+ jump(i0, i1)
+ """
+ expected = """
+ [i0, i1]
+ i2 = int_and(i0, 255)
+ i3 = int_sub_ovf(i2, i1)
+ guard_no_overflow() []
+ i4 = int_le(i3, 10)
+ guard_true(i4) []
+ i5 = int_ge(i3, 2)
+ guard_true(i5) []
+ jump(i0, i1)
+ """
+ self.optimize_loop(ops, 'Not, Not', expected)
+
+
+
+
##class TestOOtype(BaseTestOptimizeOpt, OOtypeMixin):
## def test_instanceof(self):
Modified: pypy/trunk/pypy/jit/metainterp/test/test_resume.py
==============================================================================
--- pypy/trunk/pypy/jit/metainterp/test/test_resume.py (original)
+++ pypy/trunk/pypy/jit/metainterp/test/test_resume.py Thu Sep 9 18:23:42 2010
@@ -1,7 +1,7 @@
import py
from pypy.rpython.lltypesystem import lltype, llmemory, rffi
-from pypy.jit.metainterp.optimizeopt import VirtualValue, OptValue, VArrayValue
-from pypy.jit.metainterp.optimizeopt import VStructValue
+from pypy.jit.metainterp.optimizeopt.virtualize import VirtualValue, OptValue, VArrayValue
+from pypy.jit.metainterp.optimizeopt.virtualize import VStructValue
from pypy.jit.metainterp.resume import *
from pypy.jit.metainterp.history import BoxInt, BoxPtr, ConstInt
from pypy.jit.metainterp.history import ConstPtr, ConstFloat
Modified: pypy/trunk/pypy/module/pypyjit/test/test_pypy_c.py
==============================================================================
--- pypy/trunk/pypy/module/pypyjit/test/test_pypy_c.py (original)
+++ pypy/trunk/pypy/module/pypyjit/test/test_pypy_c.py Thu Sep 9 18:23:42 2010
@@ -110,6 +110,7 @@
if sys.platform.startswith('win'):
py.test.skip("XXX this is not Windows-friendly")
+ print logfilepath
child_stdout = os.popen('PYPYLOG=":%s" "%s" "%s"' % (
logfilepath, self.pypy_c, filepath), 'r')
result = child_stdout.read()
@@ -118,6 +119,7 @@
assert result.splitlines()[-1].strip() == 'OK :-)'
self.parse_loops(logfilepath)
self.print_loops()
+ print logfilepath
if self.total_ops > expected_max_ops:
assert 0, "too many operations: got %d, expected maximum %d" % (
self.total_ops, expected_max_ops)
@@ -846,6 +848,221 @@
return intimg[i - 1]
''', maxops, ([tc], res))
+ def test_intbound_simple(self):
+ ops = ('<', '>', '<=', '>=', '==', '!=')
+ nbr = (3, 7)
+ for o1 in ops:
+ for o2 in ops:
+ for n1 in nbr:
+ for n2 in nbr:
+ src = '''
+ def f(i):
+ a, b = 3, 3
+ if i %s %d:
+ a = 0
+ else:
+ a = 1
+ if i %s %d:
+ b = 0
+ else:
+ b = 1
+ return a + b * 2
+
+ def main():
+ res = [0] * 4
+ idx = []
+ for i in range(15):
+ idx.extend([i] * 1500)
+ for i in idx:
+ res[f(i)] += 1
+ return res
+
+ ''' % (o1, n1, o2, n2)
+
+ exec(str(py.code.Source(src)))
+ res = [0] * 4
+ for i in range(15):
+ res[f(i)] += 1500
+ self.run_source(src, 268, ([], res))
+
+ def test_intbound_addsub_mix(self):
+ tests = ('i > 4', 'i > 2', 'i + 1 > 2', '1 + i > 4',
+ 'i - 1 > 1', '1 - i > 1', '1 - i < -3',
+ 'i == 1', 'i == 5', 'i != 1', '-2 * i < -4')
+ for t1 in tests:
+ for t2 in tests:
+ print t1, t2
+ src = '''
+ def f(i):
+ a, b = 3, 3
+ if %s:
+ a = 0
+ else:
+ a = 1
+ if %s:
+ b = 0
+ else:
+ b = 1
+ return a + b * 2
+
+ def main():
+ res = [0] * 4
+ idx = []
+ for i in range(15):
+ idx.extend([i] * 1500)
+ for i in idx:
+ res[f(i)] += 1
+ return res
+
+ ''' % (t1, t2)
+
+ exec(str(py.code.Source(src)))
+ res = [0] * 4
+ for i in range(15):
+ res[f(i)] += 1500
+ self.run_source(src, 280, ([], res))
+
+ def test_intbound_gt(self):
+ self.run_source('''
+ def main():
+ i, a, b = 0, 0, 0
+ while i < 2000:
+ if i > -1:
+ a += 1
+ if i > -2:
+ b += 1
+ i += 1
+ return (a, b)
+ ''', 48, ([], (2000, 2000)))
+
+ def test_intbound_sub_lt(self):
+ self.run_source('''
+ def main():
+ i, a, b = 0, 0, 0
+ while i < 2000:
+ if i - 10 < 1995:
+ a += 1
+ i += 1
+ return (a, b)
+ ''', 38, ([], (2000, 0)))
+
+ def test_intbound_addsub_ge(self):
+ self.run_source('''
+ def main():
+ i, a, b = 0, 0, 0
+ while i < 2000:
+ if i + 5 >= 5:
+ a += 1
+ if i - 1 >= -1:
+ b += 1
+ i += 1
+ return (a, b)
+ ''', 56, ([], (2000, 2000)))
+
+ def test_intbound_addmul_ge(self):
+ self.run_source('''
+ def main():
+ i, a, b = 0, 0, 0
+ while i < 2000:
+ if i + 5 >= 5:
+ a += 1
+ if 2 * i >= 0:
+ b += 1
+ i += 1
+ return (a, b)
+ ''', 53, ([], (2000, 2000)))
+
+ def test_intbound_eq(self):
+ self.run_source('''
+ def main(a):
+ i, s = 0, 0
+ while i < 1500:
+ if a == 7:
+ s += a + 1
+ elif i == 10:
+ s += i
+ else:
+ s += 1
+ i += 1
+ return s
+ ''', 69, ([7], 12000), ([42], 1509), ([10], 1509))
+
+ def test_intbound_mul(self):
+ self.run_source('''
+ def main(a):
+ i, s = 0, 0
+ while i < 1500:
+ assert i >= 0
+ if 2 * i < 30000:
+ s += 1
+ else:
+ s += a
+ i += 1
+ return s
+ ''', 43, ([7], 1500))
+
+ def test_assert(self):
+ self.run_source('''
+ def main(a):
+ i, s = 0, 0
+ while i < 1500:
+ assert a == 7
+ s += a + 1
+ i += 1
+ return s
+ ''', 38, ([7], 8*1500))
+
+ def test_zeropadded(self):
+ self.run_source('''
+ from array import array
+ class ZeroPadded(array):
+ def __new__(cls, l):
+ self = array.__new__(cls, 'd', range(l))
+ return self
+
+ def __getitem__(self, i):
+ if i < 0 or i >= self.__len__():
+ return 0
+ return array.__getitem__(self, i)
+
+
+ def main():
+ buf = ZeroPadded(2000)
+ i = 10
+ sa = 0
+ while i < 2000 - 10:
+ sa += buf[i-2] + buf[i-1] + buf[i] + buf[i+1] + buf[i+2]
+ i += 1
+ return sa
+
+ ''', 232, ([], 9895050.0))
+
+ def test_circular(self):
+ self.run_source('''
+ from array import array
+ class Circular(array):
+ def __new__(cls):
+ self = array.__new__(cls, 'd', range(256))
+ return self
+ def __getitem__(self, i):
+ # assert self.__len__() == 256 (FIXME: does not improve)
+ return array.__getitem__(self, i & 255)
+
+ def main():
+ buf = Circular()
+ i = 10
+ sa = 0
+ while i < 2000 - 10:
+ sa += buf[i-2] + buf[i-1] + buf[i] + buf[i+1] + buf[i+2]
+ i += 1
+ return sa
+
+ ''', 170, ([], 1239690.0))
+
+
+
+ # test_circular
+
class AppTestJIT(PyPyCJITTests):
def setup_class(cls):
if not option.runappdirect:
More information about the Pypy-commit
mailing list