From b62095815137b308a4457c20fec97ca9672c599a Mon Sep 17 00:00:00 2001
From: Julian Blake Kongslie
Date: Sat, 25 Jun 2022 12:54:33 -0700
Subject: Testing some actual support for destinations and custom steps.

---
 aisa/aisa.h | 44 +++++++++++++++++++++---------------------
 main.cpp    | 63 ++++++++++++++++++++++++++++++++++++++++---------------------
 2 files changed, 64 insertions(+), 43 deletions(-)

diff --git a/aisa/aisa.h b/aisa/aisa.h
index 8cb302e..123b12a 100644
--- a/aisa/aisa.h
+++ b/aisa/aisa.h
@@ -2,6 +2,7 @@
 
 #include <coroutine>
 #include <cstdint>
+#include <initializer_list>
 #include <iostream>
 #include <optional>
 #include <utility>
@@ -16,6 +17,7 @@ namespace aisa {
 
     template<typename CRTP> struct EvalState {
         CRTP & crtp() noexcept { return static_cast<CRTP &>(*this); }
+
         task<regval_t> async_load_reg(regnum_t rn)
         {
             while (true) {
@@ -24,12 +26,21 @@ namespace aisa {
                 co_await suspend();
             }
         }
+
+        task<void> async_store_reg(regnum_t rn, regval_t rv)
+        {
+            while (true) {
+                if (crtp().store_reg(rn, rv))
+                    co_return;
+                co_await suspend();
+            }
+        }
     };
 
     struct Step {
-        const std::optional<std::pair<regnum_t, regval_t>> predicate;
-        const std::vector<regnum_t> source_regs;
-        const std::vector<regnum_t> destination_regs;
+        std::optional<std::pair<regnum_t, regval_t>> predicate;
+        std::vector<regnum_t> source_regs;
+        std::vector<regnum_t> destination_regs;
 
         std::optional<regnum_t> predicate_reg() const
         {
@@ -45,33 +56,22 @@ namespace aisa {
             return {};
         }
 
-        template<typename State> task<void> evaluate(State &state) const
+        virtual std::vector<regval_t> compute_destinations(const std::vector<regval_t> &source_vals) const = 0;
+
+        template<typename State> task<void> eval(State &state) const
         {
             if (predicate.has_value()) {
-                std::cout << "checking predicate...\n";
-                std::cout << "\texpect " << predicate->second << "\n";
                 regval_t pval = co_await state.async_load_reg(predicate->first);
-                std::cout << "\tgot " << pval << "\n";
-                if (pval != predicate->second) {
-                    std::cout << "\tpredicate skipped\n";
+                if (pval != predicate->second)
                     co_return;
-                } else {
-                    std::cout << "\tpredicate not skipped\n";
-                }
             }
-            std::cout << "reading sources...\n";
             std::vector<regval_t> source_vals;
             source_vals.reserve(source_regs.size());
-            for (unsigned int i = 0; i < source_regs.size(); ++i) {
-                std::cout << "\tgetting source " << i << "...\n";
-                source_vals.emplace_back(co_await state.async_load_reg(source_regs[i]));
-                std::cout << "\t\tgot " << source_vals.back() << "\n";
-            }
-            std::cout << "sources:";
             for (unsigned int i = 0; i < source_regs.size(); ++i)
-                std::cout << " " << source_regs[i] << "=" << source_vals[i];
-            std::cout << "\n";
-            std::cout << "done with evaluate\n";
+                source_vals.emplace_back(co_await state.async_load_reg(source_regs[i]));
+            auto destination_vals = compute_destinations(source_vals);
+            for (unsigned int i = 0; i < destination_regs.size(); ++i)
+                co_await state.async_store_reg(destination_regs[i], destination_vals[i]);
         }
     };
 
diff --git a/main.cpp b/main.cpp
index 0240bb5..25bd99b 100644
--- a/main.cpp
+++ b/main.cpp
@@ -9,11 +9,23 @@ int main(int argc, const char *argv[])
 {
     std::cout << "Version " << GIT_TAG << "\n";
 
-    aisa::Step step;
-    const_cast<std::optional<std::pair<aisa::regnum_t, aisa::regval_t>> &>(step.predicate) = std::optional(std::make_pair(123, 456));
-    const_cast<std::vector<aisa::regnum_t> &>(step.source_regs).emplace_back(12);
-    const_cast<std::vector<aisa::regnum_t> &>(step.source_regs).emplace_back(34);
-    const_cast<std::vector<aisa::regnum_t> &>(step.source_regs).emplace_back(56);
+    struct CopyStep : public aisa::Step {
+        CopyStep(std::pair<aisa::regnum_t, aisa::regval_t> pred, const std::initializer_list<std::pair<aisa::regnum_t, aisa::regnum_t>> &regs)
+        {
+            predicate = std::move(pred);
+            source_regs.reserve(regs.size());
+            destination_regs.reserve(regs.size());
+            for (const auto &rp : regs) {
+                source_regs.emplace_back(rp.first);
+                destination_regs.emplace_back(rp.second);
+            }
+        }
+
+        std::vector<aisa::regval_t> compute_destinations(const std::vector<aisa::regval_t> &source_vals) const override
+        {
+            return source_vals;
+        }
+    } step{{123, 456}, {{1, 2}, {3, 4}, {5, 6}}};
 
     struct State : public aisa::EvalState<State> {
         std::map<aisa::regnum_t, aisa::regval_t> regs;
@@ -28,33 +40,42 @@ int main(int argc, const char *argv[])
             std::cout << "(not available)\n";
             return {};
         }
+
+        bool store_reg(aisa::regnum_t rn, aisa::regval_t rv)
+        {
+            std::cout << "state.store_reg(" << rn << " <- " << rv << ")\n";
+            regs[rn] = rv;
+            return true;
+        }
     } state;
 
     auto t = state.async_load_reg(999);
-    t();
-    t();
-    t();
-    std::cout << "set regs[999] = 54321\n"; state.regs[999] = 54321;
+    std::cout << "run\n"; t();
+    std::cout << "run\n"; t();
+    std::cout << "run\n"; t();
+    std::cout << "set regs[999] = 54321\n"; state.store_reg(999, 54321);
     std::optional<aisa::regval_t> result;
-    while (!result.has_value())
+    while (!result.has_value()) {
+        std::cout << "run\n";
         result = t();
+    }
     std::cout << "result = " << *result << "\n";
 
     std::cout << "\n\n\n";
 
-    auto w = step.evaluate(state);
-    w();
-    w();
-    w();
-    std::cout << "set predicate (valid)\n"; state.regs[step.predicate->first] = step.predicate->second;
-    w();
-    w();
-    w();
+    auto w = step.eval(state);
+    std::cout << "run\n"; w();
+    std::cout << "run\n"; w();
+    std::cout << "run\n"; w();
+    std::cout << "set predicate (valid)\n"; state.store_reg(step.predicate->first, step.predicate->second);
+    std::cout << "run\n"; w();
+    std::cout << "run\n"; w();
+    std::cout << "run\n"; w();
     std::cout << "set regs (all)\n";
-    for (int i = 10; i < 100; ++i)
-        state.regs[i] = 1000 + i;
+    for (int i = 0; i < 10; ++i)
+        state.store_reg(i, 1000 + i);
     for (bool done = false; !done; done = w())
-        ;
+        std::cout << "run\n";
     std::cout << "huzzah!\n";
 
     return 0;
-- 
cgit v1.2.3