clean slate implementation

Author: tanneberger

.gitignore

@@ -4,3 +4,4 @@ cmake-build-debug
 cmake-build-release
 .idea
 result
+Makefile

examples/CMakeLists.txt

@@ -7,3 +7,4 @@ add_subdirectory(count)
 add_subdirectory(ports)
 add_subdirectory(hello)
 add_subdirectory(power_train)
+add_subdirectory(multiport_mutation)

examples/multiport_mutation/CMakeLists.txt

@@ -0,0 +1,3 @@
+add_executable(mutation_multiports main.cc)
+target_link_libraries(mutation_multiports reactor-cpp)
+add_dependencies(examples mutation_multiports)

examples/multiport_mutation/consumer.hh

@@ -0,0 +1,42 @@
+#ifndef CONSUMER_HH // NOLINT
+#define CONSUMER_HH // NOLINT
+
+#include <reactor-cpp/reactor-cpp.hh>
+#include <reactor-cpp/scopes.hh>
+
+using namespace reactor;
+using namespace std::chrono_literals;
+
+class Consumer final : public Reactor { // NOLINT
+  class Inner : public Scope {
+    Inner(Reactor* reactor, std::size_t index)
+        : Scope(reactor)
+        , index_(index) {}
+    std::size_t index_ = 0;
+
+    void reaction_1(const Input<unsigned>& in) const {
+      std::cout << "consumer: " << index_ << " received value:" << *in.get() << '\n';
+    }
+
+    friend Consumer;
+  };
+
+  Inner _lf_inner;
+  Reaction handle{"handle", 1, this, [this]() { _lf_inner.reaction_1(this->in); }};
+
+public:
+  Consumer(const std::string& name, Environment* env, std::size_t index)
+      : Reactor(name, env)
+      , _lf_inner(this, index) {
+    std::cout << "creating instance of consumer" << '\n';
+  }
+  ~Consumer() override { std::cout << "Consumer Object is deleted" << '\n'; };
+
+  Input<unsigned> in{"in", this}; // NOLINT
+
+  void assemble() override {
+    handle.declare_trigger(&in);
+  }
+};
+
+#endif // CONSUMER_HH

examples/multiport_mutation/load_balancer.hh

@@ -0,0 +1,61 @@
+#ifndef LOAD_BALANCER_HH // NOLINT
+#define LOAD_BALANCER_HH // NOLINT
+
+#include <reactor-cpp/reactor-cpp.hh>
+
+#include "reactor-cpp/mutations/multiport.hh"
+
+using namespace reactor;
+using namespace std::chrono_literals;
+
+class LoadBalancer final : public Reactor { // NOLINT
+  class Inner : public MutableScope {
+    explicit Inner(Reactor* reactor)
+        : MutableScope(reactor) {}
+
+    // reaction bodies
+    static void reaction_1(const Input<unsigned>& inbound, Output<unsigned>& scale_bank,
+                           Multiport<Output<unsigned>>& outbound) {
+      if (std::rand() % 15 == 0) {                   // NOLINT
+        scale_bank.set(std::rand() % 20 + 1); // NOLINT
+      }
+      const unsigned sel = std::rand() % outbound.size(); // NOLINT
+      std::cout << "Sending out to:" << sel << '\n';
+      outbound[sel].set(inbound.get());
+      outbound[std::min(4ul, outbound.size() - 1)].set(inbound.get());
+    }
+
+
+    friend LoadBalancer;
+  };
+
+  Inner _lf_inner;
+  Reaction process{"process", 2, this, [this]() { Inner::reaction_1(this->inbound, this->scale_bank, this->out); }};
+
+public:
+  LoadBalancer(const std::string& name, Environment* env)
+      : Reactor(name, env)
+      , _lf_inner(this) {
+    out.reserve(4);
+    std::cout << "creating instance of load balancer" << '\n';
+    for (size_t _lf_idx = 0; _lf_idx < 4; _lf_idx++) {
+      out.create_new_port();
+    }
+  }
+  ~LoadBalancer() override = default;
+
+  ModifableMultiport<Output<unsigned>> out{"out", this};          // NOLINT
+  std::size_t out_size_ = 0;
+  Input<unsigned> inbound{"inbound", this};                 // NOLINT
+  Output<unsigned> scale_bank{"scale_bank", this};          // NOLINT
+
+  void assemble() override {
+    std::cout << "assemble LoadBalancer\n";
+    for (auto& _lf_port : out) {
+      process.declare_antidependency(&_lf_port);
+    }
+    process.declare_trigger(&inbound);
+  }
+};
+
+#endif // LOAD_BALANCER_HH

