Author: Maciej Fijalkowski <[email protected]>
Branch: optresult-unroll
Changeset: r78441:60495ed32c01
Date: 2015-07-05 18:07 +0200
http://bitbucket.org/pypy/pypy/changeset/60495ed32c01/
Log: start writing direct tests of short preamble support
diff --git a/rpython/jit/metainterp/compile.py
b/rpython/jit/metainterp/compile.py
--- a/rpython/jit/metainterp/compile.py
+++ b/rpython/jit/metainterp/compile.py
@@ -103,19 +103,6 @@
# ____________________________________________________________
-class Memo(object):
- def __init__(self, initial_args=None, initial_res=None):
- self.snapshots = {}
- self.box_mapping = {}
- if initial_args is not None:
- for i in range(len(initial_args)):
- self.box_mapping[initial_args[i]] = initial_res[i]
-
- def get(self, box, default):
- return self.box_mapping.get(box, default)
-
- def set(self, box, newbox):
- self.box_mapping[box] = newbox
def compile_loop(metainterp, greenkey, start,
inputargs, jumpargs,
diff --git a/rpython/jit/metainterp/optimizeopt/pure.py
b/rpython/jit/metainterp/optimizeopt/pure.py
--- a/rpython/jit/metainterp/optimizeopt/pure.py
+++ b/rpython/jit/metainterp/optimizeopt/pure.py
@@ -221,10 +221,11 @@
ops = sb.optimizer._newoperations
for i, op in enumerate(ops):
if op.is_always_pure():
- sb.add_potential(op, op)
+ sb.add_potential(op)
if op.is_ovf() and ops[i + 1].getopnum() == rop.GUARD_NO_OVERFLOW:
- sb.add_potential(op, op)
+ sb.add_potential(op)
for i in self.call_pure_positions:
+ yyy
op = ops[i]
assert op.getopnum() == rop.CALL
op = op.copy_and_change(rop.CALL_PURE)
diff --git a/rpython/jit/metainterp/optimizeopt/shortpreamble.py
b/rpython/jit/metainterp/optimizeopt/shortpreamble.py
new file mode 100644
--- /dev/null
+++ b/rpython/jit/metainterp/optimizeopt/shortpreamble.py
@@ -0,0 +1,118 @@
+
+from rpython.jit.metainterp.resoperation import rop, ResOperation
+from rpython.jit.metainterp.history import Const
+
+class BoxNotProducable(Exception):
+ pass
+
+
+class ShortBoxes(object):
+ def __init__(self):
+ self.potential_ops = {}
+ self.inputarg_boxes = {}
+ self.synthetic = {}
+ self.alternatives = {}
+ self.extra_same_as = []
+
+ def create_short_boxes(self, optimizer, inputargs):
+ for box in inputargs:
+ self.inputarg_boxes[box] = None
+ optimizer.produce_potential_short_preamble_ops(self)
+
+ self.short_boxes = {}
+ self.short_boxes_in_production = {}
+
+ for op in self.potential_ops.keys():
+ try:
+ self.produce_short_preamble_op(op)
+ except BoxNotProducable:
+ pass
+
+ self.short_boxes_in_production = None # Not needed anymore
+
+ def prioritized_alternatives(self, box):
+ if box not in self.alternatives:
+ return [self.potential_ops[box]]
+ alts = self.alternatives[box]
+ hi, lo = 0, len(alts) - 1
+ while hi < lo:
+ if alts[lo] is None: # Inputarg, lowest priority
+ alts[lo], alts[-1] = alts[-1], alts[lo]
+ lo -= 1
+ elif alts[lo] not in self.synthetic: # Hi priority
+ alts[hi], alts[lo] = alts[lo], alts[hi]
+ hi += 1
+ else: # Low priority
+ lo -= 1
+ return alts
+
+ def add_to_short(self, op):
+ if op in self.short_boxes:
+ xxx
+ #if op is None:
+ # xxx
+ # oldop = self.short_boxes[box]
+ # self.rename[op] = oldop
+ # self.short_boxes[box] = None
+ # self.short_boxes[oldop] = oldop
+ #else:
+ # xxxx
+ # newop = op.clone()
+ # newbox = newop.result = op.result.clonebox()
+ # self.short_boxes[newop.result] = newop
+ #xxx
+ #value = self.optimizer.getvalue(box)
+ #self.optimizer.emit_operation(ResOperation(rop.SAME_AS, [box],
newbox))
+ #self.optimizer.make_equal_to(newbox, value)
+ #if op is None:
+ # if self.short_boxes[box] is not box:
+ # xxx
+ #else:
+ # if self.short_boxes[box] is not op:
+ # if self.short_boxes[box] is None:
+ # self.short_boxes[box] = op
+ # else:
+ # xxx
+ else:
+ self.short_boxes[op] = None
+
+ def produce_short_preamble_op(self, op):
+ if op in self.short_boxes:
+ return
+ if op in self.inputarg_boxes:
+ return
+ if isinstance(op, Const):
+ return
+ if op in self.short_boxes_in_production:
+ raise BoxNotProducable
+ self.short_boxes_in_production[op] = None
+
+ if op in self.potential_ops:
+ ops = self.prioritized_alternatives(op)
+ produced_one = False
+ for newop in ops:
+ try:
+ if newop:
+ for arg in newop.getarglist():
+ self.produce_short_preamble_op(arg)
+ except BoxNotProducable:
+ pass
+ else:
+ produced_one = True
+ self.add_to_short(newop)
+ if not produced_one:
+ raise BoxNotProducable
+ else:
+ raise BoxNotProducable
+
+ def add_potential(self, op, result=None, synthetic=False):
+ if result is None:
+ result = op
+ if result in self.potential_ops:
+ if result not in self.alternatives:
+ self.alternatives[result] = [self.potential_ops[result]]
+ self.alternatives[result].append(op)
+ else:
+ self.potential_ops[result] = op
+ if synthetic:
+ self.synthetic[result] = True
diff --git a/rpython/jit/metainterp/optimizeopt/test/test_short.py
b/rpython/jit/metainterp/optimizeopt/test/test_short.py
new file mode 100644
--- /dev/null
+++ b/rpython/jit/metainterp/optimizeopt/test/test_short.py
@@ -0,0 +1,48 @@
+
+""" Short preamble tests
+"""
+
+from rpython.jit.metainterp.resoperation import InputArgInt, ResOperation, rop
+from rpython.jit.metainterp.optimizeopt.shortpreamble import ShortBoxes
+from rpython.jit.metainterp.history import AbstractDescr
+
+class Descr(AbstractDescr):
+ pass
+
+class Opt(object):
+ def __init__(self, oplist):
+ self.oplist = oplist
+
+ def produce_potential_short_preamble_ops(self, sb):
+ for op in self.oplist:
+ if isinstance(op, tuple):
+ op, r = op
+ else:
+ op, r = op, op
+ sb.add_potential(op, r)
+
+class TestShortBoxes(object):
+ def test_pure_ops(self):
+ i0 = InputArgInt()
+ i1 = InputArgInt()
+ op = ResOperation(rop.INT_ADD, [i0, i1])
+ sb = ShortBoxes()
+ sb.create_short_boxes(Opt([op]), [i0, i1])
+ assert sb.short_boxes == {op: None}
+
+ def test_pure_ops_does_not_work(self):
+ i0 = InputArgInt()
+ i1 = InputArgInt()
+ op = ResOperation(rop.INT_ADD, [i0, i1])
+ sb = ShortBoxes()
+ sb.create_short_boxes(Opt([op]), [i0])
+ assert sb.short_boxes == {}
+
+ def test_multiple_similar_ops(self):
+ i0 = InputArgInt()
+ i1 = InputArgInt()
+ op = ResOperation(rop.INT_ADD, [i0, i1])
+ op1 = ResOperation(rop.GETFIELD_GC_I, [i0], descr=Descr())
+ sb = ShortBoxes()
+ sb.create_short_boxes(Opt([op, (op1, op)]), [i0, i1])
+
diff --git a/rpython/jit/metainterp/optimizeopt/test/test_unroll.py
b/rpython/jit/metainterp/optimizeopt/test/test_unroll.py
--- a/rpython/jit/metainterp/optimizeopt/test/test_unroll.py
+++ b/rpython/jit/metainterp/optimizeopt/test/test_unroll.py
@@ -4,11 +4,11 @@
from rpython.jit.metainterp.optimizeopt.test.test_util import BaseTest,\
LLtypeMixin, FakeMetaInterpStaticData
-from rpython.jit.metainterp.history import (TreeLoop, AbstractDescr,
+from rpython.jit.metainterp.history import (TreeLoop, AbstractDescr, ConstInt,
JitCellToken, TargetToken)
from rpython.jit.metainterp.resoperation import rop, ResOperation
from rpython.jit.metainterp.optimizeopt.virtualstate import \
- NotVirtualStateInfo, LEVEL_CONSTANT
+ NotVirtualStateInfo, LEVEL_CONSTANT, LEVEL_UNKNOWN
class FakeOptimizer(object):
optearlyforce = None
@@ -38,7 +38,7 @@
start_state = self._do_optimize_loop(preamble, None,
export_state=True)
vs = preamble.operations[-1].getdescr().virtual_state
- return start_state, vs
+ return start_state, vs, loop
def test_simple(self):
loop = """
@@ -47,7 +47,22 @@
guard_value(i1, 1) []
jump(i1)
"""
- es, vs = self.optimize(loop)
+ es, vs, loop = self.optimize(loop)
assert isinstance(vs.state[0], NotVirtualStateInfo)
+ # the virtual state is constant, so we don't need to have it in
+ # inputargs
assert vs.make_inputargs([1], FakeOptimizer()) == []
assert vs.state[0].level == LEVEL_CONSTANT
+ # we have exported values for i1, which happens to be an inputarg
+ assert es.inputarg_mapping[0][1].getint() == 1
+ assert isinstance(es.inputarg_mapping[0][1], ConstInt)
+
+ def test_not_constant(self):
+ loop = """
+ [i0]
+ i1 = int_add(i0, 1)
+ jump(i0)
+ """
+ es, vs, loop = self.optimize(loop)
+ assert isinstance(vs.state[0], NotVirtualStateInfo)
+ assert vs.state[0].level == LEVEL_UNKNOWN
diff --git a/rpython/jit/metainterp/optimizeopt/test/test_util.py
b/rpython/jit/metainterp/optimizeopt/test/test_util.py
--- a/rpython/jit/metainterp/optimizeopt/test/test_util.py
+++ b/rpython/jit/metainterp/optimizeopt/test/test_util.py
@@ -464,7 +464,6 @@
assert loop.operations[0].getopnum() == rop.LABEL
loop.inputargs = loop.operations[0].getarglist()
- start_state.orig_inputargs = inputargs
self._do_optimize_loop(loop, call_pure_results, start_state,
export_state=False)
extra_same_as = []
diff --git a/rpython/jit/metainterp/optimizeopt/unroll.py
b/rpython/jit/metainterp/optimizeopt/unroll.py
--- a/rpython/jit/metainterp/optimizeopt/unroll.py
+++ b/rpython/jit/metainterp/optimizeopt/unroll.py
@@ -1,6 +1,5 @@
import sys
-from rpython.jit.metainterp.compile import Memo
from rpython.jit.metainterp.history import TargetToken, JitCellToken, Const
from rpython.jit.metainterp.logger import LogOperations
from rpython.jit.metainterp.optimize import InvalidLoop
@@ -8,10 +7,9 @@
from rpython.jit.metainterp.optimizeopt.optimizer import Optimizer,\
Optimization
from rpython.jit.metainterp.optimizeopt.virtualstate import
(VirtualStateConstructor,
- ShortBoxes, BadVirtualState, VirtualStatesCantMatch)
+ BadVirtualState, VirtualStatesCantMatch)
from rpython.jit.metainterp.resoperation import rop, ResOperation,\
OpHelpers, AbstractInputArg, GuardResOp, AbstractResOp
-from rpython.jit.metainterp.resume import Snapshot
from rpython.jit.metainterp import compile
from rpython.rlib.debug import debug_print, debug_start, debug_stop
@@ -44,12 +42,6 @@
self.emitting_dissabled = False
self.emitted_guards = 0
- def ensure_imported(self, value):
- if not self.emitting_dissabled and value in self.importable_values:
- imp = self.importable_values[value]
- del self.importable_values[value]
- imp.import_value(value)
-
def emit_operation(self, op):
if self.emitting_dissabled:
return
@@ -82,21 +74,14 @@
modifier = VirtualStateConstructor(self.optimizer)
return modifier.get_virtual_state(args)
- def fix_snapshot(self, jump_args, snapshot):
- if snapshot is None:
- return None
- snapshot_args = snapshot.boxes
- new_snapshot_args = []
- for a in snapshot_args:
- a = self.getvalue(a).get_key_box()
- new_snapshot_args.append(a)
- prev = self.fix_snapshot(jump_args, snapshot.prev)
- return Snapshot(prev, new_snapshot_args)
-
def propagate_all_forward(self, starting_state, export_state=True):
self.optimizer.exporting_state = export_state
loop = self.optimizer.loop
self.optimizer.clear_newoperations()
+ for op in loop.operations:
+ assert op.get_forwarded() is None
+ for op in loop.inputargs:
+ assert op.get_forwarded() is None
start_label = loop.operations[0]
if start_label.getopnum() == rop.LABEL:
@@ -220,30 +205,30 @@
def export_state(self, targetop):
original_jump_args = targetop.getarglist()
+ label_op = self.optimizer.loop.operations[0]
jump_args = [self.get_box_replacement(a) for a in original_jump_args]
+ virtual_state = self.get_virtual_state(jump_args)
+ target_token = targetop.getdescr()
+ assert isinstance(target_token, TargetToken)
+ target_token.virtual_state = virtual_state
+ return ExportedState([(label_op.getarg(i), jump_args[i]) for i in
range(len(jump_args))], [], [], [])
+ xxx
- virtual_state = self.get_virtual_state(jump_args)
inputargs = virtual_state.make_inputargs(jump_args, self.optimizer)
short_inputargs = virtual_state.make_inputargs(jump_args,
self.optimizer, keyboxes=True)
- if self.boxes_created_this_iteration is not None:
- for box in self.inputargs:
- self.boxes_created_this_iteration[box] = None
-
- short_boxes = ShortBoxes(self.optimizer, inputargs)
-
- proven_constants = []
- for i in range(len(original_jump_args)):
- srcbox = jump_args[i]
- if srcbox is not original_jump_args[i]:
- if srcbox.type == 'r':
- info = self.optimizer.getptrinfo(srcbox)
- if info and info.is_virtual():
- xxx
- if original_jump_args[i] is not srcbox and srcbox.is_constant():
- proven_constants.append((original_jump_args[i], srcbox))
+ #proven_constants = []
+ #for i in range(len(original_jump_args)):
+ # srcbox = jump_args[i]
+ ## if srcbox is not original_jump_args[i]:
+ # if srcbox.type == 'r':
+ # info = self.optimizer.getptrinfo(srcbox)
+ # if info and info.is_virtual():
+ # xxx
+ # if original_jump_args[i] is not srcbox and srcbox.is_constant():
+ # proven_constants.append((original_jump_args[i], srcbox))
#opnum = OpHelpers.same_as_for_type(original_jump_args[i].type)
#op = ResOperation(opnum, [srcbox])
#self.optimizer.emit_operation(op)
@@ -263,20 +248,16 @@
#inputarg_setup_ops = original_jump_args
#inputarg_setup_ops = self.optimizer.get_newoperations()
- target_token = targetop.getdescr()
- assert isinstance(target_token, TargetToken)
- targetop.initarglist(inputargs)
- target_token.virtual_state = virtual_state
target_token.short_preamble = [ResOperation(rop.LABEL,
short_inputargs, None)]
- exported_values = {}
- for box in inputargs:
- exported_values[box] = self.optimizer.getinfo(box)
- for op in short_boxes.operations():
- if op and op.type != 'v':
- exported_values[op] = self.optimizer.getinfo(op)
+ #exported_values = {}
+ #for box in inputargs:
+ # exported_values[box] = self.optimizer.getinfo(box)
+ #for op in short_boxes.operations():
+ # if op and op.type != 'v':
+ # exported_values[op] = self.optimizer.getinfo(op)
- return ExportedState(short_boxes, proven_constants, exported_values)
+ return ExportedState([], [])
def import_state(self, targetop, exported_state):
if not targetop: # Trace did not start with a label
@@ -295,21 +276,20 @@
self.initial_virtual_state = virtual_state
return
- self.short = target_token.short_preamble[:]
- self.short_seen = {}
- self.short_boxes = exported_state.short_boxes
+ self.short = [] # target_token.short_preamble[:]
+ #self.short_seen = {}
self.initial_virtual_state = target_token.virtual_state
- inpargs = self.initial_virtual_state.make_inputargs(
- exported_state.orig_inputargs, self.optimizer)
- for i, arg in enumerate(inpargs):
- if arg is not self.inputargs[i]:
- arg.set_forwarded(self.inputargs[i])
- for box in self.inputargs:
- preamble_info = exported_state.exported_values[box]
- self.optimizer.setinfo_from_preamble(box, preamble_info)
- for box, const in exported_state.proven_constants:
- box.set_forwarded(const)
+ #inpargs = self.initial_virtual_state.make_inputargs(
+ # exported_state.orig_inputargs, self.optimizer)
+ #for i, arg in enumerate(inpargs):
+ # if arg is not self.inputargs[i]:
+ # arg.set_forwarded(self.inputargs[i])
+ #for box in self.inputargs:
+ # preamble_info = exported_state.exported_values[box]
+ # self.optimizer.setinfo_from_preamble(box, preamble_info)
+ #for box, const in exported_state.state:
+ # box.set_forwarded(const)
# Setup the state of the new optimizer by emiting the
# short operations and discarding the result
@@ -318,14 +298,14 @@
#for source, target in exported_state.inputarg_setup_ops:
# source.set_forwarded(target)
- for op in self.short_boxes.operations():
- if not op:
- continue
- if op.is_always_pure():
- self.pure(op.getopnum(),
- PreambleOp(op, self.optimizer.getinfo(op)))
- else:
- yyy
+ #for op in self.short_boxes.operations():
+ # if not op:
+ # continue
+ # if op.is_always_pure():
+ # self.pure(op.getopnum(),
+ # PreambleOp(op, self.optimizer.getinfo(op)))
+ # else:
+ # yyy
return
seen = {}
for op in self.short_boxes.operations():
@@ -717,23 +697,30 @@
'it has at the start of the target loop')
i += 1
-
-class ValueImporter(object):
- def __init__(self, unroll, value, op):
- self.unroll = unroll
- self.preamble_value = value
- self.op = op
-
- def import_value(self, value):
- value.import_from(self.preamble_value, self.unroll.optimizer)
- self.unroll.add_op_to_short(self.op, False, True)
-
+class ShortPreambleBuilder(object):
+ """ A place that builds short preamble and the necessary
+ arguments for the label and the jump
+ """
class ExportedState(object):
- def __init__(self, short_boxes, proven_constants, exported_values):
- self.short_boxes = short_boxes
- self.proven_constants = proven_constants
- self.exported_values = exported_values
+ """ Exported state consists of a few pieces of information:
+
+ * inputarg_mapping - a list of tuples with original inputarg box
+ as the first element and the second element being
+ what it maps to (potentially const)
+ * exported_infos - a mapping from ops to infos, including inputargs
+ * pure operations - a list of pure operations that can produce various
+ ops
+ * heap cache operations - an additional list of how to produce various
+ ops
+ """
+
+ def __init__(self, inputarg_mapping, exported_infos, pure_ops,
+ heap_cache_ops):
+ self.inputarg_mapping = inputarg_mapping
+ self.exported_infos = exported_infos
+ self.pure_ops = pure_ops
+ self.heap_cache_ops = heap_cache_ops
def dump(self, metainterp_sd):
debug_start("jit-exported-state")
diff --git a/rpython/jit/metainterp/optimizeopt/virtualstate.py
b/rpython/jit/metainterp/optimizeopt/virtualstate.py
--- a/rpython/jit/metainterp/optimizeopt/virtualstate.py
+++ b/rpython/jit/metainterp/optimizeopt/virtualstate.py
@@ -5,12 +5,12 @@
from rpython.jit.metainterp.optimizeopt.intutils import IntUnbounded
from rpython.jit.metainterp.resoperation import rop, ResOperation,\
AbstractInputArg
-from rpython.jit.metainterp.compile import Memo
from rpython.rlib.debug import debug_start, debug_stop, debug_print
from rpython.rlib.objectmodel import we_are_translated
LEVEL_UNKNOWN = '\x00'
-LEVEL_CONSTANT = '\x01'
+LEVEL_NONNULL = '\x01'
+LEVEL_CONSTANT = '\x02'
class BadVirtualState(Exception):
pass
@@ -286,6 +286,8 @@
info = optimizer.getinfo(box)
if info and info.is_constant():
self.level = LEVEL_CONSTANT
+ elif box.type == 'r' and info and info.is_nonnull():
+ self.level = LEVEL_NONNULL
else:
self.level = LEVEL_UNKNOWN
return
@@ -617,172 +619,3 @@
def visit_varraystruct(self, arraydescr, fielddescrs):
return VArrayStructStateInfo(arraydescr, fielddescrs)
-
-class BoxNotProducable(Exception):
- pass
-
-
-class ShortBoxes(object):
- def __init__(self, optimizer, surviving_boxes):
- self.potential_ops = {}
- self.alternatives = {}
- self.synthetic = {}
- self.optimizer = optimizer
- self.assumed_classes = {}
-
- assert surviving_boxes is not None
- for box in surviving_boxes:
- self.potential_ops[box] = None
- optimizer.produce_potential_short_preamble_ops(self)
-
- self.short_boxes = {}
- self.short_boxes_in_production = {}
-
- for op in self.potential_ops.keys():
- try:
- self.produce_short_preamble_op(op)
- except BoxNotProducable:
- pass
-
- self.short_boxes_in_production = None # Not needed anymore
- #else:
- # self.short_boxes = {}
-
- def dump(self, logops):
- if 0:
- for op, resop in self.short_boxes.iteritems():
- if isinstance(op, AbstractInputArg):
- assert resop is None
- debug_print(logops.repr_of_arg(op))
- else:
- debug_print("%s:%s"% (logops.repr_of_resop(op),
- logops.repr_of_resop(resop)))
-
- def prioritized_alternatives(self, box):
- if box not in self.alternatives:
- return [self.potential_ops[box]]
- alts = self.alternatives[box]
- hi, lo = 0, len(alts) - 1
- while hi < lo:
- if alts[lo] is None: # Inputarg, lowest priority
- alts[lo], alts[-1] = alts[-1], alts[lo]
- lo -= 1
- elif alts[lo] not in self.synthetic: # Hi priority
- alts[hi], alts[lo] = alts[lo], alts[hi]
- hi += 1
- else: # Low priority
- lo -= 1
- return alts
-
- def add_to_short(self, box, op):
- if box in self.short_boxes:
- xxx
- return # XXX avoid those corner cases
- #if op is None:
- # xxx
- # oldop = self.short_boxes[box]
- # self.rename[op] = oldop
- # self.short_boxes[box] = None
- # self.short_boxes[oldop] = oldop
- #else:
- # xxxx
- # newop = op.clone()
- # newbox = newop.result = op.result.clonebox()
- # self.short_boxes[newop.result] = newop
- #xxx
- #value = self.optimizer.getvalue(box)
- #self.optimizer.emit_operation(ResOperation(rop.SAME_AS, [box],
newbox))
- #self.optimizer.make_equal_to(newbox, value)
- #if op is None:
- # if self.short_boxes[box] is not box:
- # xxx
- #else:
- # if self.short_boxes[box] is not op:
- # if self.short_boxes[box] is None:
- # self.short_boxes[box] = op
- # else:
- # xxx
- if op is None:
- oldop = self.short_boxes[box].clone()
- oldres = oldop.result
- newbox = oldop.result = oldres.clonebox()
- self.rename[box] = newbox
- self.short_boxes[box] = None
- self.short_boxes[newbox] = oldop
- else:
- newop = op.clone()
- newbox = newop.result = op.result.clonebox()
- self.short_boxes[newop.result] = newop
- value = self.optimizer.getvalue(box)
- self.optimizer.emit_operation(ResOperation(rop.SAME_AS, [box],
newbox))
- self.optimizer.make_equal_to(newbox, value)
- else:
- self.short_boxes[box] = op
-
- def produce_short_preamble_op(self, op):
- if op in self.short_boxes:
- return
- if isinstance(op, Const):
- return
- if op in self.short_boxes_in_production:
- raise BoxNotProducable
- self.short_boxes_in_production[op] = None
-
- if op in self.potential_ops:
- ops = self.prioritized_alternatives(op)
- produced_one = False
- for newop in ops:
- try:
- if newop:
- for arg in newop.getarglist():
- self.produce_short_preamble_op(arg)
- except BoxNotProducable:
- pass
- else:
- produced_one = True
- self.add_to_short(op, newop)
- if not produced_one:
- raise BoxNotProducable
- else:
- raise BoxNotProducable
-
- def add_potential(self, key, op, synthetic=False):
- #try:
- # value = self.optimizer.values[key]
- # if value in self.optimizer.opaque_pointers:
- # classbox = value.get_constant_class(self.optimizer.cpu)
- # if classbox:
- # self.assumed_classes[key] = classbox
- #except KeyError:
- # pass
- if key not in self.potential_ops:
- self.potential_ops[key] = op
- else:
- if key not in self.alternatives:
- self.alternatives[key] = [self.potential_ops[key]]
- self.alternatives[key].append(op)
- if synthetic:
- self.synthetic[op] = True
-
- def debug_print(self, logops):
- if 0:
- debug_start('jit-short-boxes')
- for box, op in self.short_boxes.items():
- if op:
- debug_print(logops.repr_of_arg(box) + ': ' +
logops.repr_of_resop(op))
- 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()
- ops.sort(key=str, reverse=True)
- return ops
- return self.short_boxes.values()
-
- def producer(self, box):
- return self.short_boxes[box]
-
- def has_producer(self, box):
- return box in self.short_boxes
_______________________________________________
pypy-commit mailing list
[email protected]
https://mail.python.org/mailman/listinfo/pypy-commit
