diff --git a/reference_model/include/operators.h b/reference_model/include/operators.h
index b0a3227..25477d7 100644
--- a/reference_model/include/operators.h
+++ b/reference_model/include/operators.h
@@ -19,6 +19,9 @@
 #ifndef OPERATORS_H_
 #define OPERATORS_H_
 
+#include "func_config.h"
+#include "func_debug.h"
+
 #include <stddef.h>
 #include <stdint.h>
 
@@ -69,7 +72,11 @@
         size_t size;
     };
 
-    tosa_status_t tosa_run_argmax(tosa_tensor_t client_input, const int32_t client_axis, tosa_tensor_t client_output);
+    tosa_status_t tosa_run_argmax(tosa_tensor_t client_input,
+                                  const int32_t client_axis,
+                                  tosa_tensor_t client_output,
+                                  const func_config_t& func_config = func_config_t{},
+                                  const func_debug_t& func_debug   = func_debug_t{});
 
     tosa_status_t tosa_run_avg_pool2d(tosa_tensor_t client_input,
                                       const int32_t client_kernel[2],
@@ -77,7 +84,9 @@
                                       const int32_t client_pad[4],
                                       const int32_t client_input_zp,
                                       const int32_t client_output_zp,
-                                      tosa_tensor_t client_output);
+                                      tosa_tensor_t client_output,
+                                      const func_config_t& func_config = func_config_t{},
+                                      const func_debug_t& func_debug   = func_debug_t{});
 
     tosa_status_t tosa_run_conv2d(tosa_tensor_t client_input,
                                   tosa_tensor_t client_weight,
@@ -87,7 +96,9 @@
                                   const int32_t client_dilation[2],
                                   const int32_t client_input_zp,
                                   const int32_t client_weight_zp,
-                                  tosa_tensor_t client_output);
+                                  tosa_tensor_t client_output,
+                                  const func_config_t& func_config = func_config_t{},
+                                  const func_debug_t& func_debug   = func_debug_t{});
 
     tosa_status_t tosa_run_conv3d(tosa_tensor_t client_input,
                                   tosa_tensor_t client_weight,
@@ -97,7 +108,9 @@
                                   const int32_t client_dilation[3],
                                   const int32_t client_input_zp,
                                   const int32_t client_weight_zp,
-                                  tosa_tensor_t client_output);
+                                  tosa_tensor_t client_output,
+                                  const func_config_t& func_config = func_config_t{},
+                                  const func_debug_t& func_debug   = func_debug_t{});
 
     tosa_status_t tosa_run_depthwise_conv2d(tosa_tensor_t client_input,
                                             tosa_tensor_t client_weight,
@@ -107,20 +120,26 @@
                                             const int32_t client_dilation[2],
                                             const int32_t client_input_zp,
                                             const int32_t client_weight_zp,
-                                            tosa_tensor_t client_output);
+                                            tosa_tensor_t client_output,
+                                            const func_config_t& func_config = func_config_t{},
+                                            const func_debug_t& func_debug   = func_debug_t{});
 
     tosa_status_t tosa_run_fully_connected(tosa_tensor_t client_input,
                                            tosa_tensor_t client_weight,
                                            tosa_tensor_t client_bias,
                                            const int32_t client_input_zp,
                                            const int32_t client_weight_zp,
-                                           tosa_tensor_t client_output);
+                                           tosa_tensor_t client_output,
+                                           const func_config_t& func_config = func_config_t{},
+                                           const func_debug_t& func_debug   = func_debug_t{});
 
     tosa_status_t tosa_run_matmul(tosa_tensor_t client_a,
                                   tosa_tensor_t client_b,
                                   const int32_t client_a_zp,
                                   const int32_t client_b_zp,
-                                  tosa_tensor_t client_output);
+                                  tosa_tensor_t client_output,
+                                  const func_config_t& func_config = func_config_t{},
+                                  const func_debug_t& func_debug   = func_debug_t{});
 
     tosa_status_t tosa_run_max_pool2d(tosa_tensor_t client_input,
                                       const int32_t client_kernel[2],
@@ -128,7 +147,9 @@
                                       const int32_t client_pad[4],
                                       const int32_t client_input_zp,
                                       const int32_t client_output_zp,
-                                      tosa_tensor_t client_output);
+                                      tosa_tensor_t client_output,
+                                      const func_config_t& func_config = func_config_t{},
+                                      const func_debug_t& func_debug   = func_debug_t{});
 
     tosa_status_t tosa_run_transpose_conv2d(tosa_tensor_t client_input,
                                             tosa_tensor_t client_weight,
@@ -140,184 +161,340 @@
                                             const int32_t client_pad[],
                                             const int32_t client_dilation_len,
                                             const int32_t client_dilation[],
-                                            tosa_tensor_t client_output);
+                                            tosa_tensor_t client_output,
+                                            const func_config_t& func_config = func_config_t{},
+                                            const func_debug_t& func_debug   = func_debug_t{});
 
     tosa_status_t tosa_run_clamp(tosa_tensor_t client_input,
                                  const int32_t client_min_int,
                                  const int32_t client_max_int,
                                  const float client_min_fp,
                                  const float client_max_fp,
-                                 tosa_tensor_t client_output);
+                                 tosa_tensor_t client_output,
+                                 const func_config_t& func_config = func_config_t{},
+                                 const func_debug_t& func_debug   = func_debug_t{});
 
-    tosa_status_t tosa_run_sigmoid(tosa_tensor_t client_input, tosa_tensor_t client_output);
+    tosa_status_t tosa_run_erf(tosa_tensor_t client_input,
+                               tosa_tensor_t client_output,
+                               const func_config_t& func_config = func_config_t{},
+                               const func_debug_t& func_debug   = func_debug_t{});
 
-    tosa_status_t tosa_run_tanh(tosa_tensor_t client_input, tosa_tensor_t client_output);
+    tosa_status_t tosa_run_sigmoid(tosa_tensor_t client_input,
+                                   tosa_tensor_t client_output,
+                                   const func_config_t& func_config = func_config_t{},
+                                   const func_debug_t& func_debug   = func_debug_t{});
 
-    tosa_status_t tosa_run_erf(tosa_tensor_t client_input, tosa_tensor_t client_output);
+    tosa_status_t tosa_run_tanh(tosa_tensor_t client_input,
+                                tosa_tensor_t client_output,
+                                const func_config_t& func_config = func_config_t{},
+                                const func_debug_t& func_debug   = func_debug_t{});
 
-    tosa_status_t tosa_run_add(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output);
+    tosa_status_t tosa_run_add(tosa_tensor_t client_input1,
+                               tosa_tensor_t client_input2,
+                               tosa_tensor_t client_output,
+                               const func_config_t& func_config = func_config_t{},
+                               const func_debug_t& func_debug   = func_debug_t{});
 
     tosa_status_t tosa_run_arithmetic_right_shift(tosa_tensor_t client_input1,
                                                   tosa_tensor_t client_input2,
                                                   const bool client_round,
-                                                  tosa_tensor_t client_output);
+                                                  tosa_tensor_t client_output,
+                                                  const func_config_t& func_config = func_config_t{},
+                                                  const func_debug_t& func_debug   = func_debug_t{});
 
-    tosa_status_t
-        tosa_run_bitwise_and(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output);
+    tosa_status_t tosa_run_bitwise_and(tosa_tensor_t client_input1,
+                                       tosa_tensor_t client_input2,
+                                       tosa_tensor_t client_output,
+                                       const func_config_t& func_config = func_config_t{},
+                                       const func_debug_t& func_debug   = func_debug_t{});
 
-    tosa_status_t
-        tosa_run_bitwise_or(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output);
+    tosa_status_t tosa_run_bitwise_or(tosa_tensor_t client_input1,
+                                      tosa_tensor_t client_input2,
+                                      tosa_tensor_t client_output,
+                                      const func_config_t& func_config = func_config_t{},
+                                      const func_debug_t& func_debug   = func_debug_t{});
 
-    tosa_status_t
-        tosa_run_bitwise_xor(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output);
+    tosa_status_t tosa_run_bitwise_xor(tosa_tensor_t client_input1,
+                                       tosa_tensor_t client_input2,
+                                       tosa_tensor_t client_output,
+                                       const func_config_t& func_config = func_config_t{},
+                                       const func_debug_t& func_debug   = func_debug_t{});
 
-    tosa_status_t
-        tosa_run_intdiv(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output);
+    tosa_status_t tosa_run_intdiv(tosa_tensor_t client_input1,
+                                  tosa_tensor_t client_input2,
+                                  tosa_tensor_t client_output,
+                                  const func_config_t& func_config = func_config_t{},
+                                  const func_debug_t& func_debug   = func_debug_t{});
 
-    tosa_status_t
-        tosa_run_logical_and(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output);
+    tosa_status_t tosa_run_logical_and(tosa_tensor_t client_input1,
+                                       tosa_tensor_t client_input2,
+                                       tosa_tensor_t client_output,
+                                       const func_config_t& func_config = func_config_t{},
+                                       const func_debug_t& func_debug   = func_debug_t{});
 
     tosa_status_t tosa_run_logical_left_shift(tosa_tensor_t client_input1,
                                               tosa_tensor_t client_input2,
-                                              tosa_tensor_t client_output);
+                                              tosa_tensor_t client_output,
+                                              const func_config_t& func_config = func_config_t{},
+                                              const func_debug_t& func_debug   = func_debug_t{});
 
     tosa_status_t tosa_run_logical_right_shift(tosa_tensor_t client_input1,
                                                tosa_tensor_t client_input2,
-                                               tosa_tensor_t client_output);
+                                               tosa_tensor_t client_output,
+                                               const func_config_t& func_config = func_config_t{},
+                                               const func_debug_t& func_debug   = func_debug_t{});
 
