Optimize the declaration and usage of exec_ctx

README.md

@@ -124,7 +124,7 @@ I considered how many types of nodes are needed to represent a function in the e
 
     EntryArgumentNode: A node used to obtain the entry argument variables of a function.
 
-    ExecContextNode: A node used to obtain the context variables of the execution engine.
+    ExecContextNode: A node used to obtain the context variables of the execution engine. (Legacy — kept for backward compatibility; new code does not need to construct it explicitly because codegen auto-injects exec_ctx for functions registered via `RegisterReadOnlyCFuncWithExecCtx`.)
 
     ConstValueNode: Scalar constant node.
 
@@ -309,9 +309,9 @@ The library is designed around a "compile once, execute from many threads" patte
 Recommended pattern for parallel execution: one shared `ExecEngine` plus one `ExecContext` per worker thread.
 
 # Attention
-1. If you need to allocate memory that you cannot manage yourself and require the execution engine to manage it for you, you need to use the ExecContextNode. The ExecContext structure corresponding to ExecContextNode contains an arena. By using it to allocate memory, the memory will be automatically released when the execution is complete.
+1. If you need to allocate memory that you cannot manage yourself and require the execution engine to manage it for you, register your C function with `RegisterReadOnlyCFuncWithExecCtx`. The function should accept a trailing `void* ctx` parameter (which is the `ExecContext` pointer); the AST does **not** pass it explicitly — codegen automatically forwards the per-execution context. The `ExecContext` carries an arena, so memory allocated through `exec_ctx->arena` is freed automatically when execution ends.
 
-You can refer to test/exec_context_node_test.cc for more details. For example:
+For example:
 
 ```c++
 using namespace jitfusion;
@@ -330,13 +330,14 @@ U32ListStruct CreateU32List(void* ctx) {
 int main() {
   std::unique_ptr<FunctionRegistry> func_registry;
   FunctionRegistryFactory::CreateFunctionRegistry(&func_registry);
-  FunctionSignature sign("create_u32_list", {ValueType::kPtr}, ValueType::kU32List);
-  func_registry->RegisterReadOnlyCFunc(sign, reinterpret_cast<void*>(CreateU32List));
-
-  auto args_node = std::unique_ptr<ExecNode>(new ExecContextNode);
-  std::vector<std::unique_ptr<ExecNode>> create_func_args;
-  create_func_args.emplace_back(std::move(args_node));
-  auto create_func_node = std::unique_ptr<ExecNode>(new FunctionNode("create_u32_list", std::move(create_func_args)));
+  // User-visible signature has no trailing kPtr; the trailing exec_ctx is
+  // injected by codegen at every call site.
+  FunctionSignature sign("create_u32_list", {}, ValueType::kU32List);
+  func_registry->RegisterReadOnlyCFuncWithExecCtx(sign, reinterpret_cast<void*>(CreateU32List));
+
+  // No ExecContextNode in the AST — codegen wires exec_ctx through.
+  auto create_func_node = std::unique_ptr<ExecNode>(
+      new FunctionNode("create_u32_list", std::vector<std::unique_ptr<ExecNode>>{}));
 
   ExecEngine exec_engine;
   auto st = exec_engine.Compile(create_func_node, func_registry);

athena/README.md

@@ -38,7 +38,7 @@ when condition1 {
 
 Note: Variables modified inside `when` branches must maintain the same type as their original declaration. Nested `when` blocks are also supported.
 
-* 5.You can obtain the input parameter pointer through the entry_arg name, access the ExecContext via exec_ctx and obtain the output parameter pointer through the output name.
+* 5.You can obtain the input parameter pointer through the `entry_arg` name and the output parameter pointer through the `output` name. (The `exec_ctx` identifier is also still recognised as a legacy keyword that materialises the `ExecContext` pointer; new code does not need to pass it because functions registered via `RegisterReadOnlyCFuncWithExecCtx` get it injected by codegen.)
 
 * 6.Comments are supported in two C/C++ styles:
   * Line comments start with `//` and extend to the end of the line.

