Add fast-path unary operations and optional heapcache-skipping record helpers

Author: 3tty0n

rpython/jit/codewriter/genextension.py

@@ -1031,6 +1031,64 @@ def emit_unspecialized_float_gt(self):
     def emit_unspecialized_float_ge(self):
         return self._emit_unspecialized_float_comparison_fast("FLOAT_GE", ">=")
 
+    def _emit_unspecialized_int_unary_fast(self, rop_name, py_op):
+        arg0, result = self._get_args_and_res()
+        lines = []
+        self._emit_sync_registers(lines)
+        box0 = self._get_as_box_after_sync(arg0)
+        lines.append("_v0 = %s" % self._get_as_unboxed_after_sync(arg0))
+        lines.append("_res = %s_v0" % py_op)
+        lines.append("_op = self.metainterp.history.record1_int(rop.%s, %s, _res)" % (
+            rop_name, box0))
+        lines.append("self.registers_i[%d] = _op" % result.index)
+        lines.append("i%d = _res" % result.index)
+        next_consts = self.constant_registers - {result}
+        self._emit_jump(lines, constant_registers=next_consts)
+        return lines
+
+    def _emit_unspecialized_float_unary_fast(self, rop_name, py_op):
+        arg0, result = self._get_args_and_res()
+        lines = []
+        self._emit_sync_registers(lines)
+        box0 = self._get_as_box_after_sync(arg0)
+        lines.append("_v0 = %s" % self._get_as_unboxed_after_sync(arg0))
+        lines.append("_res = %s_v0" % py_op)
+        lines.append("_op = self.metainterp.history.record1_float(rop.%s, %s, _res)" % (
+            rop_name, box0))
+        lines.append("self.registers_f[%d] = _op" % result.index)
+        lines.append("f%d = _res" % result.index)
+        next_consts = self.constant_registers - {result}
+        self._emit_jump(lines, constant_registers=next_consts)
+        return lines
+
+    def _emit_unspecialized_int_is_true_fast(self):
+        arg0, result = self._get_args_and_res()
+        lines = []
+        self._emit_sync_registers(lines)
+        box0 = self._get_as_box_after_sync(arg0)
+        lines.append("_v0 = %s" % self._get_as_unboxed_after_sync(arg0))
+        lines.append("_res = int(bool(_v0))")
+        lines.append("_op = self.metainterp.history.record1_int(rop.INT_IS_TRUE, %s, _res)" % box0)
+        lines.append("self.registers_i[%d] = _op" % result.index)
+        lines.append("i%d = _res" % result.index)
+        next_consts = self.constant_registers - {result}
+        self._emit_jump(lines, constant_registers=next_consts)
+        return lines
+
+    def _emit_unspecialized_int_is_zero_fast(self):
+        arg0, result = self._get_args_and_res()
+        lines = []
+        self._emit_sync_registers(lines)
+        box0 = self._get_as_box_after_sync(arg0)
+        lines.append("_v0 = %s" % self._get_as_unboxed_after_sync(arg0))
+        lines.append("_res = int(_v0 == 0)")
+        lines.append("_op = self.metainterp.history.record1_int(rop.INT_IS_ZERO, %s, _res)" % box0)
+        lines.append("self.registers_i[%d] = _op" % result.index)
+        lines.append("i%d = _res" % result.index)
+        next_consts = self.constant_registers - {result}
+        self._emit_jump(lines, constant_registers=next_consts)
+        return lines
+
     def _emit_jump(self, lines, target_pc=-1, constant_registers=None, indent=''):
         if target_pc == -1:
             target_pc = self.work_list.pc_to_nextpc[self.orig_pc]
@@ -1562,68 +1620,46 @@ def _emit_unspecialized_float_binary(self):
     emit_unspecialized_float_ge = _emit_unspecialized_float_binary
 
     def emit_unspecialized_int_neg(self):
-        lines = []
-        arg0, result = self._get_args_and_res()
-        self._emit_n_ary_if([arg0], lines)
-        self._emit_jump(lines, constant_registers=self.constant_registers.union({arg0}),
-                        indent='    ', target_pc=self.orig_pc)
-        lines.append("else:")
-        lines.append("    self.registers_i[%d] = self.%s(%s)" % (
-            result.index, self.methodname,
-            self._get_as_box(arg0)))
-        self._emit_jump(lines, indent='    ')
-        return lines
+        return self._emit_unspecialized_int_unary_fast("INT_NEG", "-")
 
-    def emit_unspecialized_int_abs(self):
-        lines = []
-        arg0, result = self._get_args_and_res()
-        self._emit_n_ary_if([arg0], lines)
-        self._emit_jump(lines, constant_registers=self.constant_registers.union({arg0}),
-                        indent='    ', target_pc=self.orig_pc)
-        lines.append("else:")
-        lines.append("    self.registers_i[%d] = self.%s(%s)" % (
-            result.index, self.methodname,
-            self._get_as_box(arg0)))
-        self._emit_jump(lines, indent='    ')
-        return lines
+    def emit_unspecialized_int_invert(self):
+        return self._emit_unspecialized_int_unary_fast("INT_INVERT", "~")
+
+    def emit_unspecialized_int_is_true(self):
+        return self._emit_unspecialized_int_is_true_fast()
+
+    def emit_unspecialized_int_is_zero(self):
+        return self._emit_unspecialized_int_is_zero_fast()
 
     def emit_unspecialized_float_neg(self):