-    tosa_status_t
-        tosa_run_logical_or(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output);
+    tosa_status_t tosa_run_logical_or(tosa_tensor_t client_input1,
+                                      tosa_tensor_t client_input2,
+                                      tosa_tensor_t client_output,
+                                      const func_config_t& func_config = func_config_t{},
+                                      const func_debug_t& func_debug   = func_debug_t{});
 
-    tosa_status_t
-        tosa_run_logical_xor(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output);
+    tosa_status_t tosa_run_logical_xor(tosa_tensor_t client_input1,
+                                       tosa_tensor_t client_input2,
+                                       tosa_tensor_t client_output,
+                                       const func_config_t& func_config = func_config_t{},
+                                       const func_debug_t& func_debug   = func_debug_t{});
 
-    tosa_status_t
-        tosa_run_maximum(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output);
+    tosa_status_t tosa_run_maximum(tosa_tensor_t client_input1,
+                                   tosa_tensor_t client_input2,
+                                   tosa_tensor_t client_output,
+                                   const func_config_t& func_config = func_config_t{},
+                                   const func_debug_t& func_debug   = func_debug_t{});
 
-    tosa_status_t
-        tosa_run_minimum(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output);
+    tosa_status_t tosa_run_minimum(tosa_tensor_t client_input1,
+                                   tosa_tensor_t client_input2,
+                                   tosa_tensor_t client_output,
+                                   const func_config_t& func_config = func_config_t{},
+                                   const func_debug_t& func_debug   = func_debug_t{});
 
     tosa_status_t tosa_run_mul(tosa_tensor_t client_input1,
                                tosa_tensor_t client_input2,
                                const int32_t client_shift,
-                               tosa_tensor_t client_output);
+                               tosa_tensor_t client_output,
+                               const func_config_t& func_config = func_config_t{},
+                               const func_debug_t& func_debug   = func_debug_t{});
 
-    tosa_status_t tosa_run_pow(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output);
+    tosa_status_t tosa_run_pow(tosa_tensor_t client_input1,
+                               tosa_tensor_t client_input2,
+                               tosa_tensor_t client_output,
+                               const func_config_t& func_config = func_config_t{},
+                               const func_debug_t& func_debug   = func_debug_t{});
 
-    tosa_status_t tosa_run_sub(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output);
+    tosa_status_t tosa_run_sub(tosa_tensor_t client_input1,
+                               tosa_tensor_t client_input2,
+                               tosa_tensor_t client_output,
+                               const func_config_t& func_config = func_config_t{},
+                               const func_debug_t& func_debug   = func_debug_t{});
 
     tosa_status_t tosa_run_table(tosa_tensor_t client_input,
                                  const int32_t client_table_len,
                                  const int16_t client_table[],
-                                 tosa_tensor_t client_output);
+                                 tosa_tensor_t client_output,
+                                 const func_config_t& func_config = func_config_t{},
+                                 const func_debug_t& func_debug   = func_debug_t{});
 
-    tosa_status_t tosa_run_abs(tosa_tensor_t client_input1, tosa_tensor_t client_output);
+    tosa_status_t tosa_run_abs(tosa_tensor_t client_input1,
+                               tosa_tensor_t client_output,
+                               const func_config_t& func_config = func_config_t{},
+                               const func_debug_t& func_debug   = func_debug_t{});
 
-    tosa_status_t tosa_run_bitwise_not(tosa_tensor_t client_input1, tosa_tensor_t client_output);
+    tosa_status_t tosa_run_bitwise_not(tosa_tensor_t client_input1,
+                                       tosa_tensor_t client_output,
+                                       const func_config_t& func_config = func_config_t{},
+                                       const func_debug_t& func_debug   = func_debug_t{});
 
-    tosa_status_t tosa_run_ceil(tosa_tensor_t client_input1, tosa_tensor_t client_output);
+    tosa_status_t tosa_run_ceil(tosa_tensor_t client_input1,
+                                tosa_tensor_t client_output,
+                                const func_config_t& func_config = func_config_t{},
+                                const func_debug_t& func_debug   = func_debug_t{});
 
-    tosa_status_t tosa_run_clz(tosa_tensor_t client_input1, tosa_tensor_t client_output);
+    tosa_status_t tosa_run_clz(tosa_tensor_t client_input1,
+                               tosa_tensor_t client_output,
+                               const func_config_t& func_config = func_config_t{},
+                               const func_debug_t& func_debug   = func_debug_t{});
 
-    tosa_status_t tosa_run_exp(tosa_tensor_t client_input1, tosa_tensor_t client_output);
+    tosa_status_t tosa_run_exp(tosa_tensor_t client_input1,
+                               tosa_tensor_t client_output,
+                               const func_config_t& func_config = func_config_t{},
+                               const func_debug_t& func_debug   = func_debug_t{});
 
-    tosa_status_t tosa_run_floor(tosa_tensor_t client_input1, tosa_tensor_t client_output);
+    tosa_status_t tosa_run_floor(tosa_tensor_t client_input1,
+                                 tosa_tensor_t client_output,
+                                 const func_config_t& func_config = func_config_t{},
+                                 const func_debug_t& func_debug   = func_debug_t{});
 
-    tosa_status_t tosa_run_log(tosa_tensor_t client_input1, tosa_tensor_t client_output);
+    tosa_status_t tosa_run_log(tosa_tensor_t client_input1,
+                               tosa_tensor_t client_output,
+                               const func_config_t& func_config = func_config_t{},
+                               const func_debug_t& func_debug   = func_debug_t{});
 
-    tosa_status_t tosa_run_logical_not(tosa_tensor_t client_input1, tosa_tensor_t client_output);
+    tosa_status_t tosa_run_logical_not(tosa_tensor_t client_input1,
+                                       tosa_tensor_t client_output,
+                                       const func_config_t& func_config = func_config_t{},
+                                       const func_debug_t& func_debug   = func_debug_t{});
 
     tosa_status_t tosa_run_negate(tosa_tensor_t client_input1,
                                   const int32_t client_input1_zp,
                                   const int32_t client_output_zp,
-                                  tosa_tensor_t client_output);
+                                  tosa_tensor_t client_output,
+                                  const func_config_t& func_config = func_config_t{},
+                                  const func_debug_t& func_debug   = func_debug_t{});
 
-    tosa_status_t tosa_run_reciprocal(tosa_tensor_t client_input1, tosa_tensor_t client_output);
+    tosa_status_t tosa_run_reciprocal(tosa_tensor_t client_input1,
+                                      tosa_tensor_t client_output,
+                                      const func_config_t& func_config = func_config_t{},
+                                      const func_debug_t& func_debug   = func_debug_t{});
 
-    tosa_status_t tosa_run_rsqrt(tosa_tensor_t client_input1, tosa_tensor_t client_output);
+    tosa_status_t tosa_run_rsqrt(tosa_tensor_t client_input1,
+                                 tosa_tensor_t client_output,
+                                 const func_config_t& func_config = func_config_t{},
+                                 const func_debug_t& func_debug   = func_debug_t{});
 
     tosa_status_t tosa_run_select(tosa_tensor_t client_input1,
                                   tosa_tensor_t client_input2,
                                   tosa_tensor_t client_input3,
-                                  tosa_tensor_t client_output);
+                                  tosa_tensor_t client_output,
+                                  const func_config_t& func_config = func_config_t{},
+                                  const func_debug_t& func_debug   = func_debug_t{});
 
-    tosa_status_t tosa_run_equal(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output);
+    tosa_status_t tosa_run_equal(tosa_tensor_t client_input1,
+                                 tosa_tensor_t client_input2,
+                                 tosa_tensor_t client_output,
+                                 const func_config_t& func_config = func_config_t{},
+                                 const func_debug_t& func_debug   = func_debug_t{});
 
-    tosa_status_t
-        tosa_run_greater(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output);
+    tosa_status_t tosa_run_greater(tosa_tensor_t client_input1,
+                                   tosa_tensor_t client_input2,
+                                   tosa_tensor_t client_output,
+                                   const func_config_t& func_config = func_config_t{},
+                                   const func_debug_t& func_debug   = func_debug_t{});
 
-    tosa_status_t
-        tosa_run_greater_equal(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output);
+    tosa_status_t tosa_run_greater_equal(tosa_tensor_t client_input1,
+                                         tosa_tensor_t client_input2,
+                                         tosa_tensor_t client_output,
+                                         const func_config_t& func_config = func_config_t{},
+                                         const func_debug_t& func_debug   = func_debug_t{});
 
-    tosa_status_t
-        tosa_run_reduce_all(tosa_tensor_t client_input, const int32_t client_axis, tosa_tensor_t client_output);
+    tosa_status_t tosa_run_reduce_all(tosa_tensor_t client_input,
+                                      const int32_t client_axis,
+                                      tosa_tensor_t client_output,
+                                      const func_config_t& func_config = func_config_t{},
+                                      const func_debug_t& func_debug   = func_debug_t{});
 
-    tosa_status_t
-        tosa_run_reduce_any(tosa_tensor_t client_input, const int32_t client_axis, tosa_tensor_t client_output);
+    tosa_status_t tosa_run_reduce_any(tosa_tensor_t client_input,
+                                      const int32_t client_axis,
+                                      tosa_tensor_t client_output,
+                                      const func_config_t& func_config = func_config_t{},
+                                      const func_debug_t& func_debug   = func_debug_t{});
 
