Author: fijal
Branch: jit-leaner-frontend
Changeset: r83341:3136716f1017
Date: 2016-03-25 13:08 +0200
http://bitbucket.org/pypy/pypy/changeset/3136716f1017/

Log:    whack a bit where we store metainterp_sd. Additionally use USHORT as
        opposed to SHORT

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
@@ -76,7 +76,7 @@
 
         #assert not unroll
         opt = Optimizer(metainterp_sd, jitdriver_sd, optimizations)
-        return opt.propagate_all_forward(self.trace.get_iter(metainterp_sd),
+        return opt.propagate_all_forward(self.trace.get_iter(),
             self.call_pure_results)
 
 class BridgeCompileData(CompileData):
diff --git a/rpython/jit/metainterp/history.py 
b/rpython/jit/metainterp/history.py
--- a/rpython/jit/metainterp/history.py
+++ b/rpython/jit/metainterp/history.py
@@ -674,10 +674,10 @@
         self.consts = []
         self._cache = []
 
-    def set_inputargs(self, inpargs):
+    def set_inputargs(self, inpargs, metainterp_sd):
         from rpython.jit.metainterp.opencoder import Trace
 
-        self.trace = Trace(inpargs)
+        self.trace = Trace(inpargs, metainterp_sd)
         self.inputargs = inpargs
         if self._cache:
             # hack to record the ops *after* we know our inputargs
@@ -860,7 +860,7 @@
 
     def check_history(self, expected=None, **check):
         insns = {}
-        t = self.history.trace.get_iter(self.metainterp_sd)
+        t = self.history.trace.get_iter()
         while not t.done():
             op = t.next()
             opname = op.getopname()
diff --git a/rpython/jit/metainterp/logger.py b/rpython/jit/metainterp/logger.py
--- a/rpython/jit/metainterp/logger.py
+++ b/rpython/jit/metainterp/logger.py
@@ -20,7 +20,7 @@
 
     def _unpack_trace(self, trace):
         ops = []
-        i = trace.get_iter(self.metainterp_sd)
+        i = trace.get_iter()
         while not i.done():
             ops.append(i.next())
         return i.inputargs, ops
diff --git a/rpython/jit/metainterp/opencoder.py 
b/rpython/jit/metainterp/opencoder.py
--- a/rpython/jit/metainterp/opencoder.py
+++ b/rpython/jit/metainterp/opencoder.py
@@ -18,10 +18,13 @@
 TAGINT, TAGCONSTPTR, TAGCONSTOTHER, TAGBOX = range(4)
 TAGMASK = 0x3
 TAGSHIFT = 2
-SMALL_INT_STOP  = 2 ** (15 - TAGSHIFT)
-SMALL_INT_START = -SMALL_INT_STOP
-MIN_SHORT = -2**15 + 1
-MAX_SHORT = 2**15 - 1
+
+STORAGE_TP = rffi.USHORT
+MAX_SIZE = 2**16-1
+SMALL_INT_STOP  = (2 ** (15 - TAGSHIFT)) - 1
+SMALL_INT_START = -SMALL_INT_STOP # we might want to distribute them uneven
+MIN_SHORT = 0
+MAX_SHORT = 2**16 - 1
 
 class FrontendTagOverflow(Exception):
     pass
@@ -78,6 +81,7 @@
                  metainterp_sd=None):
         self.trace = trace
         self.metainterp_sd = metainterp_sd
+        self.all_descr_len = len(metainterp_sd.all_descrs)
         self._cache = [None] * trace._index
         if force_inputargs is not None:
             # the trace here is cut and we're working from
@@ -98,8 +102,8 @@
         self.start_index = start
         self.end = end
 
-    def get_dead_ranges(self, metainterp_sd=None):
-        return self.trace.get_dead_ranges(self.metainterp_sd)
+    def get_dead_ranges(self):
+        return self.trace.get_dead_ranges()
 
     def kill_cache_at(self, pos):
         if pos:
@@ -123,7 +127,7 @@
         if tag == TAGBOX:
             return self._get(v)
         elif tag == TAGINT:
-            return ConstInt(v)
+            return ConstInt(v + SMALL_INT_START)
         elif tag == TAGCONSTPTR:
             return ConstPtr(self.trace._refs[v])
         elif tag == TAGCONSTOTHER:
@@ -174,10 +178,10 @@
             if descr_index == 0 or rop.is_guard(opnum):
                 descr = None
             else:
-                if descr_index < 0:
-                    descr = self.metainterp_sd.all_descrs[-descr_index-1]
+                if descr_index < self.all_descr_len + 1:
+                    descr = self.metainterp_sd.all_descrs[descr_index - 1]
                 else:
