Merge pull request #42 from lf-lang/input-actions

Keep track of input actions in the environment

Author: cmnrd

examples/count/main.cc

@@ -37,7 +37,7 @@ class Count : public Reactor {
 };
 
 auto main() -> int {
-  Environment env{4, true};
+  Environment env{4};
 
   Count count{&env};
   env.assemble();

examples/hello/main.cc

@@ -31,7 +31,7 @@ class Hello : public Reactor {
 };
 
 auto main() -> int {
-  Environment env{4, false, false, 5s};
+  Environment env{4, false, 5s};
 
   Hello hello{&env};
   env.assemble();

include/reactor-cpp/action.hh

@@ -9,6 +9,8 @@
 #ifndef REACTOR_CPP_ACTION_HH
 #define REACTOR_CPP_ACTION_HH
 
+#include "environment.hh"
+#include "fwd.hh"
 #include "logical_time.hh"
 #include "reactor.hh"
 #include "value_ptr.hh"
@@ -37,6 +39,12 @@ protected:
       : ReactorElement(name, ReactorElement::Type::Action, container)
       , min_delay_(min_delay)
       , logical_(logical) {}
+  BaseAction(const std::string& name, Environment* environment, bool logical, Duration min_delay)
+      : ReactorElement(name, ReactorElement::Type::Action, environment)
+      , min_delay_(min_delay)
+      , logical_(logical) {
+    environment->register_input_action(this);
+  }
 
 public:
   [[nodiscard]] auto inline triggers() const noexcept -> const auto& { return triggers_; }
@@ -63,6 +71,8 @@ protected:
 
   Action(const std::string& name, Reactor* container, bool logical, Duration min_delay)
       : BaseAction(name, container, logical, min_delay) {}
+  Action(const std::string& name, Environment* environment, bool logical, Duration min_delay)
+      : BaseAction(name, environment, logical, min_delay) {}
 
 public:
   // Normally, we should lock the mutex while moving to make this
@@ -107,6 +117,8 @@ template <> class Action<void> : public BaseAction {
 protected:
   Action(const std::string& name, Reactor* container, bool logical, Duration min_delay)
       : BaseAction(name, container, logical, min_delay) {}
+  Action(const std::string& name, Environment* environment, bool logical, Duration min_delay)
+      : BaseAction(name, environment, logical, min_delay) {}
 
 public:
   template <class Dur = Duration> void schedule(Dur delay = Dur::zero());
@@ -118,7 +130,11 @@ public:
 template <class T> class PhysicalAction : public Action<T> {
 public:
   PhysicalAction(const std::string& name, Reactor* container)
-      : Action<T>(name, container, false, Duration::zero()) {}
+      : Action<T>(name, container, false, Duration::zero()) {
+    // all physical actions act as input actions to the program as they can be
+    // scheduled from external threads
+    container->environment()->register_input_action(this);
+  }
 };
 
 template <class T> class LogicalAction : public Action<T> {

include/reactor-cpp/environment.hh

@@ -13,6 +13,7 @@
 #include <string>
 #include <vector>
 
+#include "fwd.hh"
 #include "reactor-cpp/logging.hh"
 #include "reactor-cpp/time.hh"
 #include "reactor.hh"
@@ -36,10 +37,12 @@ private:
   const log::NamedLogger log_;
   const unsigned int num_workers_{default_number_worker};
   unsigned int max_reaction_index_{default_max_reaction_index};
-  const bool run_forever_{default_run_forever};
+  bool run_forever_{default_run_forever};
   const bool fast_fwd_execution_{default_fast_fwd_execution};
 
   std::set<Reactor*> top_level_reactors_{};
+  /// Set of actions that act as an input to the reactor program in this environment
+  std::set<BaseAction*> input_actions_{};
   std::set<Reaction*> reactions_{};
   std::vector<Dependency> dependencies_{};
 
@@ -64,13 +67,14 @@ private:
   auto startup(const TimePoint& start_time) -> std::thread;
 
 public:
-  explicit Environment(unsigned int num_workers, bool run_forever = default_run_forever,
-                       bool fast_fwd_execution = default_fast_fwd_execution, const Duration& timeout = Duration::max());
+  explicit Environment(unsigned int num_workers, bool fast_fwd_execution = default_fast_fwd_execution,
+                       const Duration& timeout = Duration::max());
   explicit Environment(const std::string& name, Environment* containing_environment);
 
   auto name() -> const std::string& { return name_; }
 
   void register_reactor(Reactor* reactor);
+  void register_input_action(BaseAction* action);
   void assemble();
   auto startup() -> std::thread;
   void sync_shutdown();

include/reactor-cpp/trace.hh

@@ -62,13 +62,13 @@ TRACEPOINT_EVENT(
                   ctf_integer(unsigned long long, timestamp_ns, tag_arg.time_point().time_since_epoch().count())
                       ctf_integer(unsigned long, timestamp_microstep, tag_arg.micro_step())))
 
-TRACEPOINT_EVENT(reactor_cpp, trigger_reaction,
-                 TP_ARGS(const std::string&, reactor_name_arg, const std::string&, reaction_name_arg,
-                         const reactor::LogicalTime&, tag_arg),
-                 TP_FIELDS(ctf_string(reactor_name, reactor_name_arg.c_str()) ctf_string(reaction_name,
-                                                                                         reaction_name_arg.c_str())
-                               ctf_integer(unsigned long long, timestamp_ns, tag_arg.time_point().time_since_epoch().count())
-                                   ctf_integer(unsigned long, timestamp_microstep, tag_arg.micro_step())))
+TRACEPOINT_EVENT(
+    reactor_cpp, trigger_reaction,
+    TP_ARGS(const std::string&, reactor_name_arg, const std::string&, reaction_name_arg, const reactor::LogicalTime&,
+            tag_arg),
+    TP_FIELDS(ctf_string(reactor_name, reactor_name_arg.c_str()) ctf_string(reaction_name, reaction_name_arg.c_str())
+                  ctf_integer(unsigned long long, timestamp_ns, tag_arg.time_point().time_since_epoch().count())
+                      ctf_integer(unsigned long, timestamp_microstep, tag_arg.micro_step())))
 
 #endif /* REACTOR_CPP_TRACE_HH */
 

lib/environment.cc

@@ -23,10 +23,9 @@
 
 namespace reactor {
 
-Environment::Environment(unsigned int num_workers, bool run_forever, bool fast_fwd_execution, const Duration& timeout)
+Environment::Environment(unsigned int num_workers, bool fast_fwd_execution, const Duration& timeout)
     : log_("Environment")
     , num_workers_(num_workers)
-    , run_forever_(run_forever)
     , fast_fwd_execution_(fast_fwd_execution)
     , top_environment_(this)
     , scheduler_(this)
@@ -36,7 +35,6 @@ Environment::Environment(const std::string& name, Environment* containing_enviro
     : name_(name)
     , log_("Environment " + name)
     , num_workers_(containing_environment->num_workers_)
-    , run_forever_(containing_environment->run_forever_)
     , fast_fwd_execution_(containing_environment->fast_fwd_execution_)
     , containing_environment_(containing_environment)
     , top_environment_(containing_environment_->top_environment_)
@@ -52,6 +50,13 @@ void Environment::register_reactor(Reactor* reactor) {
   reactor_assert(top_level_reactors_.insert(reactor).second);
 }
 
+void Environment::register_input_action(BaseAction* action) {
+  reactor_assert(action != nullptr);
+  validate(this->phase() == Phase::Construction, "Input actions may only be registered during construction phase!");
+  reactor_assert(input_actions_.insert(action).second);
+  run_forever_ = true;
+}
+
 void recursive_assemble(Reactor* container) { // NOLINT
   container->assemble();
   for (auto* reactor : container->reactors()) {