-    tosa_status_t
-        tosa_run_reduce_max(tosa_tensor_t client_input, const int32_t client_axis, tosa_tensor_t client_output);
+    tosa_status_t tosa_run_reduce_max(tosa_tensor_t client_input,
+                                      const int32_t client_axis,
+                                      tosa_tensor_t client_output,
+                                      const func_config_t& func_config = func_config_t{},
+                                      const func_debug_t& func_debug   = func_debug_t{});
 
-    tosa_status_t
-        tosa_run_reduce_min(tosa_tensor_t client_input, const int32_t client_axis, tosa_tensor_t client_output);
+    tosa_status_t tosa_run_reduce_min(tosa_tensor_t client_input,
+                                      const int32_t client_axis,
+                                      tosa_tensor_t client_output,
+                                      const func_config_t& func_config = func_config_t{},
+                                      const func_debug_t& func_debug   = func_debug_t{});
 
-    tosa_status_t
-        tosa_run_reduce_product(tosa_tensor_t client_input, const int32_t client_axis, tosa_tensor_t client_output);
+    tosa_status_t tosa_run_reduce_product(tosa_tensor_t client_input,
+                                          const int32_t client_axis,
+                                          tosa_tensor_t client_output,
+                                          const func_config_t& func_config = func_config_t{},
+                                          const func_debug_t& func_debug   = func_debug_t{});
 
-    tosa_status_t
-        tosa_run_reduce_sum(tosa_tensor_t client_input, const int32_t client_axis, tosa_tensor_t client_output);
+    tosa_status_t tosa_run_reduce_sum(tosa_tensor_t client_input,
+                                      const int32_t client_axis,
+                                      tosa_tensor_t client_output,
+                                      const func_config_t& func_config = func_config_t{},
+                                      const func_debug_t& func_debug   = func_debug_t{});
 
-    tosa_status_t tosa_run_concat(tosa_tensor_t client_input1, const int32_t client_axis, tosa_tensor_t client_output);
+    tosa_status_t tosa_run_concat(tosa_tensor_t client_input1,
+                                  const int32_t client_axis,
+                                  tosa_tensor_t client_output,
+                                  const func_config_t& func_config = func_config_t{},
+                                  const func_debug_t& func_debug   = func_debug_t{});
 
     tosa_status_t tosa_run_pad(tosa_tensor_t client_input1,
                                const int32_t client_padding_len,
                                const int32_t client_padding[],
                                const int32_t client_pad_const_int,
                                const float client_pad_const_fp,
-                               tosa_tensor_t client_output);
+                               tosa_tensor_t client_output,
+                               const func_config_t& func_config = func_config_t{},
+                               const func_debug_t& func_debug   = func_debug_t{});
 
-    tosa_status_t tosa_run_dim(tosa_tensor_t client_input1, const int32_t client_axis, tosa_tensor_t client_output);
+    tosa_status_t tosa_run_dim(tosa_tensor_t client_input1,
+                               const int32_t client_axis,
+                               tosa_tensor_t client_output,
+                               const func_config_t& func_config = func_config_t{},
+                               const func_debug_t& func_debug   = func_debug_t{});
 
     tosa_status_t tosa_run_reshape(tosa_tensor_t client_input1,
                                    const int32_t client_new_shape_len,
                                    const int32_t client_new_shape[],
-                                   tosa_tensor_t client_output);
+                                   tosa_tensor_t client_output,
+                                   const func_config_t& func_config = func_config_t{},
+                                   const func_debug_t& func_debug   = func_debug_t{});
 
-    tosa_status_t tosa_run_reverse(tosa_tensor_t client_input, const int32_t client_axis, tosa_tensor_t client_output);
+    tosa_status_t tosa_run_reverse(tosa_tensor_t client_input,
+                                   const int32_t client_axis,
+                                   tosa_tensor_t client_output,
+                                   const func_config_t& func_config = func_config_t{},
+                                   const func_debug_t& func_debug   = func_debug_t{});
 
     tosa_status_t tosa_run_slice(tosa_tensor_t client_input1,
                                  const int32_t client_start_len,
                                  const int32_t client_start[],
                                  const int32_t client_size_len,
                                  const int32_t client_size[],
-                                 tosa_tensor_t client_output);
+                                 tosa_tensor_t client_output,
+                                 const func_config_t& func_config = func_config_t{},
+                                 const func_debug_t& func_debug   = func_debug_t{});
 
     tosa_status_t tosa_run_tile(tosa_tensor_t client_input1,
                                 const int32_t client_multiples_len,
                                 const int32_t client_multiples[],
-                                tosa_tensor_t client_output);
+                                tosa_tensor_t client_output,
+                                const func_config_t& func_config = func_config_t{},
+                                const func_debug_t& func_debug   = func_debug_t{});
 
     tosa_status_t tosa_run_transpose(tosa_tensor_t client_input1,
                                      const int32_t client_perms_len,
                                      const int32_t client_perms[],
-                                     tosa_tensor_t client_output);
+                                     tosa_tensor_t client_output,
+                                     const func_config_t& func_config = func_config_t{},
+                                     const func_debug_t& func_debug   = func_debug_t{});
 
-    tosa_status_t
-        tosa_run_gather(tosa_tensor_t client_values, tosa_tensor_t client_indices, tosa_tensor_t client_output);
+    tosa_status_t tosa_run_gather(tosa_tensor_t client_values,
+                                  tosa_tensor_t client_indices,
+                                  tosa_tensor_t client_output,
+                                  const func_config_t& func_config = func_config_t{},
+                                  const func_debug_t& func_debug   = func_debug_t{});
 
     tosa_status_t tosa_run_scatter(tosa_tensor_t client_values_in,
                                    tosa_tensor_t client_indices,
                                    tosa_tensor_t client_input,
-                                   tosa_tensor_t client_values_out);
+                                   tosa_tensor_t client_values_out,
+                                   const func_config_t& func_config = func_config_t{},
+                                   const func_debug_t& func_debug   = func_debug_t{});
 
     tosa_status_t tosa_run_resize(tosa_tensor_t client_input,
                                   const int16_t client_scale[4],
                                   const int16_t client_offset[2],
                                   const int16_t client_border[2],
                                   const tosa_mode_t client_mode,
-                                  tosa_tensor_t client_output);
+                                  tosa_tensor_t client_output,
+                                  const func_config_t& func_config = func_config_t{},
+                                  const func_debug_t& func_debug   = func_debug_t{});
 
-    tosa_status_t tosa_run_cast(tosa_tensor_t client_input, tosa_tensor_t client_output);
+    tosa_status_t tosa_run_cast(tosa_tensor_t client_input,
+                                tosa_tensor_t client_output,
+                                const func_config_t& func_config = func_config_t{},
+                                const func_debug_t& func_debug   = func_debug_t{});
 
     tosa_status_t tosa_run_rescale(tosa_tensor_t client_input,
                                    tosa_tensor_t client_output,
@@ -329,9 +506,14 @@
                                    const int32_t client_shift[],
                                    const bool client_scale32,
                                    const bool client_double_round,
-                                   const bool client_per_channel);
+                                   const bool client_per_channel,
+                                   const func_config_t& func_config = func_config_t{},
+                                   const func_debug_t& func_debug   = func_debug_t{});
 
-    tosa_status_t tosa_run_identity(tosa_tensor_t client_input1, tosa_tensor_t client_output);
+    tosa_status_t tosa_run_identity(tosa_tensor_t client_input1,
+                                    tosa_tensor_t client_output,
+                                    const func_config_t& func_config = func_config_t{},
+                                    const func_debug_t& func_debug   = func_debug_t{});
 
 #ifdef __cplusplus
 }
