Author: Maciej Fijalkowski <[email protected]>
Branch: optresult
Changeset: r77853:20ebcf1752f1
Date: 2015-06-04 13:33 +0200
http://bitbucket.org/pypy/pypy/changeset/20ebcf1752f1/
Log: kill dead code
diff --git a/rpython/jit/metainterp/optimizeopt/util.py
b/rpython/jit/metainterp/optimizeopt/util.py
--- a/rpython/jit/metainterp/optimizeopt/util.py
+++ b/rpython/jit/metainterp/optimizeopt/util.py
@@ -69,27 +69,10 @@
quicksort(array, pivotnewindex + 1, right)
def sort_descrs(lst):
+ # unused, should I leave it or kill it?
quicksort(lst, 0, len(lst)-1)
-def descrlist_hash(l):
- res = 0x345678
- for descr in l:
- y = compute_identity_hash(descr)
- res = intmask((1000003 * res) ^ y)
- return res
-
-def descrlist_eq(l1, l2):
- if len(l1) != len(l2):
- return False
- for i in range(len(l1)):
- if l1[i] is not l2[i]:
- return False
- return True
-
-def descrlist_dict():
- return r_dict(descrlist_eq, descrlist_hash)
-
# ____________________________________________________________
def args_eq(args1, args2):
diff --git a/rpython/jit/metainterp/optimizeopt/virtualize.py
b/rpython/jit/metainterp/optimizeopt/virtualize.py
--- a/rpython/jit/metainterp/optimizeopt/virtualize.py
+++ b/rpython/jit/metainterp/optimizeopt/virtualize.py
@@ -1,518 +1,13 @@
from rpython.jit.codewriter.effectinfo import EffectInfo
-from rpython.jit.metainterp.executor import execute
-from rpython.jit.codewriter.heaptracker import vtable2descr, descr2vtable
-from rpython.jit.metainterp.history import Const, ConstInt, BoxInt
-from rpython.jit.metainterp.history import CONST_NULL, BoxPtr
+from rpython.jit.codewriter.heaptracker import descr2vtable
+from rpython.jit.metainterp.history import ConstInt
+from rpython.jit.metainterp.history import CONST_NULL
from rpython.jit.metainterp.optimizeopt import info, optimizer
from rpython.jit.metainterp.optimizeopt.optimizer import REMOVED
-from rpython.jit.metainterp.optimizeopt.util import (make_dispatcher_method,
- descrlist_dict,
sort_descrs)
+from rpython.jit.metainterp.optimizeopt.util import make_dispatcher_method
-from rpython.jit.metainterp.optimizeopt.rawbuffer import RawBuffer,
InvalidRawOperation
+from rpython.jit.metainterp.optimizeopt.rawbuffer import InvalidRawOperation
from rpython.jit.metainterp.resoperation import rop, ResOperation
-from rpython.rlib.objectmodel import we_are_translated, specialize
-from rpython.jit.metainterp.optimizeopt.intutils import IntUnbounded
-
-class AbstractVirtualInfo(info.PtrInfo):
- _attrs_ = ('_cached_vinfo',)
- is_about_raw = False
- _cached_vinfo = None
-
- def is_forced_virtual(self):
- xxx
- return self.box is not None
-
- #def force_box(self, optforce):
- # xxxx
- # if self.box is None:
- # optforce.forget_numberings(self.source_op)
- # self._really_force(optforce)
- # return self.box
-
- def force_at_end_of_preamble(self, already_forced, optforce):
- xxxx
- value = already_forced.get(self, None)
- if value:
- return value
- return OptValue(self.force_box(optforce))
-
- def visitor_walk_recursive(self, visitor):
- # checks for recursion: it is False unless
- # we have already seen the very same keybox
- if self.box is None and not
visitor.already_seen_virtual(self.source_op):
- self._visitor_walk_recursive(visitor)
-
- def _visitor_walk_recursive(self, visitor):
- raise NotImplementedError("abstract base")
-
- @specialize.argtype(1)
- def _visitor_dispatch_virtual_type(self, visitor):
- raise NotImplementedError("abstract base")
-
- def _really_force(self, optforce):
- raise NotImplementedError("abstract base")
-
- def import_from(self, other, optimizer):
- raise NotImplementedError("should not be called at this level")
-
-def get_fielddescrlist_cache(cpu):
- if not hasattr(cpu, '_optimizeopt_fielddescrlist_cache'):
- result = descrlist_dict()
- cpu._optimizeopt_fielddescrlist_cache = result
- return result
- return cpu._optimizeopt_fielddescrlist_cache
-get_fielddescrlist_cache._annspecialcase_ = "specialize:memo"
-
-class AbstractVirtualStructInfo(AbstractVirtualInfo):
- _attrs_ = ('_fields',)
-
- def __init__(self):
- AbstractVirtualInfo.__init__(self)
- #self._fields = {}
-
- def getfield(self, ofs, default):
- return self._fields.get(ofs, default)
-
- def setfield(self, ofs, fieldvalue):
- assert isinstance(fieldvalue, optimizer.OptValue)
- self._fields[ofs] = fieldvalue
-
- def _get_descr(self):
- raise NotImplementedError
-
- def _is_immutable_and_filled_with_constants(self, memo=None):
- # check if it is possible to force the given structure into a
- # compile-time constant: this is allowed only if it is declared
- # immutable, if all fields are already filled, and if each field
- # is either a compile-time constant or (recursively) a structure
- # which also answers True to the same question.
- #
- # check that all fields are filled. The following equality check
- # also fails if count == -1, meaning "not an immutable at all".
- count = self._get_descr().count_fields_if_immutable()
- if count != len(self._fields):
- return False
- #
- # initialize 'memo'
- if memo is None:
- memo = {}
- elif self in memo:
- return True # recursive case: assume yes
- memo[self] = None
- #
- for value in self._fields.itervalues():
- if value.is_constant():
- pass # it is a constant value: ok
- elif (isinstance(value, AbstractVirtualStructValue)
- and value.is_virtual()):
- # recursive check
- if not value._is_immutable_and_filled_with_constants(memo):
- return False
- else:
- return False # not a constant at all
- return True
-
- 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, optforce)
- return 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 = optforce.optimizer.constant_fold(op)
- self.make_constant(box)
- for ofs, value in self._fields.iteritems():
- subbox = value.force_box(optforce)
- assert isinstance(subbox, Const)
- execute(optforce.optimizer.cpu, None, rop.SETFIELD_GC,
- ofs, box, subbox)
- # keep self._fields, because it's all immutable anyway
- else:
- optforce.emit_operation(op)
- op = optforce.getlastop()
- self.box = box = op
- #
- iteritems = self._fields.iteritems()
- if not we_are_translated(): #random order is fine, except for tests
- iteritems = list(iteritems)
- iteritems.sort(key=lambda (x, y): x.sort_key())
- for ofs, value in iteritems:
- subbox = value.force_box(optforce)
- op = ResOperation(rop.SETFIELD_GC, [box, subbox], descr=ofs)
- optforce.emit_operation(op)
-
- def _get_field_descr_list(self):
- _cached_sorted_fields = self._cached_sorted_fields
- if self._fields is None:
- nfields = 0
- else:
- nfields = len(self._fields)
- if (_cached_sorted_fields is not None and
- nfields == len(_cached_sorted_fields)):
- lst = self._cached_sorted_fields
- else:
- if self._fields is None:
- lst = []
- else:
- lst = self._fields.keys()
- sort_descrs(lst)
- cache = get_fielddescrlist_cache(self.cpu)
- result = cache.get(lst, None)
- if result is None:
- cache[lst] = lst
- else:
- lst = result
- # store on self, to not have to repeatedly get it from the global
- # cache, which involves sorting
- self._cached_sorted_fields = lst
- return lst
-
- def _visitor_walk_recursive(self, visitor):
- lst = self._get_field_descr_list()
- fieldboxes = [self._fields[ofs].get_key_box() for ofs in lst]
- visitor.register_virtual_fields(self.source_op, fieldboxes)
- for ofs in lst:
- fieldvalue = self._fields[ofs]
- fieldvalue.visitor_walk_recursive(visitor)
-
-class VirtualInfo(AbstractVirtualStructInfo):
-
- def __init__(self, known_class, descr):
- AbstractVirtualStructInfo.__init__(self)
- assert isinstance(known_class, Const)
- self.known_class = known_class
- self.descr = descr
-
- @specialize.argtype(1)
- def _visitor_dispatch_virtual_type(self, visitor):
- fielddescrs = self._get_field_descr_list()
- return visitor.visit_virtual(self.known_class, fielddescrs)
-
- def _get_descr(self):
- return vtable2descr(self.cpu, self.known_class.getint())
-
- def __repr__(self):
- cls_name = self.known_class.value.adr.ptr._obj._TYPE._name
- if self._fields is None:
- return '<VirtualValue FORCED cls=%s>' % (cls_name,)
- field_names = [field.name for field in self._fields]
- return "<VirtualValue cls=%s fields=%s>" % (cls_name, field_names)
-
-class VStructInfo(AbstractVirtualStructInfo):
-
- def __init__(self, cpu, structdescr, source_op):
- xxx
- AbstractVirtualStructValue.__init__(self, cpu, source_op)
- self.structdescr = structdescr
-
- @specialize.argtype(1)
- def _visitor_dispatch_virtual_type(self, visitor):
- fielddescrs = self._get_field_descr_list()
- return visitor.visit_vstruct(self.structdescr, fielddescrs)
-
- def _get_descr(self):
- return self.structdescr
-
-class AbstractVArrayInfo(AbstractVirtualInfo):
- """
- Base class for VArrayValue (for normal GC arrays) and VRawBufferValue (for
- malloc()ed memory)
- """
-
- def getlength(self):
- return len(self._items)
-
- def get_item_value(self, i):
- raise NotImplementedError
-
- def set_item_value(self, i, newval):
- raise NotImplementedError
-
- def _visitor_walk_recursive(self, visitor):
- itemboxes = []
- for i in range(self.getlength()):
- itemvalue = self.get_item_value(i)
- if itemvalue is not None:
- box = itemvalue.get_key_box()
- else:
- box = None
- itemboxes.append(box)
- visitor.register_virtual_fields(self.source_op, itemboxes)
- for i in range(self.getlength()):
- itemvalue = self.get_item_value(i)
- if itemvalue is not None:
- itemvalue.visitor_walk_recursive(visitor)
-
-
-class VArrayInfo(AbstractVArrayInfo):
-
- def __init__(self, arraydescr, constvalue, size, source_op,
- clear=False):
- AbstractVirtualValue.__init__(self, source_op)
- self.arraydescr = arraydescr
- self.constvalue = constvalue
- if clear:
- self._items = [constvalue] * size
- else:
- self._items = [None] * size
- self.clear = clear
-
- def getlength(self):
- return len(self._items)
-
- def get_missing_null_value(self):
- return self.constvalue
-
- def get_item_value(self, i):
- """Return the i'th item, unless it is 'constvalue' on a 'clear'
- array. In that case (or if the i'th item is already None),
- return None. The idea is that this method returns the value
- that must be set into an array that was allocated "correctly",
- i.e. if 'clear' is True, that means with zero=True."""
- subvalue = self._items[i]
- if self.clear and (subvalue is self.constvalue or
- subvalue.is_null()):
- subvalue = None
- return subvalue
-
- def set_item_value(self, i, newval):
- self._items[i] = newval
-
- def getitem(self, index):
- res = self._items[index]
- return res
-
- def setitem(self, index, itemvalue):
- assert isinstance(itemvalue, optimizer.OptValue)
- self._items[index] = itemvalue
-
- def force_at_end_of_preamble(self, already_forced, optforce):
- # note that this method is on VArrayValue instead of
- # AbstractVArrayValue because we do not want to support virtualstate
- # for rawbuffers for now
- if self in already_forced:
- return self
- already_forced[self] = self
- for index in range(self.getlength()):
- itemval = self._items[index]
- # XXX should be skip alltogether, but I don't wanna know or
- # fight unrolling just yet
- if itemval is None:
- itemval = self.constvalue
- itemval = itemval.force_at_end_of_preamble(already_forced,
optforce)
- self.set_item_value(index, itemval)
- return 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
- # XXX two possible optimizations:
- # * if source_op is NEW_ARRAY_CLEAR, emit NEW_ARRAY if it's
- # immediately followed by SETARRAYITEM_GC into all items (hard?)
- # * if source_op is NEW_ARRAY, emit NEW_ARRAY_CLEAR if it's
- # followed by setting most items to zero anyway
- optforce.emit_operation(self.source_op)
- op = optforce.getlastop() # potentially replaced
- self.box = box = op
- for index in range(len(self._items)):
- subvalue = self._items[index]
- if subvalue is None:
- continue
- if self.clear:
- if subvalue is self.constvalue or subvalue.is_null():
- continue
- subbox = subvalue.force_box(optforce)
- op = ResOperation(rop.SETARRAYITEM_GC,
- [box, ConstInt(index), subbox],
- descr=self.arraydescr)
- optforce.emit_operation(op)
-
- @specialize.argtype(1)
- def _visitor_dispatch_virtual_type(self, visitor):
- return visitor.visit_varray(self.arraydescr, self.clear)
-
-
-class VArrayStructInfo(AbstractVirtualInfo):
- def __init__(self, arraydescr, size, source_op):
- AbstractVirtualValue.__init__(self, source_op)
- self.arraydescr = arraydescr
- self._items = [{} for _ in xrange(size)]
-
- def getlength(self):
- return len(self._items)
-
- def getinteriorfield(self, index, ofs, default):
- return self._items[index].get(ofs, default)
-
- def setinteriorfield(self, index, ofs, itemvalue):
- assert isinstance(itemvalue, optimizer.OptValue)
- self._items[index][ofs] = itemvalue
-
- def _really_force(self, optforce):
- assert self.source_op is not None
- if not we_are_translated():
- self.source_op.name = 'FORCE ' + self.source_op.name
- optforce.emit_operation(self.source_op)
- op = optforce.getlastop()
- self.box = box = op
- for index in range(len(self._items)):
- iteritems = self._items[index].iteritems()
- # random order is fine, except for tests
- if not we_are_translated():
- iteritems = list(iteritems)
- iteritems.sort(key=lambda (x, y): x.sort_key())
- for descr, value in iteritems:
- subbox = value.force_box(optforce)
- op = ResOperation(rop.SETINTERIORFIELD_GC,
- [box, ConstInt(index), subbox], descr=descr
- )
- optforce.emit_operation(op)
-
- def _get_list_of_descrs(self):
- descrs = []
- for item in self._items:
- item_descrs = item.keys()
- sort_descrs(item_descrs)
- descrs.append(item_descrs)
- return descrs
-
- def _visitor_walk_recursive(self, visitor):
- itemdescrs = self._get_list_of_descrs()
- itemboxes = []
- for i in range(len(self._items)):
- for descr in itemdescrs[i]:
- itemboxes.append(self._items[i][descr].get_key_box())
- visitor.register_virtual_fields(self.keybox, itemboxes)
- for i in range(len(self._items)):
- for descr in itemdescrs[i]:
- self._items[i][descr].visitor_walk_recursive(visitor)
-
- def force_at_end_of_preamble(self, already_forced, optforce):
- if self in already_forced:
- return self
- already_forced[self] = self
- for index in range(len(self._items)):
- for descr in self._items[index].keys():
- self._items[index][descr] =
self._items[index][descr].force_at_end_of_preamble(already_forced, optforce)
- return self
-
- @specialize.argtype(1)
- def _visitor_dispatch_virtual_type(self, visitor):
- return visitor.visit_varraystruct(self.arraydescr,
self._get_list_of_descrs())
-
-
-class VRawBufferInfo(AbstractVArrayInfo):
- is_about_raw = True
-
- def __init__(self, cpu, logops, size, source_op):
- AbstractVirtualValue.__init__(self, source_op)
- # note that size is unused, because we assume that the buffer is big
- # enough to write/read everything we need. If it's not, it's undefined
- # behavior anyway, although in theory we could probably detect such
- # cases here
- self.size = size
- self.buffer = RawBuffer(cpu, logops)
-
- def getintbound(self):
- return IntUnbounded()
-
- def getlength(self):
- return len(self.buffer.values)
-
- def get_item_value(self, i):
- return self.buffer.values[i]
-
- def set_item_value(self, i, newval):
- self.buffer.values[i] = newval
-
- def getitem_raw(self, offset, length, descr):
- if not self.is_virtual():
- raise InvalidRawOperation
- # see 'test_virtual_raw_buffer_forced_but_slice_not_forced'
- # for the test above: it's not enough to check is_virtual()
- # on the original object, because it might be a VRawSliceValue
- # instead. If it is a virtual one, then we'll reach here anway.
- return self.buffer.read_value(offset, length, descr)
-
- def setitem_raw(self, offset, length, descr, value):
- if not self.is_virtual():
- raise InvalidRawOperation
- self.buffer.write_value(offset, length, descr, value)
-
- def _really_force(self, optforce):
- op = self.source_op
- assert op is not None
- if not we_are_translated():
- op.name = 'FORCE ' + self.source_op.name
- optforce.emit_operation(self.source_op)
- self.box = optforce.getlastop()
- for i in range(len(self.buffer.offsets)):
- # write the value
- offset = self.buffer.offsets[i]
- descr = self.buffer.descrs[i]
- itemvalue = self.buffer.values[i]
- itembox = itemvalue.force_box(optforce)
- op = ResOperation(rop.RAW_STORE,
- [self.box, ConstInt(offset), itembox],
- descr=descr)
- optforce.emit_operation(op)
-
- @specialize.argtype(1)
- def _visitor_dispatch_virtual_type(self, visitor):
- # I *think* we need to make a copy of offsets and descrs because we
- # want a snapshot of the virtual state right now: if we grow more
- # elements later, we don't want them to go in this virtual state
- return visitor.visit_vrawbuffer(self.size,
- self.buffer.offsets[:],
- self.buffer.descrs[:])
-
-
-class VRawSliceInfo(AbstractVirtualInfo):
- is_about_raw = True
-
- def __init__(self, rawbuffer_value, offset, source_op):
- AbstractVirtualValue.__init__(self, source_op)
- self.rawbuffer_value = rawbuffer_value
- self.offset = offset
-
- def getintbound(self):
- return IntUnbounded()
-
- def _really_force(self, optforce):
- op = self.source_op
- assert op is not None
- if not we_are_translated():
- op.name = 'FORCE ' + self.source_op.name
- self.rawbuffer_value.force_box(optforce)
- optforce.emit_operation(op)
- self.box = optforce.getlastop()
-
- def setitem_raw(self, offset, length, descr, value):
- self.rawbuffer_value.setitem_raw(self.offset+offset, length, descr,
value)
-
- def getitem_raw(self, offset, length, descr):
- return self.rawbuffer_value.getitem_raw(self.offset+offset, length,
descr)
-
- def _visitor_walk_recursive(self, visitor):
- box = self.rawbuffer_value.get_key_box()
- visitor.register_virtual_fields(self.keybox, [box])
- self.rawbuffer_value.visitor_walk_recursive(visitor)
-
- @specialize.argtype(1)
- def _visitor_dispatch_virtual_type(self, visitor):
- return visitor.visit_vrawslice(self.offset)
class OptVirtualize(optimizer.Optimization):
_______________________________________________
pypy-commit mailing list
[email protected]
https://mail.python.org/mailman/listinfo/pypy-commit