-                    descr = self.trace._descrs[descr_index]
+                    descr = self.trace._descrs[descr_index - 
self.all_descr_len - 1]
         else:
             descr = None
         res = ResOperation(opnum, args, descr=descr)
@@ -202,9 +206,10 @@
         assert cut[1] > self.count
         self.trace.cut_at(cut)
 
-    def get_iter(self, metainterp_sd=None):
+    def get_iter(self):
         iter = TraceIterator(self.trace, self.start, self.trace._pos,
-                             self.inputargs, metainterp_sd=metainterp_sd)
+                             self.inputargs,
+                             metainterp_sd=self.trace.metainterp_sd)
         iter._count = self.count
         iter.start_index = self.index
         iter._index = self.index
@@ -237,8 +242,8 @@
 class Trace(BaseTrace):
     _deadranges = (-1, None)
 
-    def __init__(self, inputargs):
-        self._ops = [rffi.cast(rffi.SHORT, -15)] * 30000
+    def __init__(self, inputargs, metainterp_sd):
+        self._ops = [rffi.cast(STORAGE_TP, 0)] * MAX_SIZE
         self._pos = 0
         self._consts_bigint = 0
         self._consts_float = 0
@@ -259,14 +264,15 @@
         self._start = len(inputargs)
         self._pos = self._start
         self.inputargs = inputargs
+        self.metainterp_sd = metainterp_sd
 
     def append(self, v):
         if self._pos >= len(self._ops):
             # grow by 2X
-            self._ops = self._ops + [rffi.cast(rffi.SHORT, -15)] * 
len(self._ops)
-        if not MIN_SHORT < v < MAX_SHORT:
+            self._ops = self._ops + [rffi.cast(STORAGE_TP, 0)] * len(self._ops)
+        if not MIN_SHORT <= v <= MAX_SHORT:
             raise FrontendTagOverflow
-        self._ops[self._pos] = rffi.cast(rffi.SHORT, v)
+        self._ops[self._pos] = rffi.cast(STORAGE_TP, v)
         self._pos += 1
 
     def done(self):
@@ -305,7 +311,7 @@
             if (isinstance(box, ConstInt) and
                 isinstance(box.getint(), int) and # symbolics
                 SMALL_INT_START <= box.getint() < SMALL_INT_STOP):
-                return tag(TAGINT, box.getint())
+                return tag(TAGINT, box.getint() - SMALL_INT_START)
             elif isinstance(box, ConstInt):
                 self._consts_bigint += 1
                 if not isinstance(box.getint(), int):
@@ -367,18 +373,18 @@
 
     def _encode_descr(self, descr):
         if descr.descr_index != -1:
-            return -descr.descr_index-1
+            return descr.descr_index + 1
         self._descrs.append(descr)
-        return len(self._descrs) - 1
+        return len(self._descrs) - 1 + len(self.metainterp_sd.all_descrs) + 1
 
     def _list_of_boxes(self, boxes):
-        array = [rffi.cast(rffi.SHORT, 0)] * len(boxes)
+        array = [rffi.cast(STORAGE_TP, 0)] * len(boxes)
         for i in range(len(boxes)):
             array[i] = self._encode(boxes[i])
         return array
 
     def new_array(self, lgt):
-        return [rffi.cast(rffi.SHORT, 0)] * lgt
+        return [rffi.cast(STORAGE_TP, 0)] * lgt
 
     def create_top_snapshot(self, jitcode, pc, frame, flag, vable_boxes, 
vref_boxes):
         self._total_snapshots += 1
@@ -390,7 +396,7 @@
         assert rffi.cast(lltype.Signed, self._ops[self._pos - 1]) == 0
         # guards have no descr
         self._snapshots.append(s)
-        self._ops[self._pos - 1] = rffi.cast(rffi.SHORT, len(self._snapshots) 
- 1)
+        self._ops[self._pos - 1] = rffi.cast(STORAGE_TP, len(self._snapshots) 
- 1)
         return s
 
     def create_empty_top_snapshot(self, vable_boxes, vref_boxes):
@@ -402,7 +408,7 @@
         assert rffi.cast(lltype.Signed, self._ops[self._pos - 1]) == 0
         # guards have no descr
         self._snapshots.append(s)
-        self._ops[self._pos - 1] = rffi.cast(rffi.SHORT, len(self._snapshots) 
- 1)
+        self._ops[self._pos - 1] = rffi.cast(STORAGE_TP, len(self._snapshots) 
- 1)
         return s
 
     def create_snapshot(self, jitcode, pc, frame, flag):
@@ -410,19 +416,19 @@
         array = frame.get_list_of_active_boxes(flag, self.new_array, 
self._encode)
         return Snapshot(combine_uint(jitcode.index, pc), array)
 
