File 1181-Reduce-the-size-of-the-JITted-code-for-try... of Package erlang

Overview Repositories Revisions Requests Users Attributes Meta

File 1181-Reduce-the-size-of-the-JITted-code-for-try_case.patch of Package erlang (Revision f3bee4d07123a779fa551247d172e6f0)

Currently displaying revision f3bee4d07123a779fa551247d172e6f0 , Show latest

From 945ac57a9197a279b2e258d74cbb388b6bb75d63 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Thu, 8 Jul 2021 07:24:23 +0200
Subject: [PATCH 1/2] Reduce the size of the JITted code for try_case

This commit reduces X register shuffling after an exception has
occurred. This will slightly reduce the size of the JITted code, but
is unlikely to improve speed because is usually rare that execeptions
are raised.
---
 erts/emulator/beam/beam_common.c            | 28 +++++++++++------
 erts/emulator/beam/emu/instrs.tab           | 33 +++++++++++++--------
 erts/emulator/beam/jit/arm/instr_common.cpp | 32 ++++++++++----------
 erts/emulator/beam/jit/x86/instr_common.cpp | 23 +++++++++-----
 4 files changed, 70 insertions(+), 46 deletions(-)

diff --git a/erts/emulator/beam/beam_common.c b/erts/emulator/beam/beam_common.c
index bf3fede0f7..35662c3adb 100644
--- a/erts/emulator/beam/beam_common.c
+++ b/erts/emulator/beam/beam_common.c
@@ -522,15 +522,17 @@ handle_error(Process* c_p, ErtsCodePtr pc, Eterm* reg,
 	&& !(c_p->freason & EXF_PANIC)) {
 	ErtsCodePtr new_pc;
         /* The Beam handler code (catch_end or try_end) checks reg[0]
-	   for THE_NON_VALUE to see if the previous code finished
-	   abnormally. If so, reg[1], reg[2] and reg[3] should hold the
-	   exception class, term and trace, respectively. (If the
-	   handler is just a trap to native code, these registers will
-	   be ignored.) */
+         * for THE_NON_VALUE to see if the previous code finished
+         * abnormally. If so, reg[1], reg[2] and reg[3] should hold
+         * the term, trace, and exception class, respectively. Note
+         * that the handler code will only need to move the class
+         * to reg[0] to have all registers correctly set up for the
+         * code that follows.
+         */
 	reg[0] = THE_NON_VALUE;
-	reg[1] = exception_tag[GET_EXC_CLASS(c_p->freason)];
-	reg[2] = Value;
-	reg[3] = c_p->ftrace;
+	reg[1] = Value;
+	reg[2] = c_p->ftrace;
+	reg[3] = exception_tag[GET_EXC_CLASS(c_p->freason)];
         if ((new_pc = next_catch(c_p, reg))) {
 
 #if defined(BEAMASM) && (defined(NATIVE_ERLANG_STACK) || defined(__aarch64__))
@@ -576,6 +578,7 @@ next_catch(Process* c_p, Eterm *reg) {
     ErtsCodePtr return_to_trace_address = NULL;
     int have_return_to_trace = 0;
     Eterm *ptr, *prev;
+    ErtsCodePtr handler;
 
     ptr = prev = c_p->stop;
     ASSERT(ptr <= STACK_START(c_p));
@@ -659,7 +662,14 @@ next_catch(Process* c_p, Eterm *reg) {
         erts_trace_return_to(c_p, return_to_trace_address);
     }
 
-    return catch_pc(*ptr);
+    /* Clear the try_tag or catch_tag in the stack frame so that we
+     * don't have to do it in the JITted code for the try_case
+     * instruction. (Unfortunately, a catch_end will still need to
+     * clear the catch_tag because it is executed even when no
+     * exception has occurred.) */
+    handler = catch_pc(*ptr);
+    *ptr = NIL;
+    return handler;
 }
 
 /*
diff --git a/erts/emulator/beam/emu/instrs.tab b/erts/emulator/beam/emu/instrs.tab
index b719fbe030..74f75ff1ce 100644
--- a/erts/emulator/beam/emu/instrs.tab
+++ b/erts/emulator/beam/emu/instrs.tab
@@ -1086,28 +1086,39 @@ catch(Y, Fail) {
 }
 
 catch_end(Y) {
+    /*
+     * At entry:
+     *
+     *    x0 = Result of expression or THE_NON_VALUE
+     *
+     * If x0 is THE_NON_VALUE, the following registers are also set:
+     *
+     *    x1 = Error reason/thrown value
+     *    x2 = Stacktrace
+     *    x3 = Exception class
+     */
     $try_end($Y);
     if (is_non_value(r(0))) {
-        c_p->fvalue = NIL;
-        c_p->ftrace = NIL;
-        if (x(1) == am_throw) {
-            r(0) = x(2);
+        ASSERT(c_p->fvalue == NIL);
+        ASSERT(c_p->ftrace == NIL);
+        if (x(3) == am_throw) {
+            r(0) = x(1);
         } else {
-            if (x(1) == am_error) {
+            if (x(3) == am_error) {
                 SWAPOUT;
-                x(2) = add_stacktrace(c_p, x(2), x(3));
+                x(1) = add_stacktrace(c_p, x(1), x(2));
                 SWAPIN;
             }
-            /* only x(2) is included in the rootset here */
+            /* only x(1) is included in the rootset here */
             if ((E - HTOP) < (3 + S_RESERVED)) {
                 $GC_SWAPOUT();
                 PROCESS_MAIN_CHK_LOCKS(c_p);
-                FCALLS -= erts_garbage_collect_nobump(c_p, 3, reg+2, 1, FCALLS);
+                FCALLS -= erts_garbage_collect_nobump(c_p, 3, reg+1, 1, FCALLS);
                 ERTS_VERIFY_UNUSED_TEMP_ALLOC(c_p);
                 PROCESS_MAIN_CHK_LOCKS(c_p);
                 SWAPIN;
             }
-            r(0) = TUPLE2(HTOP, am_EXIT, x(2));
+            r(0) = TUPLE2(HTOP, am_EXIT, x(1));
             HTOP += 3;
         }
     }
@@ -1124,9 +1135,7 @@ try_case(Y) {
     ASSERT(is_non_value(r(0)));
     ASSERT(c_p->fvalue == NIL);
     ASSERT(c_p->ftrace == NIL);
-    r(0) = x(1);
-    x(1) = x(2);
-    x(2) = x(3);
+    r(0) = x(3);
 }
 
 try_case_end(Src) {
diff --git a/erts/emulator/beam/jit/arm/instr_common.cpp b/erts/emulator/beam/jit/arm/instr_common.cpp
index 212eaaacb4..adc8112a2e 100644
--- a/erts/emulator/beam/jit/arm/instr_common.cpp
+++ b/erts/emulator/beam/jit/arm/instr_common.cpp
@@ -1377,12 +1377,13 @@ void BeamGlobalAssembler::emit_catch_end_shared() {
           after_gc = a.newLabel();
 
     /* XREG0 = THE_NON_VALUE
-     * XREG1 = class
-     * XREG2 = error reason/thrown value
-     * XREG3 = raw stacktrace. */
+     * XREG1 = error reason/thrown value
+     * XREG2 = raw stacktrace.
+     * XREG3 = class
+     */
 
-    a.mov(XREG0, XREG2);
-    a.cmp(XREG1, imm(am_throw));
+    a.mov(XREG0, XREG1);
+    a.cmp(XREG3, imm(am_throw));
 
     a.cond_ne().b(not_throw);
 
@@ -1395,11 +1396,11 @@ void BeamGlobalAssembler::emit_catch_end_shared() {
 
         a.mov(ARG1, XREG0);
 
-        a.cmp(XREG1, imm(am_error));
+        a.cmp(XREG3, imm(am_error));
         a.cond_ne().b(not_error);
 
         a.mov(ARG2, XREG0);
-        a.mov(ARG3, XREG3);
+        a.mov(ARG3, XREG2);
 
         /* This is an error, attach a stacktrace to the reason. */
         ERTS_CT_ASSERT(ERTS_HIGHEST_CALLEE_SAVE_XREG >= 2);
@@ -1467,20 +1468,17 @@ void BeamModuleAssembler::emit_try_end(const ArgVal &Y) {
 
 void BeamModuleAssembler::emit_try_case(const ArgVal &Y) {
     /* XREG0 = THE_NON_VALUE
-     * XREG1 = class
-     * XREG2 = error reason/thrown value
-     * XREG3 = raw stacktrace.
-     *
-     * These need to be shifted down one step. */
-    a.mov(XREG0, XREG1);
-    a.mov(XREG1, XREG2);
-    a.mov(XREG2, XREG3);
+     * XREG1 = error reason/thrown value
+     * XREG2 = raw stacktrace.
+     * XREG3 = class */
 
     a.ldr(TMP1, arm::Mem(c_p, offsetof(Process, catches)));
+    a.mov(XREG0, XREG3);
     a.sub(TMP1, TMP1, imm(1));
     a.str(TMP1, arm::Mem(c_p, offsetof(Process, catches)));
-    mov_imm(TMP1, NIL);
-    mov_arg(Y, TMP1);
+
+    /* The try_tag in the Y slot in the stack frame has already been
+     * cleared. */
 
 #ifdef DEBUG
     Label ok = a.newLabel();
diff --git a/erts/emulator/beam/jit/x86/instr_common.cpp b/erts/emulator/beam/jit/x86/instr_common.cpp
index c132e30909..e0dd4d792b 100644
--- a/erts/emulator/beam/jit/x86/instr_common.cpp
+++ b/erts/emulator/beam/jit/x86/instr_common.cpp
@@ -1609,6 +1609,14 @@ void BeamModuleAssembler::emit_catch(const ArgVal &Y, const ArgVal &Fail) {
     catches.push_back({{patch_addr, 0x1, 0}, labels[Fail.getValue()]});
 }
 
+/*
+ * At entry:
+ *
+ *    x0 = THE_NON_VALUE
+ *    x1 = Term
+ *    x2 = Stacktrace
+ *    x3 = Exception class
+ */
 void BeamGlobalAssembler::emit_catch_end_shared() {
     Label not_throw = a.newLabel(), not_error = a.newLabel(),
           after_gc = a.newLabel();
@@ -1616,9 +1624,9 @@ void BeamGlobalAssembler::emit_catch_end_shared() {
     emit_enter_frame();
 
     /* Load thrown value / reason into ARG2 for add_stacktrace */
-    a.mov(ARG2, getXRef(2));
+    a.mov(ARG2, getXRef(1));
 
-    a.cmp(getXRef(1), imm(am_throw));
+    a.cmp(getXRef(3), imm(am_throw));
     a.short_().jne(not_throw);
 
     /* Thrown value, return it in x0 */
@@ -1629,7 +1637,7 @@ void BeamGlobalAssembler::emit_catch_end_shared() {
 
     a.bind(not_throw);
     {
-        a.cmp(getXRef(1), imm(am_error));
+        a.cmp(getXRef(3), imm(am_error));
         /* NOTE: Short won't reach if JIT_HARD_DEBUG is defined. */
         a.jne(not_error);
 
@@ -1638,7 +1646,7 @@ void BeamGlobalAssembler::emit_catch_end_shared() {
 
         a.mov(ARG1, c_p);
         /* ARG2 set above. */
-        a.mov(ARG3, getXRef(3));
+        a.mov(ARG3, getXRef(2));
         runtime_call<3>(add_stacktrace);
 
         emit_leave_runtime<Update::eStack | Update::eHeap>();
@@ -1694,12 +1702,11 @@ void BeamModuleAssembler::emit_try_end(const ArgVal &Y) {
 }
 
 void BeamModuleAssembler::emit_try_case(const ArgVal &Y) {
+    /* The try_tag in the Y slot in the stack frame has already been
+     * cleared. */
     a.dec(x86::qword_ptr(c_p, offsetof(Process, catches)));
-    mov_arg(Y, NIL);
-    a.movups(x86::xmm0, x86::xmmword_ptr(registers, 1 * sizeof(Eterm)));
     a.mov(RET, getXRef(3));
-    a.movups(x86::xmmword_ptr(registers, 0 * sizeof(Eterm)), x86::xmm0);
-    a.mov(getXRef(2), RET);
+    a.mov(getXRef(0), RET);
 
 #ifdef DEBUG
     Label fvalue_ok = a.newLabel(), assertion_failed = a.newLabel();
-- 
2.31.1

Places

File 1181-Reduce-the-size-of-the-JITted-code-for-try_case.patch of Package erlang (Revision f3bee4d07123a779fa551247d172e6f0)

Places