athena/test/const_value_test.cc

@@ -62,9 +62,9 @@ TEST(ConstValueTest, ListMergeOptimizeTest) {
   std::string code = R"(
   a = [1, 2, 3];
   b = [1, 2, 3];
-  c = ListAdd(a, b, exec_ctx);
-  d = ListAdd(b, a, exec_ctx);
-  e = ListAdd(c, d, exec_ctx);
+  c = ListAdd(a, b);
+  d = ListAdd(b, a);
+  e = ListAdd(c, d);
   )";
   ASSERT_TRUE(athena.Compile(code, func_registry).ok());
   RetType ret;

athena/test/exec_error_test.cc

@@ -27,7 +27,7 @@ TEST(ExecErrorTest, SingleExpressionRuntimeError) {
   std::string code = R"(
   a = [1, 2, 3];
   b = [4, 5];
-  r = ListAdd(a, b, exec_ctx);
+  r = ListAdd(a, b);
   )";
   ASSERT_TRUE(athena.Compile(code, func_registry).ok());
   RetType ret;
@@ -43,7 +43,7 @@ TEST(ExecErrorTest, WithExecContextRuntimeError) {
   std::string code = R"(
   a = [1, 2, 3];
   b = [4, 5];
-  r = ListAdd(a, b, exec_ctx);
+  r = ListAdd(a, b);
   )";
   ASSERT_TRUE(athena.Compile(code, func_registry).ok());
   ExecContext exec_ctx(4096);
@@ -74,7 +74,7 @@ TEST(ExecErrorTest, BatchExecutePartialFailure) {
   store(output, 0, r);
   )";
   std::string code2 = R"(
-  r = ListAdd([1, 2, 3], [4, 5], exec_ctx);
+  r = ListAdd([1, 2, 3], [4, 5]);
   )";
   std::string code3 = R"(
   a = load(entry_arg, 0);

athena/test/pipeline_test.cc

@@ -81,8 +81,8 @@ TEST(FilterTest, Test1) {
   EXPECT_TRUE(func_registry->RegisterReadOnlyCFunc(sign, reinterpret_cast<void*>(LoadI32List)).ok());
   std::string code = R"(
   a = load(entry_arg, 0);
-  b = GenLargeBitmap(a, 3, exec_ctx);
-  FilterByBitmap(a, b, exec_ctx);
+  b = GenLargeBitmap(a, 3);
+  FilterByBitmap(a, b);
   )";
   ASSERT_TRUE(athena.Compile(code, func_registry).ok());
   RetType ret;
@@ -101,8 +101,8 @@ TEST(FilterTest, Test2) {
   std::string code = R"(
   a = load(entry_arg, 0);
   b = load(entry_arg, 1);
-  c = GenLargeBitmap(a, b, exec_ctx);
-  FilterByBitmap(a, c, exec_ctx);
+  c = GenLargeBitmap(a, b);
+  FilterByBitmap(a, c);
   )";
   ASSERT_TRUE(athena.Compile(code, func_registry).ok());
   RetType ret;
@@ -122,9 +122,9 @@ TEST(CustomPassTest, CommutativeCallCanonicalizerPass1) {
   std::string code = R"(
   a = load(entry_arg, 0);
   b = load(entry_arg, 1);
-  c = ListAdd(a, b, exec_ctx);
-  d = ListAdd(b, a, exec_ctx);
-  e = ListAdd(c, d, exec_ctx);
+  c = ListAdd(a, b);
+  d = ListAdd(b, a);
+  e = ListAdd(c, d);
   )";
   ASSERT_TRUE(athena.Compile(code, func_registry).ok());
   RetType ret;
