[pypy-commit] pypy jit-leaner-frontend: start passing those tests, slowly

fijal pypy.commits at gmail.com
Mon Mar 7 03:35:41 EST 2016


Author: fijal
Branch: jit-leaner-frontend
Changeset: r82837:7d27725a0a80
Date: 2016-03-07 10:34 +0200
http://bitbucket.org/pypy/pypy/changeset/7d27725a0a80/

Log:	start passing those tests, slowly

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
@@ -29,7 +29,7 @@
     memo = None
     
     def forget_optimization_info(self):
-        return
+        return # no longer necessary?
         for arg in self.start_label.getarglist():
             arg.set_forwarded(None)
         for op in self.operations:
@@ -41,14 +41,14 @@
 
     This is the case of label() ops label()
     """
-    def __init__(self, start_label, end_label, operations,
+    def __init__(self, start_label, end_label, trace,
                  call_pure_results=None, enable_opts=None):
         self.start_label = start_label
         self.end_label = end_label
         self.enable_opts = enable_opts
         assert start_label.getopnum() == rop.LABEL
         assert end_label.getopnum() == rop.LABEL
-        self.operations = operations
+        self.trace = trace
         self.call_pure_results = call_pure_results
 
     def optimize(self, metainterp_sd, jitdriver_sd, optimizations, unroll):
@@ -58,13 +58,13 @@
         if unroll:
             opt = UnrollOptimizer(metainterp_sd, jitdriver_sd, optimizations)
             return opt.optimize_preamble(self.start_label, self.end_label,
-                                         self.operations,
+                                         self.trace,
                                          self.call_pure_results,
                                          self.box_names_memo)
         else:
             opt = Optimizer(metainterp_sd, jitdriver_sd, optimizations)
             return opt.propagate_all_forward(self.start_label.getarglist(),
-               self.operations, self.call_pure_results)
+               self.trace, self.call_pure_results)
 
 class SimpleCompileData(CompileData):
     """ This represents label() ops jump with no extra info associated with
@@ -264,7 +264,8 @@
         enable_opts = enable_opts.copy()
         del enable_opts['unroll']
 
-    ops = history.operations[start:]
+    assert start == 0
+    #ops = history.operations[start:]
     if 'unroll' not in enable_opts or not metainterp.cpu.supports_guard_gc_type:
         return compile_simple_loop(metainterp, greenkey, start, inputargs, ops,
                                    jumpargs, enable_opts)
@@ -273,7 +274,7 @@
                          descr=TargetToken(jitcell_token))
     end_label = ResOperation(rop.LABEL, jumpargs, descr=jitcell_token)
     call_pure_results = metainterp.call_pure_results
