Author: Carl Friedrich Bolz <[email protected]>
Branch:
Changeset: r81746:80bb10086af7
Date: 2016-01-13 21:43 +0100
http://bitbucket.org/pypy/pypy/changeset/80bb10086af7/
Log: merge
diff --git a/rpython/jit/metainterp/optimizeopt/heap.py
b/rpython/jit/metainterp/optimizeopt/heap.py
--- a/rpython/jit/metainterp/optimizeopt/heap.py
+++ b/rpython/jit/metainterp/optimizeopt/heap.py
@@ -32,8 +32,8 @@
# 1. 'cached_infos' is a list listing all the infos that are
# caching this descr
#
- # 2. we just did one setfield, which is delayed (and thus
- # not synchronized). 'lazy_setfield' is the delayed
+ # 2. we just did one set(field/arrayitem), which is delayed (and thus
+ # not synchronized). '_lazy_set' is the delayed
# ResOperation. In this state, 'cached_infos' contains
# out-of-date information. More precisely, the field
# value pending in the ResOperation is *not* visible in
@@ -41,7 +41,7 @@
#
self.cached_infos = []
self.cached_structs = []
- self._lazy_setfield = None
+ self._lazy_set = None
def register_info(self, structop, info):
# invariant: every struct or array ptr info, that is not virtual and
@@ -53,27 +53,27 @@
def produce_potential_short_preamble_ops(self, optimizer, shortboxes,
descr, index=-1):
- assert self._lazy_setfield is None
+ assert self._lazy_set is None
for i, info in enumerate(self.cached_infos):
structbox = optimizer.get_box_replacement(self.cached_structs[i])
info.produce_short_preamble_ops(structbox, descr, index, optimizer,
shortboxes)
def possible_aliasing(self, optheap, opinfo):
- # If lazy_setfield is set and contains a setfield on a different
+ # If lazy_set is set and contains a setfield on a different
# structvalue, then we are annoyed, because it may point to either
# the same or a different structure at runtime.
# XXX constants?
- return (self._lazy_setfield is not None
+ return (self._lazy_set is not None
and (not optheap.getptrinfo(
- self._lazy_setfield.getarg(0)).same_info(opinfo)))
+ self._lazy_set.getarg(0)).same_info(opinfo)))
def do_setfield(self, optheap, op):
# Update the state with the SETFIELD_GC/SETARRAYITEM_GC operation 'op'.
structinfo = optheap.ensure_ptr_info_arg0(op)
arg1 = optheap.get_box_replacement(self._get_rhs_from_set_op(op))
if self.possible_aliasing(optheap, structinfo):
- self.force_lazy_setfield(optheap, op.getdescr())
+ self.force_lazy_set(optheap, op.getdescr())
assert not self.possible_aliasing(optheap, structinfo)
cached_field = self._getfield(structinfo, op.getdescr(), optheap,
False)
if cached_field is not None:
@@ -86,27 +86,27 @@
# cached_fieldvalue = self._cached_fields.get(structvalue, None)
if not cached_field or not cached_field.same_box(arg1):
- # common case: store the 'op' as lazy_setfield
- self._lazy_setfield = op
+ # common case: store the 'op' as lazy_set
+ self._lazy_set = op
else:
# this is the case where the pending setfield ends up
# storing precisely the value that is already there,
# as proved by 'cached_fields'. In this case, we don't
- # need any _lazy_setfield: the heap value is already right.
- # Note that this may reset to None a non-None lazy_setfield,
+ # need any _lazy_set: the heap value is already right.
+ # Note that this may reset to None a non-None lazy_set,
# cancelling its previous effects with no side effect.
# Now, we have to force the item in the short preamble
self._getfield(structinfo, op.getdescr(), optheap)
- self._lazy_setfield = None
+ self._lazy_set = None
def getfield_from_cache(self, optheap, opinfo, descr):
# Returns the up-to-date field's value, or None if not cached.
if self.possible_aliasing(optheap, opinfo):
- self.force_lazy_setfield(optheap, descr)
- if self._lazy_setfield is not None:
- op = self._lazy_setfield
+ self.force_lazy_set(optheap, descr)
+ if self._lazy_set is not None:
+ op = self._lazy_set
return optheap.get_box_replacement(self._get_rhs_from_set_op(op))
else:
res = self._getfield(opinfo, descr, optheap)
@@ -114,15 +114,15 @@
return res.get_box_replacement()
return None
- def force_lazy_setfield(self, optheap, descr, can_cache=True):
- op = self._lazy_setfield
+ def force_lazy_set(self, optheap, descr, can_cache=True):
+ op = self._lazy_set
if op is not None:
- # This is the way _lazy_setfield is usually reset to None.
+ # This is the way _lazy_set is usually reset to None.
# Now we clear _cached_fields, because actually doing the
# setfield might impact any of the stored result (because of
# possible aliasing).
self.invalidate(descr)
- self._lazy_setfield = None
+ self._lazy_set = None
if optheap.postponed_op:
for a in op.getarglist():
if a is optheap.postponed_op:
@@ -250,7 +250,7 @@
def flush(self):
self.cached_dict_reads.clear()
self.corresponding_array_descrs.clear()
- self.force_all_lazy_setfields_and_arrayitems()
+ self.force_all_lazy_sets()
self.emit_postponed_op()
def emit_postponed_op(self):
@@ -326,7 +326,7 @@
return
if op.is_guard():
self.optimizer.pendingfields = (
- self.force_lazy_setfields_and_arrayitems_for_guard())
+ self.force_lazy_sets_for_guard())
return
opnum = op.getopnum()
if (opnum == rop.SETFIELD_GC or # handled specially
@@ -354,7 +354,7 @@
if not effectinfo.has_random_effects():
self.force_from_effectinfo(effectinfo)
return
- self.force_all_lazy_setfields_and_arrayitems()
+ self.force_all_lazy_sets()
self.clean_caches()
def optimize_CALL_I(self, op):
@@ -432,7 +432,7 @@
# XXX we can get the wrong complexity here, if the lists
# XXX stored on effectinfo are large
for fielddescr in effectinfo.readonly_descrs_fields:
- self.force_lazy_setfield(fielddescr)
+ self.force_lazy_set(fielddescr)
for arraydescr in effectinfo.readonly_descrs_arrays:
self.force_lazy_setarrayitem(arraydescr)
for fielddescr in effectinfo.write_descrs_fields:
@@ -442,7 +442,7 @@
del self.cached_dict_reads[fielddescr]
except KeyError:
pass
- self.force_lazy_setfield(fielddescr, can_cache=False)
+ self.force_lazy_set(fielddescr, can_cache=False)
for arraydescr in effectinfo.write_descrs_arrays:
self.force_lazy_setarrayitem(arraydescr, can_cache=False)
if arraydescr in self.corresponding_array_descrs:
@@ -453,16 +453,16 @@
pass # someone did it already
if effectinfo.check_forces_virtual_or_virtualizable():
vrefinfo = self.optimizer.metainterp_sd.virtualref_info
- self.force_lazy_setfield(vrefinfo.descr_forced)
+ self.force_lazy_set(vrefinfo.descr_forced)
# ^^^ we only need to force this field; the other fields
# of virtualref_info and virtualizable_info are not gcptrs.
- def force_lazy_setfield(self, descr, can_cache=True):
+ def force_lazy_set(self, descr, can_cache=True):
try:
cf = self.cached_fields[descr]
except KeyError:
return
- cf.force_lazy_setfield(self, descr, can_cache)
+ cf.force_lazy_set(self, descr, can_cache)
def force_lazy_setarrayitem(self, arraydescr, indexb=None, can_cache=True):
try:
@@ -471,35 +471,35 @@
return
for idx, cf in submap.iteritems():
if indexb is None or indexb.contains(idx):
- cf.force_lazy_setfield(self, None, can_cache)
+ cf.force_lazy_set(self, None, can_cache)
- def force_all_lazy_setfields_and_arrayitems(self):
+ def force_all_lazy_sets(self):
items = self.cached_fields.items()
if not we_are_translated():
items.sort(key=str, reverse=True)
for descr, cf in items:
- cf.force_lazy_setfield(self, descr)
+ cf.force_lazy_set(self, descr)
for submap in self.cached_arrayitems.itervalues():
for index, cf in submap.iteritems():
- cf.force_lazy_setfield(self, None)
+ cf.force_lazy_set(self, None)
- def force_lazy_setfields_and_arrayitems_for_guard(self):
+ def force_lazy_sets_for_guard(self):
pendingfields = []
items = self.cached_fields.items()
if not we_are_translated():
items.sort(key=str, reverse=True)
for descr, cf in items:
- op = cf._lazy_setfield
+ op = cf._lazy_set
if op is None:
continue
val = op.getarg(1)
if self.optimizer.is_virtual(val):
pendingfields.append(op)
continue
- cf.force_lazy_setfield(self, descr)
+ cf.force_lazy_set(self, descr)
for descr, submap in self.cached_arrayitems.iteritems():
for index, cf in submap.iteritems():
- op = cf._lazy_setfield
+ op = cf._lazy_set
if op is None:
continue
# the only really interesting case that we need to handle in
the
@@ -511,7 +511,7 @@
if self.optimizer.is_virtual(op.getarg(2)):
pendingfields.append(op)
else:
- cf.force_lazy_setfield(self, descr)
+ cf.force_lazy_set(self, descr)
return pendingfields
def optimize_GETFIELD_GC_I(self, op):
diff --git a/rpython/jit/metainterp/optimizeopt/info.py
b/rpython/jit/metainterp/optimizeopt/info.py
--- a/rpython/jit/metainterp/optimizeopt/info.py
+++ b/rpython/jit/metainterp/optimizeopt/info.py
@@ -528,6 +528,7 @@
if self._items is None:
self._items = [None] * (index + 1)
if index >= len(self._items):
+ assert not self.is_virtual()
self._items = self._items + [None] * (index - len(self._items) + 1)
self._items[index] = op
if cf is not None:
_______________________________________________
pypy-commit mailing list
[email protected]
https://mail.python.org/mailman/listinfo/pypy-commit