-    def get_iter(self, metainterp_sd=None):
-        assert metainterp_sd
-        return TraceIterator(self, self._start, self._pos, 
metainterp_sd=metainterp_sd)
+    def get_iter(self):
+        return TraceIterator(self, self._start, self._pos,
+                             metainterp_sd=self.metainterp_sd)
 
-    def get_live_ranges(self, metainterp_sd):
-        t = self.get_iter(metainterp_sd)
+    def get_live_ranges(self):
+        t = self.get_iter()
         liveranges = [0] * self._index
         index = t._count
         while not t.done():
             index = t.next_element_update_live_range(index, liveranges)
         return liveranges
 
-    def get_dead_ranges(self, metainterp_sd=None):
+    def get_dead_ranges(self):
         """ Same as get_live_ranges, but returns a list of "dying" indexes,
         such as for each index x, the number found there is for sure dead
         before x
@@ -438,7 +444,7 @@
         if self._deadranges != (-1, None):
             if self._deadranges[0] == self._count:
                 return self._deadranges[1]
-        liveranges = self.get_live_ranges(metainterp_sd)
+        liveranges = self.get_live_ranges()
         deadranges = [0] * (self._index + 2)
         assert len(deadranges) == len(liveranges) + 2
         for i in range(self._start, len(liveranges)):
@@ -448,8 +454,8 @@
         self._deadranges = (self._count, deadranges)
         return deadranges
 
-    def unpack(self, metainterp_sd):
-        iter = self.get_iter(metainterp_sd)
+    def unpack(self):
+        iter = self.get_iter()
         ops = []
         while not iter.done():
             ops.append(iter.next())
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
@@ -123,8 +123,7 @@
     
     def optimize_preamble(self, trace, runtime_boxes, call_pure_results, memo):
         info, newops = self.optimizer.propagate_all_forward(
-            trace.get_iter(self.optimizer.metainterp_sd),
-            call_pure_results, flush=False)
+            trace.get_iter(), call_pure_results, flush=False)
         exported_state = self.export_state(info.jump_op.getarglist(),
                                            info.inputargs,
                                            runtime_boxes, memo)
@@ -136,7 +135,7 @@
 
     def optimize_peeled_loop(self, trace, celltoken, state,
                              call_pure_results, inline_short_preamble=True):
-        trace = trace.get_iter(self.optimizer.metainterp_sd)
+        trace = trace.get_iter()
         try:
             label_args = self.import_state(trace.inputargs, state)
         except VirtualStatesCantMatch:
@@ -227,7 +226,7 @@
 
     def optimize_bridge(self, trace, runtime_boxes, call_pure_results,
                         inline_short_preamble, box_names_memo):
-        trace = trace.get_iter(self.optimizer.metainterp_sd)
+        trace = trace.get_iter()
         self._check_no_forwarding([trace.inputargs])
         info, ops = self.optimizer.propagate_all_forward(trace,
             call_pure_results, False)
diff --git a/rpython/jit/metainterp/pyjitpl.py 
b/rpython/jit/metainterp/pyjitpl.py
--- a/rpython/jit/metainterp/pyjitpl.py
+++ b/rpython/jit/metainterp/pyjitpl.py
@@ -2332,7 +2332,8 @@
         num_green_args = self.jitdriver_sd.num_green_args
         original_greenkey = original_boxes[:num_green_args]
         self.resumekey = compile.ResumeFromInterpDescr(original_greenkey)
-        self.history.set_inputargs(original_boxes[num_green_args:])
+        self.history.set_inputargs(original_boxes[num_green_args:],
+                                   self.staticdata)
         self.seen_loop_header_for_jdindex = -1
         try:
             self.interpret()
@@ -2552,7 +2553,7 @@
             except ChangeFrame:
                 pass
         else:
-            self.history.set_inputargs(inputargs)
+            self.history.set_inputargs(inputargs, self.staticdata)
             assert not exception
 
     def get_procedure_token(self, greenkey, with_compiled_targets=False):
diff --git a/rpython/jit/metainterp/test/test_opencoder.py 
b/rpython/jit/metainterp/test/test_opencoder.py
--- a/rpython/jit/metainterp/test/test_opencoder.py
+++ b/rpython/jit/metainterp/test/test_opencoder.py
@@ -17,7 +17,7 @@
     pass
 
 class metainterp_sd(object):
-    pass
+    all_descrs = []
 
 class FakeOp(AbstractResOp):
     def __init__(self, pos):
_______________________________________________
pypy-commit mailing list
pypy-commit@python.org
https://mail.python.org/mailman/listinfo/pypy-commit

Reply via email to