@@ -143,9 +143,9 @@ TEST(CustomPassTest, CommutativeCallCanonicalizerPass2) {
   std::string code = R"(
   a = [1, 2, 3];
   b = [4, 5, 6];
-  c = ListAdd(a, b, exec_ctx);
-  d = ListAdd(b, a, exec_ctx);
-  e = ListAdd(c, d, exec_ctx);
+  c = ListAdd(a, b);
+  d = ListAdd(b, a);
+  e = ListAdd(c, d);
   )";
   ASSERT_TRUE(athena.Compile(code, func_registry).ok());
   RetType ret;

athena/test/ref_node_test.cc

@@ -282,7 +282,7 @@ TEST(RefNodeTest, RefNodeWithListOperations) {
   std::string code = R"(
   a = load(entry_arg, 0);
   b = load(entry_arg, 1);
-  c = ListAdd(a, b, exec_ctx);
+  c = ListAdd(a, b);
   d = Len(c);
   e = Len(a) + Len(b);
   store(output, 0, CastF32(d));

benchmark/bench_common.h

@@ -126,8 +126,9 @@ inline std::unique_ptr<ExecNode> MakeListUnaryCall(const std::string& func_name,
 // Convenience alias kept for readability.
 inline std::unique_ptr<ExecNode> MakeListSumExpr(int list_len) { return MakeListUnaryCall("Sum", list_len); }
 
-// Build `func_name(list, exec_ctx)` — one-arg list kernels that require an
-// ExecContext pointer (arithmetic/basic kernels that allocate output lists).
+// Build `func_name(list)` — one-arg list kernels that allocate output lists.
+// (The C-level kernel still takes a trailing exec_ctx pointer; codegen now
+// auto-injects it, so the user-visible AST has no ctx node.)
 inline std::unique_ptr<ExecNode> MakeListUnaryCtxCall(const std::string& func_name, int list_len) {
   std::vector<int64_t> values;
   values.reserve(list_len);
@@ -136,11 +137,10 @@ inline std::unique_ptr<ExecNode> MakeListUnaryCtxCall(const std::string& func_na
   }
   std::vector<std::unique_ptr<ExecNode>> args;
   args.emplace_back(new ConstantListValueNode(std::move(values)));
-  args.emplace_back(new jitfusion::ExecContextNode());
   return std::unique_ptr<ExecNode>(new FunctionNode(func_name, std::move(args)));
 }
 
-// Build `func_name(list<f64>, exec_ctx)` — unary kernels that only accept float lists
+// Build `func_name(list<f64>)` — unary kernels that only accept float lists
 // (ListCeil, ListFloor, ListRound).
 inline std::unique_ptr<ExecNode> MakeListUnaryCtxCallF64(const std::string& func_name, int list_len) {
   std::vector<double> values;
@@ -150,11 +150,10 @@ inline std::unique_ptr<ExecNode> MakeListUnaryCtxCallF64(const std::string& func
   }
   std::vector<std::unique_ptr<ExecNode>> args;
   args.emplace_back(new ConstantListValueNode(std::move(values)));
-  args.emplace_back(new jitfusion::ExecContextNode());
   return std::unique_ptr<ExecNode>(new FunctionNode(func_name, std::move(args)));
 }
 
-// Build `func_name(list<int64>, scalar_int, exec_ctx)` — list-scalar broadcast.
+// Build `func_name(list<int64>, scalar_int)` — list-scalar broadcast.
 inline std::unique_ptr<ExecNode> MakeListScalarCtxCall(const std::string& func_name, int list_len, int64_t scalar_val) {
   std::vector<int64_t> values;
   values.reserve(list_len);
@@ -164,11 +163,10 @@ inline std::unique_ptr<ExecNode> MakeListScalarCtxCall(const std::string& func_n
   std::vector<std::unique_ptr<ExecNode>> args;
   args.emplace_back(new ConstantListValueNode(std::move(values)));
   args.emplace_back(new ConstantValueNode(scalar_val));
-  args.emplace_back(new jitfusion::ExecContextNode());
   return std::unique_ptr<ExecNode>(new FunctionNode(func_name, std::move(args)));
 }
 
-// Build `func_name(list<uint64>, scalar<uint64>, exec_ctx)` — bitwise list-scalar.
+// Build `func_name(list<uint64>, scalar<uint64>)` — bitwise list-scalar.
 // Bitwise kernels are only registered for unsigned integer types.
 inline std::unique_ptr<ExecNode> MakeListScalarCtxCallU64(const std::string& func_name, int list_len,
                                                           uint64_t scalar_val) {
@@ -180,11 +178,10 @@ inline std::unique_ptr<ExecNode> MakeListScalarCtxCallU64(const std::string& fun
   std::vector<std::unique_ptr<ExecNode>> args;
   args.emplace_back(new ConstantListValueNode(std::move(values)));
   args.emplace_back(new ConstantValueNode(scalar_val));
-  args.emplace_back(new jitfusion::ExecContextNode());
   return std::unique_ptr<ExecNode>(new FunctionNode(func_name, std::move(args)));
 }
 
-// Build `func_name(list<uint64>, list<uint64>, exec_ctx)` — bitwise list-list.
+// Build `func_name(list<uint64>, list<uint64>)` — bitwise list-list.
 inline std::unique_ptr<ExecNode> MakeListListCtxCallU64(const std::string& func_name, int list_len) {
   std::vector<uint64_t> lhs;
   std::vector<uint64_t> rhs;
@@ -197,11 +194,10 @@ inline std::unique_ptr<ExecNode> MakeListListCtxCallU64(const std::string& func_
   std::vector<std::unique_ptr<ExecNode>> args;
   args.emplace_back(new ConstantListValueNode(std::move(lhs)));
   args.emplace_back(new ConstantListValueNode(std::move(rhs)));
-  args.emplace_back(new jitfusion::ExecContextNode());
   return std::unique_ptr<ExecNode>(new FunctionNode(func_name, std::move(args)));
 }
 
-// Build `func_name(list<int64>, list<int64>, exec_ctx)` — element-wise list-list.
+// Build `func_name(list<int64>, list<int64>)` — element-wise list-list.
 inline std::unique_ptr<ExecNode> MakeListListCtxCall(const std::string& func_name, int list_len) {
   std::vector<int64_t> lhs;
   std::vector<int64_t> rhs;
@@ -214,11 +210,10 @@ inline std::unique_ptr<ExecNode> MakeListListCtxCall(const std::string& func_nam
   std::vector<std::unique_ptr<ExecNode>> args;
   args.emplace_back(new ConstantListValueNode(std::move(lhs)));
   args.emplace_back(new ConstantListValueNode(std::move(rhs)));
-  args.emplace_back(new jitfusion::ExecContextNode());
   return std::unique_ptr<ExecNode>(new FunctionNode(func_name, std::move(args)));
 }
 
-// Build `func_name(list<int64>, scalar, scalar, exec_ctx)` — the IfEqual /
+// Build `func_name(list<int64>, scalar, scalar)` — the IfEqual /
 // IfLess / etc. family: "for each element, if cond(elem, pivot) pick a else b".
 inline std::unique_ptr<ExecNode> MakeListIfSelectCall(const std::string& func_name, int list_len) {
   std::vector<int64_t> values;
@@ -230,7 +225,6 @@ inline std::unique_ptr<ExecNode> MakeListIfSelectCall(const std::string& func_na
   args.emplace_back(new ConstantListValueNode(std::move(values)));
   args.emplace_back(new ConstantValueNode(static_cast<int64_t>(list_len / 2)));
   args.emplace_back(new ConstantValueNode(static_cast<int64_t>(-1)));
-  args.emplace_back(new jitfusion::ExecContextNode());
   return std::unique_ptr<ExecNode>(new FunctionNode(func_name, std::move(args)));
 }
 

benchmark/bench_list_agg.cc

@@ -2,23 +2,23 @@
  * @Author: victorika
  * @Date: 2026-04-30 16:07:33
  * @Last Modified by: victorika
- * @Last Modified time: 2026-04-30 16:07:33
+ * @Last Modified time: 2026-05-11 16:58:15
  */
 // C. List aggregation + C-group. See bench_compile.cc for the split overview.
 
 #include "benchmark/bench_common.h"
 
 namespace {
 
-using ::jitfusion::bench::CompileOrDie;
-using ::jitfusion::bench::MakeListUnaryCall;
-using ::jitfusion::bench::MakeRegistry;
 using ::jitfusion::ConstantListValueNode;
 using ::jitfusion::ConstantValueNode;
 using ::jitfusion::ExecContext;
 using ::jitfusion::ExecNode;
 using ::jitfusion::FunctionNode;
 using ::jitfusion::RetType;
+using ::jitfusion::bench::CompileOrDie;
+using ::jitfusion::bench::MakeListUnaryCall;
+using ::jitfusion::bench::MakeRegistry;
 
 // =============================================================================
 // C. List aggregation — kernel cost vs. list length
@@ -237,12 +237,11 @@ std::unique_ptr<ExecNode> MakeGroupKeysList(int len, int distinct) {
   return std::unique_ptr<ExecNode>(new ConstantListValueNode(std::move(values)));
 }
 
-// Build `GroupIndex(keys_list, exec_ctx)` — the only non-sugar group node in
-// the family; its kernel is the 2-arg form.
+// Build `GroupIndex(keys_list)` — the only non-sugar group node in
+// the family.
 std::unique_ptr<ExecNode> MakeGroupIndexNode(int len, int distinct) {
   std::vector<std::unique_ptr<ExecNode>> args;
   args.emplace_back(MakeGroupKeysList(len, distinct));
-  args.emplace_back(new jitfusion::ExecContextNode());
   return std::unique_ptr<ExecNode>(new FunctionNode("GroupIndex", std::move(args)));
 }
 
@@ -288,15 +287,14 @@ void BM_Execute_GroupCount(benchmark::State& state) {
 }
 BENCHMARK(BM_Execute_GroupCount)->Args({4096, 16})->Args({4096, 256})->Args({4096, 4096});
 
-// Helper: build the sugar-form call `func_name(keys_or_values, GroupIndex(...), exec_ctx)`.
+// Helper: build the sugar-form call `func_name(keys_or_values, GroupIndex(...))`.
 // The keys list drives GroupIndex; the same list is also fed as values/keys
 // to the aggregate under test. That's fine because all aggregates accept
 // integer lists and we measure compute time, not numerical content.
 std::unique_ptr<ExecNode> MakeGroupSugarCall(const std::string& func_name, int len, int distinct) {
   std::vector<std::unique_ptr<ExecNode>> args;
   args.emplace_back(MakeGroupKeysList(len, distinct));
   args.emplace_back(MakeGroupIndexNode(len, distinct));
-  args.emplace_back(new jitfusion::ExecContextNode());
   return std::unique_ptr<ExecNode>(new FunctionNode(func_name, std::move(args)));
 }
 

benchmark/bench_list_basic.cc

@@ -2,7 +2,7 @@
  * @Author: victorika
  * @Date: 2026-04-30 16:07:33
  * @Last Modified by: victorika
- * @Last Modified time: 2026-04-30 16:07:33
+ * @Last Modified time: 2026-05-11 16:58:35
  */
 // G. List basic (shape manipulation) + H. List element-wise unary.
 // See bench_compile.cc for the split overview.
@@ -11,18 +11,18 @@
 
 namespace {
 
-using ::jitfusion::bench::CompileOrDie;
-using ::jitfusion::bench::MakeListListCtxCall;
-using ::jitfusion::bench::MakeListUnaryCall;
-using ::jitfusion::bench::MakeListUnaryCtxCall;
-using ::jitfusion::bench::MakeListUnaryCtxCallF64;
-using ::jitfusion::bench::MakeRegistry;
 using ::jitfusion::ConstantListValueNode;
 using ::jitfusion::ConstantValueNode;
 using ::jitfusion::ExecContext;
 using ::jitfusion::ExecNode;
 using ::jitfusion::FunctionNode;
 using ::jitfusion::RetType;
+using ::jitfusion::bench::CompileOrDie;
+using ::jitfusion::bench::MakeListListCtxCall;
+using ::jitfusion::bench::MakeListUnaryCall;
+using ::jitfusion::bench::MakeListUnaryCtxCall;
+using ::jitfusion::bench::MakeListUnaryCtxCallF64;
+using ::jitfusion::bench::MakeRegistry;
 
 // =============================================================================
 // G. List basic — shape-manipulation kernels
@@ -163,7 +163,7 @@ void BM_Execute_ListMurmurHash3X8632(benchmark::State& state) {
 }
 BENCHMARK(BM_Execute_ListMurmurHash3X8632)->Arg(256)->Arg(4096);
 
-// ListConcat(listA, listB, ctx).
+// ListConcat(listA, listB).
 void BM_Execute_ListConcat(benchmark::State& state) {
   const int len = static_cast<int>(state.range(0));
   auto reg = MakeRegistry();
@@ -181,7 +181,7 @@ void BM_Execute_ListConcat(benchmark::State& state) {
 }
 BENCHMARK(BM_Execute_ListConcat)->Arg(256)->Arg(4096);
 
-// CrossJoin(stringlist a, stringlist b, string sep, ctx) — produces a
+// CrossJoin(stringlist a, stringlist b, string sep) — produces a
 // length-(|a| * |b|) stringlist of "a[i] + sep + b[j]". Output size is
 // quadratic in the input length, so we sweep the per-side length from 16..256
 // (yielding 256..65536 output elements) instead of the usual 256/4096 sweep
@@ -201,7 +201,7 @@ void BM_Execute_CrossJoin(benchmark::State& state) {
   args.emplace_back(new ConstantListValueNode(std::move(a)));
   args.emplace_back(new ConstantListValueNode(std::move(b)));
   args.emplace_back(new ConstantValueNode(std::string("_")));
-  args.emplace_back(new jitfusion::ExecContextNode());
+
   std::unique_ptr<ExecNode> node(new FunctionNode("CrossJoin", std::move(args)));
 
   auto engine = CompileOrDie(std::move(node), reg);
@@ -218,7 +218,7 @@ void BM_Execute_CrossJoin(benchmark::State& state) {
 }
 BENCHMARK(BM_Execute_CrossJoin)->Arg(16)->Arg(64)->Arg(256);
 
-// ZipConcat(stringlist a, stringlist b, string sep, ctx) — per-position
+// ZipConcat(stringlist a, stringlist b, string sep) — per-position
 // concatenation, output length equals |a| (== |b|). Linear cost in input
 // length, so it shares the standard 256/4096 sweep with the other linear
 // list kernels.
@@ -237,7 +237,7 @@ void BM_Execute_ZipConcat(benchmark::State& state) {
   args.emplace_back(new ConstantListValueNode(std::move(a)));
   args.emplace_back(new ConstantListValueNode(std::move(b)));
   args.emplace_back(new ConstantValueNode(std::string(":")));
-  args.emplace_back(new jitfusion::ExecContextNode());
+
   std::unique_ptr<ExecNode> node(new FunctionNode("ZipConcat", std::move(args)));
 
   auto engine = CompileOrDie(std::move(node), reg);
@@ -284,7 +284,7 @@ void BM_Execute_ListIn(benchmark::State& state) {
 BENCHMARK(BM_Execute_ListIn)->Arg(256)->Arg(4096);
 
 // =============================================================================
-// H. List element-wise unary (func(list, ctx) -> list)
+// H. List element-wise unary (func(list) -> list)
 // =============================================================================
 
 #define JITFUSION_DEFINE_LIST_UNARY_BM(NAME)                           \