-        lines = []
-        arg0, result = self._get_args_and_res()
-        self._emit_n_ary_if([arg0], lines)
-        self._emit_jump(lines, constant_registers=self.constant_registers.union({arg0}),
-                        indent='    ', target_pc=self.orig_pc)
-        lines.append("else:")
-        lines.append("    self.registers_f[%d] = self.%s(%s)" % (
-            result.index, self.methodname,
-            self._get_as_box(arg0)))
-        self._emit_jump(lines)
-        return lines
+        return self._emit_unspecialized_float_unary_fast("FLOAT_NEG", "-")
 
     def emit_unspecialized_float_abs(self):
-        lines = []
         arg0, result = self._get_args_and_res()
-        self._emit_n_ary_if([arg0], lines)
-        self._emit_jump(lines, constant_registers=self.constant_registers.union({arg0}),
-                        indent='    ', target_pc=self.orig_pc)
-        lines.append("else:")
-        lines.append("    self.registers_f[%d] = self.%s(%s)" % (
-            result.index, self.methodname,
-            self._get_as_box(arg0)))
-        self._emit_jump(lines)
+        lines = []
+        self._emit_sync_registers(lines)
+        box0 = self._get_as_box_after_sync(arg0)
+        lines.append("_v0 = %s" % self._get_as_unboxed_after_sync(arg0))
+        lines.append("_res = abs(_v0)")
+        lines.append("_op = self.metainterp.history.record1_float(rop.FLOAT_ABS, %s, _res)" % box0)
+        lines.append("self.registers_f[%d] = _op" % result.index)
+        lines.append("f%d = _res" % result.index)
+        next_consts = self.constant_registers - {result}
+        self._emit_jump(lines, constant_registers=next_consts)
         return lines
 
-    def emit_unspecialized_int_invert(self):
-        lines = []
+    def emit_unspecialized_int_force_ge_zero(self):
         arg0, result = self._get_args_and_res()
-        self._emit_n_ary_if([arg0], lines)
-        self._emit_jump(lines, constant_registers=self.constant_registers.union({arg0}),
-                        indent='    ', target_pc=self.orig_pc)
-        lines.append("else:")
-        lines.append("    self.registers_i[%d] = self.%s(%s)" % (
-            result.index, self.methodname,
-            self._get_as_box(arg0)))
-        self._emit_jump(lines)
+        lines = []
+        self._emit_sync_registers(lines)
+        box0 = self._get_as_box_after_sync(arg0)
+        lines.append("_v0 = %s" % self._get_as_unboxed_after_sync(arg0))
+        lines.append("_res = _v0 if _v0 >= 0 else 0")
+        lines.append("_op = self.metainterp.history.record1_int(rop.INT_FORCE_GE_ZERO, %s, _res)" % box0)
+        lines.append("self.registers_i[%d] = _op" % result.index)
+        lines.append("i%d = _res" % result.index)
+        next_consts = self.constant_registers - {result}
+        self._emit_jump(lines, constant_registers=next_consts)
         return lines
 
     def emit_unspecialized_strgetitem(self):
@@ -1664,21 +1700,6 @@ def emit_unspecialized_guard_value(self):
     emit_unspecialized_int_guard_value = emit_unspecialized_guard_value
     emit_unspecialized_ref_guard_value = emit_unspecialized_guard_value
 
-    def emit_unspecialized_int_is_true(self):
-        args = self._get_args()
-        res = self.insn[self.resindex]
-        arg, = self._get_args()
-        result = self.insn[self.resindex]
-        lines = []
-        self._emit_n_ary_if([arg], lines)
-        self._emit_jump(lines, constant_registers=self.constant_registers.union({arg}),
-                        indent='    ', target_pc=self.orig_pc)
-        lines.append("self.registers_%s[%s] = self.opimpl_%s(%s)" % (
-            result.kind[0], result.index,
-            self.insn[0], self._get_as_box(arg)))
-        self._emit_jump(lines)
-        return lines
-
     def emit_unspecialized_guard_class(self):
         arg0 = self.insn[1]
         res = self.insn[self.resindex]

rpython/jit/metainterp/pyjitpl.py

@@ -27,9 +27,37 @@
 from rpython.rlib.unroll import unrolling_iterable
 from rpython.rtyper.lltypesystem import lltype, rffi, llmemory
 from rpython.rtyper import rclass
+import os
 
 SIZE_LIVE_OP = OFFSET_SIZE + 1
 
