File 1115-jit-Use-a-span-instead-of-std-vector-for-i... of Package erlang

Overview Repositories Revisions Requests Users Attributes Meta

File 1115-jit-Use-a-span-instead-of-std-vector-for-instruction.patch of Package erlang (Revision ffafb71295e53bdc1d802585b2f6a0bd)

Currently displaying revision ffafb71295e53bdc1d802585b2f6a0bd , Show latest

From 2f56082e641ff3954c32145babb564c8768f538b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?John=20H=C3=B6gberg?= <john@erlang.org>
Date: Sun, 25 Apr 2021 10:27:30 +0200
Subject: [PATCH 15/20] jit: Use a span instead of std::vector for instruction
 arguments

This shaves off an allocation on each instruction as we can point
directly into the BeamOp's argument array.
---
 erts/emulator/beam/jit/beam_jit_common.hpp    | 101 ++++++++++++++----
 erts/emulator/beam/jit/beam_jit_main.cpp      |  81 +++++++++-----
 erts/emulator/beam/jit/x86/beam_asm.hpp       |  11 +-
 .../emulator/beam/jit/x86/beam_asm_module.cpp |   5 +-
 erts/emulator/beam/jit/x86/instr_arith.cpp    |  16 ++-
 erts/emulator/beam/jit/x86/instr_common.cpp   |  10 +-
 erts/emulator/beam/jit/x86/instr_map.cpp      |  46 ++++----
 erts/emulator/beam/jit/x86/instr_select.cpp   |  42 ++++----
 erts/emulator/internal_doc/beam_makeops.md    |   6 +-
 erts/emulator/utils/beam_makeops              |   8 +-
 10 files changed, 198 insertions(+), 128 deletions(-)

diff --git a/erts/emulator/beam/jit/beam_jit_common.hpp b/erts/emulator/beam/jit/beam_jit_common.hpp
index e97fa1b6f4..b91533ddbc 100644
--- a/erts/emulator/beam/jit/beam_jit_common.hpp
+++ b/erts/emulator/beam/jit/beam_jit_common.hpp
@@ -39,7 +39,7 @@ extern "C"
 #include "beam_file.h"
 }
 
