making it working

Author: tanneberger

examples/multiport_mutation/load_balancer.hh

@@ -35,9 +35,9 @@ private:
 
       auto antideps = (outbound[0]).anti_dependencies();
 
-      MutationChangeOutputMultiportSize change_size{temp, this->reactor_, antideps, new_size};
+      auto change_size = std::make_shared<MutationChangeOutputMultiportSize<unsigned>>(temp, this->reactor_, antideps, new_size);
 
-      add_to_transaction(&change_size);
+      add_to_transaction(change_size);
 
       commit_transaction();
 

examples/multiport_mutation/main.cc

@@ -33,9 +33,9 @@ class Inner: public MutableScope {
         std::string __lf_inst_name = "consumer_" + std::to_string(index);
         return std::make_unique<Consumer>(__lf_inst_name, reactor->environment(), index);
       };
-      MutationChangeBankSize change_size{&reactor_bank, this->reactor_, new_size, lambda};
+      auto change_size = std::make_shared<MutationChangeBankSize<std::unique_ptr<Consumer>>>(&reactor_bank, this->reactor_, new_size, lambda);
 
-      add_to_transaction(&change_size);
+      add_to_transaction(change_size);
 
       // old topology
       commit_transaction();
@@ -48,9 +48,8 @@ class Inner: public MutableScope {
       } else {
         std::cout << "load_balancer size:" << load_balancer.size() << " bank size: " << reactor_bank.size() << std::endl;
         for (auto i = 0; i < new_size; i++) {
-            std::cout << "add connection: " << i << std::endl;
-            MutationAddConnection<Output<unsigned>, Input<unsigned>> add_conn{&load_balancer[i], &reactor_bank[i].get()->in, reactor_};
-            add_to_transaction(&add_conn);
+            auto add_conn = std::make_shared<MutationAddConnection<Output<unsigned>, Input<unsigned>>>(&load_balancer[i], &reactor_bank[i].get()->in, reactor_);
+            add_to_transaction(add_conn);
         }
         commit_transaction(true);
       }

include/reactor-cpp/port.hh

@@ -106,7 +106,7 @@ public:
 
   [[nodiscard]] auto triggers() const noexcept -> const auto& { return triggers_; }
   [[nodiscard]] auto dependencies() const noexcept -> const auto& { return dependencies_; }
-  [[nodiscard]] auto anti_dependencies() const noexcept -> const auto& { return anti_dependencies_; }
+  [[nodiscard]] auto anti_dependencies() noexcept -> auto& { return anti_dependencies_; } //TODO: make it const again
   [[nodiscard]] auto port_type() const noexcept -> PortType { return type_; }
 
   void register_set_callback(const PortCallback& callback);

include/reactor-cpp/scopes.hh

@@ -44,7 +44,7 @@ public:
   ~MutableScope() = default;
 
   void commit_transaction(bool recalculate = false);
-  void add_to_transaction(Mutation* mutation);
+  void add_to_transaction(const std::shared_ptr<Mutation>& mutation);
 
 };
 

include/reactor-cpp/transaction.hh

@@ -10,6 +10,7 @@
 #define REACTOR_CPP_TRANSACTION_HH
 
 #include <vector>
+#include <memory>
 
 #include "mutations.hh"
 //#include "reactor.hh"
@@ -22,13 +23,13 @@ class Environment;
 class Transaction {
 private:
   Environment* environment_ = nullptr;
-  std::vector<Mutation*> mutations_{};
+  std::vector<std::shared_ptr<Mutation>> mutations_{};
 
 public:
   explicit Transaction(Reactor* parent);
   ~Transaction() = default;
 
-  void push_back(Mutation* mutation);
+  void push_back(const std::shared_ptr<Mutation>& mutation);
   auto execute(bool recalculate = false) -> MutationResult;
 };
 }

lib/mutation/connection.cc

@@ -15,8 +15,8 @@ template <class A, class B> auto reactor::MutationAddConnection<A, B>::run() ->
   reactor_->environment()->draw_connection(source_, sink_, ConnectionProperties{});
   sink_->set_inward_binding(source_);
   source_->add_outward_binding(sink_);
-  std::cout << "from: " << source_->fqn() << "(" << source_ << ")"
-                       << " --> to: " << sink_->fqn() << "(" << sink_ << ")" << std::endl;
+  //std::cout << "from: " << source_->fqn() << "(" << source_ << ")"
+  //                     << " --> to: " << sink_->fqn() << "(" << sink_ << ")" << std::endl;
   return Success;
 }
 

lib/mutation/multiport.cc

@@ -12,8 +12,6 @@ reactor::MutationChangeOutputMultiportSize<T>::MutationChangeOutputMultiportSize
 template<class T>
 void reactor::MutationChangeOutputMultiportSize<T>::change_size(std::size_t new_size) {
   auto current_size = multiport_->size();
-  std::cout << "scaling from: " << current_size << " to " << new_size << std::endl;
-
   if (current_size >= new_size) {
     // downscale
 
@@ -29,6 +27,8 @@ void reactor::MutationChangeOutputMultiportSize<T>::change_size(std::size_t new_
     for (auto* anti_dep : anti_dependencies_) {
         anti_dep->clear_antidependencies();
         for (auto i = 0; i < new_size; i++) {
+
+            multiport_->operator[](i).anti_dependencies().clear();
             anti_dep->declare_antidependency(&multiport_->operator[](i));
         }
     }
@@ -40,12 +40,12 @@ void reactor::MutationChangeOutputMultiportSize<T>::change_size(std::size_t new_
       multiport_->emplace_back(port_name_, reactor_);
     }
 
-    for (auto* anti_dep : anti_dependencies_) {
+    /*for (auto* anti_dep : anti_dependencies_) {
         anti_dep->clear_antidependencies();
         for (auto i = 0; i < new_size; i++) {
             anti_dep->declare_antidependency(&multiport_->operator[](i));
         }
-    }
+    }*/
 
 
   }

lib/reaction.cc

@@ -91,7 +91,7 @@ void Reaction::declare_dependency(BasePort* port) {
 void Reaction::declare_antidependency(BasePort* port) {
   reactor_assert(port != nullptr);
   reactor_assert(this->environment() == port->environment());
-  assert_phase(this, Phase::Assembly);
+  //assert_phase(this, Phase::Assembly);
 
   if (port->is_output()) {
     validate(this->container() == port->container(), "Antidependent output ports must belong to the same reactor as "

lib/scopes.cc

@@ -2,7 +2,7 @@
 
 #include "reactor-cpp/scopes.hh"
 
-void reactor::MutableScope::add_to_transaction(Mutation* mutation) {
+void reactor::MutableScope::add_to_transaction(const std::shared_ptr<Mutation>& mutation) {
   transaction_.push_back(mutation);
 }
 

lib/transaction.cc

@@ -10,7 +10,7 @@
 auto reactor::Transaction::execute(bool recalculate) -> MutationResult {
 
    this->environment_->start_mutation();
-   for (auto *mutation : mutations_) {
+   for (auto mutation : mutations_) {
      mutation->run();
    }
 
@@ -24,10 +24,11 @@ auto reactor::Transaction::execute(bool recalculate) -> MutationResult {
    }
 
    this->environment_->stop_mutation();
+
    mutations_.clear();
-    return Success;
+   return Success;
 }
 
-void reactor::Transaction::push_back(reactor::Mutation* mutation) {
+void reactor::Transaction::push_back(const std::shared_ptr<reactor::Mutation>& mutation) {
     mutations_.push_back(mutation);
 }