+SKIP_HEAPCACHE_PURE_INT = os.environ.get('PYPY_SKIP_HEAPCACHE_PURE_INT', '') == '1'
+FAST_INT_RECORD = os.environ.get('PYPY_FAST_INT_RECORD', '') == '1'
+
+class PyjitplCounters(object):
+    _record_helper_calls = 0
+    _record_int_binop_calls = 0
+    _heapcache_skipped = 0
+    _heapcache_called = 0
+
+    @staticmethod
+    def reset():
+        PyjitplCounters._record_helper_calls = 0
+        PyjitplCounters._record_int_binop_calls = 0
+        PyjitplCounters._heapcache_skipped = 0
+        PyjitplCounters._heapcache_called = 0
+
+    @staticmethod
+    def report():
+        if not we_are_translated():
+            total = PyjitplCounters._record_helper_calls + PyjitplCounters._record_int_binop_calls
+            if total > 0:
+                debug_print("PYJITPL_COUNTERS: record_helper=%d record_int_binop=%d heapcache_skipped=%d heapcache_called=%d" % (
+                    PyjitplCounters._record_helper_calls,
+                    PyjitplCounters._record_int_binop_calls,
+                    PyjitplCounters._heapcache_skipped,
+                    PyjitplCounters._heapcache_called))
+
 CONST_0      = ConstInt(0)
 CONST_1      = ConstInt(1)
 
@@ -297,11 +325,6 @@ def opimpl_%s(self, b1, b2):
     def special_int_add(self, position):
         from rpython.jit.metainterp.blackhole import signedord
         from rpython.jit.metainterp.history import IntFrontendOp
-        # bit of a micro-optimization: int_add with a constant argument is one
-        # of the most common opcodes in PyPy, and this way we
-        # - allocate one ConstInt fewer in the (common) non-recorded case
-        # - don't wrap and unwrap
-        # - only check one of the arguments for constness
         assert position >= 0
         code = self.bytecode
         position += 1
@@ -321,7 +344,10 @@ def special_int_add(self, position):
         else:
             assert isinstance(b1, IntFrontendOp)
             resvalue = b1.getint() + c
-            resbox = self.metainterp._record_helper(rop.INT_ADD, resvalue, None, b1, ConstInt(c))
+            if FAST_INT_RECORD:
+                resbox = self.metainterp._record_int_binop(rop.INT_ADD, resvalue, b1, ConstInt(c))
+            else:
+                resbox = self.metainterp._record_helper(rop.INT_ADD, resvalue, None, b1, ConstInt(c))
         regs[ord(code[position])] = resbox
         self.pc = position + 1
 
@@ -2785,10 +2811,17 @@ def _record_helper_varargs(self, opnum, resvalue, descr, argboxes):
 
     @specialize.arg(1)
     def _record_helper(self, opnum, resvalue, descr, *argboxes):
-        # record the operation
+        if not we_are_translated():
+            PyjitplCounters._record_helper_calls += 1
         profiler = self.staticdata.profiler
         profiler.count_ops(opnum, Counters.RECORDED_OPS)
-        self.heapcache.invalidate_caches(opnum, descr, *argboxes)
+        if SKIP_HEAPCACHE_PURE_INT and self.heapcache._is_pure_int_op(opnum):
+            if not we_are_translated():
+                PyjitplCounters._heapcache_skipped += 1
+        else:
+            if not we_are_translated():
+                PyjitplCounters._heapcache_called += 1
+            self.heapcache.invalidate_caches(opnum, descr, *argboxes)
         if self.framestack:
             self.framestack[-1].jitcode.traced_operations += 1
 
@@ -2811,6 +2844,39 @@ def _record_helper(self, opnum, resvalue, descr, *argboxes):
         if op.type != 'v':
             return op
 
+    @always_inline
+    def _record_int_binop(self, opnum, resvalue, b1, b2):
+        if not we_are_translated():
+            PyjitplCounters._record_int_binop_calls += 1
+        profiler = self.staticdata.profiler
+        profiler.count_ops(opnum, Counters.RECORDED_OPS)
+        if self.framestack:
+            self.framestack[-1].jitcode.traced_operations += 1
+        op = self.history.record2_int(opnum, b1, b2, resvalue)
+        return op
+
+    @always_inline
+    def _record_int_unop(self, opnum, resvalue, b1):
+        if not we_are_translated():
+            PyjitplCounters._record_int_binop_calls += 1
+        profiler = self.staticdata.profiler
+        profiler.count_ops(opnum, Counters.RECORDED_OPS)
+        if self.framestack:
+            self.framestack[-1].jitcode.traced_operations += 1
+        op = self.history.record1_int(opnum, b1, resvalue)
+        return op
+
+    @always_inline
+    def _record_float_binop(self, opnum, resvalue, b1, b2):
+        if not we_are_translated():
+            PyjitplCounters._record_int_binop_calls += 1
+        profiler = self.staticdata.profiler
+        profiler.count_ops(opnum, Counters.RECORDED_OPS)
+        if self.framestack:
+            self.framestack[-1].jitcode.traced_operations += 1
+        op = self.history.record2_float(opnum, b1, b2, resvalue)
+        return op
+
     def execute_new_with_vtable(self, descr):
         resbox = self.execute_and_record(rop.NEW_WITH_VTABLE, descr)
         self.heapcache.new(resbox)