Author: Maciej Fijalkowski <[email protected]>
Branch: optresult-unroll
Changeset: r79088:f107bebc383e
Date: 2015-08-20 18:10 +0200
http://bitbucket.org/pypy/pypy/changeset/f107bebc383e/
Log: start passing virtualstate tests
diff --git a/rpython/jit/metainterp/optimizeopt/test/test_util.py
b/rpython/jit/metainterp/optimizeopt/test/test_util.py
--- a/rpython/jit/metainterp/optimizeopt/test/test_util.py
+++ b/rpython/jit/metainterp/optimizeopt/test/test_util.py
@@ -117,6 +117,7 @@
#nodebox = InputArgRef(lltype.cast_opaque_ptr(llmemory.GCREF, node))
node2 = lltype.malloc(NODE2)
node2.parent.parent.typeptr = node_vtable2
+ node2addr = lltype.cast_opaque_ptr(llmemory.GCREF, node2)
myptr = lltype.cast_opaque_ptr(llmemory.GCREF, node)
myptr2 = lltype.cast_opaque_ptr(llmemory.GCREF, lltype.malloc(NODE))
nullptr = lltype.nullptr(llmemory.GCREF.TO)
diff --git a/rpython/jit/metainterp/optimizeopt/test/test_virtualstate.py
b/rpython/jit/metainterp/optimizeopt/test/test_virtualstate.py
--- a/rpython/jit/metainterp/optimizeopt/test/test_virtualstate.py
+++ b/rpython/jit/metainterp/optimizeopt/test/test_virtualstate.py
@@ -25,21 +25,6 @@
self.optearlyforce = None
class BaseTestGenerateGuards(BaseTest):
-
- def _box_or_value(self, boxinfo=None):
- if boxinfo is None:
- return None, None
- else:
- xxx
- # el
- if isinstance(box_or_value, OptValue):
- value = box_or_value
- box = value.box
- else:
- box = box_or_value
- value = OptValue(box)
- return value, box
-
def guards(self, info1, info2, box_or_value, expected, inputargs=None):
value, box = self._box_or_value(box_or_value)
if inputargs is None:
@@ -61,22 +46,20 @@
assert equaloplists(guards, loop.operations, False,
boxmap)
- def check_no_guards(self, info1, info2, boxinfo=None, state=None):
- assert boxinfo is None
- boxinfo, _ = self._box_or_value(boxinfo)
+ def check_no_guards(self, info1, info2, box=None, opinfo=None, state=None):
if info1.position == -1:
info1.position = 0
if info2.position == -1:
info2.position = 0
if state is None:
state = GenerateGuardState(self.cpu)
- info1.generate_guards(info2, boxinfo, None, state)
+ info1.generate_guards(info2, box, opinfo, state)
assert not state.extra_guards
return state
def check_invalid(self, info1, info2, box_or_value=None, state=None):
assert box_or_value is None
- value, _ = self._box_or_value(box_or_value)
+ value, _ = None, None # self._box_or_value(box_or_value)
if info1.position == -1:
info1.position = 0
if info2.position == -1:
@@ -175,8 +158,8 @@
assert not isgeneral('r', value1, 'r', value2)
def test_field_matching_generalization(self):
- const1 = NotVirtualStateInfo(OptValue(ConstInt(1)))
- const2 = NotVirtualStateInfo(OptValue(ConstInt(2)))
+ const1 = NotVirtualStateInfo(self.cpu, 'i', ConstIntBound(1))
+ const2 = NotVirtualStateInfo(self.cpu, 'i', ConstIntBound(2))
const1.position = const2.position = 1
self.check_invalid(const1, const2)
self.check_invalid(const2, const1)
@@ -197,20 +180,17 @@
fldtst(VArrayStructStateInfo(fakedescr, [[fielddescr]]),
VArrayStructStateInfo(fakedescr, [[fielddescr]]))
def test_known_class_generalization(self):
- knownclass1 = PtrOptValue(BoxPtr())
- knownclass1.make_constant_class(None, ConstPtr(self.myptr))
- info1 = NotVirtualStateInfo(knownclass1)
+ knownclass1 = info.InstancePtrInfo(ConstPtr(self.myptr))
+ info1 = NotVirtualStateInfo(self.cpu, 'r', knownclass1)
info1.position = 0
- knownclass2 = PtrOptValue(BoxPtr())
- knownclass2.make_constant_class(None, ConstPtr(self.myptr))
- info2 = NotVirtualStateInfo(knownclass2)
+ knownclass2 = info.InstancePtrInfo(ConstPtr(self.myptr))
+ info2 = NotVirtualStateInfo(self.cpu, 'r', knownclass2)
info2.position = 0
self.check_no_guards(info1, info2)
self.check_no_guards(info2, info1)
- knownclass3 = PtrOptValue(BoxPtr())
- knownclass3.make_constant_class(None, ConstPtr(self.myptr2))
- info3 = NotVirtualStateInfo(knownclass3)
+ knownclass3 = info.InstancePtrInfo(ConstPtr(self.myptr2))
+ info3 = NotVirtualStateInfo(self.cpu, 'r', knownclass3)
info3.position = 0
self.check_invalid(info1, info3)
self.check_invalid(info2, info3)
@@ -228,49 +208,46 @@
def test_generate_guards_nonvirtual_all_combinations(self):
# set up infos
- unknown_val = PtrOptValue(self.nodebox)
- unknownnull_val = PtrOptValue(BoxPtr(self.nullptr))
- unknown_info = NotVirtualStateInfo(unknown_val)
+ #unknown_val = PtrOptValue(self.nodebox)
+ #unknownnull_val = PtrOptValue(BoxPtr(self.nullptr))
+ unknown_info = NotVirtualStateInfo(self.cpu, 'r', None)
- nonnull_val = PtrOptValue(self.nodebox)
- nonnull_val.make_nonnull(None)
- nonnull_info = NotVirtualStateInfo(nonnull_val)
+ nonnull_info = NotVirtualStateInfo(self.cpu, 'r',
info.NonNullPtrInfo())
- knownclass_val = PtrOptValue(self.nodebox)
- classbox = self.cpu.ts.cls_of_box(self.nodebox)
- knownclass_val.make_constant_class(None, classbox,)
- knownclass_info = NotVirtualStateInfo(knownclass_val)
- knownclass2_val = PtrOptValue(self.nodebox2)
- classbox = self.cpu.ts.cls_of_box(self.nodebox2)
- knownclass2_val.make_constant_class(None, classbox)
- knownclass2_info = NotVirtualStateInfo(knownclass2_val)
+ classbox1 = self.cpu.ts.cls_of_box(ConstPtr(self.nodeaddr))
+ knownclass_info = NotVirtualStateInfo(self.cpu, 'r',
+ info.InstancePtrInfo(classbox1))
+ classbox2 = self.cpu.ts.cls_of_box(ConstPtr(self.node2addr))
+ knownclass2_info = NotVirtualStateInfo(self.cpu, 'r',
+ info.InstancePtrInfo(classbox2))
- constant_val = IntOptValue(BoxInt())
- constant_val.make_constant(ConstInt(1))
- constant_info = NotVirtualStateInfo(constant_val)
- constclass_val = PtrOptValue(self.nodebox)
- constclass_val.make_constant(self.nodebox.constbox())
- constclass_info = NotVirtualStateInfo(constclass_val)
- constclass2_val = PtrOptValue(self.nodebox)
- constclass2_val.make_constant(self.nodebox2.constbox())
- constclass2_info = NotVirtualStateInfo(constclass2_val)
- constantnull_val = PtrOptValue(ConstPtr(self.nullptr))
- constantnull_info = NotVirtualStateInfo(constantnull_val)
+ constant_info = NotVirtualStateInfo(self.cpu, 'i',
+ ConstIntBound(1))
+ constclass_val = info.ConstPtrInfo(ConstPtr(self.nodeaddr))
+ constclass_info = NotVirtualStateInfo(self.cpu, 'r', constclass_val)
+ constclass2_info = NotVirtualStateInfo(self.cpu, 'r',
+ info.ConstPtrInfo(ConstPtr(self.node2addr)))
+ constantnull_info = NotVirtualStateInfo(self.cpu, 'r',
+ info.ConstPtrInfo(ConstPtr(self.nullptr)))
# unknown unknown
- self.check_no_guards(unknown_info, unknown_info, unknown_val)
self.check_no_guards(unknown_info, unknown_info)
+ self.check_no_guards(unknown_info, unknown_info,
+ InputArgRef(), info.PtrInfo())
# unknown nonnull
- self.check_no_guards(unknown_info, nonnull_info, nonnull_val)
+ self.check_no_guards(unknown_info, nonnull_info,
+ InputArgRef(), info.NonNullPtrInfo())
self.check_no_guards(unknown_info, nonnull_info)
# unknown knownclass
- self.check_no_guards(unknown_info, knownclass_info, knownclass_val)
+ self.check_no_guards(unknown_info, knownclass_info,
+ InputArgRef(), info.InstancePtrInfo(classbox1))
self.check_no_guards(unknown_info, knownclass_info)
# unknown constant
- self.check_no_guards(unknown_info, constant_info, constant_val)
+ self.check_no_guards(unknown_info, constant_info,
+ ConstInt(1), ConstIntBound(1))
self.check_no_guards(unknown_info, constant_info)
diff --git a/rpython/jit/metainterp/optimizeopt/virtualstate.py
b/rpython/jit/metainterp/optimizeopt/virtualstate.py
--- a/rpython/jit/metainterp/optimizeopt/virtualstate.py
+++ b/rpython/jit/metainterp/optimizeopt/virtualstate.py
@@ -122,14 +122,17 @@
raise VirtualStatesCantMatch("field descrs don't match")
for i in range(len(self.fielddescrs)):
- yyy
if other.fielddescrs[i] is not self.fielddescrs[i]:
raise VirtualStatesCantMatch("field descrs don't match")
- if value is not None:
- v = value._fields[self.fielddescrs[i]] # must be there
+ if box is not None:
+ fieldbox = opinfo._fields[self.fielddescrs[i].get_index()]
+ # must be there
+ fieldinfo = fieldbox.get_forwarded()
else:
- v = None
- self.fieldstate[i].generate_guards(other.fieldstate[i], v, state)
+ fieldbox = None
+ fieldinfo = None
+ self.fieldstate[i].generate_guards(other.fieldstate[i], fieldbox,
+ fieldinfo, state)
def _generalization_of_structpart(self, other):
@@ -196,14 +199,15 @@
raise VirtualStatesCantMatch("other is a different kind of array")
if len(self.fieldstate) != len(other.fieldstate):
raise VirtualStatesCantMatch("other has a different length")
- v = None
+ fieldbox = None
+ fieldinfo = None
for i in range(len(self.fieldstate)):
- xxxx
- if value is not None:
- assert isinstance(value, virtualize.VArrayValue)
- v = value._items[i]
+ if box is not None:
+ assert isinstance(opinfo, info.ArrayPtrInfo)
+ fieldbox = opinfo._items[i]
+ fieldinfo = fieldbox.get_forwarded()
self.fieldstate[i].generate_guards(other.fieldstate[i],
- v, state)
+ fieldbox, fieldinfo, state)
def enum_forced_boxes(self, boxes, box, optimizer, force_boxes=False):
box = optimizer.get_box_replacement(box)
@@ -234,7 +238,7 @@
self.arraydescr = arraydescr
self.fielddescrs = fielddescrs
- def _generate_guards(self, other, value, state):
+ def _generate_guards(self, other, box, opinfo, state):
if not isinstance(other, VArrayStructStateInfo):
raise VirtualStatesCantMatch("other is not an
VArrayStructStateInfo")
if self.arraydescr is not other.arraydescr:
@@ -244,7 +248,8 @@
raise VirtualStatesCantMatch("other has a different length")
p = 0
- v = None
+ fieldbox = None
+ fieldinfo = None
for i in range(len(self.fielddescrs)):
if len(self.fielddescrs[i]) != len(other.fielddescrs[i]):
raise VirtualStatesCantMatch("other has a different length")
@@ -252,11 +257,12 @@
descr = self.fielddescrs[i][j]
if descr is not other.fielddescrs[i][j]:
raise VirtualStatesCantMatch("other is a different kind of
array")
- if value is not None:
+ if box is not None:
+ xxx
assert isinstance(value, virtualize.VArrayStructValue)
v = value._items[i][descr]
self.fieldstate[p].generate_guards(other.fieldstate[p],
- v,
+ fieldbox, fieldinfo,
state)
p += 1
_______________________________________________
pypy-commit mailing list
[email protected]
https://mail.python.org/mailman/listinfo/pypy-commit
