add operation plugin

diff --git a/include/simgrid/plugins/operation.hpp b/include/simgrid/plugins/operation.hpp
new file mode 100644 (file)
index 0000000..ae4fdb1
--- /dev/null
+++ b/include/simgrid/plugins/operation.hpp
@@ -0,0 +1,84 @@
+#ifndef SIMGRID_PLUGINS_OPERATION_H_
+#define SIMGRID_PLUGINS_OPERATION_H_
+
+#include <simgrid/s4u/Activity.hpp>
+#include <xbt/Extendable.hpp>
+
+#include <map>
+#include <set>
+
+namespace simgrid::plugins {
+
+class Operation;
+using OperationPtr = std::shared_ptr<Operation>;
+class ExecOp;
+using ExecOpPtr = std::shared_ptr<ExecOp>;
+class CommOp;
+using CommOpPtr = std::shared_ptr<CommOp>;
+
+class ExtendedAttributeActivity {
+public:
+  static simgrid::xbt::Extension<simgrid::s4u::Activity, ExtendedAttributeActivity> EXTENSION_ID;
+  Operation* operation_;
+
+  ExtendedAttributeActivity(){};
+};
+
+class Operation {
+private:
+  static bool inited_;
+  std::set<Operation*> successors_                 = {};
+  std::map<Operation*, unsigned int> predecessors_ = {};
+  std::function<void(Operation*)> end_func         = [](Operation*) {};
+
+  void add_predecessor(Operation* predecessor);
+  bool ready_to_run() const;
+  void receive(Operation* source);
+  void complete();
+
+protected:
+  std::string name_;
+  double amount_;
+  int iteration_limit_          = -1;
+  unsigned int iteration_count_ = 0;
+  bool working_                 = false;
+  simgrid::s4u::ActivityPtr current_activity_;
+  Operation(const std::string& name, double amount);
+  ~Operation() = default;
+  void consume();
+  void call_end();
+
+public:
+  static void init();
+  std::string get_name();
+  void set_iteration_limit(unsigned int n);
+  void add_successor(OperationPtr op);
+  void on_end(std::function<void(Operation*)> func);
+  virtual void execute() = 0;
+};
+
+class ExecOp : public Operation {
+private:
+  simgrid::s4u::Host* host_;
+
+  ExecOp(const std::string& name, double flops, simgrid::s4u::Host* host);
+
+public:
+  static ExecOpPtr create(const std::string& name, double flops, simgrid::s4u::Host* host);
+  void execute();
+};
+
+class CommOp : public Operation {
+private:
+  simgrid::s4u::Host* source_;
+  simgrid::s4u::Host* destination_;
+
+  CommOp(const std::string& name, double bytes, simgrid::s4u::Host* source, simgrid::s4u::Host* destination);
+
+public:
+  static CommOpPtr create(const std::string& name, double bytes, simgrid::s4u::Host* source,
+                          simgrid::s4u::Host* destination);
+  void execute();
+};
+} // namespace simgrid::plugins
+#endif
\ No newline at end of file

