Author: Maciej Fijalkowski <[email protected]>
Branch: result-in-resops
Changeset: r57406:3920f1a8b8b2
Date: 2012-09-20 16:32 +0200
http://bitbucket.org/pypy/pypy/changeset/3920f1a8b8b2/
Log: remove inliner and start hacking on unrolling
diff --git a/TODO b/TODO
new file mode 100644
--- /dev/null
+++ b/TODO
@@ -0,0 +1,2 @@
+
+* make OptValue somehow leaner using subclassing instead of one-size-fit-most
diff --git a/pypy/jit/metainterp/compile.py b/pypy/jit/metainterp/compile.py
--- a/pypy/jit/metainterp/compile.py
+++ b/pypy/jit/metainterp/compile.py
@@ -12,9 +12,8 @@
from pypy.jit.metainterp.history import TreeLoop, JitCellToken, TargetToken
from pypy.jit.metainterp.history import AbstractFailDescr
from pypy.jit.metainterp.resoperation import BoxPtr, BoxFloat, Box, BoxInt
-from pypy.jit.metainterp import history, resoperation
+from pypy.jit.metainterp import resoperation
from pypy.jit.metainterp.optimize import InvalidLoop
-from pypy.jit.metainterp.inliner import Inliner
from pypy.jit.metainterp.resume import NUMBERING, PENDINGFIELDSP
from pypy.jit.codewriter import heaptracker, longlong
@@ -408,18 +407,18 @@
class DoneWithThisFrameDescrVoid(_DoneWithThisFrameDescr):
def handle_fail(self, metainterp_sd, jitdriver_sd):
- assert jitdriver_sd.result_type == history.VOID
+ assert jitdriver_sd.result_type == resoperation.VOID
raise metainterp_sd.DoneWithThisFrameVoid()
class DoneWithThisFrameDescrInt(_DoneWithThisFrameDescr):
def handle_fail(self, metainterp_sd, jitdriver_sd):
- assert jitdriver_sd.result_type == history.INT
+ assert jitdriver_sd.result_type == resoperation.INT
result = metainterp_sd.cpu.get_latest_value_int(0)
raise metainterp_sd.DoneWithThisFrameInt(result)
class DoneWithThisFrameDescrRef(_DoneWithThisFrameDescr):
def handle_fail(self, metainterp_sd, jitdriver_sd):
- assert jitdriver_sd.result_type == history.REF
+ assert jitdriver_sd.result_type == resoperation.REF
cpu = metainterp_sd.cpu
result = cpu.get_latest_value_ref(0)
cpu.clear_latest_values(1)
@@ -427,7 +426,7 @@
class DoneWithThisFrameDescrFloat(_DoneWithThisFrameDescr):
def handle_fail(self, metainterp_sd, jitdriver_sd):
- assert jitdriver_sd.result_type == history.FLOAT
+ assert jitdriver_sd.result_type == resoperation.FLOAT
result = metainterp_sd.cpu.get_latest_value_float(0)
raise metainterp_sd.DoneWithThisFrameFloat(result)
@@ -505,11 +504,11 @@
else:
if i > self.CNT_BASE_MASK:
return # probably never, but better safe than sorry
- if box.type == history.INT:
+ if box.type == resoperation.INT:
cnt = self.CNT_INT
- elif box.type == history.REF:
+ elif box.type == resoperation.REF:
cnt = self.CNT_REF
- elif box.type == history.FLOAT:
+ elif box.type == resoperation.FLOAT:
cnt = self.CNT_FLOAT
else:
assert 0, box.type
@@ -838,9 +837,9 @@
assert len(redargtypes) == nb_red_args
inputargs = []
for kind in redargtypes:
- if kind == history.INT: box = BoxInt()
- elif kind == history.REF: box = BoxPtr()
- elif kind == history.FLOAT: box = BoxFloat()
+ if kind == resoperation.INT: box = BoxInt()
+ elif kind == resoperation.REF: box = BoxPtr()
+ elif kind == resoperation.FLOAT: box = BoxFloat()
else: raise AssertionError
inputargs.append(box)
k = jitdriver_sd.portal_runner_adr
diff --git a/pypy/jit/metainterp/inliner.py b/pypy/jit/metainterp/inliner.py
deleted file mode 100644
--- a/pypy/jit/metainterp/inliner.py
+++ /dev/null
@@ -1,46 +0,0 @@
-
-from pypy.jit.metainterp.resoperation import Const
-from pypy.jit.metainterp.resume import Snapshot
-
-class Inliner(object):
- def __init__(self, inputargs, jump_args):
- assert len(inputargs) == len(jump_args)
- self.argmap = {}
- for i in range(len(inputargs)):
- if inputargs[i] in self.argmap:
- assert self.argmap[inputargs[i]] == jump_args[i]
- else:
- self.argmap[inputargs[i]] = jump_args[i]
- self.snapshot_map = {None: None}
-
- def inline_op(self, op):
- newop = op.copy_if_modified_by_optimization(self, force_copy=True)
- if newop.is_guard():
- args = op.getfailargs()
- if args:
- newop.setfailargs([self.get_value_replacement(a) for a in
args])
-
- self.argmap[op] = newop
- self.inline_descr_inplace(newop.getdescr())
- return newop
-
- def inline_descr_inplace(self, descr):
- from pypy.jit.metainterp.compile import ResumeGuardDescr
- if isinstance(descr, ResumeGuardDescr):
- descr.rd_snapshot = self.inline_snapshot(descr.rd_snapshot)
-
- def get_value_replacement(self, arg):
- if arg is None:
- return None
- if isinstance(arg, Const):
- return arg
- return self.argmap[arg]
-
- def inline_snapshot(self, snapshot):
- if snapshot in self.snapshot_map:
- return self.snapshot_map[snapshot]
- boxes = [self.get_value_replacement(a) for a in snapshot.boxes]
- new_snapshot = Snapshot(self.inline_snapshot(snapshot.prev), boxes)
- self.snapshot_map[snapshot] = new_snapshot
- return new_snapshot
-
diff --git a/pypy/jit/metainterp/optimizeopt/generalize.py
b/pypy/jit/metainterp/optimizeopt/generalize.py
--- a/pypy/jit/metainterp/optimizeopt/generalize.py
+++ b/pypy/jit/metainterp/optimizeopt/generalize.py
@@ -9,6 +9,7 @@
class KillHugeIntBounds(GeneralizationStrategy):
def apply(self):
+ return # so far we don't care
for v in self.optimizer.values.values():
if v.is_constant():
continue
diff --git a/pypy/jit/metainterp/optimizeopt/intbounds.py
b/pypy/jit/metainterp/optimizeopt/intbounds.py
--- a/pypy/jit/metainterp/optimizeopt/intbounds.py
+++ b/pypy/jit/metainterp/optimizeopt/intbounds.py
@@ -31,12 +31,7 @@
b = v.intbound
if b.has_lower and b.has_upper and b.lower == b.upper:
v.make_constant(ConstInt(b.lower))
-
- try:
- op = self.optimizer.producer[box]
- except KeyError:
- return
- dispatch_bounds_ops(self, op)
+ dispatch_bounds_ops(self, box)
def optimize_GUARD_TRUE(self, op):
self.emit_operation(op)
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
@@ -7,8 +7,7 @@
from pypy.jit.metainterp.optimizeopt.util import make_dispatcher_method
from pypy.jit.metainterp.resoperation import rop, AbstractResOp, opgroups,\
Const, ConstInt, ConstFloat
-from pypy.jit.metainterp.typesystem import llhelper, oohelper
-from pypy.tool.pairtype import extendabletype
+from pypy.jit.metainterp.typesystem import llhelper
from pypy.rlib.objectmodel import specialize
LEVEL_UNKNOWN = '\x00'
@@ -19,6 +18,7 @@
MODE_ARRAY = '\x00'
MODE_STR = '\x01'
MODE_UNICODE = '\x02'
+
class LenBound(object):
def __init__(self, mode, descr, bound):
self.mode = mode
@@ -29,7 +29,6 @@
return LenBound(self.mode, self.descr, self.bound.clone())
class OptValue(object):
- __metaclass__ = extendabletype
_attrs_ = ('box', 'known_class', 'last_guard', 'level', 'intbound',
'lenbound')
last_guard = None
@@ -401,23 +400,24 @@
self.resumedata_memo.forget_numberings(virtualbox)
def getinterned(self, box):
+ # WTF is this function doing?
+ if box.type != REF:
+ return box
constbox = self.get_constant_box(box)
if constbox is None:
return box
- if constbox.type == REF:
- xxx
- value = constbox.getref_base()
- if not value:
- return box
- return self.interned_refs.setdefault(value, box)
+ value = constbox.getref_base()
+ if not value:
+ return box
+ return self.interned_refs.setdefault(value, box)
#elif constbox.type == INT:
# value = constbox.getint()
# return self.interned_ints.setdefault(value, box)
- else:
- return box
@specialize.argtype(0)
def getvalue(self, box):
+ if box.is_constant():
+ return ConstantValue(box)
box = self.getinterned(box)
try:
value = box.get_extra("optimize_value")
diff --git a/pypy/jit/metainterp/optimizeopt/pure.py
b/pypy/jit/metainterp/optimizeopt/pure.py
--- a/pypy/jit/metainterp/optimizeopt/pure.py
+++ b/pypy/jit/metainterp/optimizeopt/pure.py
@@ -1,12 +1,13 @@
from pypy.jit.metainterp.optimizeopt.optimizer import Optimization, REMOVED
from pypy.jit.metainterp.resoperation import rop, create_resop_2
-from pypy.jit.metainterp.optimizeopt.util import make_dispatcher_method
+from pypy.jit.metainterp.optimizeopt.util import make_dispatcher_method,\
+ ArgsDict
class OptPure(Optimization):
def __init__(self):
self.posponedop = None
- self.pure_operations = args_dict()
- self.emitted_pure_operations = {}
+ self.pure_operations = ArgsDict()
+ self.emitted_pure_operations = []
def propagate_forward(self, op):
dispatch_opt(self, op)
@@ -37,15 +38,14 @@
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():
+ oldop = self.pure_operations.get(op)
+ if oldop is not None:
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.pure_operations.add(op)
self.remember_emitting_pure(op)
# otherwise, the operation remains
@@ -112,11 +112,13 @@
return self.pure_operations.get(key, None)
def remember_emitting_pure(self, op):
- self.emitted_pure_operations[op] = True
+ self.emitted_pure_operations.append(op)
def produce_potential_short_preamble_ops(self, sb):
for op in self.emitted_pure_operations:
- if op.getopnum() == rop.GETARRAYITEM_GC_PURE or \
+ if op.getopnum() == rop.GETARRAYITEM_GC_PURE_i or \
+ op.getopnum() == rop.GETARRAYITEM_GC_PURE_p or \
+ op.getopnum() == rop.GETARRAYITEM_GC_PURE_f or \
op.getopnum() == rop.STRGETITEM or \
op.getopnum() == rop.UNICODEGETITEM:
if not self.getvalue(op.getarg(1)).is_constant():
diff --git a/pypy/jit/metainterp/optimizeopt/test/test_util.py
b/pypy/jit/metainterp/optimizeopt/test/test_util.py
--- a/pypy/jit/metainterp/optimizeopt/test/test_util.py
+++ b/pypy/jit/metainterp/optimizeopt/test/test_util.py
@@ -13,12 +13,11 @@
from pypy.jit.codewriter.heaptracker import register_known_gctype
from pypy.jit.tool.oparser import parse, pure_parse
from pypy.jit.metainterp.quasiimmut import QuasiImmutDescr
-from pypy.jit.metainterp import compile, resume, history
+from pypy.jit.metainterp import compile, resume
from pypy.jit.metainterp.jitprof import EmptyProfiler
from pypy.config.pypyoption import get_pypy_config
from pypy.jit.metainterp.resoperation import rop, create_resop, BoxPtr,\
- create_resop_0
-from pypy.jit.metainterp.optimizeopt.unroll import Inliner
+ create_resop_0, REF, INT, FLOAT
def test_sort_descrs():
class PseudoDescr(AbstractDescr):
@@ -76,7 +75,7 @@
d = ArgsDict()
op = create_resop_0(rop.FORCE_TOKEN, 13)
assert d.get(op) is None
- d.setitem(op)
+ d.add(op)
assert d.get(op) is op
# ____________________________________________________________
@@ -378,7 +377,7 @@
return res
def _sortboxes(boxes):
- _kind2count = {history.INT: 1, history.REF: 2, history.FLOAT: 3}
+ _kind2count = {INT: 1, REF: 2, FLOAT: 3}
return sorted(boxes, key=lambda box: _kind2count[box.type])
class BaseTest(object):
@@ -407,15 +406,12 @@
assert equaloplists(optimized.operations,
expected.operations, False, remap, text_right)
- def _do_optimize_loop(self, loop):
+ def _do_optimize_loop(self, loop, call_pure_results):
from pypy.jit.metainterp.optimizeopt import optimize_trace
- #from pypy.jit.metainterp.optimizeopt.util import args_dict
self.loop = loop
- #loop.call_pure_results = args_dict()
- #if call_pure_results is not None:
- # for k, v in call_pure_results.items():
- # loop.call_pure_results[list(k)] = v
+ if call_pure_results is not None:
+ loop.call_pure_results = call_pure_results.copy()
metainterp_sd = FakeMetaInterpStaticData(self.cpu)
if hasattr(self, 'vrefinfo'):
metainterp_sd.virtualref_info = self.vrefinfo
@@ -424,7 +420,7 @@
#
optimize_trace(metainterp_sd, loop, self.enable_opts)
- def unroll_and_optimize(self, loop):#, call_pure_results=None):
+ def unroll_and_optimize(self, loop, call_pure_results=None):
operations = loop.operations
jumpop = operations[-1]
assert jumpop.getopnum() == rop.JUMP
@@ -443,19 +439,17 @@
operations + \
[create_resop(rop.LABEL, None, jump_args,
descr=token)]
- self._do_optimize_loop(preamble)#, call_pure_results)
+ self._do_optimize_loop(preamble, call_pure_results)
assert preamble.operations[-1].getopnum() == rop.LABEL
- import pdb
- pdb.set_trace()
- inliner = Inliner(inputargs, jump_args)
loop.resume_at_jump_descr = preamble.resume_at_jump_descr
+ for op in operations:
+ op.del_extra("optimize_value")
+ # deal with jump args
loop.operations = [preamble.operations[-1]] + \
- [inliner.inline_op(op) for op in cloned_operations]
+ \
- [ResOperation(rop.JUMP, [inliner.inline_arg(a) for a
in jump_args],
- None, descr=token)]
- #[inliner.inline_op(jumpop)]
+ operations + \
+ [create_resop(rop.JUMP, None, jump_args,
descr=token)]
assert loop.operations[-1].getopnum() == rop.JUMP
assert loop.operations[0].getopnum() == rop.LABEL
loop.inputargs = loop.operations[0].getarglist()
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
@@ -1,13 +1,10 @@
-from pypy.jit.codewriter.effectinfo import EffectInfo
from pypy.jit.metainterp.optimizeopt.virtualstate import VirtualStateAdder,
ShortBoxes, BadVirtualState
from pypy.jit.metainterp.compile import ResumeGuardDescr
-from pypy.jit.metainterp.history import TreeLoop, TargetToken, JitCellToken
-from pypy.jit.metainterp.jitexc import JitException
+from pypy.jit.metainterp.history import TargetToken, JitCellToken
from pypy.jit.metainterp.optimize import InvalidLoop
from pypy.jit.metainterp.optimizeopt.optimizer import *
from pypy.jit.metainterp.optimizeopt.generalize import KillHugeIntBounds
-from pypy.jit.metainterp.inliner import Inliner
-from pypy.jit.metainterp.resoperation import rop
+from pypy.jit.metainterp.resoperation import rop, create_resop
from pypy.jit.metainterp.resume import Snapshot
import sys, os
@@ -93,8 +90,7 @@
cell_token = jumpop.getdescr()
assert isinstance(cell_token, JitCellToken)
- stop_label = ResOperation(rop.LABEL, jumpop.getarglist(), None,
TargetToken(cell_token))
-
+ stop_label = create_resop(rop.LABEL, None, jumpop.getarglist(),
TargetToken(cell_token))
if jumpop.getopnum() == rop.JUMP:
if self.jump_to_already_compiled_trace(jumpop):
@@ -107,7 +103,7 @@
if start_label and self.jump_to_start_label(start_label,
stop_label):
# Initial label matches, jump to it
- jumpop = ResOperation(rop.JUMP, stop_label.getarglist(), None,
+ jumpop = create_resop(rop.JUMP, None, stop_label.getarglist(),
descr=start_label.getdescr())
if self.short:
# Construct our short preamble
@@ -199,7 +195,8 @@
assert isinstance(target_token, TargetToken)
targetop.initarglist(inputargs)
target_token.virtual_state = virtual_state
- target_token.short_preamble = [ResOperation(rop.LABEL,
short_inputargs, None)]
+ target_token.short_preamble = [create_resop(rop.LABEL, None,
+ short_inputargs)]
target_token.resume_at_jump_descr = resume_at_jump_descr
exported_values = {}
diff --git a/pypy/jit/metainterp/optimizeopt/util.py
b/pypy/jit/metainterp/optimizeopt/util.py
--- a/pypy/jit/metainterp/optimizeopt/util.py
+++ b/pypy/jit/metainterp/optimizeopt/util.py
@@ -107,41 +107,14 @@
return candidate
return None
- def setitem(self, op):
+ def add(self, op):
hash = op._get_hash_() & self.bucket_size
self.buckets[hash] = op # don't care about collisions
-# def args_eq(args1, args2):
-# make_sure_not_resized(args1)
-# make_sure_not_resized(args2)
-# if len(args1) != len(args2):
-# return False
-# for i in range(len(args1)):
-# arg1 = args1[i]
-# arg2 = args2[i]
-# if arg1 is None:
-# if arg2 is not None:
-# return False
-# elif not arg1.same_box(arg2):
-# return False
-# return True
-
-# def args_hash(args):
-# make_sure_not_resized(args)
-# res = 0x345678
-# for arg in args:
-# if arg is None:
-# y = 17
-# else:
-# y = arg._get_hash_()
-# res = intmask((1000003 * res) ^ y)
-# return res
-
-# def args_dict():
-# return r_dict(args_eq, args_hash)
-
-# def args_dict_box():
-# return r_dict(args_eq, args_hash)
+ def copy(self):
+ a = ArgsDict()
+ a.buckets = self.buckets[:]
+ return a
# ____________________________________________________________
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
@@ -681,6 +681,7 @@
raise BoxNotProducable
def add_potential(self, op, synthetic=False):
+ return # XXX
if op.result and op.result in self.optimizer.values:
value = self.optimizer.values[op.result]
if value in self.optimizer.opaque_pointers:
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
@@ -585,7 +585,8 @@
@specialize.arg(1)
def del_extra(self, key):
- delattr(self, key)
+ if hasattr(self, key):
+ delattr(self, key)
@classmethod
def getopnum(cls):
@@ -900,6 +901,8 @@
check_descr(descr)
def get_descr_hash(self):
+ if self._descr is None:
+ return 0 # for tests
return compute_identity_hash(self._descr)
class GuardResOp(ResOpWithDescr):
_______________________________________________
pypy-commit mailing list
[email protected]
http://mail.python.org/mailman/listinfo/pypy-commit