examples/multiport_mutation/main.cc

@@ -0,0 +1,93 @@
+#include <iostream>
+#include <memory>
+
+#include <reactor-cpp/mutations/bank.hh>
+#include <reactor-cpp/mutations/connection.hh>
+
+#include "./multiport_to_bank.hh"
+#include "./consumer.hh"
+#include "./load_balancer.hh"
+#include "./producer.hh"
+#include <reactor-cpp/reactor-cpp.hh>
+
+class Deployment final : public Reactor { // NOLINT
+
+  std::unique_ptr<Producer> producer_;
+  std::unique_ptr<LoadBalancer> load_balancer_;
+  std::vector<std::unique_ptr<Consumer>> consumers_;
+
+  Reaction scale_bank{"scale_bank", 1, this,
+                      [this]() { this->_inner.reaction_1(this->scale, this->consumers_, load_balancer_->out); }};
+
+
+  class Inner : public MutableScope {
+    int state = 0;
+
+  public:
+    Inner(Reactor* reactor)
+        : MutableScope(reactor) {}
+    void reaction_1(const Input<unsigned>& scale, std::vector<std::unique_ptr<Consumer>>& reactor_bank,
+                    ModifableMultiport<Output<unsigned>>& load_balancer) {
+      std::size_t new_size = *scale.get();
+      std::size_t old_size = reactor_bank.size();
+      std::function lambda = [](Environment* env, std::size_t index) {
+        std::string _lf_inst_name = "consumer_" + std::to_string(index);
+        return std::make_unique<Consumer>(_lf_inst_name, env, index);
+      };
+
+      std::function get_input_port = [](const std::unique_ptr<Consumer>& consumer) {
+        return &consumer->in;
+      };
+      auto rescale = std::make_shared<ResizeMultiportToBank<unsigned, Consumer>>(
+        &load_balancer,
+        &reactor_bank,
+        get_input_port,
+        lambda,
+        new_size);
+
+      add_to_transaction(rescale);
+
+      commit_transaction(true);
+    }
+
+    friend LoadBalancer;
+  };
+
+Inner _inner;
+
+public:
+  Deployment(const std::string& name, Environment* env)
+      : Reactor(name, env)
+      , _inner(this)
+      , producer_(std::make_unique<Producer>("producer", environment()))
+      , load_balancer_(std::make_unique<LoadBalancer>("load_balancer", environment())) {
+    std::cout << "creating instance of deployment" << '\n';
+    consumers_.reserve(4);
+    for (size_t _lf_idx = 0; _lf_idx < 4; _lf_idx++) {
+      std::string _lf_inst_name = "consumer_" + std::to_string(_lf_idx);
+      consumers_.push_back(std::make_unique<Consumer>(_lf_inst_name, environment(), _lf_idx));
+    }
+  }
+  ~Deployment() override = default;
+
+  Input<unsigned> scale{"scale", this}; // NOLINT
+
+  void assemble() override {
+    for (size_t _lf_idx = 0; _lf_idx < 4; _lf_idx++) {
+      environment()->draw_connection(load_balancer_->out[_lf_idx], consumers_[_lf_idx]->in, ConnectionProperties{});
+      environment()->draw_connection(producer_->value, load_balancer_->inbound, ConnectionProperties{});
+    }
+    environment()->draw_connection(load_balancer_->scale_bank, scale, ConnectionProperties{});
+    scale_bank.declare_trigger(&this->scale);
+  }
+};
+
+auto main() -> int {
+  Environment env{4, true};
+  auto deployment = std::make_unique<Deployment>("c1", &env);
+  env.optimize();
+  env.assemble();
+  auto thread = env.startup();
+  thread.join();
+  return 0;
+}

examples/multiport_mutation/multiport_to_bank.hh