-    preamble_data = LoopCompileData(label, end_label, ops,
+    preamble_data = LoopCompileData(label, end_label, history.trace,
                                     call_pure_results=call_pure_results,
                                     enable_opts=enable_opts)
     try:
@@ -291,7 +292,7 @@
     start_descr = TargetToken(jitcell_token,
                               original_jitcell_token=jitcell_token)
     jitcell_token.target_tokens = [start_descr]
-    loop_data = UnrolledLoopData(end_label, jump_op, ops, start_state,
+    loop_data = UnrolledLoopData(end_label, jump_op, history.trace, start_state,
                                  call_pure_results=call_pure_results,
                                  enable_opts=enable_opts)
     try:
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
@@ -654,6 +654,9 @@
         self.trace = Trace(inpargs)
         self.inputargs = inpargs
 
+    def length(self):
+        return self.trace._count
+
     def any_operation(self):
         return self.trace._count > 0
 
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
@@ -37,10 +37,13 @@
         return res
 
     def next(self):
-        r = self.main_iter._get(self._next())
+        r = self.main_iter._untag(self._next())
         assert r
         return r
 
+    def read_boxes(self, size):
+        return [self.next() for i in range(size)]
+
     def get_size_jitcode_pc(self):
         if self.save_pos >= 0:
             self.pos = self.save_pos
@@ -132,6 +135,9 @@
         self._count = 0
         self.inputargs = inputargs
 
+    def length(self):
+        return len(self._ops)
+
     def _encode(self, box):
         if isinstance(box, Const):
             if (isinstance(box, ConstInt) and
@@ -203,7 +209,7 @@
         self._ops.append(jitcode.index)
         self._ops.append(pc)
         for box in active_boxes:
-            self._ops.append(box.position) # not tagged, as it must be boxes
+            self._ops.append(self._encode(box)) # not tagged, as it must be boxes
         return pos
 
     def get_patchable_position(self):
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
@@ -121,12 +121,11 @@
         if check_newops:
             assert not self.optimizer._newoperations
     
-    def optimize_preamble(self, start_label, end_label, ops, call_pure_results,
+    def optimize_preamble(self, start_label, end_label, trace, call_pure_results,
                           memo):
-        self._check_no_forwarding([[start_label, end_label], ops])
-        info, newops = self.optimizer.propagate_all_forward(
-            start_label.getarglist()[:], ops, call_pure_results, True,
-            flush=False)
+        #self._check_no_forwarding([[start_label, end_label], ops])
+        info, newops = self.optimizer.propagate_all_forward(trace,
+            call_pure_results, flush=False)
         exported_state = self.export_state(start_label, end_label.getarglist(),
                                            info.inputargs, memo)
         exported_state.quasi_immutable_deps = info.quasi_immutable_deps
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
@@ -2259,7 +2259,7 @@
 
     def blackhole_if_trace_too_long(self):
         warmrunnerstate = self.jitdriver_sd.warmstate
-        if len(self.history.operations) > warmrunnerstate.trace_limit:
+        if self.history.length() > warmrunnerstate.trace_limit:
             jd_sd, greenkey_of_huge_function = self.find_biggest_function()
             self.staticdata.stats.record_aborted(greenkey_of_huge_function)
             self.portal_trace_positions = None
diff --git a/rpython/jit/metainterp/resume.py b/rpython/jit/metainterp/resume.py
--- a/rpython/jit/metainterp/resume.py
+++ b/rpython/jit/metainterp/resume.py
@@ -129,6 +129,7 @@
 
 def capture_resumedata(framestack, virtualizable_boxes, virtualref_boxes, t):
     n = len(framestack) - 1
+    result = t.length()
     if virtualizable_boxes is not None:
         virtualizable_boxes = ([virtualizable_boxes[-1]] +
                                 virtualizable_boxes[:-1])
@@ -147,6 +148,7 @@
         snapshot_storage.rd_frame_info_list = None
         snapshot_storage.rd_snapshot = TopSnapshot(None, virtualref_boxes,
                                                    virtualizable_boxes)
+    return result
 
 PENDINGFIELDSTRUCT = lltype.Struct('PendingField',
                                    ('lldescr', OBJECTPTR),
@@ -263,6 +265,8 @@
         """
         n = state.n
         v = state.v
+        import pdb
+        pdb.set_trace()
         liveboxes = state.liveboxes
         for i in range(length):
             box = iter.next()
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
@@ -24,6 +24,20 @@
     def get_list_of_active_boxes(self, flag):
         return self.boxes
 
+def unpack_snapshot(t, pos):
+    trace = t.trace
+    first = trace._ops[pos] # this is the size
+    pos += 1
+    boxes = []
+    while first > pos + 1:
+        snapshot_size = trace._ops[pos]
+        # 2 for jitcode and pc
+        pos += 1 + 2
+        boxes += [t._untag(trace._ops[i + pos]) for i in range(snapshot_size)]
+        pos += len(boxes)
+    return boxes
+
+
 class TestOpencoder(object):
     def unpack(self, t):
         iter = t.get_iter()
@@ -46,19 +60,6 @@
         assert l[0].getarg(0) is i0
         assert l[0].getarg(1) is i1
 
-    def unpack_snapshot(self, t, pos):
-        trace = t.trace
-        first = trace._ops[pos] # this is the size
-        pos += 1
-        boxes = []
-        while first > pos + 1:
-            snapshot_size = trace._ops[pos]
-            # 2 for jitcode and pc
-            pos += 1 + 2
-            boxes += [t._get(trace._ops[i + pos]) for i in range(snapshot_size)]
-            pos += len(boxes)
-        return boxes
-
     def test_rd_snapshot(self):
         i0, i1 = InputArgInt(), InputArgInt()
         t = Trace([i0, i1])
@@ -71,16 +72,16 @@
         resume.capture_resumedata(framestack, None, [], t)
         (i0, i1), l, iter = self.unpack(t)
         assert l[1].opnum == rop.GUARD_FALSE
-        boxes = self.unpack_snapshot(iter, l[1].rd_resume_position)
+        boxes = unpack_snapshot(iter, l[1].rd_resume_position)
         assert boxes == [i0, i1]
         t.record_op(rop.GUARD_FALSE, [add])
         resume.capture_resumedata([frame0, frame1], None, [], t)
         (i0, i1), l, iter = self.unpack(t)
         assert l[1].opnum == rop.GUARD_FALSE
-        boxes = self.unpack_snapshot(iter, l[1].rd_resume_position)
+        boxes = unpack_snapshot(iter, l[1].rd_resume_position)
         assert boxes == [i0, i1]
         assert l[2].opnum == rop.GUARD_FALSE
-        boxes = self.unpack_snapshot(iter, l[2].rd_resume_position)
+        boxes = unpack_snapshot(iter, l[2].rd_resume_position)
         assert boxes == [i0, i1, i0, i0, l[0]]
 
     def test_read_snapshot_interface(self):
diff --git a/rpython/jit/metainterp/test/test_resume.py b/rpython/jit/metainterp/test/test_resume.py
--- a/rpython/jit/metainterp/test/test_resume.py
+++ b/rpython/jit/metainterp/test/test_resume.py
@@ -13,6 +13,7 @@
      annlowlevel, PENDINGFIELDSP, unpack_uint, TAG_CONST_OFFSET, TopSnapshot
 from rpython.jit.metainterp.resumecode import unpack_numbering,\
      create_numbering, NULL_NUMBER
+from rpython.jit.metainterp.opencoder import Trace
 
 from rpython.jit.metainterp.optimizeopt import info
 from rpython.jit.metainterp.history import ConstInt, Const, AbstractDescr
@@ -145,7 +146,7 @@
     class FakeVirtualValue(info.AbstractVirtualPtrInfo):
         def visitor_dispatch_virtual_type(self, *args):
             return FakeVInfo()
-    modifier = ResumeDataVirtualAdder(None, None, None, None)
+    modifier = ResumeDataVirtualAdder(None, None, None, None, None)
     v1 = FakeVirtualValue()
     vinfo1 = modifier.make_virtual_info(v1, [1, 2, 4])
     vinfo2 = modifier.make_virtual_info(v1, [1, 2, 4])
@@ -502,8 +503,7 @@
 
 
 class FakeFrame(object):
-    parent_resumedata_snapshot = None
-    parent_resumedata_frame_info_list = None
+    parent_resume_position = -1
 
     def __init__(self, code, pc, *boxes):
         self.jitcode = code
@@ -539,49 +539,35 @@
         self.name = name
         self.index = index
 
-def test_FrameInfo_create():
-    jitcode = FakeJitCode("jitcode", 13)
-    fi = FrameInfo(None, jitcode, 1)
-    assert fi.prev is None
-    jitcode_pos, pc = unpack_uint(fi.packed_jitcode_pc)
-    assert jitcode_pos == 13
-    assert pc == 1
-
-    jitcode1 = FakeJitCode("JITCODE1", 42)
-    fi1 = FrameInfo(fi, jitcode1, 3)
-    assert fi1.prev is fi
-    jitcode_pos, pc = unpack_uint(fi1.packed_jitcode_pc)
-    assert jitcode_pos == 42
-    assert pc == 3
-
 def test_capture_resumedata():
     b1, b2, b3 = [InputArgInt(), InputArgRef(), InputArgInt()]
     c1, c2, c3 = [ConstInt(1), ConstInt(2), ConstInt(3)]
     fs = [FakeFrame(FakeJitCode("code0", 13), 0, b1, c1, b2)]
 
-    storage = Storage()
-    capture_resumedata(fs, None, [], storage)
+    t = Trace([b1, b2, b3])
+    pos = capture_resumedata(fs, None, [], t)
 
-    assert fs[0].parent_resumedata_snapshot is None
-    assert fs[0].parent_resumedata_frame_info_list is None
+    assert fs[0].parent_resume_position == -1
+    s = t.get_iter().get_snapshot_iter(pos)
 
-    assert storage.rd_frame_info_list.prev is None
-    assert unpack_uint(storage.rd_frame_info_list.packed_jitcode_pc)[0] == 13
-    assert storage.rd_snapshot.boxes == []    # for virtualrefs
-    snapshot = storage.rd_snapshot.prev
-    assert snapshot.prev is None
-    assert snapshot.boxes == fs[0]._env
+    size, jitcode, pc = s.get_size_jitcode_pc()
+    assert jitcode == 13
+    boxes = s.read_boxes(size)
+    assert boxes == fs[0]._env
 
     storage = Storage()
     fs = [FakeFrame(FakeJitCode("code0", 0), 0, b1, c1, b2),
           FakeFrame(FakeJitCode("code1", 1), 3, b3, c2, b1),
           FakeFrame(FakeJitCode("code2", 2), 9, c3, b2)]
-    capture_resumedata(fs, None, [], storage)
+    t = Trace([b1, b2, b3])
+    pos = capture_resumedata(fs, None, [], t)
 
-    frame_info_list = storage.rd_frame_info_list
-    assert frame_info_list.prev is fs[2].parent_resumedata_frame_info_list
-    assert unpack_uint(frame_info_list.packed_jitcode_pc) == (2, 9)
+    assert fs[2].parent_resume_position != -1
+    s = t.get_iter().get_snapshot_iter(pos)
+    size, jitcode, pc = s.get_size_jitcode_pc()
+    assert (jitcode, pc) == (2, 9)
 
+    xxx
     assert storage.rd_snapshot.boxes == []    # for virtualrefs
     snapshot = storage.rd_snapshot.prev
     assert snapshot.prev is fs[2].parent_resumedata_snapshot


More information about the pypy-commit mailing list