[pypy-commit] pypy default: Merging jit-optimizeopt-cleanups. It makes the the different
hakanardo
noreply at buildbot.pypy.org
Mon Oct 3 21:06:50 CEST 2011
Author: Hakan Ardo <hakan at debian.org>
Branch:
Changeset: r47803:f79884ba173a
Date: 2011-10-03 21:05 +0200
http://bitbucket.org/pypy/pypy/changeset/f79884ba173a/
Log: Merging jit-optimizeopt-cleanups. It makes the the different
Optimization stages of optimizeopt more stricly follow the model of
emitting operations to the next stage instead of manipulating
Optimizer.newoperations directly. This means fewer optimizations are
prevented due to unwanted interactions between the different stages
(for example test_remove_duplicate_pure_op_ovf_with_lazy_setfield).
Operations produced by forcing boxes are emitted by the stage doing
the forcing. Two new Optimization stages have been intorduced,
OptPure and OptEarlyForce. OptEarlyForce forces things early in the
chain and thus allows the following stages to work on the ops
produced (moste notable the OptHeap and OptPure stages).
Operations produced as an effect of forincing a lazy setfiled are
still not seen by OptHeap. The main task remaining there is to
refactor OptHeap to make it able to recieve new setfield operations
during the execution of force_lazy_XXX, force_from_effectinfo,
force_all_lazy_XXX, ...
diff --git a/pypy/jit/metainterp/optimizeopt/__init__.py b/pypy/jit/metainterp/optimizeopt/__init__.py
--- a/pypy/jit/metainterp/optimizeopt/__init__.py
+++ b/pypy/jit/metainterp/optimizeopt/__init__.py
@@ -7,6 +7,8 @@
from pypy.jit.metainterp.optimizeopt.unroll import optimize_unroll, OptInlineShortPreamble
from pypy.jit.metainterp.optimizeopt.fficall import OptFfiCall
from pypy.jit.metainterp.optimizeopt.simplify import OptSimplify
+from pypy.jit.metainterp.optimizeopt.pure import OptPure
+from pypy.jit.metainterp.optimizeopt.earlyforce import OptEarlyForce
from pypy.rlib.jit import PARAMETERS
from pypy.rlib.unroll import unrolling_iterable
@@ -14,6 +16,8 @@
('rewrite', OptRewrite),
('virtualize', OptVirtualize),
('string', OptString),
+ ('earlyforce', OptEarlyForce),
+ ('pure', OptPure),
('heap', OptHeap),
('ffi', None),
('unroll', None)]
diff --git a/pypy/jit/metainterp/optimizeopt/earlyforce.py b/pypy/jit/metainterp/optimizeopt/earlyforce.py
new file mode 100644
--- /dev/null
+++ b/pypy/jit/metainterp/optimizeopt/earlyforce.py
@@ -0,0 +1,24 @@
+from pypy.jit.metainterp.optimizeopt.optimizer import Optimization
+from pypy.jit.metainterp.optimizeopt.vstring import VAbstractStringValue
+from pypy.jit.metainterp.resoperation import rop, ResOperation
+
+class OptEarlyForce(Optimization):
+ def propagate_forward(self, op):
+ opnum = op.getopnum()
+ if (opnum != rop.SETFIELD_GC and
+ opnum != rop.SETARRAYITEM_GC and
+ opnum != rop.QUASIIMMUT_FIELD):
+
+ for arg in op.getarglist():
+ if arg in self.optimizer.values:
+ value = self.getvalue(arg)
+ value.force_box(self)
+ self.emit_operation(op)
+
+ def new(self):
+ return OptEarlyForce()
+
+ def setup(self):
+ self.optimizer.optearlyforce = self
+
+
diff --git a/pypy/jit/metainterp/optimizeopt/fficall.py b/pypy/jit/metainterp/optimizeopt/fficall.py
--- a/pypy/jit/metainterp/optimizeopt/fficall.py
+++ b/pypy/jit/metainterp/optimizeopt/fficall.py
@@ -177,10 +177,10 @@
funcinfo.descr is None):
return [op] # cannot optimize
funcsymval = self.getvalue(op.getarg(2))
- arglist = [funcsymval.force_box()]
+ arglist = [funcsymval.get_key_box()]
for push_op in funcinfo.opargs:
argval = self.getvalue(push_op.getarg(2))
- arglist.append(argval.force_box())
+ arglist.append(argval.get_key_box())
newop = ResOperation(rop.CALL_RELEASE_GIL, arglist, op.result,
descr=funcinfo.descr)
self.commit_optimization()
diff --git a/pypy/jit/metainterp/optimizeopt/heap.py b/pypy/jit/metainterp/optimizeopt/heap.py
--- a/pypy/jit/metainterp/optimizeopt/heap.py
+++ b/pypy/jit/metainterp/optimizeopt/heap.py
@@ -50,6 +50,7 @@
if not self._lazy_setfield_registered:
optheap._lazy_setfields_and_arrayitems.append(self)
self._lazy_setfield_registered = True
+
else:
# this is the case where the pending setfield ends up
# storing precisely the value that is already there,
@@ -158,12 +159,17 @@
self._lazy_setfields_and_arrayitems = []
self._remove_guard_not_invalidated = False
self._seen_guard_not_invalidated = False
+ self.posponedop = None
def force_at_end_of_preamble(self):
self.force_all_lazy_setfields_and_arrayitems()
def flush(self):
self.force_all_lazy_setfields_and_arrayitems()
+ if self.posponedop:
+ posponedop = self.posponedop
+ self.posponedop = None
+ self.next_optimization.propagate_forward(posponedop)
def new(self):
return OptHeap()
@@ -211,7 +217,15 @@
def emit_operation(self, op):
self.emitting_operation(op)
- self.next_optimization.propagate_forward(op)
+ if self.posponedop:
+ posponedop = self.posponedop
+ self.posponedop = None
+ self.next_optimization.propagate_forward(posponedop)
+ if (op.is_comparison() or op.getopnum() == rop.CALL_MAY_FORCE
+ or op.is_ovf()):
+ self.posponedop = op
+ else:
+ self.next_optimization.propagate_forward(op)
def emitting_operation(self, op):
if op.has_no_side_effect():
@@ -293,30 +307,6 @@
if indexvalue is None or indexvalue.intbound.contains(idx):
cf.force_lazy_setfield(self, can_cache)
- def fixup_guard_situation(self):
- # hackish: reverse the order of the last two operations if it makes
- # sense to avoid a situation like "int_eq/setfield_gc/guard_true",
- # which the backend (at least the x86 backend) does not handle well.
- newoperations = self.optimizer.newoperations
- if len(newoperations) < 2:
- return
- lastop = newoperations[-1]
- if (lastop.getopnum() != rop.SETFIELD_GC and
- lastop.getopnum() != rop.SETARRAYITEM_GC):
- return
- # - is_comparison() for cases like "int_eq/setfield_gc/guard_true"
- # - CALL_MAY_FORCE: "call_may_force/setfield_gc/guard_not_forced"
- # - is_ovf(): "int_add_ovf/setfield_gc/guard_no_overflow"
- prevop = newoperations[-2]
- opnum = prevop.getopnum()
- if not (prevop.is_comparison() or opnum == rop.CALL_MAY_FORCE
- or prevop.is_ovf()):
- return
- if prevop.result in lastop.getarglist():
- return
- newoperations[-2] = lastop
- newoperations[-1] = prevop
-
def _assert_valid_cf(self, cf):
# check that 'cf' is in cached_fields or cached_arrayitems
if not we_are_translated():
@@ -362,7 +352,6 @@
fieldvalue.get_key_box(), itemindex))
else:
cf.force_lazy_setfield(self)
- self.fixup_guard_situation()
return pendingfields
def optimize_GETFIELD_GC(self, op):
@@ -374,12 +363,22 @@
return
# default case: produce the operation
structvalue.ensure_nonnull()
- ###self.optimizer.optimize_default(op)
self.emit_operation(op)
# then remember the result of reading the field
fieldvalue = self.getvalue(op.result)
cf.remember_field_value(structvalue, fieldvalue, op)
+ def optimize_GETFIELD_GC_PURE(self, op):
+ structvalue = self.getvalue(op.getarg(0))
+ cf = self.field_cache(op.getdescr())
+ fieldvalue = cf.getfield_from_cache(self, structvalue)
+ if fieldvalue is not None:
+ self.make_equal_to(op.result, fieldvalue)
+ return
+ # default case: produce the operation
+ structvalue.ensure_nonnull()
+ self.emit_operation(op)
+
def optimize_SETFIELD_GC(self, op):
if self.has_pure_result(rop.GETFIELD_GC_PURE, [op.getarg(0)],
op.getdescr()):
@@ -389,6 +388,7 @@
#
cf = self.field_cache(op.getdescr())
cf.do_setfield(self, op)
+
def optimize_GETARRAYITEM_GC(self, op):
arrayvalue = self.getvalue(op.getarg(0))
@@ -413,6 +413,25 @@
fieldvalue = self.getvalue(op.result)
cf.remember_field_value(arrayvalue, fieldvalue, op)
+ def optimize_GETARRAYITEM_GC_PURE(self, op):
+ arrayvalue = self.getvalue(op.getarg(0))
+ indexvalue = self.getvalue(op.getarg(1))
+ cf = None
+ if indexvalue.is_constant():
+ arrayvalue.make_len_gt(MODE_ARRAY, op.getdescr(), indexvalue.box.getint())
+ # use the cache on (arraydescr, index), which is a constant
+ cf = self.arrayitem_cache(op.getdescr(), indexvalue.box.getint())
+ fieldvalue = cf.getfield_from_cache(self, arrayvalue)
+ if fieldvalue is not None:
+ self.make_equal_to(op.result, fieldvalue)
+ return
+ else:
+ # variable index, so make sure the lazy setarrayitems are done
+ self.force_lazy_setarrayitem(op.getdescr(), indexvalue=indexvalue)
+ # default case: produce the operation
+ arrayvalue.ensure_nonnull()
+ self.emit_operation(op)
+
def optimize_SETARRAYITEM_GC(self, op):
if self.has_pure_result(rop.GETARRAYITEM_GC_PURE, [op.getarg(0),
op.getarg(1)],
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
@@ -31,8 +31,8 @@
class OptValue(object):
__metaclass__ = extendabletype
- _attrs_ = ('box', 'known_class', 'last_guard_index', 'level', 'intbound', 'lenbound')
- last_guard_index = -1
+ _attrs_ = ('box', 'known_class', 'last_guard', 'level', 'intbound', 'lenbound')
+ last_guard = None
level = LEVEL_UNKNOWN
known_class = None
@@ -100,7 +100,7 @@
self.make_constant(other.get_key_box())
optimizer.turned_constant(self)
elif other.level == LEVEL_KNOWNCLASS:
- self.make_constant_class(other.known_class, -1)
+ self.make_constant_class(other.known_class, None)
else:
if other.level == LEVEL_NONNULL:
self.ensure_nonnull()
@@ -114,13 +114,13 @@
self.lenbound = other.lenbound.clone()
- def force_box(self):
+ def force_box(self, optforce):
return self.box
def get_key_box(self):
return self.box
- def force_at_end_of_preamble(self, already_forced):
+ def force_at_end_of_preamble(self, already_forced, optforce):
return self
def get_args_for_fail(self, modifier):
@@ -162,16 +162,16 @@
else:
return None
- def make_constant_class(self, classbox, opindex):
+ def make_constant_class(self, classbox, guardop):
assert self.level < LEVEL_KNOWNCLASS
self.known_class = classbox
self.level = LEVEL_KNOWNCLASS
- self.last_guard_index = opindex
+ self.last_guard = guardop
- def make_nonnull(self, opindex):
+ def make_nonnull(self, guardop):
assert self.level < LEVEL_NONNULL
self.level = LEVEL_NONNULL
- self.last_guard_index = opindex
+ self.last_guard = guardop
def is_nonnull(self):
level = self.level
@@ -240,26 +240,12 @@
def __init__(self):
pass # make rpython happy
- def propagate_begin_forward(self):
- if self.next_optimization:
- self.next_optimization.propagate_begin_forward()
-
- def propagate_end_forward(self):
- if self.next_optimization:
- self.next_optimization.propagate_end_forward()
-
def propagate_forward(self, op):
raise NotImplementedError
def emit_operation(self, op):
self.next_optimization.propagate_forward(op)
- def test_emittable(self, op):
- return self.is_emittable(op)
-
- def is_emittable(self, op):
- return self.next_optimization.test_emittable(op)
-
# FIXME: Move some of these here?
def getvalue(self, box):
return self.optimizer.getvalue(box)
@@ -289,19 +275,19 @@
return self.optimizer.new_const_item(arraydescr)
def pure(self, opnum, args, result):
- op = ResOperation(opnum, args, result)
- key = self.optimizer.make_args_key(op)
- if key not in self.optimizer.pure_operations:
- self.optimizer.pure_operations[key] = op
+ if self.optimizer.optpure:
+ self.optimizer.optpure.pure(opnum, args, result)
def has_pure_result(self, opnum, args, descr):
- op = ResOperation(opnum, args, None, descr)
- key = self.optimizer.make_args_key(op)
- op = self.optimizer.pure_operations.get(key, None)
- if op is None:
- return False
- return op.getdescr() is descr
+ if self.optimizer.optpure:
+ return self.optimizer.optpure.has_pure_result(opnum, args, descr)
+ return False
+ def get_pure_result(self, key):
+ if self.optimizer.optpure:
+ return self.optimizer.optpure.get_pure_result(key)
+ return None
+
def setup(self):
pass
@@ -322,6 +308,9 @@
def produce_potential_short_preamble_ops(self, potential_ops):
pass
+ def forget_numberings(self, box):
+ self.optimizer.forget_numberings(box)
+
class Optimizer(Optimization):
def __init__(self, metainterp_sd, loop, optimizations=None, bridge=False):
@@ -333,14 +322,16 @@
self.interned_refs = self.cpu.ts.new_ref_dict()
self.resumedata_memo = resume.ResumeDataLoopMemo(metainterp_sd)
self.bool_boxes = {}
- self.pure_operations = args_dict()
self.producer = {}
self.pendingfields = []
- self.posponedop = None
self.exception_might_have_happened = False
self.quasi_immutable_deps = None
self.opaque_pointers = {}
- self.newoperations = []
+ self.replaces_guard = {}
+ self._newoperations = []
+ self.optimizer = self
+ self.optpure = None
+ self.optearlyforce = None
if loop is not None:
self.call_pure_results = loop.call_pure_results
@@ -369,21 +360,20 @@
def flush(self):
for o in self.optimizations:
o.flush()
- assert self.posponedop is None
def new(self):
new = Optimizer(self.metainterp_sd, self.loop)
return self._new(new)
def _new(self, new):
- assert self.posponedop is None
optimizations = [o.new() for o in self.optimizations]
new.set_optimizations(optimizations)
new.quasi_immutable_deps = self.quasi_immutable_deps
return new
def produce_potential_short_preamble_ops(self, sb):
- raise NotImplementedError('This is implemented in unroll.UnrollableOptimizer')
+ for opt in self.optimizations:
+ opt.produce_potential_short_preamble_ops(sb)
def turned_constant(self, value):
for o in self.optimizations:
@@ -433,6 +423,13 @@
return constbox
return None
+ def get_newoperations(self):
+ self.flush()
+ return self._newoperations
+
+ def clear_newoperations(self):
+ self._newoperations = []
+
def make_equal_to(self, box, value, replace=False):
assert isinstance(value, OptValue)
assert replace or box not in self.values
@@ -481,15 +478,10 @@
def propagate_all_forward(self):
self.exception_might_have_happened = self.bridge
- self.newoperations = []
- self.first_optimization.propagate_begin_forward()
- self.i = 0
- while self.i < len(self.loop.operations):
- op = self.loop.operations[self.i]
+ self.clear_newoperations()
+ for op in self.loop.operations:
self.first_optimization.propagate_forward(op)
- self.i += 1
- self.first_optimization.propagate_end_forward()
- self.loop.operations = self.newoperations
+ self.loop.operations = self.get_newoperations()
self.loop.quasi_immutable_deps = self.quasi_immutable_deps
# accumulate counters
self.resumedata_memo.update_counters(self.metainterp_sd.profiler)
@@ -501,9 +493,6 @@
self.producer[op.result] = op
dispatch_opt(self, op)
- def test_emittable(self, op):
- return True
-
def emit_operation(self, op):
if op.returns_bool_result():
self.bool_boxes[self.getvalue(op.result)] = None
@@ -519,14 +508,30 @@
pass
else:
self.ensure_imported(value)
- op.setarg(i, value.force_box())
+ op.setarg(i, value.force_box(self))
self.metainterp_sd.profiler.count(jitprof.OPT_OPS)
if op.is_guard():
self.metainterp_sd.profiler.count(jitprof.OPT_GUARDS)
- op = self.store_final_boxes_in_guard(op)
+ if self.replaces_guard and op in self.replaces_guard:
+ self.replace_op(self.replaces_guard[op], op)
+ del self.replaces_guard[op]
+ return
+ else:
+ op = self.store_final_boxes_in_guard(op)
elif op.can_raise():
self.exception_might_have_happened = True
- self.newoperations.append(op)
+ self._newoperations.append(op)
+
+ def replace_op(self, old_op, new_op):
+ # XXX: Do we want to cache indexes to prevent search?
+ i = len(self._newoperations)
+ while i > 0:
+ i -= 1
+ if self._newoperations[i] is old_op:
+ self._newoperations[i] = new_op
+ break
+ else:
+ assert False
def store_final_boxes_in_guard(self, op):
descr = op.getdescr()
@@ -574,51 +579,8 @@
args[n + 1] = op.getdescr()
return args
- @specialize.argtype(0)
def optimize_default(self, op):
- canfold = op.is_always_pure()
- if op.is_ovf():
- self.posponedop = op
- return
- if self.posponedop:
- nextop = op
- op = self.posponedop
- self.posponedop = None
- canfold = nextop.getopnum() == rop.GUARD_NO_OVERFLOW
- else:
- nextop = None
-
- if canfold:
- for i in range(op.numargs()):
- if self.get_constant_box(op.getarg(i)) is None:
- break
- else:
- # all constant arguments: constant-fold away
- resbox = self.constant_fold(op)
- # note that INT_xxx_OVF is not done from here, and the
- # overflows in the INT_xxx operations are ignored
- self.make_constant(op.result, resbox)
- return
-
- # did we do the exact same operation already?
- args = self.make_args_key(op)
- oldop = self.pure_operations.get(args, None)
- if oldop is not None and oldop.getdescr() is op.getdescr():
- assert oldop.getopnum() == op.getopnum()
- self.make_equal_to(op.result, self.getvalue(oldop.result),
- True)
- return
- else:
- self.pure_operations[args] = op
- self.remember_emitting_pure(op)
-
- # otherwise, the operation remains
self.emit_operation(op)
- if nextop:
- self.emit_operation(nextop)
-
- def remember_emitting_pure(self, op):
- pass
def constant_fold(self, op):
argboxes = [self.get_constant_box(op.getarg(i))
@@ -636,11 +598,6 @@
def optimize_DEBUG_MERGE_POINT(self, op):
self.emit_operation(op)
- def optimize_CAST_OPAQUE_PTR(self, op):
- value = self.getvalue(op.getarg(0))
- self.opaque_pointers[value] = True
- self.make_equal_to(op.result, value)
-
def optimize_GETARRAYITEM_GC_PURE(self, op):
indexvalue = self.getvalue(op.getarg(1))
if indexvalue.is_constant():
diff --git a/pypy/jit/metainterp/optimizeopt/pure.py b/pypy/jit/metainterp/optimizeopt/pure.py
new file mode 100644
--- /dev/null
+++ b/pypy/jit/metainterp/optimizeopt/pure.py
@@ -0,0 +1,115 @@
+from pypy.jit.metainterp.optimizeopt.optimizer import Optimization
+from pypy.jit.metainterp.resoperation import rop, ResOperation
+from pypy.jit.metainterp.optimizeopt.util import (make_dispatcher_method,
+ args_dict)
+
+class OptPure(Optimization):
+ def __init__(self):
+ self.posponedop = None
+ self.pure_operations = args_dict()
+ self.emitted_pure_operations = {}
+
+ def propagate_forward(self, op):
+ dispatch_opt(self, op)
+
+ def optimize_default(self, op):
+ canfold = op.is_always_pure()
+ if op.is_ovf():
+ self.posponedop = op
+ return
+ if self.posponedop:
+ nextop = op
+ op = self.posponedop
+ self.posponedop = None
+ canfold = nextop.getopnum() == rop.GUARD_NO_OVERFLOW
+ else:
+ nextop = None
+
+ if canfold:
+ for i in range(op.numargs()):
+ if self.get_constant_box(op.getarg(i)) is None:
+ break
+ else:
+ # all constant arguments: constant-fold away
+ resbox = self.optimizer.constant_fold(op)
+ # note that INT_xxx_OVF is not done from here, and the
+ # overflows in the INT_xxx operations are ignored
+ self.optimizer.make_constant(op.result, resbox)
+ return
+
+ # did we do the exact same operation already?
+ args = self.optimizer.make_args_key(op)
+ oldop = self.pure_operations.get(args, None)
+ if oldop is not None and oldop.getdescr() is op.getdescr():
+ assert oldop.getopnum() == op.getopnum()
+ self.optimizer.make_equal_to(op.result, self.getvalue(oldop.result),
+ True)
+ return
+ else:
+ self.pure_operations[args] = op
+ self.remember_emitting_pure(op)
+
+ # otherwise, the operation remains
+ self.emit_operation(op)
+ if op.returns_bool_result():
+ self.optimizer.bool_boxes[self.getvalue(op.result)] = None
+ if nextop:
+ self.emit_operation(nextop)
+
+ def optimize_CALL_PURE(self, op):
+ args = self.optimizer.make_args_key(op)
+ oldop = self.pure_operations.get(args, None)
+ if oldop is not None and oldop.getdescr() is op.getdescr():
+ assert oldop.getopnum() == op.getopnum()
+ self.make_equal_to(op.result, self.getvalue(oldop.result))
+ return
+ else:
+ self.pure_operations[args] = op
+ self.remember_emitting_pure(op)
+
+ # replace CALL_PURE with just CALL
+ args = op.getarglist()
+ self.emit_operation(ResOperation(rop.CALL, args, op.result,
+ op.getdescr()))
+
+ def flush(self):
+ assert self.posponedop is None
+
+ def new(self):
+ assert self.posponedop is None
+ return OptPure()
+
+ def setup(self):
+ self.optimizer.optpure = self
+
+ def pure(self, opnum, args, result):
+ op = ResOperation(opnum, args, result)
+ key = self.optimizer.make_args_key(op)
+ if key not in self.pure_operations:
+ self.pure_operations[key] = op
+
+ def has_pure_result(self, opnum, args, descr):
+ op = ResOperation(opnum, args, None, descr)
+ key = self.optimizer.make_args_key(op)
+ op = self.pure_operations.get(key, None)
+ if op is None:
+ return False
+ return op.getdescr() is descr
+
+ def get_pure_result(self, key):
+ return self.pure_operations.get(key, None)
+
+ def remember_emitting_pure(self, op):
+ self.emitted_pure_operations[op] = True
+
+ def produce_potential_short_preamble_ops(self, sb):
+ for op in self.emitted_pure_operations:
+ if op.getopnum() == rop.GETARRAYITEM_GC_PURE or \
+ op.getopnum() == rop.STRGETITEM or \
+ op.getopnum() == rop.UNICODEGETITEM:
+ if not self.getvalue(op.getarg(1)).is_constant():
+ continue
+ sb.add_potential(op)
+
+dispatch_opt = make_dispatcher_method(OptPure, 'optimize_',
+ default=OptPure.optimize_default)
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
@@ -31,21 +31,8 @@
dispatch_opt(self, op)
- def test_emittable(self, op):
- opnum = op.getopnum()
- for value, cls, func in optimize_guards:
- if opnum == value:
- assert isinstance(op, cls)
- try:
- func(self, op, dryrun=True)
- return self.is_emittable(op)
- except InvalidLoop:
- return False
- return self.is_emittable(op)
-
-
def try_boolinvers(self, op, targs):
- oldop = self.optimizer.pure_operations.get(targs, None)
+ oldop = self.get_pure_result(targs)
if oldop is not None and oldop.getdescr() is op.getdescr():
value = self.getvalue(oldop.result)
if value.is_constant():
@@ -73,7 +60,7 @@
oldopnum = opboolreflex[op.getopnum()] # FIXME: add INT_ADD, INT_MUL
targs = self.optimizer.make_args_key(ResOperation(oldopnum, [args[1], args[0]],
None))
- oldop = self.optimizer.pure_operations.get(targs, None)
+ oldop = self.get_pure_result(targs)
if oldop is not None and oldop.getdescr() is op.getdescr():
self.make_equal_to(op.result, self.getvalue(oldop.result))
return True
@@ -214,40 +201,7 @@
self.emit_operation(op)
self.pure(rop.FLOAT_NEG, [op.result], v1)
- def optimize_CALL_PURE(self, op):
- arg_consts = []
- for i in range(op.numargs()):
- arg = op.getarg(i)
- const = self.get_constant_box(arg)
- if const is None:
- break
- arg_consts.append(const)
- else:
- # all constant arguments: check if we already know the result
- try:
- result = self.optimizer.call_pure_results[arg_consts]
- except KeyError:
- pass
- else:
- self.make_constant(op.result, result)
- return
-
- args = self.optimizer.make_args_key(op)
- oldop = self.optimizer.pure_operations.get(args, None)
- if oldop is not None and oldop.getdescr() is op.getdescr():
- assert oldop.getopnum() == op.getopnum()
- self.make_equal_to(op.result, self.getvalue(oldop.result))
- return
- else:
- self.optimizer.pure_operations[args] = op
- self.optimizer.remember_emitting_pure(op)
-
- # replace CALL_PURE with just CALL
- args = op.getarglist()
- self.emit_operation(ResOperation(rop.CALL, args, op.result,
- op.getdescr()))
-
- def optimize_guard(self, op, constbox, emit_operation=True, dryrun=False):
+ def optimize_guard(self, op, constbox, emit_operation=True):
value = self.getvalue(op.getarg(0))
if value.is_constant():
box = value.box
@@ -255,62 +209,57 @@
if not box.same_constant(constbox):
raise InvalidLoop
return
- if dryrun: return
if emit_operation:
self.emit_operation(op)
value.make_constant(constbox)
self.optimizer.turned_constant(value)
- def optimize_GUARD_ISNULL(self, op, dryrun=False):
+ def optimize_GUARD_ISNULL(self, op):
value = self.getvalue(op.getarg(0))
if value.is_null():
return
elif value.is_nonnull():
raise InvalidLoop
- if dryrun: return
self.emit_operation(op)
value.make_constant(self.optimizer.cpu.ts.CONST_NULL)
- def optimize_GUARD_NONNULL(self, op, dryrun=False):
+ def optimize_GUARD_NONNULL(self, op):
value = self.getvalue(op.getarg(0))
if value.is_nonnull():
return
elif value.is_null():
raise InvalidLoop
- if dryrun: return
self.emit_operation(op)
- value.make_nonnull(len(self.optimizer.newoperations) - 1)
+ value.make_nonnull(op)
- def optimize_GUARD_VALUE(self, op, dryrun=False):
+ def optimize_GUARD_VALUE(self, op):
value = self.getvalue(op.getarg(0))
- emit_operation = True
- if not dryrun and value.last_guard_index != -1:
+ if value.last_guard:
# there already has been a guard_nonnull or guard_class or
# guard_nonnull_class on this value, which is rather silly.
# replace the original guard with a guard_value
- old_guard_op = self.optimizer.newoperations[value.last_guard_index]
- new_guard_op = old_guard_op.copy_and_change(rop.GUARD_VALUE,
- args = [old_guard_op.getarg(0), op.getarg(1)])
- self.optimizer.newoperations[value.last_guard_index] = new_guard_op
+ old_guard_op = value.last_guard
+ op = old_guard_op.copy_and_change(rop.GUARD_VALUE,
+ args = [old_guard_op.getarg(0), op.getarg(1)])
+ self.optimizer.replaces_guard[op] = old_guard_op
# hack hack hack. Change the guard_opnum on
# new_guard_op.getdescr() so that when resuming,
# the operation is not skipped by pyjitpl.py.
- descr = new_guard_op.getdescr()
+ descr = op.getdescr()
assert isinstance(descr, compile.ResumeGuardDescr)
descr.guard_opnum = rop.GUARD_VALUE
- descr.make_a_counter_per_value(new_guard_op)
- emit_operation = False
+ descr.make_a_counter_per_value(op)
constbox = op.getarg(1)
assert isinstance(constbox, Const)
- self.optimize_guard(op, constbox, emit_operation, dryrun)
+ self.optimize_guard(op, constbox)
- def optimize_GUARD_TRUE(self, op, dryrun=False):
- self.optimize_guard(op, CONST_1, dryrun=dryrun)
+ def optimize_GUARD_TRUE(self, op):
+ self.optimize_guard(op, CONST_1)
- def optimize_GUARD_FALSE(self, op, dryrun=False):
- self.optimize_guard(op, CONST_0, dryrun=dryrun)
+ def optimize_GUARD_FALSE(self, op):
+ self.optimize_guard(op, CONST_0)
- def optimize_GUARD_CLASS(self, op, dryrun=False):
+ def optimize_GUARD_CLASS(self, op):
value = self.getvalue(op.getarg(0))
expectedclassbox = op.getarg(1)
assert isinstance(expectedclassbox, Const)
@@ -319,38 +268,32 @@
if realclassbox.same_constant(expectedclassbox):
return
raise InvalidLoop
- if dryrun: return
- emit_operation = True
- if value.last_guard_index != -1:
+ if value.last_guard:
# there already has been a guard_nonnull or guard_class or
# guard_nonnull_class on this value.
- old_guard_op = self.optimizer.newoperations[value.last_guard_index]
+ old_guard_op = value.last_guard
if old_guard_op.getopnum() == rop.GUARD_NONNULL:
# it was a guard_nonnull, which we replace with a
# guard_nonnull_class.
- new_guard_op = old_guard_op.copy_and_change (rop.GUARD_NONNULL_CLASS,
+ op = old_guard_op.copy_and_change (rop.GUARD_NONNULL_CLASS,
args = [old_guard_op.getarg(0), op.getarg(1)])
- self.optimizer.newoperations[value.last_guard_index] = new_guard_op
+ self.optimizer.replaces_guard[op] = old_guard_op
# hack hack hack. Change the guard_opnum on
# new_guard_op.getdescr() so that when resuming,
# the operation is not skipped by pyjitpl.py.
- descr = new_guard_op.getdescr()
+ descr = op.getdescr()
assert isinstance(descr, compile.ResumeGuardDescr)
descr.guard_opnum = rop.GUARD_NONNULL_CLASS
- emit_operation = False
- if emit_operation:
- self.emit_operation(op)
- last_guard_index = len(self.optimizer.newoperations) - 1
- else:
- last_guard_index = value.last_guard_index
- value.make_constant_class(expectedclassbox, last_guard_index)
+ self.emit_operation(op)
+ value.make_constant_class(expectedclassbox, op)
- def optimize_GUARD_NONNULL_CLASS(self, op, dryrun=False):
- self.optimize_GUARD_NONNULL(op, True)
- self.optimize_GUARD_CLASS(op, dryrun)
+ def optimize_GUARD_NONNULL_CLASS(self, op):
+ value = self.getvalue(op.getarg(0))
+ if value.is_null():
+ raise InvalidLoop
+ self.optimize_GUARD_CLASS(op)
- def optimize_GUARD_NO_EXCEPTION(self, op, dryrun=False):
- if dryrun: return
+ def optimize_GUARD_NO_EXCEPTION(self, op):
if not self.optimizer.exception_might_have_happened:
return
self.emit_operation(op)
@@ -470,7 +413,7 @@
newop = ResOperation(rop.SETARRAYITEM_GC,
[op.getarg(2),
ConstInt(index + dest_start),
- val.force_box()], None,
+ val.get_key_box()], None,
descr=source_value.arraydescr)
self.emit_operation(newop)
return True
@@ -478,6 +421,25 @@
return True # 0-length arraycopy
return False
+ def optimize_CALL_PURE(self, op):
+ arg_consts = []
+ for i in range(op.numargs()):
+ arg = op.getarg(i)
+ const = self.get_constant_box(arg)
+ if const is None:
+ break
+ arg_consts.append(const)
+ else:
+ # all constant arguments: check if we already know the result
+ try:
+ result = self.optimizer.call_pure_results[arg_consts]
+ except KeyError:
+ pass
+ else:
+ self.make_constant(op.result, result)
+ return
+ self.emit_operation(op)
+
def optimize_INT_FLOORDIV(self, op):
v1 = self.getvalue(op.getarg(0))
v2 = self.getvalue(op.getarg(1))
@@ -492,6 +454,10 @@
args = [op.getarg(0), ConstInt(highest_bit(val))])
self.emit_operation(op)
+ def optimize_CAST_OPAQUE_PTR(self, op):
+ value = self.getvalue(op.getarg(0))
+ self.optimizer.opaque_pointers[value] = True
+ self.make_equal_to(op.result, value)
dispatch_opt = make_dispatcher_method(OptRewrite, 'optimize_',
default=OptRewrite.emit_operation)
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
@@ -39,8 +39,9 @@
def test_sharing_field_lists_of_virtual():
class FakeOptimizer(object):
- class cpu(object):
- pass
+ class optimizer(object):
+ class cpu(object):
+ pass
opt = FakeOptimizer()
virt1 = virtualize.AbstractVirtualStructValue(opt, None)
lst1 = virt1._get_field_descr_list()
@@ -69,7 +70,7 @@
class FakeVirtualValue(virtualize.AbstractVirtualValue):
def _make_virtual(self, *args):
return FakeVInfo()
- v1 = FakeVirtualValue(None, None, None)
+ v1 = FakeVirtualValue(None, None)
vinfo1 = v1.make_virtual_info(None, [1, 2, 4])
vinfo2 = v1.make_virtual_info(None, [1, 2, 4])
assert vinfo1 is vinfo2
@@ -111,7 +112,7 @@
class BaseTestBasic(BaseTest):
- enable_opts = "intbounds:rewrite:virtualize:string:heap"
+ enable_opts = "intbounds:rewrite:virtualize:string:earlyforce:pure:heap"
def optimize_loop(self, ops, optops, call_pure_results=None):
@@ -651,8 +652,8 @@
i3 = getfield_gc(p3, descr=valuedescr)
escape(i3)
p1 = new_with_vtable(ConstClass(node_vtable))
+ p1sub = new_with_vtable(ConstClass(node_vtable2))
setfield_gc(p1, i1, descr=valuedescr)
- p1sub = new_with_vtable(ConstClass(node_vtable2))
setfield_gc(p1sub, i1, descr=valuedescr)
setfield_gc(p1, p1sub, descr=nextdescr)
jump(i1, p1, p2)
@@ -667,10 +668,10 @@
p3sub = getfield_gc(p3, descr=nextdescr)
i3 = getfield_gc(p3sub, descr=valuedescr)
escape(i3)
+ p1 = new_with_vtable(ConstClass(node_vtable))
p2sub = new_with_vtable(ConstClass(node_vtable2))
setfield_gc(p2sub, i1, descr=valuedescr)
setfield_gc(p2, p2sub, descr=nextdescr)
- p1 = new_with_vtable(ConstClass(node_vtable))
jump(i1, p1, p2)
"""
# The same as test_p123_simple, but in the end the "old" p2 contains
diff --git a/pypy/jit/metainterp/optimizeopt/test/test_optimizefficall.py b/pypy/jit/metainterp/optimizeopt/test/test_optimizefficall.py
--- a/pypy/jit/metainterp/optimizeopt/test/test_optimizefficall.py
+++ b/pypy/jit/metainterp/optimizeopt/test/test_optimizefficall.py
@@ -36,7 +36,7 @@
class TestFfiCall(BaseTestBasic, LLtypeMixin):
- enable_opts = "intbounds:rewrite:virtualize:string:heap:ffi"
+ enable_opts = "intbounds:rewrite:virtualize:string:pure:earlyforce:heap:ffi"
class namespace:
cpu = LLtypeMixin.cpu
diff --git a/pypy/jit/metainterp/optimizeopt/test/test_optimizeopt.py b/pypy/jit/metainterp/optimizeopt/test/test_optimizeopt.py
--- a/pypy/jit/metainterp/optimizeopt/test/test_optimizeopt.py
+++ b/pypy/jit/metainterp/optimizeopt/test/test_optimizeopt.py
@@ -68,7 +68,7 @@
class BaseTestWithUnroll(BaseTest):
- enable_opts = "intbounds:rewrite:virtualize:string:heap:unroll"
+ enable_opts = "intbounds:rewrite:virtualize:string:earlyforce:pure:heap:unroll"
def optimize_loop(self, ops, expected, expected_preamble=None,
call_pure_results=None, expected_short=None):
@@ -825,8 +825,8 @@
i3 = getfield_gc(p2, descr=valuedescr)
escape(i3)
p4 = new_with_vtable(ConstClass(node_vtable))
+ p1sub = new_with_vtable(ConstClass(node_vtable2))
setfield_gc(p4, i1, descr=valuedescr)
- p1sub = new_with_vtable(ConstClass(node_vtable2))
setfield_gc(p1sub, i1, descr=valuedescr)
setfield_gc(p4, p1sub, descr=nextdescr)
jump(i1, p4)
@@ -865,13 +865,7 @@
p3sub = new_with_vtable(ConstClass(node_vtable2))
setfield_gc(p3sub, i1, descr=valuedescr)
setfield_gc(p1, p3sub, descr=nextdescr)
- # XXX: We get two extra operations here because the setfield
- # above is the result of forcing p1 and thus not
- # registered with the heap optimizer. I've makred tests
- # below with VIRTUALHEAP if they suffer from this issue
- p3sub2 = getfield_gc(p1, descr=nextdescr)
- guard_nonnull_class(p3sub2, ConstClass(node_vtable2)) []
- jump(i1, p1, p3sub2)
+ jump(i1, p1, p3sub)
"""
self.optimize_loop(ops, expected, preamble)
@@ -902,9 +896,7 @@
guard_true(i2b) []
p3 = new_with_vtable(ConstClass(node_vtable))
setfield_gc(p3, i2, descr=nextdescr)
- # XXX: VIRTUALHEAP (see above)
- i3 = getfield_gc(p3, descr=nextdescr)
- jump(p3, i3)
+ jump(p3, i2)
"""
self.optimize_loop(ops, expected, preamble)
@@ -1219,7 +1211,15 @@
setfield_gc(p3, p30, descr=valuedescr)
jump(i29, p30, p3)
"""
- expected = preamble
+ expected = """
+ [i0, p1, p3]
+ i28 = int_add(i0, 1)
+ i29 = int_add(i28, 1)
+ p30 = new_with_vtable(ConstClass(node_vtable))
+ setfield_gc(p3, p30, descr=valuedescr)
+ setfield_gc(p30, i28, descr=nextdescr)
+ jump(i29, p30, p3)
+ """
self.optimize_loop(ops, expected, preamble)
def test_nonvirtual_1(self):
@@ -2408,8 +2408,8 @@
guard_class(p2, ConstClass(node_vtable)) []
p3 = getfield_gc(p1, descr=otherdescr)
guard_class(p3, ConstClass(node_vtable)) []
+ p3a = new_with_vtable(ConstClass(node_vtable))
setfield_gc(p3, p2, descr=otherdescr)
- p3a = new_with_vtable(ConstClass(node_vtable))
escape(p3a)
jump(p3a)
"""
@@ -2421,9 +2421,9 @@
# setfield_gc(p3, p2, descr=otherdescr) # p3a.other = p2a
# p1a = new_with_vtable(ConstClass(node_vtable2))
# p2a = new_with_vtable(ConstClass(node_vtable))
+ p3anew = new_with_vtable(ConstClass(node_vtable))
p2 = new_with_vtable(ConstClass(node_vtable))
setfield_gc(p3a, p2, descr=otherdescr) # p3a.other = p2a
- p3anew = new_with_vtable(ConstClass(node_vtable))
escape(p3anew)
jump(p3anew)
"""
@@ -2458,9 +2458,9 @@
p3 = getfield_gc(p1, descr=otherdescr)
guard_class(p3, ConstClass(node_vtable)) []
# p1a = new_with_vtable(ConstClass(node_vtable2))
+ p3a = new_with_vtable(ConstClass(node_vtable))
p2a = new_with_vtable(ConstClass(node_vtable))
setfield_gc(p3, p2a, descr=otherdescr)
- p3a = new_with_vtable(ConstClass(node_vtable))
escape(p3a)
# setfield_gc(p1a, p2a, descr=nextdescr)
# setfield_gc(p1a, p3a, descr=otherdescr)
@@ -2468,9 +2468,9 @@
"""
expected = """
[p2, p3]
+ p3a = new_with_vtable(ConstClass(node_vtable))
p2a = new_with_vtable(ConstClass(node_vtable))
setfield_gc(p3, p2a, descr=otherdescr)
- p3a = new_with_vtable(ConstClass(node_vtable))
escape(p3a)
jump(p2a, p3a)
"""
@@ -2790,7 +2790,6 @@
self.optimize_loop(ops, expected, preamble)
def test_remove_duplicate_pure_op_ovf_with_lazy_setfield(self):
- py.test.skip('this optimization is not yet supprted')
ops = """
[i1, p1]
i3 = int_add_ovf(i1, 1)
@@ -5961,13 +5960,18 @@
escape(i0)
jump(p1)
"""
- expected = """
+ preamble = """
[p1]
i0 = ptr_eq(p1, NULL)
escape(i0)
- jump(p1)
- """
- self.optimize_strunicode_loop_extradescrs(ops, expected, expected)
+ jump(p1, i0)
+ """
+ expected = """
+ [p1, i0]
+ escape(i0)
+ jump(p1, i0)
+ """
+ self.optimize_strunicode_loop_extradescrs(ops, expected, preamble)
def test_str_equal_none2(self):
ops = """
@@ -5976,13 +5980,18 @@
escape(i0)
jump(p1)
"""
- expected = """
+ preamble = """
[p1]
i0 = ptr_eq(p1, NULL)
escape(i0)
- jump(p1)
- """
- self.optimize_strunicode_loop_extradescrs(ops, expected, expected)
+ jump(p1, i0)
+ """
+ expected = """
+ [p1, i0]
+ escape(i0)
+ jump(p1, i0)
+ """
+ self.optimize_strunicode_loop_extradescrs(ops, expected, preamble)
def test_str_equal_nonnull1(self):
ops = """
@@ -7220,6 +7229,29 @@
"""
self.optimize_loop(ops, expected)
+ def test_heap_cache_forced_virtuals(self):
+ ops = """
+ [i1, i2, p0]
+ p1 = new(descr=ssize)
+ setfield_gc(p1, i1, descr=adescr)
+ setfield_gc(p1, i2, descr=bdescr)
+ call(p0, p1, descr=writeadescr)
+ i3 = getfield_gc(p1, descr=adescr)
+ i4 = getfield_gc(p1, descr=bdescr)
+ jump(i3, i4, p0)
+ """
+ expected = """
+ [i1, i2, p0]
+ p1 = new(descr=ssize)
+ setfield_gc(p1, i1, descr=adescr)
+ call(p0, p1, descr=writeadescr)
+ i3 = getfield_gc(p1, descr=adescr)
+ setfield_gc(p1, i2, descr=bdescr)
+ jump(i3, i2, p0)
+ """
+ self.optimize_loop(ops, expected)
+
+
def test_setarrayitem_followed_by_arraycopy(self):
ops = """
[p1, p2]
@@ -7230,6 +7262,27 @@
"""
self.optimize_loop(ops, ops)
+ def test_heap_cache_virtuals_forced_by_delayed_setfield(self):
+ py.test.skip('not yet supoprted')
+ ops = """
+ [i1, p0]
+ p1 = new(descr=ssize)
+ setfield_gc(p1, i1, descr=valuedescr)
+ setfield_gc(p0, p1, descr=adescr)
+ call(p0, descr=writeadescr)
+ i2 = getfield_gc(p1, descr=valuedescr)
+ jump(i2, p0)
+ """
+ expected = """
+ [i1, p0]
+ p1 = new(descr=ssize)
+ setfield_gc(p1, i1, descr=valuedescr)
+ setfield_gc(p0, p1, descr=adescr)
+ call(p0, descr=writeadescr)
+ jump(i1, p0)
+ """
+ self.optimize_loop(ops, expected)
+
class TestLLtype(OptimizeOptTest, LLtypeMixin):
pass
diff --git a/pypy/jit/metainterp/optimizeopt/unroll.py b/pypy/jit/metainterp/optimizeopt/unroll.py
--- a/pypy/jit/metainterp/optimizeopt/unroll.py
+++ b/pypy/jit/metainterp/optimizeopt/unroll.py
@@ -75,7 +75,6 @@
self.importable_values = {}
self.emitting_dissabled = False
self.emitted_guards = 0
- self.emitted_pure_operations = {}
def ensure_imported(self, value):
if not self.emitting_dissabled and value in self.importable_values:
@@ -96,21 +95,6 @@
new = UnrollableOptimizer(self.metainterp_sd, self.loop)
return self._new(new)
- def remember_emitting_pure(self, op):
- self.emitted_pure_operations[op] = True
-
- def produce_potential_short_preamble_ops(self, sb):
- for op in self.emitted_pure_operations:
- if op.getopnum() == rop.GETARRAYITEM_GC_PURE or \
- op.getopnum() == rop.STRGETITEM or \
- op.getopnum() == rop.UNICODEGETITEM:
- if not self.getvalue(op.getarg(1)).is_constant():
- continue
- sb.add_potential(op)
- for opt in self.optimizations:
- opt.produce_potential_short_preamble_ops(sb)
-
-
class UnrollOptimizer(Optimization):
"""Unroll the loop into two iterations. The first one will
@@ -154,7 +138,7 @@
KillHugeIntBounds(self.optimizer).apply()
- loop.preamble.operations = self.optimizer.newoperations
+ loop.preamble.operations = self.optimizer.get_newoperations()
jump_args = [self.getvalue(a).get_key_box() for a in jump_args]
start_resumedescr = loop.preamble.start_resumedescr.clone_if_mutable()
@@ -167,8 +151,9 @@
virtual_state = modifier.get_virtual_state(jump_args)
values = [self.getvalue(arg) for arg in jump_args]
- inputargs = virtual_state.make_inputargs(values)
- short_inputargs = virtual_state.make_inputargs(values, keyboxes=True)
+ inputargs = virtual_state.make_inputargs(values, self.optimizer)
+ short_inputargs = virtual_state.make_inputargs(values, self.optimizer,
+ keyboxes=True)
self.constant_inputargs = {}
for box in jump_args:
@@ -197,7 +182,7 @@
# operations needed to setup the proper state of those virtuals
# in the peeled loop
inputarg_setup_ops = []
- preamble_optimizer.newoperations = []
+ preamble_optimizer.clear_newoperations()
seen = {}
for box in inputargs:
if box in seen:
@@ -211,9 +196,8 @@
continue
seen[box] = True
value = preamble_optimizer.getvalue(box)
- value.force_box()
- preamble_optimizer.flush()
- inputarg_setup_ops += preamble_optimizer.newoperations
+ value.force_box(preamble_optimizer)
+ inputarg_setup_ops += preamble_optimizer.get_newoperations()
# Setup the state of the new optimizer by emiting the
# short preamble operations and discarding the result
@@ -244,13 +228,13 @@
virtual_state)
loop.inputargs = inputargs
- args = [preamble_optimizer.getvalue(self.short_boxes.original(a)).force_box()\
+ args = [preamble_optimizer.getvalue(self.short_boxes.original(a)).force_box(preamble_optimizer)\
for a in inputargs]
jmp = ResOperation(rop.JUMP, args, None)
jmp.setdescr(loop.token)
loop.preamble.operations.append(jmp)
- loop.operations = self.optimizer.newoperations
+ loop.operations = self.optimizer.get_newoperations()
maxguards = self.optimizer.metainterp_sd.warmrunnerdesc.memory_manager.max_retrace_guards
if self.optimizer.emitted_guards > maxguards:
@@ -335,9 +319,10 @@
assert jumpop
original_jumpargs = jumpop.getarglist()[:]
values = [self.getvalue(arg) for arg in jumpop.getarglist()]
- jumpargs = virtual_state.make_inputargs(values)
+ jumpargs = virtual_state.make_inputargs(values, self.optimizer)
jumpop.initarglist(jumpargs)
- jmp_to_short_args = virtual_state.make_inputargs(values, keyboxes=True)
+ jmp_to_short_args = virtual_state.make_inputargs(values, self.optimizer,
+ keyboxes=True)
self.short_inliner = Inliner(short_inputargs, jmp_to_short_args)
for box, const in self.constant_inputargs.items():
@@ -347,11 +332,11 @@
newop = self.short_inliner.inline_op(op)
self.optimizer.send_extra_operation(newop)
- self.optimizer.flush()
+ newoperations = self.optimizer.get_newoperations()
i = j = 0
- while i < len(self.optimizer.newoperations) or j < len(jumpargs):
- if i == len(self.optimizer.newoperations):
+ while i < len(newoperations) or j < len(jumpargs):
+ if i == len(newoperations):
while j < len(jumpargs):
a = jumpargs[j]
if self.optimizer.loop.logops:
@@ -360,7 +345,7 @@
jumpargs, short_seen)
j += 1
else:
- op = self.optimizer.newoperations[i]
+ op = newoperations[i]
self.boxes_created_this_iteration[op.result] = True
args = op.getarglist()
@@ -375,6 +360,7 @@
self.import_box(a, inputargs, short, short_jumpargs,
jumpargs, short_seen)
i += 1
+ newoperations = self.optimizer.get_newoperations()
jumpop.initarglist(jumpargs)
self.optimizer.send_extra_operation(jumpop)
@@ -468,7 +454,7 @@
inputargs.append(box)
box = newresult
if box in self.optimizer.values:
- box = self.optimizer.values[box].force_box()
+ box = self.optimizer.values[box].force_box(self.optimizer)
jumpargs.append(box)
@@ -483,11 +469,6 @@
if op.getopnum() == rop.JUMP:
loop_token = op.getdescr()
assert isinstance(loop_token, LoopToken)
- # FIXME: Use a tree, similar to the tree formed by the full
- # preamble and it's bridges, instead of a list to save time and
- # memory. This should also allow better behaviour in
- # situations that the is_emittable() chain currently cant
- # handle and the inlining fails unexpectedly belwo.
short = loop_token.short_preamble
if short:
args = op.getarglist()
@@ -523,7 +504,7 @@
values = [self.getvalue(arg)
for arg in op.getarglist()]
- args = sh.virtual_state.make_inputargs(values,
+ args = sh.virtual_state.make_inputargs(values, self.optimizer,
keyboxes=True)
inliner = Inliner(sh.inputargs, args)
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
@@ -10,13 +10,12 @@
class AbstractVirtualValue(optimizer.OptValue):
- _attrs_ = ('optimizer', 'keybox', 'source_op', '_cached_vinfo')
+ _attrs_ = ('keybox', 'source_op', '_cached_vinfo')
box = None
level = optimizer.LEVEL_NONNULL
_cached_vinfo = None
- def __init__(self, optimizer, keybox, source_op=None):
- self.optimizer = optimizer
+ def __init__(self, keybox, source_op=None):
self.keybox = keybox # only used as a key in dictionaries
self.source_op = source_op # the NEW_WITH_VTABLE/NEW_ARRAY operation
# that builds this box
@@ -29,17 +28,17 @@
return self.keybox
return self.box
- def force_box(self):
+ def force_box(self, optforce):
if self.box is None:
- self.optimizer.forget_numberings(self.keybox)
- self._really_force()
+ optforce.forget_numberings(self.keybox)
+ self._really_force(optforce)
return self.box
- def force_at_end_of_preamble(self, already_forced):
+ def force_at_end_of_preamble(self, already_forced, optforce):
value = already_forced.get(self, None)
if value:
return value
- return OptValue(self.force_box())
+ return OptValue(self.force_box(optforce))
def make_virtual_info(self, modifier, fieldnums):
if fieldnums is None:
@@ -55,7 +54,7 @@
def _make_virtual(self, modifier):
raise NotImplementedError("abstract base")
- def _really_force(self):
+ def _really_force(self, optforce):
raise NotImplementedError("abstract base")
def import_from(self, other, optimizer):
@@ -70,10 +69,11 @@
get_fielddescrlist_cache._annspecialcase_ = "specialize:memo"
class AbstractVirtualStructValue(AbstractVirtualValue):
- _attrs_ = ('_fields', '_cached_sorted_fields')
+ _attrs_ = ('_fields', 'cpu', '_cached_sorted_fields')
- def __init__(self, optimizer, keybox, source_op=None):
- AbstractVirtualValue.__init__(self, optimizer, keybox, source_op)
+ def __init__(self, cpu, keybox, source_op=None):
+ AbstractVirtualValue.__init__(self, keybox, source_op)
+ self.cpu = cpu
self._fields = {}
self._cached_sorted_fields = None
@@ -87,45 +87,44 @@
def _get_descr(self):
raise NotImplementedError
- def _is_immutable_and_filled_with_constants(self):
+ def _is_immutable_and_filled_with_constants(self, optforce):
count = self._get_descr().count_fields_if_immutable()
if count != len(self._fields): # always the case if count == -1
return False
for value in self._fields.itervalues():
- subbox = value.force_box()
+ subbox = value.force_box(optforce)
if not isinstance(subbox, Const):
return False
return True
- def force_at_end_of_preamble(self, already_forced):
+ def force_at_end_of_preamble(self, already_forced, optforce):
if self in already_forced:
return self
already_forced[self] = self
if self._fields:
for ofs in self._fields.keys():
- self._fields[ofs] = self._fields[ofs].force_at_end_of_preamble(already_forced)
+ self._fields[ofs] = self._fields[ofs].force_at_end_of_preamble(already_forced, optforce)
return self
- def _really_force(self):
+ def _really_force(self, optforce):
op = self.source_op
assert op is not None
# ^^^ This case should not occur any more (see test_bug_3).
#
if not we_are_translated():
op.name = 'FORCE ' + self.source_op.name
-
- if self._is_immutable_and_filled_with_constants():
- box = self.optimizer.constant_fold(op)
+
+ if self._is_immutable_and_filled_with_constants(optforce):
+ box = optforce.optimizer.constant_fold(op)
self.make_constant(box)
for ofs, value in self._fields.iteritems():
- subbox = value.force_box()
+ subbox = value.force_box(optforce)
assert isinstance(subbox, Const)
- execute(self.optimizer.cpu, None, rop.SETFIELD_GC,
+ execute(optforce.optimizer.cpu, None, rop.SETFIELD_GC,
ofs, box, subbox)
# keep self._fields, because it's all immutable anyway
else:
- newoperations = self.optimizer.newoperations
- newoperations.append(op)
+ optforce.emit_operation(op)
self.box = box = op.result
#
iteritems = self._fields.iteritems()
@@ -135,10 +134,11 @@
for ofs, value in iteritems:
if value.is_null():
continue
- subbox = value.force_box()
+ subbox = value.force_box(optforce)
op = ResOperation(rop.SETFIELD_GC, [box, subbox], None,
descr=ofs)
- newoperations.append(op)
+
+ optforce.emit_operation(op)
def _get_field_descr_list(self):
_cached_sorted_fields = self._cached_sorted_fields
@@ -155,7 +155,7 @@
else:
lst = self._fields.keys()
sort_descrs(lst)
- cache = get_fielddescrlist_cache(self.optimizer.cpu)
+ cache = get_fielddescrlist_cache(self.cpu)
result = cache.get(lst, None)
if result is None:
cache[lst] = lst
@@ -180,8 +180,8 @@
class VirtualValue(AbstractVirtualStructValue):
level = optimizer.LEVEL_KNOWNCLASS
- def __init__(self, optimizer, known_class, keybox, source_op=None):
- AbstractVirtualStructValue.__init__(self, optimizer, keybox, source_op)
+ def __init__(self, cpu, known_class, keybox, source_op=None):
+ AbstractVirtualStructValue.__init__(self, cpu, keybox, source_op)
assert isinstance(known_class, Const)
self.known_class = known_class
@@ -190,7 +190,7 @@
return modifier.make_virtual(self.known_class, fielddescrs)
def _get_descr(self):
- return vtable2descr(self.optimizer.cpu, self.known_class.getint())
+ return vtable2descr(self.cpu, self.known_class.getint())
def __repr__(self):
cls_name = self.known_class.value.adr.ptr._obj._TYPE._name
@@ -201,8 +201,8 @@
class VStructValue(AbstractVirtualStructValue):
- def __init__(self, optimizer, structdescr, keybox, source_op=None):
- AbstractVirtualStructValue.__init__(self, optimizer, keybox, source_op)
+ def __init__(self, cpu, structdescr, keybox, source_op=None):
+ AbstractVirtualStructValue.__init__(self, cpu, keybox, source_op)
self.structdescr = structdescr
def _make_virtual(self, modifier):
@@ -215,10 +215,10 @@
class VArrayValue(AbstractVirtualValue):
- def __init__(self, optimizer, arraydescr, size, keybox, source_op=None):
- AbstractVirtualValue.__init__(self, optimizer, keybox, source_op)
+ def __init__(self, arraydescr, constvalue, size, keybox, source_op=None):
+ AbstractVirtualValue.__init__(self, keybox, source_op)
self.arraydescr = arraydescr
- self.constvalue = optimizer.new_const_item(arraydescr)
+ self.constvalue = constvalue
self._items = [self.constvalue] * size
def getlength(self):
@@ -232,31 +232,30 @@
assert isinstance(itemvalue, optimizer.OptValue)
self._items[index] = itemvalue
- def force_at_end_of_preamble(self, already_forced):
+ 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)):
- self._items[index] = self._items[index].force_at_end_of_preamble(already_forced)
+ self._items[index] = self._items[index].force_at_end_of_preamble(already_forced, optforce)
return self
- def _really_force(self):
+ 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
- newoperations = self.optimizer.newoperations
- newoperations.append(self.source_op)
+ optforce.emit_operation(self.source_op)
self.box = box = self.source_op.result
for index in range(len(self._items)):
subvalue = self._items[index]
if subvalue is not self.constvalue:
if subvalue.is_null():
continue
- subbox = subvalue.force_box()
+ subbox = subvalue.force_box(optforce)
op = ResOperation(rop.SETARRAYITEM_GC,
[box, ConstInt(index), subbox], None,
descr=self.arraydescr)
- newoperations.append(op)
+ optforce.emit_operation(op)
def get_args_for_fail(self, modifier):
if self.box is None and not modifier.already_seen_virtual(self.keybox):
@@ -279,17 +278,18 @@
return OptVirtualize()
def make_virtual(self, known_class, box, source_op=None):
- vvalue = VirtualValue(self.optimizer, known_class, box, source_op)
+ vvalue = VirtualValue(self.optimizer.cpu, known_class, box, source_op)
self.make_equal_to(box, vvalue)
return vvalue
def make_varray(self, arraydescr, size, box, source_op=None):
- vvalue = VArrayValue(self.optimizer, arraydescr, size, box, source_op)
+ constvalue = self.new_const_item(arraydescr)
+ vvalue = VArrayValue(arraydescr, constvalue, size, box, source_op)
self.make_equal_to(box, vvalue)
return vvalue
def make_vstruct(self, structdescr, box, source_op=None):
- vvalue = VStructValue(self.optimizer, structdescr, box, source_op)
+ vvalue = VStructValue(self.optimizer.cpu, structdescr, box, source_op)
self.make_equal_to(box, vvalue)
return vvalue
@@ -362,7 +362,6 @@
self.make_equal_to(op.result, fieldvalue)
else:
value.ensure_nonnull()
- ###self.heap_op_optimizer.optimize_GETFIELD_GC(op, value)
self.emit_operation(op)
# note: the following line does not mean that the two operations are
@@ -377,7 +376,6 @@
value.setfield(op.getdescr(), fieldvalue)
else:
value.ensure_nonnull()
- ###self.heap_op_optimizer.optimize_SETFIELD_GC(op, value, fieldvalue)
self.emit_operation(op)
def optimize_NEW_WITH_VTABLE(self, op):
@@ -417,7 +415,6 @@
self.make_equal_to(op.result, itemvalue)
return
value.ensure_nonnull()
- ###self.heap_op_optimizer.optimize_GETARRAYITEM_GC(op, value)
self.emit_operation(op)
# note: the following line does not mean that the two operations are
@@ -432,7 +429,6 @@
value.setitem(indexbox.getint(), self.getvalue(op.getarg(2)))
return
value.ensure_nonnull()
- ###self.heap_op_optimizer.optimize_SETARRAYITEM_GC(op, value, fieldvalue)
self.emit_operation(op)
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
@@ -30,7 +30,7 @@
def _generate_guards(self, other, box, cpu, extra_guards):
raise InvalidLoop
- def enum_forced_boxes(self, boxes, value):
+ def enum_forced_boxes(self, boxes, value, optimizer):
raise NotImplementedError
def enum(self, virtual_state):
@@ -100,14 +100,14 @@
def _generalization_of(self, other):
raise NotImplementedError
- def enum_forced_boxes(self, boxes, value):
+ def enum_forced_boxes(self, boxes, value, optimizer):
assert isinstance(value, virtualize.AbstractVirtualStructValue)
assert value.is_virtual()
for i in range(len(self.fielddescrs)):
v = value._fields[self.fielddescrs[i]]
s = self.fieldstate[i]
if s.position > self.position:
- s.enum_forced_boxes(boxes, v)
+ s.enum_forced_boxes(boxes, v, optimizer)
def _enum(self, virtual_state):
for s in self.fieldstate:
@@ -177,14 +177,14 @@
return False
return True
- def enum_forced_boxes(self, boxes, value):
+ def enum_forced_boxes(self, boxes, value, optimizer):
assert isinstance(value, virtualize.VArrayValue)
assert value.is_virtual()
for i in range(len(self.fieldstate)):
v = value._items[i]
s = self.fieldstate[i]
if s.position > self.position:
- s.enum_forced_boxes(boxes, v)
+ s.enum_forced_boxes(boxes, v, optimizer)
def _enum(self, virtual_state):
for s in self.fieldstate:
@@ -316,11 +316,11 @@
import pdb; pdb.set_trace()
raise NotImplementedError
- def enum_forced_boxes(self, boxes, value):
+ def enum_forced_boxes(self, boxes, value, optimizer):
if self.level == LEVEL_CONSTANT:
return
assert 0 <= self.position_in_notvirtuals
- boxes[self.position_in_notvirtuals] = value.force_box()
+ boxes[self.position_in_notvirtuals] = value.force_box(optimizer)
def _enum(self, virtual_state):
if self.level == LEVEL_CONSTANT:
@@ -377,11 +377,13 @@
self.state[i].generate_guards(other.state[i], args[i],
cpu, extra_guards, renum)
- def make_inputargs(self, values, keyboxes=False):
+ def make_inputargs(self, values, optimizer, keyboxes=False):
+ if optimizer.optearlyforce:
+ optimizer = optimizer.optearlyforce
assert len(values) == len(self.state)
inputargs = [None] * len(self.notvirtuals)
for i in range(len(values)):
- self.state[i].enum_forced_boxes(inputargs, values[i])
+ self.state[i].enum_forced_boxes(inputargs, values[i], optimizer)
if keyboxes:
for i in range(len(values)):
@@ -434,7 +436,12 @@
def get_virtual_state(self, jump_args):
self.optimizer.force_at_end_of_preamble()
already_forced = {}
- values = [self.getvalue(box).force_at_end_of_preamble(already_forced)
+ if self.optimizer.optearlyforce:
+ opt = self.optimizer.optearlyforce
+ else:
+ opt = self.optimizer
+ values = [self.getvalue(box).force_at_end_of_preamble(already_forced,
+ opt)
for box in jump_args]
for value in values:
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
@@ -43,7 +43,7 @@
class __extend__(optimizer.OptValue):
"""New methods added to the base class OptValue for this file."""
- def getstrlen(self, optimization, mode):
+ def getstrlen(self, string_optimizer, mode):
if mode is mode_string:
s = self.get_constant_string_spec(mode_string)
if s is not None:
@@ -52,12 +52,12 @@
s = self.get_constant_string_spec(mode_unicode)
if s is not None:
return ConstInt(len(s))
- if optimization is None:
+ if string_optimizer is None:
return None
self.ensure_nonnull()
- box = self.force_box()
+ box = self.force_box(string_optimizer)
lengthbox = BoxInt()
- optimization.propagate_forward(ResOperation(mode.STRLEN, [box], lengthbox))
+ string_optimizer.emit_operation(ResOperation(mode.STRLEN, [box], lengthbox))
return lengthbox
@specialize.arg(1)
@@ -68,25 +68,25 @@
else:
return None
- def string_copy_parts(self, optimizer, targetbox, offsetbox, mode):
+ def string_copy_parts(self, string_optimizer, targetbox, offsetbox, mode):
# Copies the pointer-to-string 'self' into the target string
# given by 'targetbox', at the specified offset. Returns the offset
# at the end of the copy.
- lengthbox = self.getstrlen(optimizer, mode)
- srcbox = self.force_box()
- return copy_str_content(optimizer, srcbox, targetbox,
+ lengthbox = self.getstrlen(string_optimizer, mode)
+ srcbox = self.force_box(string_optimizer)
+ return copy_str_content(string_optimizer, srcbox, targetbox,
CONST_0, offsetbox, lengthbox, mode)
class VAbstractStringValue(virtualize.AbstractVirtualValue):
_attrs_ = ('mode',)
- def __init__(self, optimizer, keybox, source_op, mode):
- virtualize.AbstractVirtualValue.__init__(self, optimizer, keybox,
+ def __init__(self, keybox, source_op, mode):
+ virtualize.AbstractVirtualValue.__init__(self, keybox,
source_op)
self.mode = mode
- def _really_force(self):
+ def _really_force(self, optforce):
if self.mode is mode_string:
s = self.get_constant_string_spec(mode_string)
if s is not None:
@@ -101,12 +101,12 @@
return
assert self.source_op is not None
self.box = box = self.source_op.result
- lengthbox = self.getstrlen(self.optimizer, self.mode)
+ lengthbox = self.getstrlen(optforce, self.mode)
op = ResOperation(self.mode.NEWSTR, [lengthbox], box)
if not we_are_translated():
op.name = 'FORCE'
- self.optimizer.emit_operation(op)
- self.string_copy_parts(self.optimizer, box, CONST_0, self.mode)
+ optforce.emit_operation(op)
+ self.string_copy_parts(optforce, box, CONST_0, self.mode)
class VStringPlainValue(VAbstractStringValue):
@@ -140,20 +140,20 @@
return mode.emptystr.join([mode.chr(c.box.getint())
for c in self._chars])
- def string_copy_parts(self, optimizer, targetbox, offsetbox, mode):
+ def string_copy_parts(self, string_optimizer, targetbox, offsetbox, mode):
if not self.is_virtual() and targetbox is not self.box:
- lengthbox = self.getstrlen(optimizer, mode)
- srcbox = self.force_box()
- return copy_str_content(optimizer, srcbox, targetbox,
+ lengthbox = self.getstrlen(string_optimizer, mode)
+ srcbox = self.force_box(string_optimizer)
+ return copy_str_content(string_optimizer, srcbox, targetbox,
CONST_0, offsetbox, lengthbox, mode)
for i in range(len(self._chars)):
- charbox = self._chars[i].force_box()
+ charbox = self._chars[i].force_box(string_optimizer)
if not (isinstance(charbox, Const) and charbox.same_constant(CONST_0)):
- optimizer.emit_operation(ResOperation(mode.STRSETITEM, [targetbox,
- offsetbox,
- charbox],
+ string_optimizer.emit_operation(ResOperation(mode.STRSETITEM, [targetbox,
+ offsetbox,
+ charbox],
None))
- offsetbox = _int_add(optimizer, offsetbox, CONST_1)
+ offsetbox = _int_add(string_optimizer, offsetbox, CONST_1)
return offsetbox
def get_args_for_fail(self, modifier):
@@ -187,16 +187,16 @@
self.left = left
self.right = right
- def getstrlen(self, optimizer, mode):
+ def getstrlen(self, string_optimizer, mode):
if self.lengthbox is None:
- len1box = self.left.getstrlen(optimizer, mode)
+ len1box = self.left.getstrlen(string_optimizer, mode)
if len1box is None:
return None
- len2box = self.right.getstrlen(optimizer, mode)
+ len2box = self.right.getstrlen(string_optimizer, mode)
if len2box is None:
return None
- self.lengthbox = _int_add(optimizer, len1box, len2box)
- # ^^^ may still be None, if optimizer is None
+ self.lengthbox = _int_add(string_optimizer, len1box, len2box)
+ # ^^^ may still be None, if string_optimizer is None
return self.lengthbox
@specialize.arg(1)
@@ -209,10 +209,10 @@
return None
return s1 + s2
- def string_copy_parts(self, optimizer, targetbox, offsetbox, mode):
- offsetbox = self.left.string_copy_parts(optimizer, targetbox,
+ def string_copy_parts(self, string_optimizer, targetbox, offsetbox, mode):
+ offsetbox = self.left.string_copy_parts(string_optimizer, targetbox,
offsetbox, mode)
- offsetbox = self.right.string_copy_parts(optimizer, targetbox,
+ offsetbox = self.right.string_copy_parts(string_optimizer, targetbox,
offsetbox, mode)
return offsetbox
@@ -251,8 +251,8 @@
self.vstart = vstart
self.vlength = vlength
- def getstrlen(self, _, mode):
- return self.vlength.force_box()
+ def getstrlen(self, optforce, mode):
+ return self.vlength.force_box(optforce)
@specialize.arg(1)
def get_constant_string_spec(self, mode):
@@ -267,11 +267,11 @@
return s1[start : start + length]
return None
- def string_copy_parts(self, optimizer, targetbox, offsetbox, mode):
- lengthbox = self.getstrlen(optimizer, mode)
- return copy_str_content(optimizer,
- self.vstr.force_box(), targetbox,
- self.vstart.force_box(), offsetbox,
+ def string_copy_parts(self, string_optimizer, targetbox, offsetbox, mode):
+ lengthbox = self.getstrlen(string_optimizer, mode)
+ return copy_str_content(string_optimizer,
+ self.vstr.force_box(string_optimizer), targetbox,
+ self.vstart.force_box(string_optimizer), offsetbox,
lengthbox, mode)
def get_args_for_fail(self, modifier):
@@ -300,7 +300,7 @@
return modifier.make_vstrslice(self.mode is mode_unicode)
-def copy_str_content(optimizer, srcbox, targetbox,
+def copy_str_content(string_optimizer, srcbox, targetbox,
srcoffsetbox, offsetbox, lengthbox, mode, need_next_offset=True):
if isinstance(srcbox, ConstPtr) and isinstance(srcoffsetbox, Const):
M = 5
@@ -310,26 +310,26 @@
# up to M characters are done "inline", i.e. with STRGETITEM/STRSETITEM
# instead of just a COPYSTRCONTENT.
for i in range(lengthbox.value):
- charbox = _strgetitem(optimizer, srcbox, srcoffsetbox, mode)
- srcoffsetbox = _int_add(optimizer, srcoffsetbox, CONST_1)
- optimizer.emit_operation(ResOperation(mode.STRSETITEM, [targetbox,
- offsetbox,
- charbox],
+ charbox = _strgetitem(string_optimizer, srcbox, srcoffsetbox, mode)
+ srcoffsetbox = _int_add(string_optimizer, srcoffsetbox, CONST_1)
+ string_optimizer.emit_operation(ResOperation(mode.STRSETITEM, [targetbox,
+ offsetbox,
+ charbox],
None))
- offsetbox = _int_add(optimizer, offsetbox, CONST_1)
+ offsetbox = _int_add(string_optimizer, offsetbox, CONST_1)
else:
if need_next_offset:
- nextoffsetbox = _int_add(optimizer, offsetbox, lengthbox)
+ nextoffsetbox = _int_add(string_optimizer, offsetbox, lengthbox)
else:
nextoffsetbox = None
op = ResOperation(mode.COPYSTRCONTENT, [srcbox, targetbox,
srcoffsetbox, offsetbox,
lengthbox], None)
- optimizer.emit_operation(op)
+ string_optimizer.emit_operation(op)
offsetbox = nextoffsetbox
return offsetbox
-def _int_add(optimizer, box1, box2):
+def _int_add(string_optimizer, box1, box2):
if isinstance(box1, ConstInt):
if box1.value == 0:
return box2
@@ -337,23 +337,23 @@
return ConstInt(box1.value + box2.value)
elif isinstance(box2, ConstInt) and box2.value == 0:
return box1
- if optimizer is None:
+ if string_optimizer is None:
return None
resbox = BoxInt()
- optimizer.propagate_forward(ResOperation(rop.INT_ADD, [box1, box2], resbox))
+ string_optimizer.emit_operation(ResOperation(rop.INT_ADD, [box1, box2], resbox))
return resbox
-def _int_sub(optimizer, box1, box2):
+def _int_sub(string_optimizer, box1, box2):
if isinstance(box2, ConstInt):
if box2.value == 0:
return box1
if isinstance(box1, ConstInt):
return ConstInt(box1.value - box2.value)
resbox = BoxInt()
- optimizer.propagate_forward(ResOperation(rop.INT_SUB, [box1, box2], resbox))
+ string_optimizer.emit_operation(ResOperation(rop.INT_SUB, [box1, box2], resbox))
return resbox
-def _strgetitem(optimizer, strbox, indexbox, mode):
+def _strgetitem(string_optimizer, strbox, indexbox, mode):
if isinstance(strbox, ConstPtr) and isinstance(indexbox, ConstInt):
if mode is mode_string:
s = strbox.getref(lltype.Ptr(rstr.STR))
@@ -362,30 +362,28 @@
s = strbox.getref(lltype.Ptr(rstr.UNICODE))
return ConstInt(ord(s.chars[indexbox.getint()]))
resbox = BoxInt()
- optimizer.propagate_forward(ResOperation(mode.STRGETITEM, [strbox, indexbox],
- resbox))
+ string_optimizer.emit_operation(ResOperation(mode.STRGETITEM, [strbox, indexbox],
+ resbox))
return resbox
class OptString(optimizer.Optimization):
"Handling of strings and unicodes."
- enabled = True
-
def new(self):
return OptString()
def make_vstring_plain(self, box, source_op, mode):
- vvalue = VStringPlainValue(self.optimizer, box, source_op, mode)
+ vvalue = VStringPlainValue(box, source_op, mode)
self.make_equal_to(box, vvalue)
return vvalue
def make_vstring_concat(self, box, source_op, mode):
- vvalue = VStringConcatValue(self.optimizer, box, source_op, mode)
+ vvalue = VStringConcatValue(box, source_op, mode)
self.make_equal_to(box, vvalue)
return vvalue
def make_vstring_slice(self, box, source_op, mode):
- vvalue = VStringSliceValue(self.optimizer, box, source_op, mode)
+ vvalue = VStringSliceValue(box, source_op, mode)
self.make_equal_to(box, vvalue)
return vvalue
@@ -435,9 +433,9 @@
value.ensure_nonnull()
#
if value.is_virtual() and isinstance(value, VStringSliceValue):
- fullindexbox = _int_add(self.optimizer,
- value.vstart.force_box(),
- vindex.force_box())
+ fullindexbox = _int_add(self,
+ value.vstart.force_box(self),
+ vindex.force_box(self))
value = value.vstr
vindex = self.getvalue(fullindexbox)
#
@@ -449,7 +447,7 @@
if res is not optimizer.CVAL_UNINITIALIZED_ZERO:
return res
#
- resbox = _strgetitem(self.optimizer, value.force_box(), vindex.force_box(), mode)
+ resbox = _strgetitem(self, value.force_box(self), vindex.force_box(self), mode)
return self.getvalue(resbox)
def optimize_STRLEN(self, op):
@@ -459,7 +457,7 @@
def _optimize_STRLEN(self, op, mode):
value = self.getvalue(op.getarg(0))
- lengthbox = value.getstrlen(self.optimizer, mode)
+ lengthbox = value.getstrlen(self, mode)
self.make_equal_to(op.result, self.getvalue(lengthbox))
def optimize_COPYSTRCONTENT(self, op):
@@ -477,12 +475,12 @@
if length.is_constant() and length.box.getint() == 0:
return
- copy_str_content(self.optimizer,
- src.force_box(),
- dst.force_box(),
- srcstart.force_box(),
- dststart.force_box(),
- length.force_box(),
+ copy_str_content(self,
+ src.force_box(self),
+ dst.force_box(self),
+ srcstart.force_box(self),
+ dststart.force_box(self),
+ length.force_box(self),
mode, need_next_offset=False
)
@@ -508,6 +506,8 @@
return
self.emit_operation(op)
+ optimize_CALL_PURE = optimize_CALL
+
def opt_call_str_STR2UNICODE(self, op):
# Constant-fold unicode("constant string").
# More generally, supporting non-constant but virtual cases is
@@ -547,16 +547,16 @@
return True
#
vstr.ensure_nonnull()
- lengthbox = _int_sub(self.optimizer, vstop.force_box(),
- vstart.force_box())
+ lengthbox = _int_sub(self, vstop.force_box(self),
+ vstart.force_box(self))
#
if isinstance(vstr, VStringSliceValue):
# double slicing s[i:j][k:l]
vintermediate = vstr
vstr = vintermediate.vstr
- startbox = _int_add(self.optimizer,
- vintermediate.vstart.force_box(),
- vstart.force_box())
+ startbox = _int_add(self,
+ vintermediate.vstart.force_box(self),
+ vstart.force_box(self))
vstart = self.getvalue(startbox)
#
value = self.make_vstring_slice(op.result, op, mode)
@@ -594,8 +594,8 @@
do = EffectInfo.OS_STREQ_LENGTHOK
else:
do = EffectInfo.OS_STREQ_NONNULL
- self.generate_modified_call(do, [v1.force_box(),
- v2.force_box()], op.result, mode)
+ self.generate_modified_call(do, [v1.force_box(self),
+ v2.force_box(self)], op.result, mode)
return True
return False
@@ -603,7 +603,7 @@
l2box = v2.getstrlen(None, mode)
if isinstance(l2box, ConstInt):
if l2box.value == 0:
- lengthbox = v1.getstrlen(self.optimizer, mode)
+ lengthbox = v1.getstrlen(self, mode)
seo = self.optimizer.send_extra_operation
seo(ResOperation(rop.INT_EQ, [lengthbox, CONST_0], resultbox))
return True
@@ -614,17 +614,17 @@
vchar1 = self.strgetitem(v1, optimizer.CVAL_ZERO, mode)
vchar2 = self.strgetitem(v2, optimizer.CVAL_ZERO, mode)
seo = self.optimizer.send_extra_operation
- seo(ResOperation(rop.INT_EQ, [vchar1.force_box(),
- vchar2.force_box()],
+ seo(ResOperation(rop.INT_EQ, [vchar1.force_box(self),
+ vchar2.force_box(self)],
resultbox))
return True
if isinstance(v1, VStringSliceValue):
vchar = self.strgetitem(v2, optimizer.CVAL_ZERO, mode)
do = EffectInfo.OS_STREQ_SLICE_CHAR
- self.generate_modified_call(do, [v1.vstr.force_box(),
- v1.vstart.force_box(),
- v1.vlength.force_box(),
- vchar.force_box()],
+ self.generate_modified_call(do, [v1.vstr.force_box(self),
+ v1.vstart.force_box(self),
+ v1.vlength.force_box(self),
+ vchar.force_box(self)],
resultbox, mode)
return True
#
@@ -635,10 +635,10 @@
if v1.is_null():
self.make_constant(resultbox, CONST_1)
return True
- op = ResOperation(rop.PTR_EQ, [v1.force_box(),
+ op = ResOperation(rop.PTR_EQ, [v1.force_box(self),
llhelper.CONST_NULL],
resultbox)
- self.optimizer.emit_operation(op)
+ self.emit_operation(op)
return True
#
return False
@@ -652,8 +652,8 @@
do = EffectInfo.OS_STREQ_NONNULL_CHAR
else:
do = EffectInfo.OS_STREQ_CHECKNULL_CHAR
- self.generate_modified_call(do, [v1.force_box(),
- vchar.force_box()], resultbox,
+ self.generate_modified_call(do, [v1.force_box(self),
+ vchar.force_box(self)], resultbox,
mode)
return True
#
@@ -662,10 +662,10 @@
do = EffectInfo.OS_STREQ_SLICE_NONNULL
else:
do = EffectInfo.OS_STREQ_SLICE_CHECKNULL
- self.generate_modified_call(do, [v1.vstr.force_box(),
- v1.vstart.force_box(),
- v1.vlength.force_box(),
- v2.force_box()], resultbox, mode)
+ self.generate_modified_call(do, [v1.vstr.force_box(self),
+ v1.vstart.force_box(self),
+ v1.vlength.force_box(self),
+ v2.force_box(self)], resultbox, mode)
return True
return False
@@ -675,16 +675,11 @@
calldescr, func = cic.callinfo_for_oopspec(oopspecindex)
op = ResOperation(rop.CALL, [ConstInt(func)] + args, result,
descr=calldescr)
- self.optimizer.emit_operation(op)
+ self.emit_operation(op)
def propagate_forward(self, op):
- if not self.enabled:
- self.emit_operation(op)
- return
-
dispatch_opt(self, op)
-
dispatch_opt = make_dispatcher_method(OptString, 'optimize_',
default=OptString.emit_operation)
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
@@ -221,7 +221,6 @@
newop.setfailargs(self.getfailargs())
return newop
-
# ============
# arity mixins
# ============
diff --git a/pypy/jit/metainterp/test/test_resume.py b/pypy/jit/metainterp/test/test_resume.py
--- a/pypy/jit/metainterp/test/test_resume.py
+++ b/pypy/jit/metainterp/test/test_resume.py
@@ -576,8 +576,9 @@
class FakeOptimizer_VirtualValue(object):
- class cpu:
- pass
+ class optimizer:
+ class cpu:
+ pass
fakeoptimizer = FakeOptimizer_VirtualValue()
def ConstAddr(addr, cpu): # compatibility
@@ -1135,12 +1136,7 @@
modifier.liveboxes = {}
modifier.vfieldboxes = {}
- class FakeOptimizer(object):
- class cpu:
- pass
- def new_const_item(self, descr):
- return None
- v2 = VArrayValue(FakeOptimizer(), LLtypeMixin.arraydescr, 2, b2s)
+ v2 = VArrayValue(LLtypeMixin.arraydescr, None, 2, b2s)
v2._items = [b4s, c1s]
modifier.register_virtual_fields(b2s, [b4s, c1s])
liveboxes = []
diff --git a/pypy/jit/metainterp/test/test_string.py b/pypy/jit/metainterp/test/test_string.py
--- a/pypy/jit/metainterp/test/test_string.py
+++ b/pypy/jit/metainterp/test/test_string.py
@@ -484,6 +484,30 @@
return len(sa.val)
assert self.meta_interp(f, ['a']) == f('a')
+ def test_string_comepare_quasiimmutable(self):
+ class Sys(object):
+ _immutable_fields_ = ["defaultencoding?"]
+ def __init__(self, s):
+ self.defaultencoding = s
+ _str = self._str
+ sys = Sys(_str('ascii'))
+ mydriver = JitDriver(reds = ['n', 'sa'], greens = [])
+ def f(n):
+ sa = 0
+ sys.defaultencoding = _str('ascii')
+ while n:
+ mydriver.jit_merge_point(n=n, sa=sa)
+ if sys.defaultencoding == _str('ascii'):
+ sa += 1
+ n -= 1
+ sys.defaultencoding = _str('utf-8')
+ return sa
+ assert self.meta_interp(f, [8]) == f(8)
+ self.check_loops({'int_add': 1, 'guard_true': 1, 'int_sub': 1,
+ 'jump': 1, 'int_is_true': 1,
+ 'guard_not_invalidated': 1})
+
+
#class TestOOtype(StringTests, OOJitMixin):
# CALL = "oosend"
# CALL_PURE = "oosend_pure"
diff --git a/pypy/jit/metainterp/test/test_virtualstate.py b/pypy/jit/metainterp/test/test_virtualstate.py
--- a/pypy/jit/metainterp/test/test_virtualstate.py
+++ b/pypy/jit/metainterp/test/test_virtualstate.py
@@ -431,7 +431,7 @@
class BaseTestBridges(BaseTest):
- enable_opts = "intbounds:rewrite:virtualize:string:heap:unroll"
+ enable_opts = "intbounds:rewrite:virtualize:string:pure:heap:unroll"
def _do_optimize_bridge(self, bridge, call_pure_results):
from pypy.jit.metainterp.optimizeopt import optimize_bridge_1, build_opt_chain
diff --git a/pypy/module/pypyjit/test_pypy_c/test_00_model.py b/pypy/module/pypyjit/test_pypy_c/test_00_model.py
--- a/pypy/module/pypyjit/test_pypy_c/test_00_model.py
+++ b/pypy/module/pypyjit/test_pypy_c/test_00_model.py
@@ -50,8 +50,7 @@
cmdline.append(str(self.filepath))
#
print cmdline, logfile
- env={'PYPYLOG': 'jit-log-opt,jit-summary:' + str(logfile)}
- #env={'PYPYLOG': ':' + str(logfile)}
+ env={'PYPYLOG': 'jit-log-opt,jit-log-noopt,jit-summary:' + str(logfile)}
pipe = subprocess.Popen(cmdline,
env=env,
stdout=subprocess.PIPE,
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
@@ -366,12 +366,12 @@
# make sure that the "block" is not allocated
...
i20 = force_token()
- setfield_gc(p0, i20, descr=<SignedFieldDescr .*PyFrame.vable_token .*>)
p22 = new_with_vtable(19511408)
p24 = new_array(1, descr=<GcPtrArrayDescr>)
p26 = new_with_vtable(ConstClass(W_ListObject))
p27 = new(descr=<SizeDescr .*>)
p29 = new_array(0, descr=<GcPtrArrayDescr>)
+ setfield_gc(p0, i20, descr=<SignedFieldDescr .*PyFrame.vable_token .*>)
setfield_gc(p27, p29, descr=<GcPtrFieldDescr list.items .*>)
setfield_gc(p26, p27, descr=<.* .*W_ListObject.inst_wrappeditems .*>)
setarrayitem_gc(p24, 0, p26, descr=<GcPtrArrayDescr>)
diff --git a/pypy/module/pypyjit/test_pypy_c/test_generators.py b/pypy/module/pypyjit/test_pypy_c/test_generators.py
--- a/pypy/module/pypyjit/test_pypy_c/test_generators.py
+++ b/pypy/module/pypyjit/test_pypy_c/test_generators.py
@@ -19,8 +19,8 @@
assert loop.match_by_id("generator", """
i16 = force_token()
p45 = new_with_vtable(ConstClass(W_IntObject))
- setfield_gc(p45, i29, descr=<SignedFieldDescr .*>)
i47 = arraylen_gc(p8, descr=<GcPtrArrayDescr>) # Should be removed by backend
setarrayitem_gc(p8, 0, p45, descr=<GcPtrArrayDescr>)
+ setfield_gc(p45, i29, descr=<SignedFieldDescr .*>)
jump(..., descr=...)
""")
diff --git a/pypy/module/pypyjit/test_pypy_c/test_instance.py b/pypy/module/pypyjit/test_pypy_c/test_instance.py
--- a/pypy/module/pypyjit/test_pypy_c/test_instance.py
+++ b/pypy/module/pypyjit/test_pypy_c/test_instance.py
@@ -125,8 +125,8 @@
i12 = force_token()
--TICK--
p20 = new_with_vtable(ConstClass(W_IntObject))
+ setfield_gc(ConstPtr(ptr21), p20, descr=<GcPtrFieldDescr .*TypeCell.inst_w_value .*>)
setfield_gc(p20, i11, descr=<SignedFieldDescr.*W_IntObject.inst_intval .*>)
- setfield_gc(ConstPtr(ptr21), p20, descr=<GcPtrFieldDescr .*TypeCell.inst_w_value .*>)
jump(p0, p1, p2, p3, p4, p20, p6, i7, p20, descr=<Loop.>)
""")
More information about the pypy-commit
mailing list