Dropping the async interface, and adding some real uarch.

6 files changed, 63 insertions, 395 deletions

diff --git a/aisa/aisa.cpp b/aisa/aisa.cpp
index 811c882..8c8cd1e 100644
--- a/aisa/aisa.cpp
+++ b/aisa/aisa.cpp
@@ -6,6 +6,12 @@
 
 namespace aisa {
 
+    ISA::~ISA() { }
+
+    Task::~Task() { }
+
+    Step::~Step() { }
+
     std::optional<std::pair<std::unique_ptr<const Step>, regval_t>> Task::step(regval_t environment_val) const { return {}; }
 
     MemInfo Step::meminfo(const Wires &wires) const { return {}; }
diff --git a/aisa/aisa.h b/aisa/aisa.h
index e4e1074..a986cd7 100644
--- a/aisa/aisa.h
+++ b/aisa/aisa.h
@@ -17,7 +17,7 @@ namespace aisa {
     struct Task;
 
     struct ISA {
-        virtual ~ISA() { }
+        virtual ~ISA();
 
         virtual std::pair<std::unique_ptr<const Task>, regval_t> initial_task() const = 0;
     };
@@ -27,7 +27,7 @@ namespace aisa {
     struct Task {
         regnum_t environment;
 
-        virtual ~Task() { }
+        virtual ~Task();
 
         virtual std::string disasm() const = 0;
 
@@ -58,24 +58,10 @@ namespace aisa {
         std::vector<regnum_t> source_regs;
         std::vector<regnum_t> destination_regs;
 
-        virtual ~Step() { }
+        virtual ~Step();
 
         virtual std::string disasm(const Wires *w = nullptr) const = 0;
 
-        std::optional<regnum_t> predicate_reg() const
-        {
-            if (predicate.has_value())
-                return predicate->first;
-            return {};
-        }
-
-        std::optional<regnum_t> expected_predicate_val() const
-        {
-            if (predicate.has_value())
-                return predicate->second;
-            return {};
-        }
-
         MOp mop = MOp::NONE;
 
         virtual MemInfo meminfo(const Wires &wires) const;
diff --git a/aisa/async.h b/aisa/async.h
deleted file mode 100644
index 42e99e7..0000000
--- a/aisa/async.h
+++ /dev/null
@@ -1,225 +0,0 @@
-#pragma once
-
-#include <coroutine>
-#include <optional>
-#include <utility>
-#include <memory>
-#include <vector>
-
-#include "aisa/aisa.h"
-#include "aisa/coroutine.h" // IWYU pragma: export
-
-namespace aisa {
-
-    template<typename CRTP> struct AsyncEval {
-        CRTP & crtp() noexcept { return static_cast<CRTP &>(*this); }
-
-        task<regval_t> async_load_reg(regnum_t rn)
-        {
-            while (true) {
-                if (auto rv = crtp().load_reg(rn); rv.has_value())
-                    co_return *rv;
-                co_await std::suspend_always{};
-            }
-        }
-
-        task<void> async_store_reg(regnum_t rn, regval_t rv)
-        {
-            while (true) {
-                if (crtp().store_reg(rn, rv))
-                    co_return;
-                co_await std::suspend_always{};
-            }
-        }
-
-        task<void> async_fetch_mem(byte_t *bytes, addr_t physical_addr, addr_t size)
-        {
-            while (true) {
-                if (crtp().fetch_mem(bytes, physical_addr, size))
-                    co_return;
-                co_await std::suspend_always{};
-            }
-        }
-
-        task<void> async_store_mem(addr_t physical_addr, const byte_t *bytes, addr_t size)
-        {
-            while (true) {
-                if (crtp().store_mem(physical_addr, bytes, size))
-                    co_return;
-                co_await std::suspend_always{};
-            }
-        }
-
-        task<bool> async_predicate(const Step &step)
-        {
-            if (step.predicate.has_value()) {
-                regval_t pval = co_await crtp().async_load_reg(step.predicate->first);
-                co_return pval == step.predicate->second;
-            }
-            co_return true;
-        }
-
-        task<void> async_load_source_registers(const Step &step, Wires &w)
-        {
-            w.source_vals.resize(step.source_regs.size());
-            for (unsigned int i = 0; i < step.source_regs.size(); ++i)
-                w.source_vals[i] = co_await crtp().async_load_reg(step.source_regs[i]);
-        }
-
-        task<void> async_load_source_memory(const Step &step, const MemInfo &mi, Wires &w)
-        {
-            w.memory_val.resize(mi.size);
-            co_await crtp().async_fetch_mem(w.memory_val.data(), mi.physical_addr, mi.size);
-        }
-
-        task<void> async_load_sources(const Step &step, Wires &w)
-        {
-            co_await crtp().async_load_source_registers(step, w);
-
-            if (step.mop == MOp::LOAD) {
-                auto mi = step.meminfo(w);
-                co_await crtp().async_load_source_memory(step, mi, w);
-            }
-        }
-
-        task<void> async_write_destination_registers(const Step &step, const Wires &w)
-        {
-            for (unsigned int i = 0; i < step.destination_regs.size(); ++i)
-                co_await crtp().async_store_reg(step.destination_regs[i], w.destination_vals[i]);
-        }
-
-        task<void> async_write_destination_memory(const Step &step, const MemInfo &mi, const Wires &w)
-        {
-            co_await crtp().async_store_mem(mi.physical_addr, w.memory_val.data(), mi.size);
-        }
-
-        task<void> async_write_destinations(const Step &step, const Wires &w)
-        {
-            if (w.aborted)
-                co_return;
-
-            co_await crtp().async_write_destination_registers(step, w);
-
-            if (step.mop == MOp::STORE) {
-                auto mi = step.meminfo(w);
-                co_await crtp().async_write_destination_memory(step, mi, w);
-            }
-        }
-
-        task<void> async_push_task(std::unique_ptr<const Task> &&task)
-        {
-            while (true) {
-                if (crtp().push_task(std::move(task)))
-                    co_return;
-                co_await std::suspend_always{};
-            }
-        }
-
-        task<void> async_new_task(std::unique_ptr<const Task> &&task, regval_t environment_val)
-        {
-            auto rn = task->environment;
-            co_await crtp().async_push_task(std::move(task));
-            co_await crtp().async_store_reg(rn, environment_val);
-        }
-
-        task<Wires> async_run_step(const Step &step)
-        {
-            Wires w;
-
-            if (!co_await crtp().async_predicate(step))
-                co_return std::move(w);
-
-            co_await crtp().async_load_sources(step, w);
-
-            step.evaluate(w);
-
-            co_await crtp().async_write_destinations(step, w);
-
-            if (w.new_task.has_value())
-                co_await crtp().async_new_task(std::move(w.new_task->first), w.new_task->second);
-
-            co_return std::move(w);
-        }
-
-        task<const Task *> async_top_task()
-        {
-            while (true) {
-                if (auto rv = crtp().top_task(); rv.has_value())
-                    co_return &**rv;
-                co_await std::suspend_always{};
-            }
-        }
-
-        task<void> async_pop_task()
-        {
-            while (true) {
-                if (crtp().pop_task())
-                    co_return;
-                co_await std::suspend_always{};
-            }
-        }
-
-        task<std::optional<std::unique_ptr<const Step>>> async_fetch_step()
-        {
-            auto task = co_await crtp().async_top_task();
-
-            auto rn = task->environment;
-            auto rv = co_await crtp().async_load_reg(rn);
-
-            auto step = task->step(rv);
-            if (step.has_value()) {
-                co_await crtp().async_store_reg(rn, step->second);
-                co_return std::move(step->first);
-            } else {
-                co_await crtp().async_pop_task();
-                co_return {};
-            }
-        }
-
-        task<std::pair<std::unique_ptr<const Step>, Wires>> async_fetch_and_run_step()
-        {
-            while (true) {
-                if (auto step = co_await crtp().async_fetch_step(); step.has_value()) {
-                    auto wires = co_await crtp().async_run_step(**step);
-                    co_return {std::move(*step), std::move(wires)};
-                }
-            }
-        }
-
-        task<void> async_run_subtree()
-        {
-            while (true) {
-                if (auto step = co_await crtp().async_fetch_step(); step.has_value())
-                    co_await crtp().async_run_step_and_subtree(**step);
-                else
-                    break;
-            }
-        }
-
-        task<Wires> async_run_step_and_subtree(const Step &step)
-        {
-            auto w = co_await crtp().async_run_step(step);
-
-            if (w.new_task.has_value())
-                co_await crtp().async_run_subtree();
-
-            co_return std::move(w);
-        }
-
-        task<void> async_setup_initial_task(const ISA &isa)
-        {
-            auto task = isa.initial_task();
-
-            co_await crtp().async_new_task(std::move(task.first), task.second);
-        }
-
-        task<void> async_run(const ISA &isa)
-        {
-            co_await crtp().async_setup_initial_task(isa);
-
-            co_await crtp().async_run_subtree();
-        }
-
-    };
-
-}
diff --git a/aisa/coroutine.h b/aisa/coroutine.h
deleted file mode 100644
index 1b55362..0000000
--- a/aisa/coroutine.h
+++ /dev/null
@@ -1,119 +0,0 @@
-#pragma once
-
-#include <coroutine>
-#include <optional>
-
-namespace aisa {
-
-    template<typename result_t> struct task_promise;
-
-    template<typename result_t> struct task : public std::coroutine_handle<task_promise<result_t>> {
-        using handle = std::coroutine_handle<task_promise<result_t>>;
-        using promise_type = task_promise<result_t>;
-        bool await_ready() const noexcept { return handle::done(); }
-        result_t await_resume() const noexcept;
-        template<typename other_t> void await_suspend(std::coroutine_handle<task_promise<other_t>> h) const noexcept;
-        std::optional<result_t> operator()() noexcept;
-    };
-
-    template<> struct task<void> : public std::coroutine_handle<task_promise<void>> {
-        using handle = std::coroutine_handle<task_promise<void>>;
-        using promise_type = task_promise<void>;
-        bool await_ready() const noexcept { return handle::done(); }
-        void await_resume() const noexcept;
-        template<typename other_t> void await_suspend(std::coroutine_handle<task_promise<other_t>> h) const noexcept;
-        bool operator()() noexcept;
-    };
-
-    template<typename result_t> struct task_promise {
-        std::coroutine_handle<> precursor;
-        std::optional<result_t> result;
-        task_promise() = default;
-        task_promise(const task_promise &) = delete;
-        task<result_t> get_return_object() noexcept { return task<result_t>{std::coroutine_handle<task_promise<result_t>>::from_promise(*this)}; }
-        std::suspend_never initial_suspend() const noexcept { return {}; }
-        std::suspend_always final_suspend() const noexcept { return {}; }
-        void unhandled_exception() { }
-        void return_value(result_t x) noexcept { result = std::move(x); }
-    };
-
-    template<> struct task_promise<void> {
-        std::coroutine_handle<> precursor;
-        task_promise() = default;
-        task_promise(const task_promise &) = delete;
-        task<void> get_return_object() noexcept { return task<void>{std::coroutine_handle<task_promise<void>>::from_promise(*this)}; }
-        std::suspend_never initial_suspend() const noexcept { return {}; }
-        std::suspend_always final_suspend() const noexcept { return {}; }
-        void unhandled_exception() { }
-        void return_void() noexcept { }
-    };
-
-    template<typename result_t> result_t task<result_t>::await_resume() const noexcept
-    {
-        auto x = std::move(handle::promise().result.value());
-        handle::destroy();
-        return x;
-    }
-
-    template<typename result_t> template<typename other_t> void task<result_t>::await_suspend(std::coroutine_handle<task_promise<other_t>> h) const noexcept
-    {
-        h.promise().precursor = *this;
-    }
-
-    template<typename result_t> std::optional<result_t> task<result_t>::operator()() noexcept
-    {
-        if (!handle::operator bool())
-            return {};
-        if (!handle::done()) {
-            auto &precursor = handle::promise().precursor;
-            if (precursor) {
-                if (!precursor.done())
-                    precursor.resume();
-                if (precursor.done())
-                    precursor = nullptr;
-            }
-            if (!precursor)
-                handle::resume();
-        }
-        if (handle::done()) {
-            auto x = await_resume();
-            handle::operator=(nullptr);
-            return x;
-        }
-        return {};
-    }
-
-    inline void task<void>::await_resume() const noexcept
-    {
-        handle::destroy();
-    }
-
-    template<typename other_t> void task<void>::await_suspend(std::coroutine_handle<task_promise<other_t>> h) const noexcept
-    {
-        h.promise().precursor = *this;
-    }
-
-    inline bool task<void>::operator()() noexcept
-    {
-        if (!handle::operator bool())
-            return true;
-        if (!handle::done()) {
-            auto &precursor = handle::promise().precursor;
-            if (precursor) {
-                if (!precursor.done())
-                    precursor.resume();
-                if (precursor.done())
-                    precursor = nullptr;
-            }
-            if (!precursor)
-                handle::resume();
-        }
-        if (handle::done()) {
-            await_resume();
-            handle::operator=(nullptr);
-            return true;
-        }
-        return false;
-    }
-
-}
diff --git a/aisa/simple-models.cpp b/aisa/simple-models.cpp
new file mode 100644
index 0000000..b69dcb7
--- /dev/null
+++ b/aisa/simple-models.cpp
@@ -0,0 +1,49 @@
+#include <algorithm>
+#include <deque>
+#include <memory>
+#include <optional>
+#include <utility>
+#include <vector>
+
+#include "aisa/aisa.h"
+#include "aisa/simple-models.h"
+
+namespace aisa {
+
+    bool TaskStack::pop_task()
+    {
+        if (tasks.empty())
+            return false;
+        tasks.pop_back();
+        return true;
+    }
+
+    bool TaskStack::push_task(std::unique_ptr<const Task> &&task)
+    {
+        tasks.emplace_back(std::move(task));
+        return true;
+    }
+
+    std::optional<const Task *> TaskStack::top_task()
+    {
+        if (tasks.empty())
+            return {};
+        return tasks.back().get();
+    }
+
+    std::optional<regval_t> VectorRF::load_reg(regnum_t rn) const
+    {
+        if (rf.size() <= rn)
+            return {};
+        return rf[rn];
+    }
+
+    bool VectorRF::store_reg(regnum_t rn, regval_t rv)
+    {
+        if (rf.size() <= rn)
+            rf.resize(rn + 1);
+        rf[rn] = rv;
+        return true;
+    }
+
+}
diff --git a/aisa/simple-models.h b/aisa/simple-models.h
index 62b5388..a94f010 100644
--- a/aisa/simple-models.h
+++ b/aisa/simple-models.h
@@ -7,7 +7,6 @@
 #include <map>
 #include <memory>
 #include <optional>
-#include <utility>
 #include <vector>
 
 #include "aisa/aisa.h"
@@ -51,45 +50,17 @@ namespace aisa {
     struct TaskStack {
         std::deque<std::unique_ptr<const Task>> tasks;
 
-        bool pop_task()
-        {
-            if (tasks.empty())
-                return false;
-            tasks.pop_back();
-            return true;
-        }
-
-        bool push_task(std::unique_ptr<const Task> &&task)
-        {
-            tasks.emplace_back(std::move(task));
-            return true;
-        }
+        bool pop_task();
+        bool push_task(std::unique_ptr<const Task> &&task);
 
-        std::optional<const Task *> top_task()
-        {
-            if (tasks.empty())
-                return {};
-            return tasks.back().get();
-        }
+        std::optional<const Task *> top_task();
     };
 
     struct VectorRF {
         std::vector<std::optional<regval_t>> rf;
 
-        std::optional<regval_t> load_reg(regnum_t rn) const
-        {
-            if (rf.size() <= rn)
-                return {};
-            return rf[rn];
-        }
-
-        bool store_reg(regnum_t rn, regval_t rv)
-        {
-            if (rf.size() <= rn)
-                rf.resize(rn + 1);
-            rf[rn] = rv;
-            return true;
-        }
+        std::optional<regval_t> load_reg(regnum_t rn) const;
+        bool store_reg(regnum_t rn, regval_t rv);
     };
 
 }