snapshot

Author: tanneberger

examples/ports/main.cc

@@ -85,7 +85,7 @@ class Adder : public Reactor {
     r_add.declare_antidependency(&sum);
   }
 
-  void add() {
+  void add(Adder* self) {
     if (i1.is_present() && i2.is_present()) {
       sum.set(*i1.get() + *i2.get());
       std::cout << "setting sum\n";

include/reactor-cpp/logging.hh

@@ -30,7 +30,6 @@ private:
 
   // NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
   inline static std::mutex mutex_{};
-
   Lock lock_{};
 
 public:

include/reactor-cpp/multiport.hh

@@ -23,14 +23,14 @@ namespace reactor {
 
 class BaseMultiport { // NOLINT cppcoreguidelines-special-member-functions,-warnings-as-errors
 private:
-  std::atomic<std::size_t> size_{0};
+  std::atomic<std::size_t> present_ports_size_{0};
   std::vector<std::size_t> present_ports_{};
 
   // record that the port with the given index has been set
   void set_present(std::size_t index);
 
   // reset the list of set port indexes
-  void reset() noexcept { size_.store(0, std::memory_order_relaxed); }
+  void reset() noexcept { present_ports_size_.store(0, std::memory_order_relaxed); }
 
   [[nodiscard]] auto get_set_callback(std::size_t index) noexcept -> PortCallback;
   const PortCallback clean_callback_{[this]([[maybe_unused]] const BasePort& port) { this->reset(); }};
@@ -39,7 +39,7 @@ private:
 
 protected:
   [[nodiscard]] auto present_ports() const -> const auto& { return present_ports_; }
-  [[nodiscard]] auto present_ports_size() const -> auto { return size_.load(); }
+  [[nodiscard]] auto present_ports_size() const -> auto { return present_ports_size_.load(); }
 
   void present_ports_reserve(size_t n) { present_ports_.reserve(n); }
 
@@ -50,11 +50,15 @@ public:
   ~BaseMultiport() = default;
 };
 
+template <class T>
+class MutationChangeMultiportSize;
+
 template <class T, class A = std::allocator<T>>
 class Multiport : public BaseMultiport { // NOLINT cppcoreguidelines-special-member-functions
 protected:
   std::vector<T> ports_{}; // NOLINT cppcoreguidelines-non-private-member-variables-in-classes
 
+  friend MutationChangeMultiportSize<T>;
 public:
   using value_type = typename A::value_type;
   using size_type = typename A::size_type;

include/reactor-cpp/reaction.hh

@@ -27,6 +27,7 @@ private:
   std::set<BasePort*> dependencies_;
 
   const int priority_;
+  const bool mutation_;
   unsigned int index_{};
 
   std::function<void(void)> body_{nullptr};
@@ -37,7 +38,7 @@ private:
   void set_deadline_impl(Duration deadline, const std::function<void(void)>& handler);
 
 public:
-  Reaction(const std::string& name, int priority, Reactor* container, std::function<void(void)> body);
+  Reaction(const std::string& name, int priority, bool mutation, Reactor* container, std::function<void(void)> body);
 
   ~Reaction() override = default;
 

include/reactor-cpp/reactor-cpp.hh

@@ -21,5 +21,6 @@
 #include "reaction.hh"
 #include "reactor.hh"
 #include "time.hh"
+#include "scops.hh"
 
 #endif // REACTOR_CPP_REACTOR_CPP_HH

include/reactor-cpp/scops.hh

@@ -0,0 +1,54 @@
+/*
+* Copyright (C) 2024 TU Dresden
+* All rights reserved.
+*
+* Authors:
+*   Tassilo Tanneberger
+*/
+
+#ifndef REACTOR_CPP_SCOPS_HH
+#define REACTOR_CPP_SCOPS_HH
+
+#include "transaction.hh"
+#include "time.hh"
+
+namespace reactor {
+class Reactor;
+
+class Scope {
+private:
+  reactor::Reactor* reactor;
+
+public:
+  Scope(reactor::Reactor* reactor)
+      : reactor(reactor) {}
+
+  auto get_physical_time() const -> reactor::TimePoint { return reactor->get_physical_time(); }
+  auto get_tag() const -> reactor::Tag { return reactor->get_tag(); }
+  auto get_logical_time() const -> reactor::TimePoint { return reactor->get_logical_time(); }
+  auto get_microstep() const -> reactor::mstep_t { return reactor->get_microstep(); }
+  auto get_elapsed_logical_time() const -> reactor::Duration { return reactor->get_elapsed_logical_time(); }
+  auto get_elapsed_physical_time() const -> reactor::Duration { return reactor->get_elapsed_physical_time(); }
+  auto environment() const -> reactor::Environment* { return reactor->environment(); }
+  void request_stop() const { return environment()->sync_shutdown(); }
+};
+
+template<class HostReactor>
+class MutableScope : public Scope {
+public:
+  HostReactor* self_ = nullptr;
+  Environment* env_ = nullptr;
+  Transaction transaction_;
+
+  explicit MutableScope(reactor::Reactor* reactor) : Scope(reactor), self_(reactor), env_(reactor->environment()) {}
+  ~MutableScope() = default;
+
+  void begin_transaction();
+  void end_transaction();
+  void mutate(const std::unique_ptr<Mutation>&& mutation);
+
+};
+
+}
+
+#endif // REACTOR_CPP_SCOPS_HH

include/reactor-cpp/transaction.hh

@@ -0,0 +1,55 @@
+/*
+* Copyright (C) 2024 TU Dresden
+* All rights reserved.
+*
+* Authors:
+*   Tassilo Tanneberger
+ */
+
+#ifndef REACTOR_CPP_TRANSACTION_HH
+#define REACTOR_CPP_TRANSACTION_HH
+
+#include <vector>
+
+#include "multiport.hh"
+
+namespace reactor {
+class Reactor;
+class Environment;
+
+enum MutationResult {
+  Success = 0,
+  NotMatchingBankSize = 1,
+};
+
+class Mutation {
+public:
+  virtual auto run() -> MutationResult = 0 ;
+
+};
+
+template<class T>
+class MutationChangeMultiportSize : public Mutation {
+private:
+  Multiport<T>* multiport_ = nullptr;
+  std::size_t desired_size_ = 0;
+public:
+  MutationChangeMultiportSize(Multiport<T>* multiport, std::size_t size);
+  ~MutationChangeMultiportSize() = default;
+  void run() override;
+};
+
+
+class Transaction {
+private:
+  Reactor* parent = nullptr;
+  Environment* environment = nullptr;
+  std::vector<Mutation*> mutations_{};
+
+public:
+  void reset();
+  auto execute() -> MutationResult;
+
+};
+}
+#endif // REACTOR_CPP_TRANSACTION_HH

lib/CMakeLists.txt

@@ -7,7 +7,9 @@ set(SOURCE_FILES
     reaction.cc
     reactor.cc
     scheduler.cc
+        scops.cc
     time.cc
+    transaction.cc
     multiport.cc
     reactor_element.cc
     )

lib/multiport.cc

@@ -21,7 +21,7 @@ auto reactor::BaseMultiport::get_set_callback(std::size_t index) noexcept -> rea
 }
 
 void reactor::BaseMultiport::set_present(std::size_t index) {
-  auto calculated_index = size_.fetch_add(1, std::memory_order_relaxed);
+  auto calculated_index = present_ports_size_.fetch_add(1, std::memory_order_relaxed);
 
   reactor_assert(calculated_index < present_ports_.size());
 

lib/reaction.cc

@@ -17,10 +17,12 @@
 
 namespace reactor {
 
-Reaction::Reaction(const std::string& name, int priority, Reactor* container, std::function<void(void)> body)
+Reaction::Reaction(const std::string& name, int priority, bool mutation, Reactor* container, std::function<void(void)> body)
     : ReactorElement(name, ReactorElement::Type::Reaction, container)
     , priority_(priority)
-    , body_(std::move(std::move(body))) {
+    , mutation_(mutation)
+    , body_(std::move(std::move(body)))
+{
   reactor_assert(priority != 0);
 }