[pypy-commit] pypy default: merged virtual-dicts branch, this branch makes it possible for array of structs to be virtualized, and allows inlining into a few rdict functions, which in practice allows dicts where all the operations on them are with constant keys to remain virtual. in python code this is useful for things like "some str" % {"dict": "value"}, or g(x=x) with g(**kwargs): return kwargs['x']
alex_gaynor
noreply at buildbot.pypy.org
Thu Oct 27 18:43:15 CEST 2011
Author: Alex Gaynor <alex.gaynor at gmail.com>
Branch:
Changeset: r48514:96310036438c
Date: 2011-10-27 12:42 -0400
http://bitbucket.org/pypy/pypy/changeset/96310036438c/
Log: merged virtual-dicts branch, this branch makes it possible for array
of structs to be virtualized, and allows inlining into a few rdict
functions, which in practice allows dicts where all the operations
on them are with constant keys to remain virtual. in python code
this is useful for things like "some str" % {"dict": "value"}, or
g(x=x) with g(**kwargs): return kwargs['x']
diff --git a/pypy/jit/backend/llsupport/descr.py b/pypy/jit/backend/llsupport/descr.py
--- a/pypy/jit/backend/llsupport/descr.py
+++ b/pypy/jit/backend/llsupport/descr.py
@@ -281,6 +281,9 @@
def is_float_field(self):
return self.fielddescr.is_float_field()
+ def sort_key(self):
+ return self.fielddescr.sort_key()
+
def repr_of_descr(self):
return '<InteriorFieldDescr %s>' % self.fielddescr.repr_of_descr()
diff --git a/pypy/jit/codewriter/jtransform.py b/pypy/jit/codewriter/jtransform.py
--- a/pypy/jit/codewriter/jtransform.py
+++ b/pypy/jit/codewriter/jtransform.py
@@ -844,6 +844,10 @@
if self._is_gc(op.args[0]):
return op
+ def rewrite_op_cast_opaque_ptr(self, op):
+ # None causes the result of this op to get aliased to op.args[0]
+ return [SpaceOperation('mark_opaque_ptr', op.args, None), None]
+
def rewrite_op_force_cast(self, op):
v_arg = op.args[0]
v_result = op.result
diff --git a/pypy/jit/codewriter/test/test_jtransform.py b/pypy/jit/codewriter/test/test_jtransform.py
--- a/pypy/jit/codewriter/test/test_jtransform.py
+++ b/pypy/jit/codewriter/test/test_jtransform.py
@@ -1128,3 +1128,16 @@
varoftype(lltype.Signed))
tr = Transformer(None, None)
raises(NotImplementedError, tr.rewrite_operation, op)
+
+def test_cast_opaque_ptr():
+ S = lltype.GcStruct("S", ("x", lltype.Signed))
+ v1 = varoftype(lltype.Ptr(S))
+ v2 = varoftype(lltype.Ptr(rclass.OBJECT))
+
+ op = SpaceOperation('cast_opaque_ptr', [v1], v2)
+ tr = Transformer()
+ [op1, op2] = tr.rewrite_operation(op)
+ assert op1.opname == 'mark_opaque_ptr'
+ assert op1.args == [v1]
+ assert op1.result is None
+ assert op2 is None
\ No newline at end of file
diff --git a/pypy/jit/metainterp/blackhole.py b/pypy/jit/metainterp/blackhole.py
--- a/pypy/jit/metainterp/blackhole.py
+++ b/pypy/jit/metainterp/blackhole.py
@@ -505,9 +505,6 @@
@arguments("r", "r", returns="i")
def bhimpl_instance_ptr_ne(a, b):
return a != b
- @arguments("r", returns="r")
- def bhimpl_cast_opaque_ptr(a):
- return a
@arguments("r", returns="i")
def bhimpl_cast_ptr_to_int(a):
i = lltype.cast_ptr_to_int(a)
@@ -518,6 +515,10 @@
ll_assert((i & 1) == 1, "bhimpl_cast_int_to_ptr: not an odd int")
return lltype.cast_int_to_ptr(llmemory.GCREF, i)
+ @arguments("r")
+ def bhimpl_mark_opaque_ptr(a):
+ pass
+
@arguments("i", returns="i")
def bhimpl_int_copy(a):
return a
diff --git a/pypy/jit/metainterp/heapcache.py b/pypy/jit/metainterp/heapcache.py
--- a/pypy/jit/metainterp/heapcache.py
+++ b/pypy/jit/metainterp/heapcache.py
@@ -34,7 +34,6 @@
self.clear_caches(opnum, descr, argboxes)
def mark_escaped(self, opnum, argboxes):
- idx = 0
if opnum == rop.SETFIELD_GC:
assert len(argboxes) == 2
box, valuebox = argboxes
@@ -42,8 +41,20 @@
self.dependencies.setdefault(box, []).append(valuebox)
else:
self._escape(valuebox)
- # GETFIELD_GC doesn't escape it's argument
- elif opnum != rop.GETFIELD_GC:
+ elif opnum == rop.SETARRAYITEM_GC:
+ assert len(argboxes) == 3
+ box, indexbox, valuebox = argboxes
+ if self.is_unescaped(box) and self.is_unescaped(valuebox):
+ self.dependencies.setdefault(box, []).append(valuebox)
+ else:
+ self._escape(valuebox)
+ # GETFIELD_GC, MARK_OPAQUE_PTR, PTR_EQ, and PTR_NE don't escape their
+ # arguments
+ elif (opnum != rop.GETFIELD_GC and
+ opnum != rop.MARK_OPAQUE_PTR and
+ opnum != rop.PTR_EQ and
+ opnum != rop.PTR_NE):
+ idx = 0
for box in argboxes:
# setarrayitem_gc don't escape its first argument
if not (idx == 0 and opnum in [rop.SETARRAYITEM_GC]):
@@ -60,13 +71,13 @@
self._escape(dep)
def clear_caches(self, opnum, descr, argboxes):
- if opnum == rop.SETFIELD_GC:
- return
- if opnum == rop.SETARRAYITEM_GC:
- return
- if opnum == rop.SETFIELD_RAW:
- return
- if opnum == rop.SETARRAYITEM_RAW:
+ if (opnum == rop.SETFIELD_GC or
+ opnum == rop.SETARRAYITEM_GC or
+ opnum == rop.SETFIELD_RAW or
+ opnum == rop.SETARRAYITEM_RAW or
+ opnum == rop.SETINTERIORFIELD_GC or
+ opnum == rop.COPYSTRCONTENT or
+ opnum == rop.COPYUNICODECONTENT):
return
if rop._OVF_FIRST <= opnum <= rop._OVF_LAST:
return
@@ -75,9 +86,9 @@
if opnum == rop.CALL or opnum == rop.CALL_LOOPINVARIANT:
effectinfo = descr.get_extra_info()
ef = effectinfo.extraeffect
- if ef == effectinfo.EF_LOOPINVARIANT or \
- ef == effectinfo.EF_ELIDABLE_CANNOT_RAISE or \
- ef == effectinfo.EF_ELIDABLE_CAN_RAISE:
+ if (ef == effectinfo.EF_LOOPINVARIANT or
+ ef == effectinfo.EF_ELIDABLE_CANNOT_RAISE or
+ ef == effectinfo.EF_ELIDABLE_CAN_RAISE):
return
# A special case for ll_arraycopy, because it is so common, and its
# effects are so well defined.
diff --git a/pypy/jit/metainterp/optimizeopt/optimizer.py b/pypy/jit/metainterp/optimizeopt/optimizer.py
--- a/pypy/jit/metainterp/optimizeopt/optimizer.py
+++ b/pypy/jit/metainterp/optimizeopt/optimizer.py
@@ -209,13 +209,19 @@
def setfield(self, ofs, value):
raise NotImplementedError
+ def getlength(self):
+ raise NotImplementedError
+
def getitem(self, index):
raise NotImplementedError
- def getlength(self):
+ def setitem(self, index, value):
raise NotImplementedError
- def setitem(self, index, value):
+ def getinteriorfield(self, index, ofs, default):
+ raise NotImplementedError
+
+ def setinteriorfield(self, index, ofs, value):
raise NotImplementedError
@@ -283,11 +289,11 @@
return self.optimizer.optpure.has_pure_result(opnum, args, descr)
return False
- def get_pure_result(self, key):
+ def get_pure_result(self, key):
if self.optimizer.optpure:
return self.optimizer.optpure.get_pure_result(key)
return None
-
+
def setup(self):
pass
@@ -524,7 +530,7 @@
def replace_op(self, old_op, new_op):
# XXX: Do we want to cache indexes to prevent search?
- i = len(self._newoperations)
+ i = len(self._newoperations)
while i > 0:
i -= 1
if self._newoperations[i] is old_op:
diff --git a/pypy/jit/metainterp/optimizeopt/rewrite.py b/pypy/jit/metainterp/optimizeopt/rewrite.py
--- a/pypy/jit/metainterp/optimizeopt/rewrite.py
+++ b/pypy/jit/metainterp/optimizeopt/rewrite.py
@@ -465,10 +465,9 @@
args = [op.getarg(0), ConstInt(highest_bit(val))])
self.emit_operation(op)
- def optimize_CAST_OPAQUE_PTR(self, op):
+ def optimize_MARK_OPAQUE_PTR(self, op):
value = self.getvalue(op.getarg(0))
self.optimizer.opaque_pointers[value] = True
- self.make_equal_to(op.result, value)
def optimize_CAST_PTR_TO_INT(self, op):
self.pure(rop.CAST_INT_TO_PTR, [op.result], op.getarg(0))
diff --git a/pypy/jit/metainterp/optimizeopt/simplify.py b/pypy/jit/metainterp/optimizeopt/simplify.py
--- a/pypy/jit/metainterp/optimizeopt/simplify.py
+++ b/pypy/jit/metainterp/optimizeopt/simplify.py
@@ -25,7 +25,8 @@
# but it's a bit hard to implement robustly if heap.py is also run
pass
- optimize_CAST_OPAQUE_PTR = optimize_VIRTUAL_REF
+ def optimize_MARK_OPAQUE_PTR(self, op):
+ pass
dispatch_opt = make_dispatcher_method(OptSimplify, 'optimize_',
diff --git a/pypy/jit/metainterp/optimizeopt/test/test_optimizebasic.py b/pypy/jit/metainterp/optimizeopt/test/test_optimizebasic.py
--- a/pypy/jit/metainterp/optimizeopt/test/test_optimizebasic.py
+++ b/pypy/jit/metainterp/optimizeopt/test/test_optimizebasic.py
@@ -935,7 +935,6 @@
"""
self.optimize_loop(ops, expected)
-
def test_virtual_constant_isnonnull(self):
ops = """
[i0]
@@ -951,6 +950,32 @@
"""
self.optimize_loop(ops, expected)
+ def test_virtual_array_of_struct(self):
+ ops = """
+ [f0, f1, f2, f3]
+ p0 = new_array(2, descr=complexarraydescr)
+ setinteriorfield_gc(p0, 0, f0, descr=complexrealdescr)
+ setinteriorfield_gc(p0, 0, f1, descr=compleximagdescr)
+ setinteriorfield_gc(p0, 1, f2, descr=complexrealdescr)
+ setinteriorfield_gc(p0, 1, f3, descr=compleximagdescr)
+ f4 = getinteriorfield_gc(p0, 0, descr=complexrealdescr)
+ f5 = getinteriorfield_gc(p0, 1, descr=complexrealdescr)
+ f6 = float_mul(f4, f5)
+ f7 = getinteriorfield_gc(p0, 0, descr=compleximagdescr)
+ f8 = getinteriorfield_gc(p0, 1, descr=compleximagdescr)
+ f9 = float_mul(f7, f8)
+ f10 = float_add(f6, f9)
+ finish(f10)
+ """
+ expected = """
+ [f0, f1, f2, f3]
+ f4 = float_mul(f0, f2)
+ f5 = float_mul(f1, f3)
+ f6 = float_add(f4, f5)
+ finish(f6)
+ """
+ self.optimize_loop(ops, expected)
+
def test_nonvirtual_1(self):
ops = """
[i]
diff --git a/pypy/jit/metainterp/optimizeopt/test/test_util.py b/pypy/jit/metainterp/optimizeopt/test/test_util.py
--- a/pypy/jit/metainterp/optimizeopt/test/test_util.py
+++ b/pypy/jit/metainterp/optimizeopt/test/test_util.py
@@ -185,6 +185,18 @@
EffectInfo([], [arraydescr], [], [arraydescr],
oopspecindex=EffectInfo.OS_ARRAYCOPY))
+
+ # array of structs (complex data)
+ complexarray = lltype.GcArray(
+ lltype.Struct("complex",
+ ("real", lltype.Float),
+ ("imag", lltype.Float),
+ )
+ )
+ complexarraydescr = cpu.arraydescrof(complexarray)
+ complexrealdescr = cpu.interiorfielddescrof(complexarray, "real")
+ compleximagdescr = cpu.interiorfielddescrof(complexarray, "imag")
+
for _name, _os in [
('strconcatdescr', 'OS_STR_CONCAT'),
('strslicedescr', 'OS_STR_SLICE'),
@@ -240,7 +252,7 @@
## def get_class_of_box(self, box):
## root = box.getref(ootype.ROOT)
## return ootype.classof(root)
-
+
## cpu = runner.OOtypeCPU(None)
## NODE = ootype.Instance('NODE', ootype.ROOT, {})
## NODE._add_fields({'value': ootype.Signed,
diff --git a/pypy/jit/metainterp/optimizeopt/virtualize.py b/pypy/jit/metainterp/optimizeopt/virtualize.py
--- a/pypy/jit/metainterp/optimizeopt/virtualize.py
+++ b/pypy/jit/metainterp/optimizeopt/virtualize.py
@@ -271,6 +271,69 @@
def _make_virtual(self, modifier):
return modifier.make_varray(self.arraydescr)
+class VArrayStructValue(AbstractVirtualValue):
+ def __init__(self, arraydescr, size, keybox, source_op=None):
+ AbstractVirtualValue.__init__(self, keybox, source_op)
+ self.arraydescr = arraydescr
+ self._items = [{} for _ in xrange(size)]
+
+ def getlength(self):
+ return len(self._items)
+
+ def getinteriorfield(self, index, ofs, default):
+ return self._items[index].get(ofs, default)
+
+ def setinteriorfield(self, index, ofs, itemvalue):
+ assert isinstance(itemvalue, optimizer.OptValue)
+ self._items[index][ofs] = itemvalue
+
+ def _really_force(self, optforce):
+ assert self.source_op is not None
+ if not we_are_translated():
+ self.source_op.name = 'FORCE ' + self.source_op.name
+ optforce.emit_operation(self.source_op)
+ self.box = box = self.source_op.result
+ for index in range(len(self._items)):
+ for descr, value in self._items[index].iteritems():
+ subbox = value.force_box(optforce)
+ op = ResOperation(rop.SETINTERIORFIELD_GC,
+ [box, ConstInt(index), subbox], None, descr=descr
+ )
+ optforce.emit_operation(op)
+
+ def _get_list_of_descrs(self):
+ descrs = []
+ for item in self._items:
+ item_descrs = item.keys()
+ sort_descrs(item_descrs)
+ descrs.append(item_descrs)
+ return descrs
+
+ def get_args_for_fail(self, modifier):
+ if self.box is None and not modifier.already_seen_virtual(self.keybox):
+ itemdescrs = self._get_list_of_descrs()
+ itemboxes = []
+ for i in range(len(self._items)):
+ for descr in itemdescrs[i]:
+ itemboxes.append(self._items[i][descr].get_key_box())
+ modifier.register_virtual_fields(self.keybox, itemboxes)
+ for i in range(len(self._items)):
+ for descr in itemdescrs[i]:
+ self._items[i][descr].get_args_for_fail(modifier)
+
+ def force_at_end_of_preamble(self, already_forced, optforce):
+ if self in already_forced:
+ return self
+ already_forced[self] = self
+ for index in range(len(self._items)):
+ for descr in self._items[index].keys():
+ self._items[index][descr] = self._items[index][descr].force_at_end_of_preamble(already_forced, optforce)
+ return self
+
+ def _make_virtual(self, modifier):
+ return modifier.make_varraystruct(self.arraydescr, self._get_list_of_descrs())
+
+
class OptVirtualize(optimizer.Optimization):
"Virtualize objects until they escape."
@@ -283,8 +346,11 @@
return vvalue
def make_varray(self, arraydescr, size, box, source_op=None):
- constvalue = self.new_const_item(arraydescr)
- vvalue = VArrayValue(arraydescr, constvalue, size, box, source_op)
+ if arraydescr.is_array_of_structs():
+ vvalue = VArrayStructValue(arraydescr, size, box, source_op)
+ else:
+ constvalue = self.new_const_item(arraydescr)
+ vvalue = VArrayValue(arraydescr, constvalue, size, box, source_op)
self.make_equal_to(box, vvalue)
return vvalue
@@ -386,8 +452,7 @@
def optimize_NEW_ARRAY(self, op):
sizebox = self.get_constant_box(op.getarg(0))
- # For now we can't make arrays of structs virtual.
- if sizebox is not None and not op.getdescr().is_array_of_structs():
+ if sizebox is not None:
# if the original 'op' did not have a ConstInt as argument,
# build a new one with the ConstInt argument
if not isinstance(op.getarg(0), ConstInt):
@@ -432,6 +497,34 @@
value.ensure_nonnull()
self.emit_operation(op)
+ def optimize_GETINTERIORFIELD_GC(self, op):
+ value = self.getvalue(op.getarg(0))
+ if value.is_virtual():
+ indexbox = self.get_constant_box(op.getarg(1))
+ if indexbox is not None:
+ descr = op.getdescr()
+ fieldvalue = value.getinteriorfield(
+ indexbox.getint(), descr, None
+ )
+ if fieldvalue is None:
+ fieldvalue = self.new_const(descr)
+ self.make_equal_to(op.result, fieldvalue)
+ return
+ value.ensure_nonnull()
+ self.emit_operation(op)
+
+ def optimize_SETINTERIORFIELD_GC(self, op):
+ value = self.getvalue(op.getarg(0))
+ if value.is_virtual():
+ indexbox = self.get_constant_box(op.getarg(1))
+ if indexbox is not None:
+ value.setinteriorfield(
+ indexbox.getint(), op.getdescr(), self.getvalue(op.getarg(2))
+ )
+ return
+ value.ensure_nonnull()
+ self.emit_operation(op)
+
dispatch_opt = make_dispatcher_method(OptVirtualize, 'optimize_',
default=OptVirtualize.emit_operation)
diff --git a/pypy/jit/metainterp/optimizeopt/virtualstate.py b/pypy/jit/metainterp/optimizeopt/virtualstate.py
--- a/pypy/jit/metainterp/optimizeopt/virtualstate.py
+++ b/pypy/jit/metainterp/optimizeopt/virtualstate.py
@@ -16,7 +16,7 @@
class AbstractVirtualStateInfo(resume.AbstractVirtualInfo):
position = -1
-
+
def generalization_of(self, other, renum, bad):
raise NotImplementedError
@@ -54,7 +54,7 @@
s.debug_print(indent + " ", seen, bad)
else:
debug_print(indent + " ...")
-
+
def debug_header(self, indent):
raise NotImplementedError
@@ -77,13 +77,15 @@
bad[self] = True
bad[other] = True
return False
+
+ assert isinstance(other, AbstractVirtualStructStateInfo)
assert len(self.fielddescrs) == len(self.fieldstate)
assert len(other.fielddescrs) == len(other.fieldstate)
if len(self.fielddescrs) != len(other.fielddescrs):
bad[self] = True
bad[other] = True
return False
-
+
for i in range(len(self.fielddescrs)):
if other.fielddescrs[i] is not self.fielddescrs[i]:
bad[self] = True
@@ -112,8 +114,8 @@
def _enum(self, virtual_state):
for s in self.fieldstate:
s.enum(virtual_state)
-
-
+
+
class VirtualStateInfo(AbstractVirtualStructStateInfo):
def __init__(self, known_class, fielddescrs):
AbstractVirtualStructStateInfo.__init__(self, fielddescrs)
@@ -128,13 +130,13 @@
def debug_header(self, indent):
debug_print(indent + 'VirtualStateInfo(%d):' % self.position)
-
+
class VStructStateInfo(AbstractVirtualStructStateInfo):
def __init__(self, typedescr, fielddescrs):
AbstractVirtualStructStateInfo.__init__(self, fielddescrs)
self.typedescr = typedescr
- def _generalization_of(self, other):
+ def _generalization_of(self, other):
if not isinstance(other, VStructStateInfo):
return False
if self.typedescr is not other.typedescr:
@@ -143,7 +145,7 @@
def debug_header(self, indent):
debug_print(indent + 'VStructStateInfo(%d):' % self.position)
-
+
class VArrayStateInfo(AbstractVirtualStateInfo):
def __init__(self, arraydescr):
self.arraydescr = arraydescr
@@ -157,11 +159,7 @@
bad[other] = True
return False
renum[self.position] = other.position
- if not isinstance(other, VArrayStateInfo):
- bad[self] = True
- bad[other] = True
- return False
- if self.arraydescr is not other.arraydescr:
+ if not self._generalization_of(other):
bad[self] = True
bad[other] = True
return False
@@ -177,6 +175,10 @@
return False
return True
+ def _generalization_of(self, other):
+ return (isinstance(other, VArrayStateInfo) and
+ self.arraydescr is other.arraydescr)
+
def enum_forced_boxes(self, boxes, value, optimizer):
assert isinstance(value, virtualize.VArrayValue)
assert value.is_virtual()
@@ -192,8 +194,75 @@
def debug_header(self, indent):
debug_print(indent + 'VArrayStateInfo(%d):' % self.position)
-
-
+
+class VArrayStructStateInfo(AbstractVirtualStateInfo):
+ def __init__(self, arraydescr, fielddescrs):
+ self.arraydescr = arraydescr
+ self.fielddescrs = fielddescrs
+
+ def generalization_of(self, other, renum, bad):
+ assert self.position != -1
+ if self.position in renum:
+ if renum[self.position] == other.position:
+ return True
+ bad[self] = True
+ bad[other] = True
+ return False
+ renum[self.position] = other.position
+ if not self._generalization_of(other):
+ bad[self] = True
+ bad[other] = True
+ return False
+
+ assert isinstance(other, VArrayStructStateInfo)
+ if len(self.fielddescrs) != len(other.fielddescrs):
+ bad[self] = True
+ bad[other] = True
+ return False
+
+ p = 0
+ for i in range(len(self.fielddescrs)):
+ if len(self.fielddescrs[i]) != len(other.fielddescrs[i]):
+ bad[self] = True
+ bad[other] = True
+ return False
+ for j in range(len(self.fielddescrs[i])):
+ if self.fielddescrs[i][j] is not other.fielddescrs[i][j]:
+ bad[self] = True
+ bad[other] = True
+ return False
+ if not self.fieldstate[p].generalization_of(other.fieldstate[p],
+ renum, bad):
+ bad[self] = True
+ bad[other] = True
+ return False
+ p += 1
+ return True
+
+ def _generalization_of(self, other):
+ return (isinstance(other, VArrayStructStateInfo) and
+ self.arraydescr is other.arraydescr)
+
+ def _enum(self, virtual_state):
+ for s in self.fieldstate:
+ s.enum(virtual_state)
+
+ def enum_forced_boxes(self, boxes, value, optimizer):
+ assert isinstance(value, virtualize.VArrayStructValue)
+ assert value.is_virtual()
+ p = 0
+ for i in range(len(self.fielddescrs)):
+ for j in range(len(self.fielddescrs[i])):
+ v = value._items[i][self.fielddescrs[i][j]]
+ s = self.fieldstate[p]
+ if s.position > self.position:
+ s.enum_forced_boxes(boxes, v, optimizer)
+ p += 1
+
+ def debug_header(self, indent):
+ debug_print(indent + 'VArrayStructStateInfo(%d):' % self.position)
+
+
class NotVirtualStateInfo(AbstractVirtualStateInfo):
def __init__(self, value):
self.known_class = value.known_class
@@ -277,7 +346,7 @@
op = ResOperation(rop.GUARD_CLASS, [box, self.known_class], None)
extra_guards.append(op)
return
-
+
if self.level == LEVEL_NONNULL and \
other.level == LEVEL_UNKNOWN and \
isinstance(box, BoxPtr) and \
@@ -285,7 +354,7 @@
op = ResOperation(rop.GUARD_NONNULL, [box], None)
extra_guards.append(op)
return
-
+
if self.level == LEVEL_UNKNOWN and \
other.level == LEVEL_UNKNOWN and \
isinstance(box, BoxInt) and \
@@ -309,7 +378,7 @@
op = ResOperation(rop.GUARD_TRUE, [res], None)
extra_guards.append(op)
return
-
+
# Remaining cases are probably not interesting
raise InvalidLoop
if self.level == LEVEL_CONSTANT:
@@ -319,7 +388,7 @@
def enum_forced_boxes(self, boxes, value, optimizer):
if self.level == LEVEL_CONSTANT:
return
- assert 0 <= self.position_in_notvirtuals
+ assert 0 <= self.position_in_notvirtuals
boxes[self.position_in_notvirtuals] = value.force_box(optimizer)
def _enum(self, virtual_state):
@@ -348,7 +417,7 @@
lb = ''
if self.lenbound:
lb = ', ' + self.lenbound.bound.__repr__()
-
+
debug_print(indent + mark + 'NotVirtualInfo(%d' % self.position +
', ' + l + ', ' + self.intbound.__repr__() + lb + ')')
@@ -370,7 +439,7 @@
return False
return True
- def generate_guards(self, other, args, cpu, extra_guards):
+ def generate_guards(self, other, args, cpu, extra_guards):
assert len(self.state) == len(other.state) == len(args)
renum = {}
for i in range(len(self.state)):
@@ -393,7 +462,7 @@
inputargs.append(box)
assert None not in inputargs
-
+
return inputargs
def debug_print(self, hdr='', bad=None):
@@ -412,7 +481,7 @@
def register_virtual_fields(self, keybox, fieldboxes):
self.fieldboxes[keybox] = fieldboxes
-
+
def already_seen_virtual(self, keybox):
return keybox in self.fieldboxes
@@ -463,6 +532,9 @@
def make_varray(self, arraydescr):
return VArrayStateInfo(arraydescr)
+ def make_varraystruct(self, arraydescr, fielddescrs):
+ return VArrayStructStateInfo(arraydescr, fielddescrs)
+
class BoxNotProducable(Exception):
pass
@@ -501,12 +573,12 @@
else: # Low priority
lo -= 1
return alts
-
+
def renamed(self, box):
if box in self.rename:
return self.rename[box]
return box
-
+
def add_to_short(self, box, op):
if op:
op = op.clone()
@@ -528,12 +600,12 @@
self.optimizer.make_equal_to(newbox, value)
else:
self.short_boxes[box] = op
-
+
def produce_short_preamble_box(self, box):
if box in self.short_boxes:
- return
+ return
if isinstance(box, Const):
- return
+ return
if box in self.potential_ops:
ops = self.prioritized_alternatives(box)
produced_one = False
@@ -570,7 +642,7 @@
else:
debug_print(logops.repr_of_arg(box) + ': None')
debug_stop('jit-short-boxes')
-
+
def operations(self):
if not we_are_translated(): # For tests
ops = self.short_boxes.values()
@@ -588,7 +660,7 @@
if not isinstance(oldbox, Const) and newbox not in self.short_boxes:
self.short_boxes[newbox] = self.short_boxes[oldbox]
self.aliases[newbox] = oldbox
-
+
def original(self, box):
while box in self.aliases:
box = self.aliases[box]
diff --git a/pypy/jit/metainterp/optimizeopt/vstring.py b/pypy/jit/metainterp/optimizeopt/vstring.py
--- a/pypy/jit/metainterp/optimizeopt/vstring.py
+++ b/pypy/jit/metainterp/optimizeopt/vstring.py
@@ -163,17 +163,6 @@
for value in self._chars:
value.get_args_for_fail(modifier)
- def FIXME_enum_forced_boxes(self, boxes, already_seen):
- key = self.get_key_box()
- if key in already_seen:
- return
- already_seen[key] = None
- if self.box is None:
- for box in self._chars:
- box.enum_forced_boxes(boxes, already_seen)
- else:
- boxes.append(self.box)
-
def _make_virtual(self, modifier):
return modifier.make_vstrplain(self.mode is mode_unicode)
@@ -226,18 +215,6 @@
self.left.get_args_for_fail(modifier)
self.right.get_args_for_fail(modifier)
- def FIXME_enum_forced_boxes(self, boxes, already_seen):
- key = self.get_key_box()
- if key in already_seen:
- return
- already_seen[key] = None
- if self.box is None:
- self.left.enum_forced_boxes(boxes, already_seen)
- self.right.enum_forced_boxes(boxes, already_seen)
- self.lengthbox = None
- else:
- boxes.append(self.box)
-
def _make_virtual(self, modifier):
return modifier.make_vstrconcat(self.mode is mode_unicode)
@@ -284,18 +261,6 @@
self.vstart.get_args_for_fail(modifier)
self.vlength.get_args_for_fail(modifier)
- def FIXME_enum_forced_boxes(self, boxes, already_seen):
- key = self.get_key_box()
- if key in already_seen:
- return
- already_seen[key] = None
- if self.box is None:
- self.vstr.enum_forced_boxes(boxes, already_seen)
- self.vstart.enum_forced_boxes(boxes, already_seen)
- self.vlength.enum_forced_boxes(boxes, already_seen)
- else:
- boxes.append(self.box)
-
def _make_virtual(self, modifier):
return modifier.make_vstrslice(self.mode is mode_unicode)
diff --git a/pypy/jit/metainterp/pyjitpl.py b/pypy/jit/metainterp/pyjitpl.py
--- a/pypy/jit/metainterp/pyjitpl.py
+++ b/pypy/jit/metainterp/pyjitpl.py
@@ -240,8 +240,8 @@
return self.execute(rop.PTR_EQ, box, history.CONST_NULL)
@arguments("box")
- def opimpl_cast_opaque_ptr(self, box):
- return self.execute(rop.CAST_OPAQUE_PTR, box)
+ def opimpl_mark_opaque_ptr(self, box):
+ return self.execute(rop.MARK_OPAQUE_PTR, box)
@arguments("box")
def _opimpl_any_return(self, box):
diff --git a/pypy/jit/metainterp/resoperation.py b/pypy/jit/metainterp/resoperation.py
--- a/pypy/jit/metainterp/resoperation.py
+++ b/pypy/jit/metainterp/resoperation.py
@@ -439,7 +439,6 @@
'PTR_NE/2b',
'INSTANCE_PTR_EQ/2b',
'INSTANCE_PTR_NE/2b',
- 'CAST_OPAQUE_PTR/1b',
#
'ARRAYLEN_GC/1d',
'STRLEN/1',
@@ -471,6 +470,7 @@
'FORCE_TOKEN/0',
'VIRTUAL_REF/2', # removed before it's passed to the backend
'READ_TIMESTAMP/0',
+ 'MARK_OPAQUE_PTR/1b',
'_NOSIDEEFFECT_LAST', # ----- end of no_side_effect operations -----
'SETARRAYITEM_GC/3d',
diff --git a/pypy/jit/metainterp/resume.py b/pypy/jit/metainterp/resume.py
--- a/pypy/jit/metainterp/resume.py
+++ b/pypy/jit/metainterp/resume.py
@@ -139,7 +139,7 @@
self.numberings = {}
self.cached_boxes = {}
self.cached_virtuals = {}
-
+
self.nvirtuals = 0
self.nvholes = 0
self.nvreused = 0
@@ -273,6 +273,9 @@
def make_varray(self, arraydescr):
return VArrayInfo(arraydescr)
+ def make_varraystruct(self, arraydescr, fielddescrs):
+ return VArrayStructInfo(arraydescr, fielddescrs)
+
def make_vstrplain(self, is_unicode=False):
if is_unicode:
return VUniPlainInfo()
@@ -402,7 +405,7 @@
virtuals[num] = vinfo
if self._invalidation_needed(len(liveboxes), nholes):
- memo.clear_box_virtual_numbers()
+ memo.clear_box_virtual_numbers()
def _invalidation_needed(self, nliveboxes, nholes):
memo = self.memo
@@ -455,7 +458,7 @@
def debug_prints(self):
raise NotImplementedError
-
+
class AbstractVirtualStructInfo(AbstractVirtualInfo):
def __init__(self, fielddescrs):
self.fielddescrs = fielddescrs
@@ -537,6 +540,29 @@
for i in self.fieldnums:
debug_print("\t\t", str(untag(i)))
+
+class VArrayStructInfo(AbstractVirtualInfo):
+ def __init__(self, arraydescr, fielddescrs):
+ self.arraydescr = arraydescr
+ self.fielddescrs = fielddescrs
+
+ def debug_prints(self):
+ debug_print("\tvarraystructinfo", self.arraydescr)
+ for i in self.fieldnums:
+ debug_print("\t\t", str(untag(i)))
+
+ @specialize.argtype(1)
+ def allocate(self, decoder, index):
+ array = decoder.allocate_array(self.arraydescr, len(self.fielddescrs))
+ decoder.virtuals_cache[index] = array
+ p = 0
+ for i in range(len(self.fielddescrs)):
+ for j in range(len(self.fielddescrs[i])):
+ decoder.setinteriorfield(i, self.fielddescrs[i][j], array, self.fieldnums[p])
+ p += 1
+ return array
+
+
class VStrPlainInfo(AbstractVirtualInfo):
"""Stands for the string made out of the characters of all fieldnums."""
@@ -884,6 +910,17 @@
self.metainterp.execute_and_record(rop.SETFIELD_GC, descr,
structbox, fieldbox)
+ def setinteriorfield(self, index, descr, array, fieldnum):
+ if descr.is_pointer_field():
+ kind = REF
+ elif descr.is_float_field():
+ kind = FLOAT
+ else:
+ kind = INT
+ fieldbox = self.decode_box(fieldnum, kind)
+ self.metainterp.execute_and_record(rop.SETINTERIORFIELD_GC, descr,
+ array, ConstInt(index), fieldbox)
+
def setarrayitem_int(self, arraydescr, arraybox, index, fieldnum):
self._setarrayitem(arraydescr, arraybox, index, fieldnum, INT)
@@ -1164,6 +1201,17 @@
newvalue = self.decode_int(fieldnum)
self.cpu.bh_setfield_gc_i(struct, descr, newvalue)
+ def setinteriorfield(self, index, descr, array, fieldnum):
+ if descr.is_pointer_field():
+ newvalue = self.decode_ref(fieldnum)
+ self.cpu.bh_setinteriorfield_gc_r(array, index, descr, newvalue)
+ elif descr.is_float_field():
+ newvalue = self.decode_float(fieldnum)
+ self.cpu.bh_setinteriorfield_gc_f(array, index, descr, newvalue)
+ else:
+ newvalue = self.decode_int(fieldnum)
+ self.cpu.bh_setinteriorfield_gc_i(array, index, descr, newvalue)
+
def setarrayitem_int(self, arraydescr, array, index, fieldnum):
newvalue = self.decode_int(fieldnum)
self.cpu.bh_setarrayitem_gc_i(arraydescr, array, index, newvalue)
diff --git a/pypy/jit/metainterp/test/test_ajit.py b/pypy/jit/metainterp/test/test_ajit.py
--- a/pypy/jit/metainterp/test/test_ajit.py
+++ b/pypy/jit/metainterp/test/test_ajit.py
@@ -10,6 +10,7 @@
from pypy.jit.metainterp.typesystem import LLTypeHelper, OOTypeHelper
from pypy.jit.metainterp.warmspot import get_stats
from pypy.jit.metainterp.warmstate import set_future_value
+from pypy.rlib import rerased
from pypy.rlib.jit import (JitDriver, we_are_jitted, hint, dont_look_inside,
loop_invariant, elidable, promote, jit_debug, assert_green,
AssertGreenFailed, unroll_safe, current_trace_length, look_inside_iff,
@@ -3494,16 +3495,70 @@
d = None
while n > 0:
myjitdriver.jit_merge_point(n=n, d=d)
- d = {}
+ d = {"q": 1}
if n % 2:
d["k"] = n
else:
d["z"] = n
- n -= len(d)
+ n -= len(d) - d["q"]
return n
res = self.meta_interp(f, [10])
assert res == 0
+ def test_virtual_dict_constant_keys(self):
+ myjitdriver = JitDriver(greens = [], reds = ["n"])
+ def g(d):
+ return d["key"] - 1
+
+ def f(n):
+ while n > 0:
+ myjitdriver.jit_merge_point(n=n)
+ n = g({"key": n})
+ return n
+
+ res = self.meta_interp(f, [10])
+ assert res == 0
+ self.check_loops({"int_sub": 1, "int_gt": 1, "guard_true": 1, "jump": 1})
+
+ def test_virtual_opaque_ptr(self):
+ myjitdriver = JitDriver(greens = [], reds = ["n"])
+ erase, unerase = rerased.new_erasing_pair("x")
+ @look_inside_iff(lambda x: isvirtual(x))
+ def g(x):
+ return x[0]
+ def f(n):
+ while n > 0:
+ myjitdriver.jit_merge_point(n=n)
+ x = []
+ y = erase(x)
+ z = unerase(y)
+ z.append(1)
+ n -= g(z)
+ return n
+ res = self.meta_interp(f, [10])
+ assert res == 0
+ self.check_loops({"int_sub": 1, "int_gt": 1, "guard_true": 1, "jump": 1})
+
+ def test_virtual_opaque_dict(self):
+ myjitdriver = JitDriver(greens = [], reds = ["n"])
+ erase, unerase = rerased.new_erasing_pair("x")
+ @look_inside_iff(lambda x: isvirtual(x))
+ def g(x):
+ return x[0]["key"] - 1
+ def f(n):
+ while n > 0:
+ myjitdriver.jit_merge_point(n=n)
+ x = [{}]
+ x[0]["key"] = n
+ x[0]["other key"] = n
+ y = erase(x)
+ z = unerase(y)
+ n = g(x)
+ return n
+ res = self.meta_interp(f, [10])
+ assert res == 0
+ self.check_loops({"int_sub": 1, "int_gt": 1, "guard_true": 1, "jump": 1})
+
class TestLLtype(BaseLLtypeTests, LLJitMixin):
@@ -3561,8 +3616,7 @@
res = self.meta_interp(main, [False, 100, True], taggedpointers=True)
def test_rerased(self):
- from pypy.rlib.rerased import erase_int, unerase_int, new_erasing_pair
- eraseX, uneraseX = new_erasing_pair("X")
+ eraseX, uneraseX = rerased.new_erasing_pair("X")
#
class X:
def __init__(self, a, b):
@@ -3575,14 +3629,14 @@
e = eraseX(X(i, j))
else:
try:
- e = erase_int(i)
+ e = rerased.erase_int(i)
except OverflowError:
return -42
if j & 1:
x = uneraseX(e)
return x.a - x.b
else:
- return unerase_int(e)
+ return rerased.unerase_int(e)
#
x = self.interp_operations(f, [-128, 0], taggedpointers=True)
assert x == -128
diff --git a/pypy/jit/metainterp/test/test_heapcache.py b/pypy/jit/metainterp/test/test_heapcache.py
--- a/pypy/jit/metainterp/test/test_heapcache.py
+++ b/pypy/jit/metainterp/test/test_heapcache.py
@@ -371,3 +371,17 @@
assert h.is_unescaped(box1)
h.invalidate_caches(rop.SETARRAYITEM_GC, None, [box2, index1, box1])
assert not h.is_unescaped(box1)
+
+ h = HeapCache()
+ h.new_array(box1, lengthbox1)
+ h.new(box2)
+ assert h.is_unescaped(box1)
+ assert h.is_unescaped(box2)
+ h.invalidate_caches(rop.SETARRAYITEM_GC, None, [box1, lengthbox2, box2])
+ assert h.is_unescaped(box1)
+ assert h.is_unescaped(box2)
+ h.invalidate_caches(
+ rop.CALL, FakeCallDescr(FakeEffektinfo.EF_RANDOM_EFFECTS), [box1]
+ )
+ assert not h.is_unescaped(box1)
+ assert not h.is_unescaped(box2)
diff --git a/pypy/jit/metainterp/test/test_tracingopts.py b/pypy/jit/metainterp/test/test_tracingopts.py
--- a/pypy/jit/metainterp/test/test_tracingopts.py
+++ b/pypy/jit/metainterp/test/test_tracingopts.py
@@ -3,6 +3,7 @@
from pypy.jit.metainterp.test.support import LLJitMixin
from pypy.rlib import jit
from pypy.rlib.rarithmetic import ovfcheck
+from pypy.rlib.rstring import StringBuilder
import py
@@ -590,4 +591,14 @@
assert res == 4
self.check_operations_history(int_add_ovf=0)
res = self.interp_operations(fn, [sys.maxint])
- assert res == 12
\ No newline at end of file
+ assert res == 12
+
+ def test_copy_str_content(self):
+ def fn(n):
+ a = StringBuilder()
+ x = [1]
+ a.append("hello world")
+ return x[0]
+ res = self.interp_operations(fn, [0])
+ assert res == 1
+ self.check_operations_history(getarrayitem_gc=0, getarrayitem_gc_pure=0 )
\ No newline at end of file
diff --git a/pypy/module/pypyjit/test_pypy_c/test_call.py b/pypy/module/pypyjit/test_pypy_c/test_call.py
--- a/pypy/module/pypyjit/test_pypy_c/test_call.py
+++ b/pypy/module/pypyjit/test_pypy_c/test_call.py
@@ -465,3 +465,25 @@
setfield_gc(p4, p22, descr=<GcPtrFieldDescr pypy.interpreter.nestedscope.Cell.inst_w_value .*>)
jump(p0, p1, p2, p3, p4, p7, p22, p7, descr=<Loop0>)
""")
+
+ def test_kwargs_virtual(self):
+ def main(n):
+ def g(**kwargs):
+ return kwargs["x"] + 1
+
+ i = 0
+ while i < n:
+ i = g(x=i)
+ return i
+
+ log = self.run(main, [500])
+ assert log.result == 500
+ loop, = log.loops_by_filename(self.filepath)
+ assert loop.match("""
+ i2 = int_lt(i0, i1)
+ guard_true(i2, descr=...)
+ i3 = force_token()
+ i4 = int_add(i0, 1)
+ --TICK--
+ jump(..., descr=...)
+ """)
\ No newline at end of file
diff --git a/pypy/module/pypyjit/test_pypy_c/test_containers.py b/pypy/module/pypyjit/test_pypy_c/test_containers.py
--- a/pypy/module/pypyjit/test_pypy_c/test_containers.py
+++ b/pypy/module/pypyjit/test_pypy_c/test_containers.py
@@ -44,7 +44,7 @@
# gc_id call is hoisted out of the loop, the id of a value obviously
# can't change ;)
assert loop.match_by_id("getitem", """
- i28 = call(ConstClass(ll_dict_lookup__dicttablePtr_objectPtr_Signed), p18, p6, i25, descr=...)
+ i26 = call(ConstClass(ll_dict_lookup), p18, p6, i25, descr=...)
...
p33 = getinteriorfield_gc(p31, i26, descr=<InteriorFieldDescr <GcPtrFieldDescr dictentry.value .*>>)
...
diff --git a/pypy/rpython/lltypesystem/rdict.py b/pypy/rpython/lltypesystem/rdict.py
--- a/pypy/rpython/lltypesystem/rdict.py
+++ b/pypy/rpython/lltypesystem/rdict.py
@@ -445,9 +445,9 @@
i = ll_dict_lookup(d, key, hash)
return _ll_dict_setitem_lookup_done(d, key, value, hash, i)
-# Leaving as dont_look_inside ATM, it has a few branches which could lead to
-# many bridges if we don't consider their possible frequency.
- at jit.dont_look_inside
+# It may be safe to look inside always, it has a few branches though, and their
+# frequencies needs to be investigated.
+ at jit.look_inside_iff(lambda d, key, value, hash, i: jit.isvirtual(d) and jit.isconstant(key))
def _ll_dict_setitem_lookup_done(d, key, value, hash, i):
valid = (i & HIGHEST_BIT) == 0
i = i & MASK
@@ -533,7 +533,7 @@
# ------- a port of CPython's dictobject.c's lookdict implementation -------
PERTURB_SHIFT = 5
- at jit.dont_look_inside
+ at jit.look_inside_iff(lambda d, key, hash: jit.isvirtual(d) and jit.isconstant(key))
def ll_dict_lookup(d, key, hash):
entries = d.entries
ENTRIES = lltype.typeOf(entries).TO
More information about the pypy-commit
mailing list