diff --git a/src/plugins/operation.cpp b/src/plugins/operation.cpp
new file mode 100644 (file)
index 0000000..5ae2e2c
--- /dev/null
+++ b/src/plugins/operation.cpp
@@ -0,0 +1,142 @@
+#include <simgrid/Exception.hpp>
+#include <simgrid/plugins/operation.hpp>
+#include <simgrid/s4u/Comm.hpp>
+#include <simgrid/s4u/Exec.hpp>
+
+#include "src/simgrid/module.hpp"
+
+SIMGRID_REGISTER_PLUGIN(operation, "Battery management", nullptr)
+XBT_LOG_NEW_DEFAULT_SUBCATEGORY(Operation, kernel, "Logging specific to the operation plugin");
+
+namespace simgrid::plugins {
+Operation::Operation(const std::string& name, double amount) : name_(name), amount_(amount) {}
+
+std::string Operation::get_name()
+{
+  return this->name_;
+}
+
+void Operation::add_predecessor(Operation* predecessor)
+{
+  this->predecessors_[predecessor] = 0;
+}
+
+bool Operation::ready_to_run() const
+{
+  if (this->working_ or (this->iteration_count_ != -1 and this->iteration_count_ >= this->iteration_limit_))
+    return false;
+  for (auto const& [key, val] : this->predecessors_)
+    if (val < 1)
+      return false;
+  return true;
+}
+
+void Operation::receive(Operation* source)
+{
+  auto it = this->predecessors_.find(source);
+  it->second++;
+  if (this->ready_to_run())
+    this->execute();
+}
+
+void Operation::complete()
+{
+  working_ = false;
+  call_end();
+  for (auto const& op : this->successors_)
+    op->receive(this);
+  if (ready_to_run())
+    execute();
+}
+
+void Operation::consume()
+{
+  for (auto const& [key, val] : predecessors_)
+    predecessors_[key] = predecessors_[key] > 0 ? predecessors_[key] - 1 : 0;
+}
+
+void Operation::call_end()
+{
+  end_func(this);
+}
+
+void Operation::init()
+{
+  if (Operation::inited_)
+    return;
+  Operation::inited_                      = true;
+  ExtendedAttributeActivity::EXTENSION_ID = simgrid::s4u::Activity::extension_create<ExtendedAttributeActivity>();
+  simgrid::s4u::Activity::on_completion_cb([&](simgrid::s4u::Activity const& activity) {
+    activity.extension<ExtendedAttributeActivity>()->operation_->complete();
+  });
+}
+
+void Operation::set_iteration_limit(unsigned int n)
+{
+  iteration_limit_ = n;
+}
+
+void Operation::add_successor(OperationPtr op)
+{
+  successors_.insert(op.get());
+  op->add_predecessor(this);
+}
+
+void Operation::on_end(std::function<void(Operation*)> func)
+{
+  end_func = func;
+}
+
+ExecOp::ExecOp(const std::string& name, double flops, simgrid::s4u::Host* host) : Operation(name, flops), host_(host) {}
+
+ExecOpPtr ExecOp::create(const std::string& name, double flops, simgrid::s4u::Host* host)
+{
+  auto op = ExecOpPtr(new ExecOp(name, flops, host));
+  return op;
+}
+
+void ExecOp::execute()
+{
+  iteration_count_++;
+  working_ = true;
+  consume();
+  simgrid::s4u::ExecPtr exec = simgrid::s4u::Exec::init();
+  exec->set_name(name_);
+  exec->set_flops_amount(amount_);
+  exec->set_host(host_);
+  exec->start();
+  exec->extension_set(new ExtendedAttributeActivity());
+  exec->extension<ExtendedAttributeActivity>()->operation_ = this;
+  current_activity_                                        = exec;
+}
+
+CommOp::CommOp(const std::string& name, double bytes, simgrid::s4u::Host* source, simgrid::s4u::Host* destination)
+    : Operation(name, bytes), source_(source), destination_(destination)
+{
+}
+
+CommOpPtr CommOp::create(const std::string& name, double bytes, simgrid::s4u::Host* source,
+                         simgrid::s4u::Host* destination)
+{
+  auto op = CommOpPtr(new CommOp(name, bytes, source, destination));
+  return op;
+}
+
+void CommOp::execute()
+{
+  iteration_count_++;
+  working_ = true;
+  consume();
+  simgrid::s4u::CommPtr comm = simgrid::s4u::Comm::sendto_init(source_, destination_);
+  comm->set_name(name_);
+  comm->set_payload_size(amount_);
+  comm->start();
+  comm->extension_set(new ExtendedAttributeActivity());
+  comm->extension<ExtendedAttributeActivity>()->operation_ = this;
+  current_activity_                                        = comm;
+}
+} // namespace simgrid::plugins
+
+simgrid::xbt::Extension<simgrid::s4u::Activity, simgrid::plugins::ExtendedAttributeActivity>
+    simgrid::plugins::ExtendedAttributeActivity::EXTENSION_ID;
+bool simgrid::plugins::Operation::inited_ = false;

diff --git a/tools/cmake/DefinePackages.cmake b/tools/cmake/DefinePackages.cmake
index 309236b..4ce4e82 100644 (file)
--- a/tools/cmake/DefinePackages.cmake
+++ b/tools/cmake/DefinePackages.cmake
@@ -454,6 +454,7 @@ set(PLUGINS_SRC
   src/plugins/vm/VmLiveMigration.hpp
   src/plugins/vm/dirty_page_tracking.cpp
   src/plugins/battery.cpp
+  src/plugins/operation.cpp
   )
 
 
@@ -636,12 +637,13 @@ set(headers_to_install
   include/simgrid/exec.h
   include/simgrid/Exception.hpp
   include/simgrid/chrono.hpp
+  include/simgrid/plugins/battery.hpp
   include/simgrid/plugins/dvfs.h
   include/simgrid/plugins/energy.h
-  include/simgrid/plugins/battery.hpp
   include/simgrid/plugins/file_system.h
   include/simgrid/plugins/live_migration.h
   include/simgrid/plugins/load.h
+  include/simgrid/plugins/operation.hpp
   include/simgrid/plugins/ProducerConsumer.hpp
   include/simgrid/instr.h
   include/simgrid/mailbox.h