@@ -0,0 +1,95 @@
+//
+// Created by tanneberger on 1/13/25.
+//
+
+#ifndef MULTIPORT_TO_BANK_HH
+#define MULTIPORT_TO_BANK_HH
+
+#include <reactor-cpp/mutations.hh>
+#include <reactor-cpp/multiport.hh>
+#include <reactor-cpp/port.hh>
+#include <reactor-cpp/mutations/multiport.hh>
+#include <reactor-cpp/mutations/bank.hh>
+#include <reactor-cpp/mutations/connection.hh>
+#include <reactor-cpp/reactor.hh>
+
+#include "../../lib/mutations/bank.cc"
+#include "../../lib/mutations/connection.cc"
+#include "../../lib/mutations/multiport.cc"
+
+#include <functional>
+
+namespace reactor {
+
+  template<class PortType, class ReactorType>
+  class ResizeMultiportToBank : public Mutation {
+     ModifableMultiport<Output<PortType>>* multiport_;
+     std::vector<std::unique_ptr<ReactorType>>* bank_;
+     std::function<Input<PortType>*(const std::unique_ptr<ReactorType>&)> get_input_port_;
+     std::function<std::unique_ptr<ReactorType>(Environment* env, std::size_t index)> create_lambda_;
+     std::size_t new_size_ = 0;
+     public:
+       ResizeMultiportToBank(ModifableMultiport<Output<PortType>>* multiport,
+                             std::vector<std::unique_ptr<ReactorType>>* bank,
+                             std::function<Input<PortType>*(const std::unique_ptr<ReactorType>&)> get_input_port,
+                             std::function<std::unique_ptr<ReactorType>(Environment* env, std::size_t index)> create_lambda,
+                             std::size_t new_size) :
+         multiport_(multiport), bank_(bank), get_input_port_(get_input_port), create_lambda_(create_lambda), new_size_(new_size) {}
+
+       ~ResizeMultiportToBank() = default;
+       auto run() -> MutationResult {
+         if (multiport_->size() != bank_->size()) {
+            return NotMatchingBankSize;
+         }
+         auto old_size = multiport_->size();
+
+         if (new_size_ > old_size) {
+            // TODO: this is an assumption
+            auto change_multiport_size =
+              std::make_shared<MutationChangeOutputMultiportSize<unsigned>>(multiport_, new_size_);
+
+            change_multiport_size->run();
+
+            auto change_bank_size = std::make_shared<MutationChangeBankSize<std::unique_ptr<ReactorType>>>(
+              bank_, (*bank_)[0]->environment(), new_size_, create_lambda_);
+
+            change_bank_size->run();
+
+            for (auto i = old_size; i < new_size_; i++) {
+               auto add_conn = std::make_shared<MutationAddConnection<Output<PortType>, Input<PortType>>>(
+                  &(*multiport_)[i], get_input_port_((*bank_)[i]), (*bank_)[0]->environment(), true);
+
+               add_conn->run();
+            }
+         } else if (new_size_ < old_size) {
+           for (auto i = old_size - 1; i >= new_size_; i--) {
+               auto add_conn = std::make_shared<MutationAddConnection<Output<PortType>, Input<PortType>>>(
+                  &(*multiport_)[i], get_input_port_((*bank_)[i]), (*bank_)[0]->environment(), false);
+
+               add_conn->run();
+            }
+
+            auto change_multiport_size =
+              std::make_shared<MutationChangeOutputMultiportSize<unsigned>>(multiport_, new_size_);
+
+            change_multiport_size->run();
+
+            auto change_bank_size = std::make_shared<MutationChangeBankSize<std::unique_ptr<ReactorType>>>(
+                 bank_, (*bank_)[0]->environment(), new_size_, create_lambda_);
+
+            change_bank_size->run();
+         }
+
+
+         return Success;
+       }
+
+       auto rollback() -> MutationResult {
+        return Success;
+       }
+  };
+}
+
+
+
+#endif //MULTIPORT_TO_BANK_HH

examples/multiport_mutation/producer.hh

@@ -0,0 +1,47 @@
+#ifndef PRODUCER_HH // NOLINT
+#define PRODUCER_HH // NOLINT
+
+#include <reactor-cpp/reactor-cpp.hh>
+
+using namespace reactor;
+using namespace std::chrono_literals;
+
+class Producer final : public Reactor { // NOLINT
+private:
+  Timer timer{"timer", this, 1s, 1s};
+  Reaction r_timer{"r_timer", 1, this, [this]() { _lf_inner.reaction_1(this->value); }};
+
+  class Inner : public Scope {
+    unsigned int counter_ = 0;
+
+    void reaction_1([[maybe_unused]] Output<unsigned>& out) {
+      std::cout << "producing value:" << counter_ << "\n";
+      out.set(counter_++);
+    }
+
+    explicit Inner(Reactor* reactor)
+        : Scope(reactor) {}
+
+    friend Producer;
+  };
+
+  Inner _lf_inner;
+
+public:
+  Producer(const std::string& name, Environment* env)
+      : Reactor(name, env)
+      , _lf_inner(this) {
+    std::cout << "creating instance of producer\n";
+  }
+  Producer() = delete;
+  ~Producer() override = default;
+
+  Output<unsigned> value{"value", this}; // NOLINT
+
+  void assemble() override {
+    r_timer.declare_trigger(&timer);
+    r_timer.declare_antidependency(&value);
+  }
+};
+
+#endif // PRODUCER_HH