special case for parameter fetching

state replace -> pop_push and pop_pop_push

3 files changed, 27 insertions, 25 deletions

diff --git a/eval/src/vespa/eval/eval/interpreted_function.cpp b/eval/src/vespa/eval/eval/interpreted_function.cpp
index 28381030f24..0974590726a 100644
--- a/eval/src/vespa/eval/eval/interpreted_function.cpp
+++ b/eval/src/vespa/eval/eval/interpreted_function.cpp
@@ -56,14 +56,6 @@ InterpretedFunction::State::init(const LazyParams &params_in) {
     if_cnt = 0;
 }
 
-void
-InterpretedFunction::State::replace(size_t prune_cnt, const Value &value) {
-    for (size_t i = 0; i < prune_cnt; ++i) {
-        stack.pop_back();
-    }
-    stack.push_back(value);
-}
-
 InterpretedFunction::Context::Context(const InterpretedFunction &ifun)
     : _state(ifun._tensor_engine)
 {
diff --git a/eval/src/vespa/eval/eval/interpreted_function.h b/eval/src/vespa/eval/eval/interpreted_function.h
index 1c57b20682f..5c896c64074 100644
--- a/eval/src/vespa/eval/eval/interpreted_function.h
+++ b/eval/src/vespa/eval/eval/interpreted_function.h
@@ -41,7 +41,13 @@ public:
         const Value &peek(size_t ridx) const {
             return stack[stack.size() - 1 - ridx];
         }
-        void replace(size_t prune_cnt, const Value &value);
+        void pop_push(const Value &value) {
+            stack.back() = value;
+        }
+        void pop_pop_push(const Value &value) {
+            stack.pop_back();
+            stack.back() = value;
+        }
     };
     class Context {
         friend class InterpretedFunction;
@@ -61,8 +67,16 @@ public:
             : function(function_in), param(0) {}
         Instruction(op_function function_in, uint64_t param_in)
             : function(function_in), param(param_in) {}
-        void update_param(uint64_t param_in) { param = param_in; }
-        void perform(State &state) const { function(state, param); }
+        void perform(State &state) const {
+            if (function == nullptr) {
+                state.stack.push_back(state.params->resolve(param, state.stash));
+            } else {
+                function(state, param);
+            }
+        }
+        static Instruction fetch_param(size_t param_idx) {
+            return Instruction(nullptr, param_idx);
+        }
     };
 
 private:
diff --git a/eval/src/vespa/eval/eval/tensor_function.cpp b/eval/src/vespa/eval/eval/tensor_function.cpp
index 62e547cbd7e..7405326e2d9 100644
--- a/eval/src/vespa/eval/eval/tensor_function.cpp
+++ b/eval/src/vespa/eval/eval/tensor_function.cpp
@@ -40,53 +40,49 @@ void op_load_const(State &state, uint64_t param) {
     state.stack.push_back(unwrap_param<Value>(param));
 }
 
-void op_load_param(State &state, uint64_t param) {
-    state.stack.push_back(state.params->resolve(param, state.stash));
-}
-
 //-----------------------------------------------------------------------------
 
 void op_double_map(State &state, uint64_t param) {
-    state.replace(1, state.stash.create<DoubleValue>(to_map_fun(param)(state.peek(0).as_double())));
+    state.pop_push(state.stash.create<DoubleValue>(to_map_fun(param)(state.peek(0).as_double())));
 }
 
 void op_double_mul(State &state, uint64_t) {
-    state.replace(2, state.stash.create<DoubleValue>(state.peek(1).as_double() * state.peek(0).as_double()));
+    state.pop_pop_push(state.stash.create<DoubleValue>(state.peek(1).as_double() * state.peek(0).as_double()));
 }
 
 void op_double_add(State &state, uint64_t) {
-    state.replace(2, state.stash.create<DoubleValue>(state.peek(1).as_double() + state.peek(0).as_double()));
+    state.pop_pop_push(state.stash.create<DoubleValue>(state.peek(1).as_double() + state.peek(0).as_double()));
 }
 
 void op_double_join(State &state, uint64_t param) {
-    state.replace(2, state.stash.create<DoubleValue>(to_join_fun(param)(state.peek(1).as_double(), state.peek(0).as_double())));
+    state.pop_pop_push(state.stash.create<DoubleValue>(to_join_fun(param)(state.peek(1).as_double(), state.peek(0).as_double())));
 }
 
 //-----------------------------------------------------------------------------
 
 void op_tensor_map(State &state, uint64_t param) {
-    state.replace(1, state.engine.map(state.peek(0), to_map_fun(param), state.stash));
+    state.pop_push(state.engine.map(state.peek(0), to_map_fun(param), state.stash));
 }
 
 void op_tensor_join(State &state, uint64_t param) {
-    state.replace(2, state.engine.join(state.peek(1), state.peek(0), to_join_fun(param), state.stash));
+    state.pop_pop_push(state.engine.join(state.peek(1), state.peek(0), to_join_fun(param), state.stash));
 }
 
 using ReduceParams = std::pair<Aggr,std::vector<vespalib::string>>;
 void op_tensor_reduce(State &state, uint64_t param) {
     const ReduceParams &params = unwrap_param<ReduceParams>(param);
-    state.replace(1, state.engine.reduce(state.peek(0), params.first, params.second, state.stash));
+    state.pop_push(state.engine.reduce(state.peek(0), params.first, params.second, state.stash));
 }
 
 using RenameParams = std::pair<std::vector<vespalib::string>,std::vector<vespalib::string>>;
 void op_tensor_rename(State &state, uint64_t param) {
     const RenameParams &params = unwrap_param<RenameParams>(param);
-    state.replace(1, state.engine.rename(state.peek(0), params.first, params.second, state.stash));
+    state.pop_push(state.engine.rename(state.peek(0), params.first, params.second, state.stash));
 }
 
 void op_tensor_concat(State &state, uint64_t param) {
     const vespalib::string &dimension = unwrap_param<vespalib::string>(param);
-    state.replace(2, state.engine.concat(state.peek(1), state.peek(0), dimension, state.stash));
+    state.pop_pop_push(state.engine.concat(state.peek(1), state.peek(0), dimension, state.stash));
 }
 
 } // namespace vespalib::eval::tensor_function
@@ -136,7 +132,7 @@ Inject::eval(const TensorEngine &, const LazyParams &params, Stash &stash) const
 Instruction
 Inject::compile_self(Stash &) const
 {
-    return Instruction(op_load_param, _param_idx);
+    return Instruction::fetch_param(_param_idx);
 }
 
 //-----------------------------------------------------------------------------