diff --git a/reference_model/src/operators.cc b/reference_model/src/operators.cc
index ae5963d..68314c9 100644
--- a/reference_model/src/operators.cc
+++ b/reference_model/src/operators.cc
@@ -100,7 +100,11 @@
 extern "C"
 {
 
-    tosa_status_t tosa_run_argmax(tosa_tensor_t client_input, const int32_t client_axis, tosa_tensor_t client_output)
+    tosa_status_t tosa_run_argmax(tosa_tensor_t client_input,
+                                  const int32_t client_axis,
+                                  tosa_tensor_t client_output,
+                                  const func_config_t& func_config,
+                                  const func_debug_t& func_debug)
     {
         // Create operator attributes
         const int32_t axis = client_axis;
@@ -119,7 +123,7 @@
                                                 { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
 
@@ -138,7 +142,9 @@
                                       const int32_t client_pad[4],
                                       const int32_t client_input_zp,
                                       const int32_t client_output_zp,
-                                      tosa_tensor_t client_output)
+                                      tosa_tensor_t client_output,
+                                      const func_config_t& func_config,
+                                      const func_debug_t& func_debug)
     {
         // Create operator attributes
         const std::vector<int32_t> pad(&client_pad[0], &client_pad[4]);
@@ -162,7 +168,7 @@
                                                 { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
 
@@ -183,7 +189,9 @@
                                   const int32_t client_dilation[2],
                                   const int32_t client_input_zp,
                                   const int32_t client_weight_zp,
-                                  tosa_tensor_t client_output)
+                                  tosa_tensor_t client_output,
+                                  const func_config_t& func_config,
+                                  const func_debug_t& func_debug)
     {
         // Create operator attributes
         const std::vector<int32_t> pad(&client_pad[0], &client_pad[4]);
@@ -210,7 +218,7 @@
                                                 { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
         TOSA_RETURN_ON_ERROR(runner.setInput(weight->GetName(), client_weight.data, client_weight.size));
@@ -233,7 +241,9 @@
                                   const int32_t client_dilation[3],
                                   const int32_t client_input_zp,
                                   const int32_t client_weight_zp,
-                                  tosa_tensor_t client_output)
+                                  tosa_tensor_t client_output,
+                                  const func_config_t& func_config,
+                                  const func_debug_t& func_debug)
     {
         // Create operator attributes
         const std::vector<int32_t> pad(&client_pad[0], &client_pad[6]);
@@ -260,7 +270,7 @@
                                                 { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
         TOSA_RETURN_ON_ERROR(runner.setInput(weight->GetName(), client_weight.data, client_weight.size));
@@ -283,7 +293,9 @@
                                             const int32_t client_dilation[2],
                                             const int32_t client_input_zp,
                                             const int32_t client_weight_zp,
-                                            tosa_tensor_t client_output)
+                                            tosa_tensor_t client_output,
+                                            const func_config_t& func_config,
+                                            const func_debug_t& func_debug)
     {
         // Create operator attributes
         const std::vector<int32_t> pad(&client_pad[0], &client_pad[4]);
@@ -310,7 +322,7 @@
                                                 { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
         TOSA_RETURN_ON_ERROR(runner.setInput(weight->GetName(), client_weight.data, client_weight.size));
@@ -330,7 +342,9 @@
                                            tosa_tensor_t client_bias,
                                            const int32_t client_input_zp,
                                            const int32_t client_weight_zp,
-                                           tosa_tensor_t client_output)
+                                           tosa_tensor_t client_output,
+                                           const func_config_t& func_config,
+                                           const func_debug_t& func_debug)
     {
         // Create operator attributes
         const int32_t input_zp  = client_input_zp;
@@ -354,7 +368,7 @@
                                                 { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
         TOSA_RETURN_ON_ERROR(runner.setInput(weight->GetName(), client_weight.data, client_weight.size));
@@ -373,7 +387,9 @@
                                   tosa_tensor_t client_b,
                                   const int32_t client_a_zp,
                                   const int32_t client_b_zp,
-                                  tosa_tensor_t client_output)
+                                  tosa_tensor_t client_output,
+                                  const func_config_t& func_config,
+                                  const func_debug_t& func_debug)
     {
         // Create operator attributes
         const int32_t a_zp = client_a_zp;
@@ -394,7 +410,7 @@
                                                 { a->GetName(), b->GetName() }, { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(a->GetName(), client_a.data, client_a.size));
         TOSA_RETURN_ON_ERROR(runner.setInput(b->GetName(), client_b.data, client_b.size));
@@ -414,7 +430,9 @@
                                       const int32_t client_pad[4],
                                       const int32_t client_input_zp,
                                       const int32_t client_output_zp,
-                                      tosa_tensor_t client_output)
+                                      tosa_tensor_t client_output,
+                                      const func_config_t& func_config,
+                                      const func_debug_t& func_debug)
     {
         // Create operator attributes
         const std::vector<int32_t> pad(&client_pad[0], &client_pad[4]);
@@ -438,7 +456,7 @@
                                                 { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
 
@@ -461,7 +479,9 @@
                                             const int32_t client_pad[],
                                             const int32_t client_dilation_len,
                                             const int32_t client_dilation[],
-                                            tosa_tensor_t client_output)
+                                            tosa_tensor_t client_output,
+                                            const func_config_t& func_config,
+                                            const func_debug_t& func_debug)
     {
         // Create operator attributes
         const std::vector<int32_t> pad(&client_pad[0], &client_pad[0] + client_pad_len);
@@ -488,7 +508,7 @@
                                                 { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
         TOSA_RETURN_ON_ERROR(runner.setInput(weight->GetName(), client_weight.data, client_weight.size));
@@ -508,7 +528,9 @@
                                  const int32_t client_max_int,
                                  const float client_min_fp,
                                  const float client_max_fp,
-                                 tosa_tensor_t client_output)
+                                 tosa_tensor_t client_output,
+                                 const func_config_t& func_config,
+                                 const func_debug_t& func_debug)
     {
         // Create operator attributes
         const int32_t min_int = client_min_int;
@@ -530,7 +552,7 @@
                                                 { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
 
@@ -543,69 +565,10 @@
         return tosa_status_valid;
     }
 
-    tosa_status_t tosa_run_sigmoid(tosa_tensor_t client_input, tosa_tensor_t client_output)
-    {
-        // Create operator attributes
-        TosaNoneAttribute attr;
-
-        // Create tensors
-        tosa::TosaSerializationTensor* input  = translate_client_tensor(client_input, "input");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
-
-        // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_SIGMOID, tosa::Attribute::Attribute_NONE, &attr,
-                                                      { input->GetName() }, { output->GetName() });
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("sigmoid", "main", { op }, { input, output }, { input->GetName() },
-                                                { output->GetName() });
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner;
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_tanh(tosa_tensor_t client_input, tosa_tensor_t client_output)
-    {
-        // Create operator attributes
-        TosaNoneAttribute attr;
-
-        // Create tensors
-        tosa::TosaSerializationTensor* input  = translate_client_tensor(client_input, "input");
-        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
-
-        // Create operator
-        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_TANH, tosa::Attribute::Attribute_NONE, &attr,
-                                                      { input->GetName() }, { output->GetName() });
-
-        // Create a tosa single-op basic block
-        tosa::TosaSerializationBasicBlock block("tanh", "main", { op }, { input, output }, { input->GetName() },
-                                                { output->GetName() });
-
-        // Setup model
-        TosaReference::ModelRunnerImpl runner;
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
-        TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
-
-        // Execute
-        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
-
-        // Extract outputs
-        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
-
-        return tosa_status_valid;
-    }
-
-    tosa_status_t tosa_run_erf(tosa_tensor_t client_input, tosa_tensor_t client_output)
+    tosa_status_t tosa_run_erf(tosa_tensor_t client_input,
+                               tosa_tensor_t client_output,
+                               const func_config_t& func_config,
+                               const func_debug_t& func_debug)
     {
         // Create operator attributes
         TosaNoneAttribute attr;
@@ -623,7 +586,7 @@
                                                 { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
 
@@ -636,7 +599,79 @@
         return tosa_status_valid;
     }
 
-    tosa_status_t tosa_run_add(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)
+    tosa_status_t tosa_run_sigmoid(tosa_tensor_t client_input,
+                                   tosa_tensor_t client_output,
+                                   const func_config_t& func_config,
+                                   const func_debug_t& func_debug)
+    {
+        // Create operator attributes
+        TosaNoneAttribute attr;
+
+        // Create tensors
+        tosa::TosaSerializationTensor* input  = translate_client_tensor(client_input, "input");
+        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+
+        // Create operator
+        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_SIGMOID, tosa::Attribute::Attribute_NONE, &attr,
+                                                      { input->GetName() }, { output->GetName() });
+
+        // Create a tosa single-op basic block
+        tosa::TosaSerializationBasicBlock block("sigmoid", "main", { op }, { input, output }, { input->GetName() },
+                                                { output->GetName() });
+
+        // Setup model
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
+        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
+        TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
+
+        // Execute
+        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
+
+        // Extract outputs
+        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+
+        return tosa_status_valid;
+    }
+
+    tosa_status_t tosa_run_tanh(tosa_tensor_t client_input,
+                                tosa_tensor_t client_output,
+                                const func_config_t& func_config,
+                                const func_debug_t& func_debug)
+    {
+        // Create operator attributes
+        TosaNoneAttribute attr;
+
+        // Create tensors
+        tosa::TosaSerializationTensor* input  = translate_client_tensor(client_input, "input");
+        tosa::TosaSerializationTensor* output = translate_client_tensor(client_output, "output");
+
+        // Create operator
+        auto op = new tosa::TosaSerializationOperator(tosa::Op::Op_TANH, tosa::Attribute::Attribute_NONE, &attr,
+                                                      { input->GetName() }, { output->GetName() });
+
+        // Create a tosa single-op basic block
+        tosa::TosaSerializationBasicBlock block("tanh", "main", { op }, { input, output }, { input->GetName() },
+                                                { output->GetName() });
+
+        // Setup model
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
+        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
+        TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
+
+        // Execute
+        TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.run());
+
+        // Extract outputs
+        TOSA_RETURN_ON_ERROR(runner.getOutput(output->GetName(), client_output.data, client_output.size));
+
+        return tosa_status_valid;
+    }
+
+    tosa_status_t tosa_run_add(tosa_tensor_t client_input1,
+                               tosa_tensor_t client_input2,
+                               tosa_tensor_t client_output,
+                               const func_config_t& func_config,
+                               const func_debug_t& func_debug)
     {
         // Create operator attributes
         TosaNoneAttribute attr;
@@ -655,7 +690,7 @@
                                                 { input1->GetName(), input2->GetName() }, { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
         TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
@@ -672,7 +707,9 @@
     tosa_status_t tosa_run_arithmetic_right_shift(tosa_tensor_t client_input1,
                                                   tosa_tensor_t client_input2,
                                                   const bool client_round,
-                                                  tosa_tensor_t client_output)
+                                                  tosa_tensor_t client_output,
+                                                  const func_config_t& func_config,
+                                                  const func_debug_t& func_debug)
     {
         // Create operator attributes
         const bool round = client_round;
@@ -693,7 +730,7 @@
                                                 { input1->GetName(), input2->GetName() }, { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
         TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
@@ -707,8 +744,11 @@
         return tosa_status_valid;
     }
 
-    tosa_status_t
-        tosa_run_bitwise_and(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)
+    tosa_status_t tosa_run_bitwise_and(tosa_tensor_t client_input1,
+                                       tosa_tensor_t client_input2,
+                                       tosa_tensor_t client_output,
+                                       const func_config_t& func_config,
+                                       const func_debug_t& func_debug)
     {
         // Create operator attributes
         TosaNoneAttribute attr;
@@ -727,7 +767,7 @@
                                                 { input1->GetName(), input2->GetName() }, { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
         TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
@@ -741,8 +781,11 @@
         return tosa_status_valid;
     }
 
-    tosa_status_t
-        tosa_run_bitwise_or(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)
+    tosa_status_t tosa_run_bitwise_or(tosa_tensor_t client_input1,
+                                      tosa_tensor_t client_input2,
+                                      tosa_tensor_t client_output,
+                                      const func_config_t& func_config,
+                                      const func_debug_t& func_debug)
     {
         // Create operator attributes
         TosaNoneAttribute attr;
@@ -761,7 +804,7 @@
                                                 { input1->GetName(), input2->GetName() }, { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
         TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
@@ -775,8 +818,11 @@
         return tosa_status_valid;
     }
 
-    tosa_status_t
-        tosa_run_bitwise_xor(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)
+    tosa_status_t tosa_run_bitwise_xor(tosa_tensor_t client_input1,
+                                       tosa_tensor_t client_input2,
+                                       tosa_tensor_t client_output,
+                                       const func_config_t& func_config,
+                                       const func_debug_t& func_debug)
     {
         // Create operator attributes
         TosaNoneAttribute attr;
@@ -795,7 +841,7 @@
                                                 { input1->GetName(), input2->GetName() }, { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
         TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
@@ -809,7 +855,11 @@
         return tosa_status_valid;
     }
 
-    tosa_status_t tosa_run_intdiv(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)
+    tosa_status_t tosa_run_intdiv(tosa_tensor_t client_input1,
+                                  tosa_tensor_t client_input2,
+                                  tosa_tensor_t client_output,
+                                  const func_config_t& func_config,
+                                  const func_debug_t& func_debug)
     {
         // Create operator attributes
         TosaNoneAttribute attr;
@@ -828,7 +878,7 @@
                                                 { input1->GetName(), input2->GetName() }, { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
         TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
@@ -842,8 +892,11 @@
         return tosa_status_valid;
     }
 
-    tosa_status_t
-        tosa_run_logical_and(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)
+    tosa_status_t tosa_run_logical_and(tosa_tensor_t client_input1,
+                                       tosa_tensor_t client_input2,
+                                       tosa_tensor_t client_output,
+                                       const func_config_t& func_config,
+                                       const func_debug_t& func_debug)
     {
         // Create operator attributes
         TosaNoneAttribute attr;
@@ -862,7 +915,7 @@
                                                 { input1->GetName(), input2->GetName() }, { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
         TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
@@ -878,7 +931,9 @@
 
     tosa_status_t tosa_run_logical_left_shift(tosa_tensor_t client_input1,
                                               tosa_tensor_t client_input2,
-                                              tosa_tensor_t client_output)
+                                              tosa_tensor_t client_output,
+                                              const func_config_t& func_config,
+                                              const func_debug_t& func_debug)
     {
         // Create operator attributes
         TosaNoneAttribute attr;
@@ -898,7 +953,7 @@
                                                 { input1->GetName(), input2->GetName() }, { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
         TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
@@ -914,7 +969,9 @@
 
     tosa_status_t tosa_run_logical_right_shift(tosa_tensor_t client_input1,
                                                tosa_tensor_t client_input2,
-                                               tosa_tensor_t client_output)
+                                               tosa_tensor_t client_output,
+                                               const func_config_t& func_config,
+                                               const func_debug_t& func_debug)
     {
         // Create operator attributes
         TosaNoneAttribute attr;
@@ -934,7 +991,7 @@
                                                 { input1->GetName(), input2->GetName() }, { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
         TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
@@ -948,8 +1005,11 @@
         return tosa_status_valid;
     }
 
-    tosa_status_t
-        tosa_run_logical_or(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)
+    tosa_status_t tosa_run_logical_or(tosa_tensor_t client_input1,
+                                      tosa_tensor_t client_input2,
+                                      tosa_tensor_t client_output,
+                                      const func_config_t& func_config,
+                                      const func_debug_t& func_debug)
     {
         // Create operator attributes
         TosaNoneAttribute attr;
@@ -968,7 +1028,7 @@
                                                 { input1->GetName(), input2->GetName() }, { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
         TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
@@ -982,8 +1042,11 @@
         return tosa_status_valid;
     }
 
-    tosa_status_t
-        tosa_run_logical_xor(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)
+    tosa_status_t tosa_run_logical_xor(tosa_tensor_t client_input1,
+                                       tosa_tensor_t client_input2,
+                                       tosa_tensor_t client_output,
+                                       const func_config_t& func_config,
+                                       const func_debug_t& func_debug)
     {
         // Create operator attributes
         TosaNoneAttribute attr;
@@ -1002,7 +1065,7 @@
                                                 { input1->GetName(), input2->GetName() }, { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
         TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
@@ -1016,8 +1079,11 @@
         return tosa_status_valid;
     }
 
-    tosa_status_t
-        tosa_run_maximum(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)
+    tosa_status_t tosa_run_maximum(tosa_tensor_t client_input1,
+                                   tosa_tensor_t client_input2,
+                                   tosa_tensor_t client_output,
+                                   const func_config_t& func_config,
+                                   const func_debug_t& func_debug)
     {
         // Create operator attributes
         TosaNoneAttribute attr;
@@ -1036,7 +1102,7 @@
                                                 { input1->GetName(), input2->GetName() }, { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
         TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
@@ -1050,8 +1116,11 @@
         return tosa_status_valid;
     }
 
-    tosa_status_t
-        tosa_run_minimum(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)
+    tosa_status_t tosa_run_minimum(tosa_tensor_t client_input1,
+                                   tosa_tensor_t client_input2,
+                                   tosa_tensor_t client_output,
+                                   const func_config_t& func_config,
+                                   const func_debug_t& func_debug)
     {
         // Create operator attributes
         TosaNoneAttribute attr;
@@ -1070,7 +1139,7 @@
                                                 { input1->GetName(), input2->GetName() }, { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
         TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
@@ -1087,7 +1156,9 @@
     tosa_status_t tosa_run_mul(tosa_tensor_t client_input1,
                                tosa_tensor_t client_input2,
                                const int32_t client_shift,
-                               tosa_tensor_t client_output)
+                               tosa_tensor_t client_output,
+                               const func_config_t& func_config,
+                               const func_debug_t& func_debug)
     {
         // Create operator attributes
         const int32_t shift = client_shift;
@@ -1107,7 +1178,7 @@
                                                 { input1->GetName(), input2->GetName() }, { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
         TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
@@ -1121,7 +1192,11 @@
         return tosa_status_valid;
     }
 
-    tosa_status_t tosa_run_pow(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)
+    tosa_status_t tosa_run_pow(tosa_tensor_t client_input1,
+                               tosa_tensor_t client_input2,
+                               tosa_tensor_t client_output,
+                               const func_config_t& func_config,
+                               const func_debug_t& func_debug)
     {
         // Create operator attributes
         TosaNoneAttribute attr;
@@ -1140,7 +1215,7 @@
                                                 { input1->GetName(), input2->GetName() }, { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
         TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
@@ -1154,7 +1229,11 @@
         return tosa_status_valid;
     }
 
-    tosa_status_t tosa_run_sub(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)
+    tosa_status_t tosa_run_sub(tosa_tensor_t client_input1,
+                               tosa_tensor_t client_input2,
+                               tosa_tensor_t client_output,
+                               const func_config_t& func_config,
+                               const func_debug_t& func_debug)
     {
         // Create operator attributes
         TosaNoneAttribute attr;
@@ -1173,7 +1252,7 @@
                                                 { input1->GetName(), input2->GetName() }, { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
         TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
@@ -1190,7 +1269,9 @@
     tosa_status_t tosa_run_table(tosa_tensor_t client_input,
                                  const int32_t client_table_len,
                                  const int16_t client_table[],
-                                 tosa_tensor_t client_output)
+                                 tosa_tensor_t client_output,
+                                 const func_config_t& func_config,
+                                 const func_debug_t& func_debug)
     {
         // Create operator attributes
         const std::vector<int16_t> table(&client_table[0], &client_table[0] + client_table_len);
@@ -1209,7 +1290,7 @@
                                                 { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
 
@@ -1222,7 +1303,10 @@
         return tosa_status_valid;
     }
 
-    tosa_status_t tosa_run_abs(tosa_tensor_t client_input1, tosa_tensor_t client_output)
+    tosa_status_t tosa_run_abs(tosa_tensor_t client_input1,
+                               tosa_tensor_t client_output,
+                               const func_config_t& func_config,
+                               const func_debug_t& func_debug)
     {
         // Create operator attributes
         TosaNoneAttribute attr;
@@ -1240,7 +1324,7 @@
                                                 { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
 
@@ -1253,7 +1337,10 @@
         return tosa_status_valid;
     }
 
-    tosa_status_t tosa_run_bitwise_not(tosa_tensor_t client_input1, tosa_tensor_t client_output)
+    tosa_status_t tosa_run_bitwise_not(tosa_tensor_t client_input1,
+                                       tosa_tensor_t client_output,
+                                       const func_config_t& func_config,
+                                       const func_debug_t& func_debug)
     {
         // Create operator attributes
         TosaNoneAttribute attr;
@@ -1271,7 +1358,7 @@
                                                 { input1->GetName() }, { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
 
@@ -1284,7 +1371,10 @@
         return tosa_status_valid;
     }
 
-    tosa_status_t tosa_run_ceil(tosa_tensor_t client_input1, tosa_tensor_t client_output)
+    tosa_status_t tosa_run_ceil(tosa_tensor_t client_input1,
+                                tosa_tensor_t client_output,
+                                const func_config_t& func_config,
+                                const func_debug_t& func_debug)
     {
         // Create operator attributes
         TosaNoneAttribute attr;
@@ -1302,7 +1392,7 @@
                                                 { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
 
@@ -1315,7 +1405,10 @@
         return tosa_status_valid;
     }
 
-    tosa_status_t tosa_run_clz(tosa_tensor_t client_input1, tosa_tensor_t client_output)
+    tosa_status_t tosa_run_clz(tosa_tensor_t client_input1,
+                               tosa_tensor_t client_output,
+                               const func_config_t& func_config,
+                               const func_debug_t& func_debug)
     {
         // Create operator attributes
         TosaNoneAttribute attr;
@@ -1333,7 +1426,7 @@
                                                 { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
 
@@ -1346,7 +1439,10 @@
         return tosa_status_valid;
     }
 
-    tosa_status_t tosa_run_exp(tosa_tensor_t client_input1, tosa_tensor_t client_output)
+    tosa_status_t tosa_run_exp(tosa_tensor_t client_input1,
+                               tosa_tensor_t client_output,
+                               const func_config_t& func_config,
+                               const func_debug_t& func_debug)
     {
         // Create operator attributes
         TosaNoneAttribute attr;
@@ -1364,7 +1460,7 @@
                                                 { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
 
@@ -1377,7 +1473,10 @@
         return tosa_status_valid;
     }
 
-    tosa_status_t tosa_run_floor(tosa_tensor_t client_input1, tosa_tensor_t client_output)
+    tosa_status_t tosa_run_floor(tosa_tensor_t client_input1,
+                                 tosa_tensor_t client_output,
+                                 const func_config_t& func_config,
+                                 const func_debug_t& func_debug)
     {
         // Create operator attributes
         TosaNoneAttribute attr;
@@ -1395,7 +1494,7 @@
                                                 { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
 
@@ -1408,7 +1507,10 @@
         return tosa_status_valid;
     }
 
-    tosa_status_t tosa_run_log(tosa_tensor_t client_input1, tosa_tensor_t client_output)
+    tosa_status_t tosa_run_log(tosa_tensor_t client_input1,
+                               tosa_tensor_t client_output,
+                               const func_config_t& func_config,
+                               const func_debug_t& func_debug)
     {
         // Create operator attributes
         TosaNoneAttribute attr;
@@ -1426,7 +1528,7 @@
                                                 { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
 
@@ -1439,7 +1541,10 @@
         return tosa_status_valid;
     }
 
-    tosa_status_t tosa_run_logical_not(tosa_tensor_t client_input1, tosa_tensor_t client_output)
+    tosa_status_t tosa_run_logical_not(tosa_tensor_t client_input1,
+                                       tosa_tensor_t client_output,
+                                       const func_config_t& func_config,
+                                       const func_debug_t& func_debug)
     {
         // Create operator attributes
         TosaNoneAttribute attr;
@@ -1457,7 +1562,7 @@
                                                 { input1->GetName() }, { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
 
@@ -1473,7 +1578,9 @@
     tosa_status_t tosa_run_negate(tosa_tensor_t client_input1,
                                   const int32_t client_input1_zp,
                                   const int32_t client_output_zp,
-                                  tosa_tensor_t client_output)
+                                  tosa_tensor_t client_output,
+                                  const func_config_t& func_config,
+                                  const func_debug_t& func_debug)
     {
         // Create operator attributes
         const int32_t input1_zp = client_input1_zp;
@@ -1493,7 +1600,7 @@
                                                 { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
 
@@ -1506,7 +1613,10 @@
         return tosa_status_valid;
     }
 
-    tosa_status_t tosa_run_reciprocal(tosa_tensor_t client_input1, tosa_tensor_t client_output)
+    tosa_status_t tosa_run_reciprocal(tosa_tensor_t client_input1,
+                                      tosa_tensor_t client_output,
+                                      const func_config_t& func_config,
+                                      const func_debug_t& func_debug)
     {
         // Create operator attributes
         TosaNoneAttribute attr;
@@ -1524,7 +1634,7 @@
                                                 { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
 
@@ -1537,7 +1647,10 @@
         return tosa_status_valid;
     }
 
-    tosa_status_t tosa_run_rsqrt(tosa_tensor_t client_input1, tosa_tensor_t client_output)
+    tosa_status_t tosa_run_rsqrt(tosa_tensor_t client_input1,
+                                 tosa_tensor_t client_output,
+                                 const func_config_t& func_config,
+                                 const func_debug_t& func_debug)
     {
         // Create operator attributes
         TosaNoneAttribute attr;
@@ -1555,7 +1668,7 @@
                                                 { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
 
@@ -1571,7 +1684,9 @@
     tosa_status_t tosa_run_select(tosa_tensor_t client_input1,
                                   tosa_tensor_t client_input2,
                                   tosa_tensor_t client_input3,
-                                  tosa_tensor_t client_output)
+                                  tosa_tensor_t client_output,
+                                  const func_config_t& func_config,
+                                  const func_debug_t& func_debug)
     {
         // Create operator attributes
         TosaNoneAttribute attr;
@@ -1593,7 +1708,7 @@
                                                 { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
         TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
@@ -1608,7 +1723,11 @@
         return tosa_status_valid;
     }
 
-    tosa_status_t tosa_run_equal(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)
+    tosa_status_t tosa_run_equal(tosa_tensor_t client_input1,
+                                 tosa_tensor_t client_input2,
+                                 tosa_tensor_t client_output,
+                                 const func_config_t& func_config,
+                                 const func_debug_t& func_debug)
     {
         // Create operator attributes
         TosaNoneAttribute attr;
@@ -1627,7 +1746,7 @@
                                                 { input1->GetName(), input2->GetName() }, { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
         TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
@@ -1641,8 +1760,11 @@
         return tosa_status_valid;
     }
 
-    tosa_status_t
-        tosa_run_greater(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)
+    tosa_status_t tosa_run_greater(tosa_tensor_t client_input1,
+                                   tosa_tensor_t client_input2,
+                                   tosa_tensor_t client_output,
+                                   const func_config_t& func_config,
+                                   const func_debug_t& func_debug)
     {
         // Create operator attributes
         TosaNoneAttribute attr;
@@ -1661,7 +1783,7 @@
                                                 { input1->GetName(), input2->GetName() }, { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
         TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
@@ -1675,8 +1797,11 @@
         return tosa_status_valid;
     }
 
-    tosa_status_t
-        tosa_run_greater_equal(tosa_tensor_t client_input1, tosa_tensor_t client_input2, tosa_tensor_t client_output)
+    tosa_status_t tosa_run_greater_equal(tosa_tensor_t client_input1,
+                                         tosa_tensor_t client_input2,
+                                         tosa_tensor_t client_output,
+                                         const func_config_t& func_config,
+                                         const func_debug_t& func_debug)
     {
         // Create operator attributes
         TosaNoneAttribute attr;
@@ -1696,7 +1821,7 @@
                                                 { input1->GetName(), input2->GetName() }, { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
         TOSA_RETURN_ON_ERROR(runner.setInput(input2->GetName(), client_input2.data, client_input2.size));
@@ -1710,8 +1835,11 @@
         return tosa_status_valid;
     }
 
-    tosa_status_t
-        tosa_run_reduce_all(tosa_tensor_t client_input, const int32_t client_axis, tosa_tensor_t client_output)
+    tosa_status_t tosa_run_reduce_all(tosa_tensor_t client_input,
+                                      const int32_t client_axis,
+                                      tosa_tensor_t client_output,
+                                      const func_config_t& func_config,
+                                      const func_debug_t& func_debug)
     {
         // Create operator attributes
         const int32_t axis = client_axis;
@@ -1730,7 +1858,7 @@
                                                 { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
 
@@ -1743,8 +1871,11 @@
         return tosa_status_valid;
     }
 
-    tosa_status_t
-        tosa_run_reduce_any(tosa_tensor_t client_input, const int32_t client_axis, tosa_tensor_t client_output)
+    tosa_status_t tosa_run_reduce_any(tosa_tensor_t client_input,
+                                      const int32_t client_axis,
+                                      tosa_tensor_t client_output,
+                                      const func_config_t& func_config,
+                                      const func_debug_t& func_debug)
     {
         // Create operator attributes
         const int32_t axis = client_axis;
@@ -1763,7 +1894,7 @@
                                                 { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
 
@@ -1776,8 +1907,11 @@
         return tosa_status_valid;
     }
 
-    tosa_status_t
-        tosa_run_reduce_max(tosa_tensor_t client_input, const int32_t client_axis, tosa_tensor_t client_output)
+    tosa_status_t tosa_run_reduce_max(tosa_tensor_t client_input,
+                                      const int32_t client_axis,
+                                      tosa_tensor_t client_output,
+                                      const func_config_t& func_config,
+                                      const func_debug_t& func_debug)
     {
         // Create operator attributes
         const int32_t axis = client_axis;
@@ -1796,7 +1930,7 @@
                                                 { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
 
@@ -1809,8 +1943,11 @@
         return tosa_status_valid;
     }
 
-    tosa_status_t
-        tosa_run_reduce_min(tosa_tensor_t client_input, const int32_t client_axis, tosa_tensor_t client_output)
+    tosa_status_t tosa_run_reduce_min(tosa_tensor_t client_input,
+                                      const int32_t client_axis,
+                                      tosa_tensor_t client_output,
+                                      const func_config_t& func_config,
+                                      const func_debug_t& func_debug)
     {
         // Create operator attributes
         const int32_t axis = client_axis;
@@ -1829,7 +1966,7 @@
                                                 { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
 
@@ -1842,8 +1979,11 @@
         return tosa_status_valid;
     }
 
-    tosa_status_t
-        tosa_run_reduce_product(tosa_tensor_t client_input, const int32_t client_axis, tosa_tensor_t client_output)
+    tosa_status_t tosa_run_reduce_product(tosa_tensor_t client_input,
+                                          const int32_t client_axis,
+                                          tosa_tensor_t client_output,
+                                          const func_config_t& func_config,
+                                          const func_debug_t& func_debug)
     {
         // Create operator attributes
         const int32_t axis = client_axis;
@@ -1863,7 +2003,7 @@
                                                 { input->GetName() }, { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
 
@@ -1876,8 +2016,11 @@
         return tosa_status_valid;
     }
 
-    tosa_status_t
-        tosa_run_reduce_sum(tosa_tensor_t client_input, const int32_t client_axis, tosa_tensor_t client_output)
+    tosa_status_t tosa_run_reduce_sum(tosa_tensor_t client_input,
+                                      const int32_t client_axis,
+                                      tosa_tensor_t client_output,
+                                      const func_config_t& func_config,
+                                      const func_debug_t& func_debug)
     {
         // Create operator attributes
         const int32_t axis = client_axis;
@@ -1896,7 +2039,7 @@
                                                 { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
 
@@ -1909,7 +2052,11 @@
         return tosa_status_valid;
     }
 
-    tosa_status_t tosa_run_concat(tosa_tensor_t client_input1, const int32_t client_axis, tosa_tensor_t client_output)
+    tosa_status_t tosa_run_concat(tosa_tensor_t client_input1,
+                                  const int32_t client_axis,
+                                  tosa_tensor_t client_output,
+                                  const func_config_t& func_config,
+                                  const func_debug_t& func_debug)
     {
         // Create operator attributes
         const int32_t axis = client_axis;
@@ -1928,7 +2075,7 @@
                                                 { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
 
@@ -1946,7 +2093,9 @@
                                const int32_t client_padding[],
                                const int32_t client_pad_const_int,
                                const float client_pad_const_fp,
-                               tosa_tensor_t client_output)
+                               tosa_tensor_t client_output,
+                               const func_config_t& func_config,
+                               const func_debug_t& func_debug)
     {
         // Create operator attributes
         const std::vector<int32_t> padding(&client_padding[0], &client_padding[0] + client_padding_len);
@@ -1967,7 +2116,7 @@
                                                 { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
 
@@ -1980,7 +2129,11 @@
         return tosa_status_valid;
     }
 
-    tosa_status_t tosa_run_dim(tosa_tensor_t client_input1, const int32_t client_axis, tosa_tensor_t client_output)
+    tosa_status_t tosa_run_dim(tosa_tensor_t client_input1,
+                               const int32_t client_axis,
+                               tosa_tensor_t client_output,
+                               const func_config_t& func_config,
+                               const func_debug_t& func_debug)
     {
         // Create operator attributes
         TosaAxisAttribute attr(client_axis);
@@ -1998,7 +2151,7 @@
                                                 { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
 
@@ -2011,7 +2164,9 @@
     tosa_status_t tosa_run_reshape(tosa_tensor_t client_input1,
                                    const int32_t client_new_shape_len,
                                    const int32_t client_new_shape[],
-                                   tosa_tensor_t client_output)
+                                   tosa_tensor_t client_output,
+                                   const func_config_t& func_config,
+                                   const func_debug_t& func_debug)
     {
         // Create operator attributes
         const std::vector<int32_t> new_shape(&client_new_shape[0], &client_new_shape[0] + client_new_shape_len);
@@ -2030,7 +2185,7 @@
                                                 { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
 
@@ -2043,7 +2198,11 @@
         return tosa_status_valid;
     }
 
-    tosa_status_t tosa_run_reverse(tosa_tensor_t client_input, const int32_t client_axis, tosa_tensor_t client_output)
+    tosa_status_t tosa_run_reverse(tosa_tensor_t client_input,
+                                   const int32_t client_axis,
+                                   tosa_tensor_t client_output,
+                                   const func_config_t& func_config,
+                                   const func_debug_t& func_debug)
     {
         // Create operator attributes
         const int32_t axis = client_axis;
@@ -2062,7 +2221,7 @@
                                                 { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
 
@@ -2080,7 +2239,9 @@
                                  const int32_t client_start[],
                                  const int32_t client_size_len,
                                  const int32_t client_size[],
-                                 tosa_tensor_t client_output)
+                                 tosa_tensor_t client_output,
+                                 const func_config_t& func_config,
+                                 const func_debug_t& func_debug)
     {
         // Create operator attributes
         const std::vector<int32_t> start(&client_start[0], &client_start[0] + client_start_len);
@@ -2100,7 +2261,7 @@
                                                 { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
 
@@ -2116,7 +2277,9 @@
     tosa_status_t tosa_run_tile(tosa_tensor_t client_input1,
                                 const int32_t client_multiples_len,
                                 const int32_t client_multiples[],
-                                tosa_tensor_t client_output)
+                                tosa_tensor_t client_output,
+                                const func_config_t& func_config,
+                                const func_debug_t& func_debug)
     {
         // Create operator attributes
         const std::vector<int32_t> multiples(&client_multiples[0], &client_multiples[0] + client_multiples_len);
@@ -2135,7 +2298,7 @@
                                                 { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
 
@@ -2151,7 +2314,9 @@
     tosa_status_t tosa_run_transpose(tosa_tensor_t client_input1,
                                      const int32_t client_perms_len,
                                      const int32_t client_perms[],
-                                     tosa_tensor_t client_output)
+                                     tosa_tensor_t client_output,
+                                     const func_config_t& func_config,
+                                     const func_debug_t& func_debug)
     {
         // Create operator attributes
         const std::vector<int32_t> perms(&client_perms[0], &client_perms[0] + client_perms_len);
@@ -2171,7 +2336,7 @@
                                                 { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
 
@@ -2184,8 +2349,11 @@
         return tosa_status_valid;
     }
 
-    tosa_status_t
-        tosa_run_gather(tosa_tensor_t client_values, tosa_tensor_t client_indices, tosa_tensor_t client_output)
+    tosa_status_t tosa_run_gather(tosa_tensor_t client_values,
+                                  tosa_tensor_t client_indices,
+                                  tosa_tensor_t client_output,
+                                  const func_config_t& func_config,
+                                  const func_debug_t& func_debug)
     {
         // Create operator attributes
         TosaNoneAttribute attr;
@@ -2204,7 +2372,7 @@
                                                 { values->GetName(), indices->GetName() }, { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(values->GetName(), client_values.data, client_values.size));
         TOSA_RETURN_ON_ERROR(runner.setInput(indices->GetName(), client_indices.data, client_indices.size));
@@ -2221,7 +2389,9 @@
     tosa_status_t tosa_run_scatter(tosa_tensor_t client_values_in,
                                    tosa_tensor_t client_indices,
                                    tosa_tensor_t client_input,
-                                   tosa_tensor_t client_values_out)
+                                   tosa_tensor_t client_values_out,
+                                   const func_config_t& func_config,
+                                   const func_debug_t& func_debug)
     {
         // Create operator attributes
         TosaNoneAttribute attr;
@@ -2243,7 +2413,7 @@
                                                 { values_out->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(values_in->GetName(), client_values_in.data, client_values_in.size));
         TOSA_RETURN_ON_ERROR(runner.setInput(indices->GetName(), client_indices.data, client_indices.size));
@@ -2263,7 +2433,9 @@
                                   const int16_t client_offset[2],
                                   const int16_t client_border[2],
                                   const tosa_mode_t client_mode,
-                                  tosa_tensor_t client_output)
+                                  tosa_tensor_t client_output,
+                                  const func_config_t& func_config,
+                                  const func_debug_t& func_debug)
     {
         // Create operator attributes
         const std::vector<int16_t> scale(&client_scale[0], &client_scale[4]);
@@ -2285,7 +2457,7 @@
                                                 { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
 
@@ -2298,7 +2470,10 @@
         return tosa_status_valid;
     }
 
-    tosa_status_t tosa_run_cast(tosa_tensor_t client_input, tosa_tensor_t client_output)
+    tosa_status_t tosa_run_cast(tosa_tensor_t client_input,
+                                tosa_tensor_t client_output,
+                                const func_config_t& func_config,
+                                const func_debug_t& func_debug)
     {
         // Create operator attributes
         TosaNoneAttribute attr;
@@ -2316,7 +2491,7 @@
                                                 { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
 
@@ -2339,7 +2514,9 @@
                                    const int32_t client_shift[],
                                    const bool client_scale32,
                                    const bool client_double_round,
-                                   const bool client_per_channel)
+                                   const bool client_per_channel,
+                                   const func_config_t& func_config,
+                                   const func_debug_t& func_debug)
     {
         // Create operator attributes
         const int32_t input_zp  = client_input_zp;
@@ -2364,7 +2541,7 @@
                                                 { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input->GetName(), client_input.data, client_input.size));
 
@@ -2377,7 +2554,10 @@
         return tosa_status_valid;
     }
 
-    tosa_status_t tosa_run_identity(tosa_tensor_t client_input1, tosa_tensor_t client_output)
+    tosa_status_t tosa_run_identity(tosa_tensor_t client_input1,
+                                    tosa_tensor_t client_output,
+                                    const func_config_t& func_config,
+                                    const func_debug_t& func_debug)
     {
         // Create operator attributes
         TosaNoneAttribute attr;
@@ -2395,7 +2575,7 @@
                                                 { output->GetName() });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         TOSA_RETURN_ON_ERROR(runner.setInput(input1->GetName(), client_input1.data, client_input1.size));
 
@@ -2408,4 +2588,4 @@
         return tosa_status_valid;
     }
 
-}    // extern "C"
+}    // extern "C"
\ No newline at end of file
diff --git a/reference_model/test/model_runner_tests.cpp b/reference_model/test/model_runner_tests.cpp
index bb57657..0b73494 100644
--- a/reference_model/test/model_runner_tests.cpp
+++ b/reference_model/test/model_runner_tests.cpp
@@ -178,6 +178,67 @@
         compareOutput(dstData, expectedData, expectedData.size());
     }
 
+    TEST_CASE("op_entry_conv2d_abs_mode")
+    {
+        // Conv parameters
+        const int32_t stride[2]   = { 1, 1 };
+        const int32_t pad[4]      = { 0, 0, 0, 0 };
+        const int32_t dilation[2] = { 1, 1 };
+
+        // Inputs/Outputs
+        tosa_datatype_t dt                = tosa_datatype_fp32_t;
+        std::vector<int32_t> input_shape  = { 1, 32, 32, 8 };
+        std::vector<int32_t> output_shape = { 1, 32, 32, 16 };
+        std::vector<int32_t> weight_shape = { 16, 1, 1, 8 };
+        std::vector<int32_t> bias_shape   = { 16 };
+        std::vector<float> srcData(32 * 32 * 8, -1.0f);
+        std::vector<float> dstData(32 * 32 * 16, 0.f);
+        std::vector<float> biasData(16, 0.f);
+        std::vector<float> weightData(16 * 8, 1.0f);
+
+        tosa_tensor_t input;
+        input.shape     = input_shape.data();
+        input.num_dims  = input_shape.size();
+        input.data_type = dt;
+        input.data      = reinterpret_cast<uint8_t*>(srcData.data());
+        input.size      = srcData.size() * sizeof(float);
+
+        tosa_tensor_t weight;
+        weight.shape     = weight_shape.data();
+        weight.num_dims  = weight_shape.size();
+        weight.data_type = dt;
+        weight.data      = reinterpret_cast<uint8_t*>(weightData.data());
+        weight.size      = weightData.size() * sizeof(float);
+
+        tosa_tensor_t bias;
+        bias.shape     = bias_shape.data();
+        bias.num_dims  = bias_shape.size();
+        bias.data_type = dt;
+        bias.data      = reinterpret_cast<uint8_t*>(biasData.data());
+        bias.size      = biasData.size() * sizeof(float);
+
+        tosa_tensor_t output;
+        output.shape     = output_shape.data();
+        output.num_dims  = output_shape.size();
+        output.data_type = dt;
+        output.data      = reinterpret_cast<uint8_t*>(dstData.data());
+        output.size      = dstData.size() * sizeof(float);
+
+        const int32_t input_zp  = 0;
+        const int32_t weight_zp = 0;
+
+        // Execution
+        func_config_t func_config;
+        func_config.abs_mode = true;
+        auto status =
+            tosa_run_conv2d(input, weight, bias, pad, stride, dilation, input_zp, weight_zp, output, func_config);
+        CHECK((status == tosa_status_valid));
+
+        // Compare results
+        std::vector<float> expectedData(32 * 32 * 16, 8.0f);
+        compareOutput(dstData, expectedData, expectedData.size());
+    }
+
     TEST_CASE("op_entry_max_pool2d")
     {
         // Pool parameters
diff --git a/scripts/operator_api/generate_api.py b/scripts/operator_api/generate_api.py
index 499eadb..f1cb6e0 100644
--- a/scripts/operator_api/generate_api.py
+++ b/scripts/operator_api/generate_api.py
@@ -1,5 +1,5 @@
 """Generate extended reference model API with eager operator execution entrypoints"""
-# Copyright (c) 2021-2022, ARM Limited.
+# Copyright (c) 2021-2023, ARM Limited.
 # SPDX-License-Identifier: Apache-2.0
 import copy
 import os
@@ -190,7 +190,7 @@
     Return a list of TOSA operators as defined by tosa.xml.
     """
     operators = []
-    ignoreOps = ["while_loop", "cond_if", "const", "custom", "fft2d", "rfft2d", "erf"]
+    ignoreOps = ["while_loop", "cond_if", "const", "custom", "fft2d", "rfft2d"]
     opsXml = tosaXml.getElementsByTagName("operator")
     allSerializeArgs = getSerializeArgs()
     for opXml in opsXml:
@@ -241,6 +241,9 @@
             argType = xmlArg.getAttribute("type")
         argShape = xmlArg.getAttribute("shape")
         argCategory = xmlArg.getAttribute("category")
+        # FullyConnected workaround
+        if (argName == "weight" or argName == "bias") and (argCategory == "attribute"):
+            argCategory = "input"
         # Update argument type
         if argType[-1:] == "*":
             argType = argType[:-1]
diff --git a/scripts/operator_api/templates/operators_cc.j2 b/scripts/operator_api/templates/operators_cc.j2
index 37a0af6..a8f1c24 100644
--- a/scripts/operator_api/templates/operators_cc.j2
+++ b/scripts/operator_api/templates/operators_cc.j2
@@ -45,12 +45,28 @@
 {
     switch (type)
     {
+        case tosa_datatype_bf16_t:
+            return tosa::DType::DType_BF16;
+        case tosa_datatype_bool_t:
+            return tosa::DType::DType_BOOL;
         case tosa_datatype_fp16_t:
             return tosa::DType::DType_FP16;
         case tosa_datatype_fp32_t:
             return tosa::DType::DType_FP32;
-        case tosa_datatype_bool_t:
-            return tosa::DType::DType_BOOL;
+        case tosa_datatype_int16_t:
+            return tosa::DType::DType_INT16;
+        case tosa_datatype_int32_t:
+            return tosa::DType::DType_INT32;
+        case tosa_datatype_int48_t:
+            return tosa::DType::DType_INT48;
+        case tosa_datatype_int4_t:
+            return tosa::DType::DType_INT4;
+        case tosa_datatype_int8_t:
+            return tosa::DType::DType_INT8;
+        case tosa_datatype_uint16_t:
+            return tosa::DType::DType_UINT16;
+        case tosa_datatype_uint8_t:
+            return tosa::DType::DType_UINT8;
         default:
             return tosa::DType::DType_UNKNOWN;
     }
@@ -83,7 +99,8 @@
         {%- for arg in operator.arguments: -%}
             {% if arg.type != "tosa_tensor_t" -%}const {% endif -%}{{arg.type}} client_{{arg.name}}{{arg.shape}}
             {% if loop.index < operator.arguments|length %},{% endif %}
-        {%- endfor -%}
+        {%- endfor -%}, const func_config_t &func_config,
+                        const func_debug_t &func_debug
     )
     {
         // Create operator attributes
@@ -157,7 +174,7 @@
                                                  });
 
         // Setup model
-        TosaReference::ModelRunnerImpl runner;
+        TosaReference::ModelRunnerImpl runner(func_config, func_debug);
         TOSA_RETURN_ON_GRAPH_STATUS_ERROR(runner.initialize(block));
         {% for input in operator.inputs: -%}
             TOSA_RETURN_ON_ERROR(runner.setInput({{input}}->GetName(), client_{{input}}.data, client_{{input}}.size));
diff --git a/scripts/operator_api/templates/operators_h.j2 b/scripts/operator_api/templates/operators_h.j2
index 803b76a..042d7a5 100644
--- a/scripts/operator_api/templates/operators_h.j2
+++ b/scripts/operator_api/templates/operators_h.j2
@@ -1,5 +1,5 @@
 
-// Copyright (c) 2022, ARM Limited.
+// Copyright (c) 2022-2023, ARM Limited.
 //
 //    Licensed under the Apache License, Version 2.0 (the "License");
 //    you may not use this file except in compliance with the License.
@@ -19,6 +19,9 @@
 #ifndef OPERATORS_H_
 #define OPERATORS_H_
 
+#include "func_config.h"
+#include "func_debug.h"
+
 #include <stddef.h>
 #include <stdint.h>
 
@@ -64,7 +67,8 @@
             {%- for arg in operator.arguments: -%}
                 {% if arg.type != "tosa_tensor_t" -%}const {% endif -%}{{arg.type}} client_{{arg.name}}{{arg.shape}}
                 {% if loop.index < operator.arguments|length %},{% endif %}
-            {%- endfor -%});
+            {%- endfor -%}, const func_config_t &func_config = func_config_t{},
+                            const func_debug_t &func_debug = func_debug_t{});
     {% endfor %}
 
 #ifdef __cplusplus