fix: Support context locals and error-context APIs

- **Labels:** `enhancement`, `abi`

Signed-off-by: Gordon Smith <GordonJSmith@gmail.com>

Author: GordonSmith

include/cmcpp.hpp

@@ -5,6 +5,7 @@
 #include <cmcpp/integer.hpp>
 #include <cmcpp/float.hpp>
 #include <cmcpp/string.hpp>
+#include <cmcpp/error_context.hpp>
 #include <cmcpp/flags.hpp>
 #include <cmcpp/list.hpp>
 #include <cmcpp/tuple.hpp>

include/cmcpp/context.hpp

@@ -5,6 +5,7 @@
 #include "runtime.hpp"
 
 #include <algorithm>
+#include <array>
 #include <deque>
 #include <future>
 #include <memory>
@@ -969,10 +970,6 @@ namespace cmcpp
         std::unordered_map<const ResourceType *, HandleTable> tables_;
     };
 
-    struct ErrorContext
-    {
-    };
-
     struct ComponentInstance
     {
         Store *store = nullptr;
@@ -1010,6 +1007,27 @@ namespace cmcpp
         inst.backpressure -= 1;
     }
 
+    class ContextLocalStorage
+    {
+    public:
+        static constexpr uint32_t LENGTH = 1;
+
+        ContextLocalStorage() = default;
+
+        void set(uint32_t index, int32_t value)
+        {
+            storage_[index] = value;
+        }
+
+        int32_t get(uint32_t index) const
+        {
+            return storage_[index];
+        }
+
+    private:
+        std::array<int32_t, LENGTH> storage_{};
+    };
+
     class Task : public std::enable_shared_from_this<Task>
     {
     public:
@@ -1184,6 +1202,16 @@ namespace cmcpp
             return state_;
         }
 
+        ContextLocalStorage &context()
+        {
+            return context_;
+        }
+
+        const ContextLocalStorage &context() const
+        {
+            return context_;
+        }
+
         ComponentInstance *component_instance() const
         {
             return inst_;
@@ -1236,6 +1264,7 @@ namespace cmcpp
         uint32_t num_borrows_ = 0;
         std::shared_ptr<Thread> thread_;
         State state_ = State::Initial;
+        ContextLocalStorage context_{};
     };
 
     inline void canon_task_return(Task &task, std::vector<std::any> result, const HostTrap &trap)
@@ -1276,25 +1305,6 @@ namespace cmcpp
         return event.code == EventCode::TASK_CANCELLED ? 1u : 0u;
     }
 
-    class ContextLocalStorage
-    {
-    public:
-        static constexpr int LENGTH = 2;
-        int array[LENGTH] = {0, 0};
-
-        ContextLocalStorage() = default;
-
-        void set(int i, int v)
-        {
-            array[i] = v;
-        }
-
-        int get(int i)
-        {
-            return array[i];
-        }
-    };
-
     struct Subtask : Waitable
     {
     };
@@ -1359,6 +1369,28 @@ namespace cmcpp
         return element.rep;
     }
 
+    inline int32_t canon_context_get(Task &task, uint32_t index, const HostTrap &trap)
+    {
+        if (auto *inst = task.component_instance())
+        {
+            ensure_may_leave(*inst, trap);
+        }
+        auto trap_cx = make_trap_context(trap);
+        trap_if(trap_cx, index >= ContextLocalStorage::LENGTH, "context index out of bounds");
+        return task.context().get(index);
+    }
+
+    inline void canon_context_set(Task &task, uint32_t index, int32_t value, const HostTrap &trap)
+    {
+        if (auto *inst = task.component_instance())
+        {
+            ensure_may_leave(*inst, trap);
+        }
+        auto trap_cx = make_trap_context(trap);
+        trap_if(trap_cx, index >= ContextLocalStorage::LENGTH, "context index out of bounds");
+        task.context().set(index, value);
+    }
+
     inline uint32_t canon_waitable_set_new(ComponentInstance &inst, const HostTrap &trap)
     {
         ensure_may_leave(inst, trap);

include/cmcpp/error_context.hpp

@@ -0,0 +1,74 @@
+#ifndef CMCPP_ERROR_CONTEXT_HPP
+#define CMCPP_ERROR_CONTEXT_HPP
+
+#include "context.hpp"
+#include "string.hpp"
+#include <utility>
+
+namespace cmcpp
+{
+    class ErrorContext : public TableEntry
+    {
+    public:
+        explicit ErrorContext(string_t message)
+            : debug_message_(std::move(message))
+        {
+        }
+
+        const string_t &debug_message() const
+        {
+            return debug_message_;
+        }
+
+    private:
+        string_t debug_message_{};
+    };
+
+    inline uint32_t canon_error_context_new(Task &task,
+                                            const LiftLowerContext *cx,
+                                            uint32_t ptr,
+                                            uint32_t tagged_code_units,
+                                            const HostTrap &trap)
+    {
+        auto *inst = task.component_instance();
+        auto trap_cx = make_trap_context(trap);
+        trap_if(trap_cx, inst == nullptr, "task missing component instance");
+        ensure_may_leave(*inst, trap);
+
+        string_t message;
+        if (cx != nullptr)
+        {
+            message = string::load_from_range<string_t>(*cx, ptr, tagged_code_units);
+        }
+
+        auto entry = std::make_shared<ErrorContext>(std::move(message));
+        return inst->table.add(entry, trap);
+    }
+
+    inline void canon_error_context_debug_message(Task &task,
+                                                  LiftLowerContext &cx,
+                                                  uint32_t index,
+                                                  uint32_t ptr,
+                                                  const HostTrap &trap)
+    {
+        auto *inst = task.component_instance();
+        auto trap_cx = make_trap_context(trap);
+        trap_if(trap_cx, inst == nullptr, "task missing component instance");
+        ensure_may_leave(*inst, trap);
+
+        auto errctx = inst->table.get<ErrorContext>(index, trap);
+        string::store(cx, errctx->debug_message(), ptr);
+    }
+
+    inline void canon_error_context_drop(Task &task, uint32_t index, const HostTrap &trap)
+    {
+        auto *inst = task.component_instance();
+        auto trap_cx = make_trap_context(trap);
+        trap_if(trap_cx, inst == nullptr, "task missing component instance");
+        ensure_may_leave(*inst, trap);
+
+        inst->table.remove<ErrorContext>(index, trap);
+    }
+}
+
+#endif // CMCPP_ERROR_CONTEXT_HPP

test/main.cpp

@@ -5,6 +5,7 @@
 using namespace cmcpp;
 
 #include <iostream>
+#include <algorithm>
 #include <string>
 #include <vector>
 #include <utility>
@@ -232,6 +233,81 @@ TEST_CASE("Backpressure counters and may_leave guards")
     CHECK_NOTHROW(canon_waitable_set_new(inst, trap));
 }
 