-struct ArgVal {
+struct ArgVal : public BeamOpArg {
     enum TYPE : int {
         Word = TAG_u,
         XReg = TAG_x,
@@ -55,10 +55,7 @@ struct ArgVal {
         Immediate = 'I'
     };
 
-    ArgVal(const BeamOpArg &arg) : ArgVal(arg.type, arg.val) {
-    }
-
-    ArgVal(int t, BeamInstr val) : type((enum TYPE)t), value(val) {
+    ArgVal(int t, UWord value) {
 #ifdef DEBUG
         switch (t) {
         case TAG_f:
@@ -87,34 +84,43 @@ struct ArgVal {
             ASSERT(0);
         }
 #endif
+        type = (enum TYPE)t;
+        val = value;
     }
 
     constexpr enum TYPE getType() const {
-        return type;
+        return (enum TYPE)type;
     }
 
     constexpr uint64_t getValue() const {
-        return value;
+        return val;
     }
 
     constexpr bool isRegister() const {
-        return type == TYPE::XReg || type == TYPE::YReg || type == TYPE::FReg;
+        switch (getType()) {
+        case TYPE::FReg:
+        case TYPE::XReg:
+        case TYPE::YReg:
+            return true;
+        default:
+            return false;
+        }
     }
 
     constexpr bool isLiteral() const {
-        return type == TYPE::Literal;
+        return getType() == TYPE::Literal;
     }
 
     constexpr bool isImmed() const {
-        return type == TYPE::Immediate;
+        return getType() == TYPE::Immediate;
     }
 
     constexpr bool isWord() const {
-        return type == TYPE::Word;
+        return getType() == TYPE::Word;
     }
 
     constexpr bool isLabel() const {
-        return type == TYPE::Label;
+        return getType() == TYPE::Label;
     }
 
     constexpr bool isConstant() const {
@@ -135,12 +141,7 @@ struct ArgVal {
 
     template<typename T>
     ArgVal operator+(T val) const {
-        return ArgVal(type, val + val);
-    }
-
-    template<typename T>
-    ArgVal operator*(T val) const {
-        return ArgVal(type, val * val);
+        return ArgVal(getType(), getValue() + val);
     }
 
     enum Relation { none, consecutive, reverse_consecutive };
@@ -160,10 +161,68 @@ struct ArgVal {
             return none;
         }
     };
+};
+
+/* This is a view into a contiguous container (like an array or `std::vector`),
+ * letting us reuse the existing argument array in `beamasm_emit` while keeping
+ * our interfaces convenient.
+ *
+ * Needless to say, spans must not live longer than the container they wrap, so
+ * you must be careful not to return a span of an rvalue or stack-allocated
+ * container.
+ *
+ * We can replace this with std::span once we require C++20. */
+template<typename T>
+class Span {
+    const T *_data;
+    size_t _size;
+
+public:
+    template<typename Container>
+    Span(const Container &other) : Span(other.data(), other.size()) {
+    }
+
+    template<typename Container>
+    Span(Container &other) : Span(other.data(), other.size()) {
+    }
+
+    Span(const T *begin, const T *end) : Span(begin, end - begin) {
+    }
+
+    Span(const T *data, size_t size) : _data(data), _size(size) {
+    }
+
+    Span<T> subspan(size_t index, size_t count) const {
+        ASSERT(index <= size() && count <= (size() - index));
+        return Span<T>(begin() + index, count);
+    }
+
+    const auto size() const {
+        return _size;
+    }
+
+    const auto begin() const {
+        return &_data[0];
+    }
 
-protected:
-    enum TYPE type;
-    uint64_t value;
+    const auto end() const {
+        return &_data[size()];
+    }
+
+    const T &operator[](size_t index) const {
+#ifdef DEBUG
+        ASSERT(index < _size);
+#endif
+        return _data[index];
+    }
+
+    const T &front() const {
+        return operator[](0);
+    }
+
+    const T &back() const {
+        return operator[](size() - 1);
+    }
 };
 
 /* ** */
diff --git a/erts/emulator/beam/jit/beam_jit_main.cpp b/erts/emulator/beam/jit/beam_jit_main.cpp
index 913a32ea44..a4d0bc9d40 100644
--- a/erts/emulator/beam/jit/beam_jit_main.cpp
+++ b/erts/emulator/beam/jit/beam_jit_main.cpp
@@ -249,29 +249,36 @@ void beamasm_init() {
 
     bma = new BeamModuleAssembler(bga, mod_name, 1 + operands.size() * 2);
 
+    std::vector<ArgVal> args;
+
     for (auto &op : operands) {
         unsigned func_label, entry_label;
 
         func_label = label++;
         entry_label = label++;
 
-        bma->emit(op_aligned_label_Lt,
-                  {ArgVal(ArgVal::Immediate, func_label),
-                   ArgVal(ArgVal::Word, sizeof(UWord))});
-        bma->emit(op_i_func_info_IaaI,
-                  {ArgVal(ArgVal::Immediate, func_label),
-                   ArgVal(ArgVal::Immediate, mod_name),
-                   ArgVal(ArgVal::Immediate, op.name),
-                   ArgVal(ArgVal::Immediate, op.arity)});
-        bma->emit(op_aligned_label_Lt,
-                  {ArgVal(ArgVal::Immediate, entry_label),
-                   ArgVal(ArgVal::Word, sizeof(UWord))});
-        bma->emit(op.operand, {});
+        args = {ArgVal(ArgVal::Immediate, func_label),
+                ArgVal(ArgVal::Word, sizeof(UWord))};
+        bma->emit(op_aligned_label_Lt, args);
+
+        args = {ArgVal(ArgVal::Immediate, func_label),
+                ArgVal(ArgVal::Immediate, mod_name),
+                ArgVal(ArgVal::Immediate, op.name),
+                ArgVal(ArgVal::Immediate, op.arity)};
+        bma->emit(op_i_func_info_IaaI, args);
+
+        args = {ArgVal(ArgVal::Immediate, entry_label),
+                ArgVal(ArgVal::Word, sizeof(UWord))};
+        bma->emit(op_aligned_label_Lt, args);
+
+        args = {};
+        bma->emit(op.operand, args);
 
         op.operand = entry_label;
     }
 
-    bma->emit(op_int_code_end, {});
+    args = {};
+    bma->emit(op_int_code_end, args);
 
     {
         /* We have no need of the module pointers as we use `getCode(...)`
@@ -451,9 +458,17 @@ extern "C"
     }
 
     int beamasm_emit(void *instance, unsigned specific_op, BeamOp *op) {
-        BeamModuleAssembler *ba = static_cast<BeamModuleAssembler *>(instance);
-        const std::vector<ArgVal> args(&op->a[0], &op->a[op->arity]);
+        /* The argument array must be safely convertible from `BeamOpArg*` to
+         * `ArgVal*` for us to reuse it directly.
+         *
+         * The exact traits we need weren't introduced until C++20, but the
+         * assertions below will catch just about everything that would break
+         * this conversion. */
+        static_assert(std::is_base_of<BeamOpArg, ArgVal>::value);
+        static_assert(std::is_standard_layout<ArgVal>::value);
 
+        BeamModuleAssembler *ba = static_cast<BeamModuleAssembler *>(instance);
+        const Span<ArgVal> args(static_cast<ArgVal *>(op->a), op->arity);
         return ba->emit(specific_op, args);
     }
 
@@ -464,21 +479,29 @@ extern "C"
                                char *buff,
                                unsigned buff_len) {
         BeamModuleAssembler ba(bga, info->mfa.module, 3);
+        std::vector<ArgVal> args;
+
+        args = {ArgVal(ArgVal::Immediate, 1),
+                ArgVal(ArgVal::Word, sizeof(UWord))};
+        ba.emit(op_aligned_label_Lt, args);
+
+        args = {ArgVal(ArgVal::Immediate, 1),
+                ArgVal(ArgVal::Immediate, info->mfa.module),
+                ArgVal(ArgVal::Immediate, info->mfa.function),
+                ArgVal(ArgVal::Immediate, info->mfa.arity)};
+        ba.emit(op_i_func_info_IaaI, args);
+
+        args = {ArgVal(ArgVal::Immediate, 2),
+                ArgVal(ArgVal::Word, sizeof(UWord))};
+        ba.emit(op_aligned_label_Lt, args);
+
+        args = {};
+        ba.emit(op_i_breakpoint_trampoline, args);
 
-        ba.emit(op_aligned_label_Lt,
-                {ArgVal(ArgVal::Immediate, 1), ArgVal(ArgVal::Word, sizeof(UWord))});
-        ba.emit(op_i_func_info_IaaI,
-                {ArgVal(ArgVal::Immediate, 1),
-                 ArgVal(ArgVal::Immediate, info->mfa.module),
-                 ArgVal(ArgVal::Immediate, info->mfa.function),
-                 ArgVal(ArgVal::Immediate, info->mfa.arity)});
-        ba.emit(op_aligned_label_Lt,
-                {ArgVal(ArgVal::Immediate, 2), ArgVal(ArgVal::Word, sizeof(UWord))});
-        ba.emit(op_i_breakpoint_trampoline, {});
-        ba.emit(op_call_nif_WWW,
-                {ArgVal(ArgVal::Immediate, (BeamInstr)normal_fptr),
-                 ArgVal(ArgVal::Immediate, (BeamInstr)lib),
-                 ArgVal(ArgVal::Immediate, (BeamInstr)dirty_fptr)});
+        args = {ArgVal(ArgVal::Immediate, (BeamInstr)normal_fptr),
+                ArgVal(ArgVal::Immediate, (BeamInstr)lib),
+                ArgVal(ArgVal::Immediate, (BeamInstr)dirty_fptr)};
+        ba.emit(op_call_nif_WWW, args);
 
         ba.codegen(buff, buff_len);
     }
diff --git a/erts/emulator/beam/jit/x86/beam_asm.hpp b/erts/emulator/beam/jit/x86/beam_asm.hpp
index 2dc9092ca8..5e6c20dff2 100644
--- a/erts/emulator/beam/jit/x86/beam_asm.hpp
+++ b/erts/emulator/beam/jit/x86/beam_asm.hpp
@@ -1039,7 +1039,7 @@ public:
                         unsigned num_labels,
                         unsigned num_functions);
 
-    bool emit(unsigned op, const std::vector<ArgVal> &args);
+    bool emit(unsigned op, const Span<ArgVal> &args);
 
     void codegen(JitAllocator *allocator,
                  const void **executable_ptr,
@@ -1062,7 +1062,7 @@ public:
         return BeamAssembler::getCode(labelName);
     }
 
-    Label embed_vararg_rodata(const std::vector<ArgVal> &args, int y_offset);
+    Label embed_vararg_rodata(const Span<ArgVal> &args, int y_offset);
 
     unsigned getCodeSize() {
         ASSERT(code.hasBaseAddress());
@@ -1108,7 +1108,6 @@ protected:
     void emit_setup_guard_bif(const std::vector<ArgVal> &args,
                               const ArgVal &bif);
 
-    void emit_bif_arg_error(std::vector<ArgVal> args, const ErtsCodeMFA *mfa);
     void emit_error(int code);
 
     x86::Mem emit_bs_get_integer_prologue(Label next,
@@ -1135,7 +1134,7 @@ protected:
 
     void emit_linear_search(x86::Gp val,
                             const ArgVal &Fail,
-                            const std::vector<ArgVal> &args);
+                            const Span<ArgVal> &args);
 
     void emit_float_instr(uint32_t instId,
                           const ArgVal &LHS,
@@ -1162,10 +1161,10 @@ protected:
     void emit_binsearch_nodes(size_t Left,
                               size_t Right,
                               const ArgVal &Fail,
-                              const std::vector<ArgVal> &args);
+                              const Span<ArgVal> &args);
 
     bool emit_optimized_three_way_select(const ArgVal &Fail,
-                                         const std::vector<ArgVal> &args);
+                                         const Span<ArgVal> &args);
 
 #ifdef DEBUG
     void emit_tuple_assertion(const ArgVal &Src, x86::Gp tuple_reg);
diff --git a/erts/emulator/beam/jit/x86/beam_asm_module.cpp b/erts/emulator/beam/jit/x86/beam_asm_module.cpp
index e404dd9455..8a044a7998 100644
--- a/erts/emulator/beam/jit/x86/beam_asm_module.cpp
+++ b/erts/emulator/beam/jit/x86/beam_asm_module.cpp
@@ -148,7 +148,7 @@ BeamModuleAssembler::BeamModuleAssembler(BeamGlobalAssembler *ga,
     }
 }
 
-Label BeamModuleAssembler::embed_vararg_rodata(const std::vector<ArgVal> &args,
+Label BeamModuleAssembler::embed_vararg_rodata(const Span<ArgVal> &args,
                                                int y_offset) {
     Label label = a.newLabel();
 
@@ -253,8 +253,7 @@ void BeamModuleAssembler::emit_nyi() {
     emit_nyi("<unspecified>");
 }
 
-bool BeamModuleAssembler::emit(unsigned specific_op,
-                               const std::vector<ArgVal> &args) {
+bool BeamModuleAssembler::emit(unsigned specific_op, const Span<ArgVal> &args) {
     comment(opc[specific_op].name);
 
 #ifdef BEAMASM_DUMP_SIZES
diff --git a/erts/emulator/beam/jit/x86/instr_arith.cpp b/erts/emulator/beam/jit/x86/instr_arith.cpp
index 4a925359d3..7e183d7631 100644
--- a/erts/emulator/beam/jit/x86/instr_arith.cpp
+++ b/erts/emulator/beam/jit/x86/instr_arith.cpp
@@ -30,14 +30,6 @@ extern "C"
 #include "erl_bif_table.h"
 }
 
-void BeamModuleAssembler::emit_bif_arg_error(std::vector<ArgVal> args,
-                                             const ErtsCodeMFA *mfa) {
-    comment("handle_error");
-    for (unsigned i = 0; i < args.size(); i++)
-        mov_arg(ArgVal(ArgVal::XReg, i), args[i]);
-    emit_raise_exception(mfa);
-}
-
 void BeamModuleAssembler::emit_is_small(Label fail, x86::Gp Reg) {
     ASSERT(ARG1 != Reg);
 
@@ -648,7 +640,13 @@ void BeamModuleAssembler::emit_i_m_div(const ArgVal &Fail,
         a.je(labels[Fail.getValue()]);
     } else {
         a.short_().jne(next);
-        emit_bif_arg_error({LHS, RHS}, &bif_mfa);
+
+        mov_arg(ARG2, LHS);
+        mov_arg(ARG3, RHS);
+        mov_arg(ArgVal(ArgVal::XReg, 0), ARG2);
+        mov_arg(ArgVal(ArgVal::XReg, 1), ARG3);
+
+        emit_raise_exception(&bif_mfa);
     }
 
     a.bind(next);
diff --git a/erts/emulator/beam/jit/x86/instr_common.cpp b/erts/emulator/beam/jit/x86/instr_common.cpp
index 6bea97fa13..f1412b49e2 100644
--- a/erts/emulator/beam/jit/x86/instr_common.cpp
+++ b/erts/emulator/beam/jit/x86/instr_common.cpp
@@ -265,7 +265,7 @@ void BeamModuleAssembler::emit_i_lambda_error(const ArgVal &Dummy) {
 void BeamModuleAssembler::emit_i_make_fun3(const ArgVal &Fun,
                                            const ArgVal &Dst,
                                            const ArgVal &NumFree,
-                                           const std::vector<ArgVal> &env) {
+                                           const Span<ArgVal> &env) {
     size_t num_free = env.size();
     ASSERT(NumFree.getValue() == num_free);
 
@@ -504,7 +504,7 @@ void BeamModuleAssembler::emit_init(const ArgVal &Y) {
 }
 
 void BeamModuleAssembler::emit_init_yregs(const ArgVal &Size,
-                                          const std::vector<ArgVal> &args) {
+                                          const Span<ArgVal> &args) {
     unsigned count = Size.getValue();
     ASSERT(count == args.size());
 
@@ -521,10 +521,10 @@ void BeamModuleAssembler::emit_init_yregs(const ArgVal &Size,
 
     while (i < count) {
         unsigned slots = 1;
-        unsigned first_y = args.at(i).getValue();
+        unsigned first_y = args[i].getValue();
 
         while (i + slots < count) {
-            ArgVal current_y = args.at(i + slots);
+            ArgVal current_y = args[i + slots];
             if (first_y + slots != current_y.getValue()) {
                 break;
             }
@@ -716,7 +716,7 @@ void BeamModuleAssembler::emit_store_cons(const ArgVal &len,
 
 void BeamModuleAssembler::emit_put_tuple2(const ArgVal &Dst,
                                           const ArgVal &Arity,
-                                          const std::vector<ArgVal> &args) {
+                                          const Span<ArgVal> &args) {
     size_t size = args.size();
     ASSERT(arityval(Arity.getValue()) == size);
 
diff --git a/erts/emulator/beam/jit/x86/instr_map.cpp b/erts/emulator/beam/jit/x86/instr_map.cpp
index 0856722d55..f0d42603bd 100644
--- a/erts/emulator/beam/jit/x86/instr_map.cpp
+++ b/erts/emulator/beam/jit/x86/instr_map.cpp
@@ -66,7 +66,7 @@ void BeamGlobalAssembler::emit_new_map_shared() {
 void BeamModuleAssembler::emit_new_map(const ArgVal &Dst,
                                        const ArgVal &Live,
                                        const ArgVal &Size,
-                                       const std::vector<ArgVal> &args) {
+                                       const Span<ArgVal> &args) {
     Label data = embed_vararg_rodata(args, CP_SIZE);
 
     ASSERT(Size.getValue() == args.size());
@@ -93,12 +93,11 @@ void BeamGlobalAssembler::emit_i_new_small_map_lit_shared() {
     a.ret();
 }
 
-void BeamModuleAssembler::emit_i_new_small_map_lit(
-        const ArgVal &Dst,
-        const ArgVal &Live,
-        const ArgVal &Keys,
-        const ArgVal &Size,
-        const std::vector<ArgVal> &args) {
+void BeamModuleAssembler::emit_i_new_small_map_lit(const ArgVal &Dst,
+                                                   const ArgVal &Live,
+                                                   const ArgVal &Keys,
+                                                   const ArgVal &Size,
+                                                   const Span<ArgVal> &args) {
     Label data = embed_vararg_rodata(args, CP_SIZE);
 
     ASSERT(Size.getValue() == args.size());
@@ -138,11 +137,10 @@ void BeamModuleAssembler::emit_i_get_map_element(const ArgVal &Fail,
     }
 }
 
-void BeamModuleAssembler::emit_i_get_map_elements(
-        const ArgVal &Fail,
-        const ArgVal &Src,
-        const ArgVal &Size,
-        const std::vector<ArgVal> &args) {
+void BeamModuleAssembler::emit_i_get_map_elements(const ArgVal &Fail,
+                                                  const ArgVal &Src,
+                                                  const ArgVal &Size,
+                                                  const Span<ArgVal> &args) {
     Label data = embed_vararg_rodata(args, 0);
 
     ASSERT(Size.getValue() == args.size());
@@ -205,12 +203,11 @@ void BeamGlobalAssembler::emit_update_map_assoc_shared() {
     a.ret();
 }
 
-void BeamModuleAssembler::emit_update_map_assoc(
-        const ArgVal &Src,
-        const ArgVal &Dst,
-        const ArgVal &Live,
-        const ArgVal &Size,
-        const std::vector<ArgVal> &args) {
+void BeamModuleAssembler::emit_update_map_assoc(const ArgVal &Src,
+                                                const ArgVal &Dst,
+                                                const ArgVal &Live,
+                                                const ArgVal &Size,
+                                                const Span<ArgVal> &args) {
     Label data = embed_vararg_rodata(args, CP_SIZE);
 
     ASSERT(Size.getValue() == args.size());
@@ -271,13 +268,12 @@ void BeamGlobalAssembler::emit_update_map_exact_body_shared() {
     }
 }
 
-void BeamModuleAssembler::emit_update_map_exact(
-        const ArgVal &Src,
-        const ArgVal &Fail,
-        const ArgVal &Dst,
-        const ArgVal &Live,
-        const ArgVal &Size,
-        const std::vector<ArgVal> &args) {
+void BeamModuleAssembler::emit_update_map_exact(const ArgVal &Src,
+                                                const ArgVal &Fail,
+                                                const ArgVal &Dst,
+                                                const ArgVal &Live,
+                                                const ArgVal &Size,
+                                                const Span<ArgVal> &args) {
     Label data = embed_vararg_rodata(args, CP_SIZE);
 
     ASSERT(Size.getValue() == args.size());
diff --git a/erts/emulator/beam/jit/x86/instr_select.cpp b/erts/emulator/beam/jit/x86/instr_select.cpp
index 05484513ad..4fef1ea6d7 100644
--- a/erts/emulator/beam/jit/x86/instr_select.cpp
+++ b/erts/emulator/beam/jit/x86/instr_select.cpp
@@ -24,7 +24,7 @@ using namespace asmjit;
 
 void BeamModuleAssembler::emit_linear_search(x86::Gp comparand,
                                              const ArgVal &Fail,
-                                             const std::vector<ArgVal> &args) {
+                                             const Span<ArgVal> &args) {
     int count = args.size() / 2;
 
     for (int i = 0; i < count; i++) {
@@ -43,11 +43,10 @@ void BeamModuleAssembler::emit_linear_search(x86::Gp comparand,
     }
 }
 
-void BeamModuleAssembler::emit_i_select_tuple_arity(
-        const ArgVal &Src,
-        const ArgVal &Fail,
-        const ArgVal &Size,
-        const std::vector<ArgVal> &args) {
+void BeamModuleAssembler::emit_i_select_tuple_arity(const ArgVal &Src,
+                                                    const ArgVal &Fail,
+                                                    const ArgVal &Size,
+                                                    const Span<ArgVal> &args) {
     mov_arg(ARG2, Src);
     emit_is_boxed(labels[Fail.getValue()], ARG2);
     x86::Gp boxed_ptr = emit_ptr_val(ARG2, ARG2);
@@ -71,11 +70,10 @@ void BeamModuleAssembler::emit_i_select_tuple_arity(
     a.jne(labels[Fail.getValue()]);
 }
 
-void BeamModuleAssembler::emit_i_select_val_lins(
-        const ArgVal &Src,
-        const ArgVal &Fail,
-        const ArgVal &Size,
-        const std::vector<ArgVal> &args) {
+void BeamModuleAssembler::emit_i_select_val_lins(const ArgVal &Src,
+                                                 const ArgVal &Fail,
+                                                 const ArgVal &Size,
+                                                 const Span<ArgVal> &args) {
     ASSERT(Size.getValue() == args.size());
     mov_arg(ARG2, Src);
     if (emit_optimized_three_way_select(Fail, args))
@@ -83,11 +81,10 @@ void BeamModuleAssembler::emit_i_select_val_lins(
     emit_linear_search(ARG2, Fail, args);
 }
 
-void BeamModuleAssembler::emit_i_select_val_bins(
-        const ArgVal &Src,
-        const ArgVal &Fail,
-        const ArgVal &Size,
-        const std::vector<ArgVal> &args) {
+void BeamModuleAssembler::emit_i_select_val_bins(const ArgVal &Src,
+                                                 const ArgVal &Fail,
+                                                 const ArgVal &Size,
+                                                 const Span<ArgVal> &args) {
     ASSERT(Size.getValue() == args.size());
     int count = args.size() / 2;
     Label fail;
@@ -115,11 +112,10 @@ void BeamModuleAssembler::emit_i_select_val_bins(
  *
  * ARG2 is the value being looked up.
  */
-void BeamModuleAssembler::emit_binsearch_nodes(
-        size_t Left,
-        size_t Right,
-        const ArgVal &Fail,
-        const std::vector<ArgVal> &args) {
+void BeamModuleAssembler::emit_binsearch_nodes(size_t Left,
+                                               size_t Right,
+                                               const ArgVal &Fail,
+                                               const Span<ArgVal> &args) {
     ASSERT(Left <= Right);
     ASSERT(Right < args.size() / 2);
     size_t mid = (Left + Right) >> 1;
@@ -179,7 +175,7 @@ void BeamModuleAssembler::emit_i_jump_on_val(const ArgVal &Src,
                                              const ArgVal &Fail,
                                              const ArgVal &Base,
                                              const ArgVal &Size,
-                                             const std::vector<ArgVal> &args) {
+                                             const Span<ArgVal> &args) {
     Label data = embed_vararg_rodata(args, 0);
     Label fail;
 
@@ -241,7 +237,7 @@ void BeamModuleAssembler::emit_i_jump_on_val(const ArgVal &Src,
  */
 bool BeamModuleAssembler::emit_optimized_three_way_select(
         const ArgVal &Fail,
-        const std::vector<ArgVal> &args) {
+        const Span<ArgVal> &args) {
     if (args.size() != 4 || (args[2].getValue() != args[3].getValue()))
         return false;
 
diff --git a/erts/emulator/internal_doc/beam_makeops.md b/erts/emulator/internal_doc/beam_makeops.md
index e93aeac52d..578858d686 100644
--- a/erts/emulator/internal_doc/beam_makeops.md
+++ b/erts/emulator/internal_doc/beam_makeops.md
@@ -2047,13 +2047,13 @@ like this:
     select_val s f I *
 
 The `*` as the last operand will make sure that the variable operands
-are passed in as a C++ vector of `ArgVal`.  Here is the emitter
-function:
+are passed in as a `Span` of `ArgVal` (will be `std::span` in C++20 onwards).
+Here is the emitter function:
 
     void BeamModuleAssembler::emit_select_val(const ArgVal &Src,
                                               const ArgVal &Fail,
                                               const ArgVal &Size,
-                                              const std::vector<ArgVal> &args) {
+                                              const Span<ArgVal> &args) {
         ASSERT(Size.getValue() == args.size());
            .
            .
diff --git a/erts/emulator/utils/beam_makeops b/erts/emulator/utils/beam_makeops
index e72c08bacd..e92c37749a 100755
--- a/erts/emulator/utils/beam_makeops
+++ b/erts/emulator/utils/beam_makeops
@@ -696,11 +696,11 @@ sub emulator_output {
                 }
 
 		if ($varargs) {
-		    # We pass variable argument lists as a vector of ArgVal,
+		    # We pass variable argument lists as a Span of ArgVal,
 		    # slicing our argument vector after the argument count.
 		    $body .= $sep .
-			"std::vector<ArgVal>(" .
-			"args.cbegin() + " . scalar(@args) . ", args.cend())";
+			"args.subspan(" . scalar(@args) . "," .
+				      "args.size() - " . scalar(@args) . ")";
 		}
 
                 $body .= ");";
@@ -723,7 +723,7 @@ sub emulator_output {
 
 		@args = ("const ArgVal&") x @args;
 		if ($varargs) {
-		    push @args, "const std::vector<ArgVal>&";
+		    push @args, "const Span<ArgVal>&";
 		}
 
                 print "void emit_$name(", join(", ", @args), ");\n";
-- 
2.26.2

Places

File 1115-jit-Use-a-span-instead-of-std-vector-for-instruction.patch of Package erlang (Revision ffafb71295e53bdc1d802585b2f6a0bd)

Places