Author: Armin Rigo <[email protected]>
Branch: jit-constptr-2
Changeset: r83591:a18554508f77
Date: 2016-04-09 17:08 +0300
http://bitbucket.org/pypy/pypy/changeset/a18554508f77/
Log: Kill _record_constptrs, no longer used
diff --git a/rpython/jit/backend/llsupport/gc.py
b/rpython/jit/backend/llsupport/gc.py
--- a/rpython/jit/backend/llsupport/gc.py
+++ b/rpython/jit/backend/llsupport/gc.py
@@ -22,38 +22,6 @@
from rpython.memory.gctransform import asmgcroot
from rpython.jit.codewriter.effectinfo import EffectInfo
-class MovableObjectTracker(object):
-
- ptr_array_type = lltype.GcArray(llmemory.GCREF)
- ptr_array_gcref = lltype.nullptr(llmemory.GCREF.TO)
-
- def __init__(self, cpu, const_pointers):
- size = len(const_pointers)
- # check that there are any moving object (i.e. chaning pointers).
- # Otherwise there is no reason for an instance of this class.
- assert size > 0
- #
- # prepare GC array to hold the pointers that may change
- self.ptr_array = lltype.malloc(MovableObjectTracker.ptr_array_type,
size)
- self.ptr_array_descr =
cpu.arraydescrof(MovableObjectTracker.ptr_array_type)
- self.ptr_array_gcref = lltype.cast_opaque_ptr(llmemory.GCREF,
self.ptr_array)
- # use always the same ConstPtr to access the array
- # (easer to read JIT trace)
- self.const_ptr_gcref_array = ConstPtr(self.ptr_array_gcref)
- #
- # assign each pointer an index and put the pointer into the GC array.
- # as pointers and addresses are not a good key to use before
translation
- # ConstPtrs are used as the key for the dict.
- self._indexes = {}
- for index in range(size):
- ptr = const_pointers[index]
- self._indexes[ptr] = index
- self.ptr_array[index] = ptr.value
-
- def get_array_index(self, const_ptr):
- index = self._indexes[const_ptr]
- assert const_ptr.value == self.ptr_array[index]
- return index
# ____________________________________________________________
class GcLLDescription(GcCache):
@@ -129,101 +97,11 @@
def gc_malloc_unicode(self, num_elem):
return self._bh_malloc_array(num_elem, self.unicode_descr)
- def _record_constptrs(self, op, gcrefs_output_list,
- ops_with_movable_const_ptr,
- changeable_const_pointers):
- l = None
- for i in range(op.numargs()):
- v = op.getarg(i)
- if isinstance(v, ConstPtr) and bool(v.value):
- p = v.value
- if not rgc.can_move(p):
- gcrefs_output_list.append(p)
- else:
- if l is None:
- l = [i]
- else:
- l.append(i)
- if v not in changeable_const_pointers:
- changeable_const_pointers.append(v)
- #
- if op.is_guard() or op.getopnum() == rop.FINISH:
- llref = cast_instance_to_gcref(op.getdescr())
- assert rgc._make_sure_does_not_move(llref)
- gcrefs_output_list.append(llref)
- #
- if l:
- ops_with_movable_const_ptr[op] = l
-
- def _rewrite_changeable_constptrs(self, op, ops_with_movable_const_ptr,
moving_obj_tracker):
- newops = []
- for arg_i in ops_with_movable_const_ptr[op]:
- v = op.getarg(arg_i)
- # assert to make sure we got what we expected
- assert isinstance(v, ConstPtr)
- array_index = moving_obj_tracker.get_array_index(v)
-
- size, offset, _ =
unpack_arraydescr(moving_obj_tracker.ptr_array_descr)
- array_index = array_index * size + offset
- args = [moving_obj_tracker.const_ptr_gcref_array,
- ConstInt(array_index),
- ConstInt(size)]
- load_op = ResOperation(rop.GC_LOAD_R, args)
- newops.append(load_op)
- op.setarg(arg_i, load_op)
- #
- newops.append(op)
- return newops
-
def rewrite_assembler(self, cpu, operations, gcrefs_output_list):
rewriter = GcRewriterAssembler(self, cpu)
newops = rewriter.rewrite(operations, gcrefs_output_list)
return newops
- XXX # kill the rest
-
- # the key is an operation that contains a ConstPtr as an argument and
- # this ConstPtrs pointer might change as it points to an object that
- # can't be made non-moving (e.g. the object is pinned).
- ops_with_movable_const_ptr = {}
- #
- # a list of such not really constant ConstPtrs.
- changeable_const_pointers = []
- for op in newops:
- # record all GCREFs, because the GC (or Boehm) cannot see them and
- # keep them alive if they end up as constants in the assembler.
- # If such a GCREF can change and we can't make the object it points
- # to non-movable, we have to handle it seperatly. Such GCREF's are
- # returned as ConstPtrs in 'changeable_const_pointers' and the
- # affected operation is returned in 'op_with_movable_const_ptr'.
- # For this special case see 'rewrite_changeable_constptrs'.
- self._record_constptrs(op, gcrefs_output_list,
- ops_with_movable_const_ptr, changeable_const_pointers)
- #
- # handle pointers that are not guaranteed to stay the same
- if len(ops_with_movable_const_ptr) > 0:
- moving_obj_tracker = MovableObjectTracker(cpu,
changeable_const_pointers)
- #
- if not we_are_translated():
- # used for testing
- self.last_moving_obj_tracker = moving_obj_tracker
- # make sure the array containing the pointers is not collected by
- # the GC (or Boehm)
- gcrefs_output_list.append(moving_obj_tracker.ptr_array_gcref)
- rgc._make_sure_does_not_move(moving_obj_tracker.ptr_array_gcref)
-
- ops = newops
- newops = []
- for op in ops:
- if op in ops_with_movable_const_ptr:
- rewritten_ops = self._rewrite_changeable_constptrs(op,
- ops_with_movable_const_ptr, moving_obj_tracker)
- newops.extend(rewritten_ops)
- else:
- newops.append(op)
- #
- return newops
-
@specialize.memo()
def getframedescrs(self, cpu):
descrs = JitFrameDescrs()
_______________________________________________
pypy-commit mailing list
[email protected]
https://mail.python.org/mailman/listinfo/pypy-commit
