Author: Maciej Fijalkowski <fij...@gmail.com> 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 pypy-commit@python.org https://mail.python.org/mailman/listinfo/pypy-commit