+TEST_CASE("Context locals provide per-task storage")
+{
+    ComponentInstance inst;
+    HostTrap trap = [](const char *msg)
+    {
+        throw std::runtime_error(msg ? msg : "trap");
+    };
+
+    Task task(inst);
+
+    CHECK(ContextLocalStorage::LENGTH == 1);
+    CHECK(canon_context_get(task, 0, trap) == 0);
+
+    canon_context_set(task, 0, 42, trap);
+    CHECK(canon_context_get(task, 0, trap) == 42);
+
+    CHECK_THROWS(canon_context_get(task, ContextLocalStorage::LENGTH, trap));
+    CHECK_THROWS(canon_context_set(task, ContextLocalStorage::LENGTH, 99, trap));
+
+    inst.may_leave = false;
+    CHECK_THROWS(canon_context_get(task, 0, trap));
+    inst.may_leave = true;
+}
+
+TEST_CASE("Error context APIs manage debug messages")
+{
+    Store store;
+    ComponentInstance inst;
+    inst.store = &store;
+
+    HostTrap trap = [](const char *msg)
+    {
+        throw std::runtime_error(msg ? msg : "trap");
+    };
+
+    Task task(inst);
+
+    Heap heap(1024);
+    auto cx = createLiftLowerContext(&heap, Encoding::Utf8);
+    cx->inst = &inst;
+
+    const std::string guest_message = "component failure";
+    const uint32_t guest_ptr = 32;
+    std::copy(guest_message.begin(), guest_message.end(), heap.memory.begin() + guest_ptr);
+    uint32_t tagged_code_units = static_cast<uint32_t>(guest_message.size());
+
+    uint32_t err_index = canon_error_context_new(task, cx.get(), guest_ptr, tagged_code_units, trap);
+    CHECK(err_index != 0);
+
+    const uint32_t record_ptr = 128;
+    canon_error_context_debug_message(task, *cx, err_index, record_ptr, trap);
+
+    uint32_t stored_ptr = integer::load<uint32_t>(*cx, record_ptr);
+    uint32_t stored_len = integer::load<uint32_t>(*cx, record_ptr + 4);
+    auto roundtrip = string::load_from_range<string_t>(*cx, stored_ptr, stored_len);
+    CHECK(roundtrip == guest_message);
+
+    inst.may_leave = false;
+    CHECK_THROWS(canon_error_context_debug_message(task, *cx, err_index, record_ptr + 16, trap));
+    inst.may_leave = true;
+
+    canon_error_context_drop(task, err_index, trap);
+    CHECK_THROWS(canon_error_context_drop(task, err_index, trap));
+
+    uint32_t empty_index = canon_error_context_new(task, nullptr, 0, 0, trap);
+    CHECK(empty_index != 0);
+
+    const uint32_t empty_record = 192;
+    canon_error_context_debug_message(task, *cx, empty_index, empty_record, trap);
+    uint32_t empty_len = integer::load<uint32_t>(*cx, empty_record + 4);
+    CHECK(empty_len == 0);
+
+    canon_error_context_drop(task, empty_index, trap);
+}
+
 TEST_CASE("Task yield, cancel, and return")
 {
     Store store;