src/kernel/actor/CommObserver.hpp

   1 /* Copyright (c) 2019-2023. The SimGrid Team. All rights reserved.          */
   2
   3 /* This program is free software; you can redistribute it and/or modify it
   4  * under the terms of the license (GNU LGPL) which comes with this package. */
   5
   6 #ifndef SIMGRID_MC_SIMCALL_COMM_OBSERVER_HPP
   7 #define SIMGRID_MC_SIMCALL_COMM_OBSERVER_HPP
   8
   9 #include "simgrid/forward.h"
  10 #include "src/kernel/actor/SimcallObserver.hpp"
  11 #include "src/mc/transition/Transition.hpp"
  12 #include "xbt/asserts.h"
  13
  14 #include <string>
  15 #include <string_view>
  16
  17 namespace simgrid::kernel::actor {
  18
  19 class ActivityTestSimcall final : public ResultingSimcall<bool> {
  20   activity::ActivityImpl* const activity_;
  21   std::string fun_call_;
  22
  23 public:
  24   ActivityTestSimcall(ActorImpl* actor, activity::ActivityImpl* activity, std::string_view fun_call)
  25       : ResultingSimcall(actor, true), activity_(activity), fun_call_(fun_call)
  26   {
  27   }
  28   activity::ActivityImpl* get_activity() const { return activity_; }
  29   void serialize(std::stringstream& stream) const override;
  30   std::string to_string() const override;
  31 };
  32
  33 class ActivityTestanySimcall final : public ResultingSimcall<ssize_t> {
  34   const std::vector<activity::ActivityImpl*>& activities_;
  35   std::vector<int> indexes_; // indexes in activities_ pointing to ready activities (=whose test() is positive)
  36   int next_value_ = 0;
  37   std::string fun_call_;
  38
  39 public:
  40   ActivityTestanySimcall(ActorImpl* actor, const std::vector<activity::ActivityImpl*>& activities,
  41                          std::string_view fun_call);
  42   bool is_enabled() override { return true; /* can return -1 if no activity is ready */ }
  43   void serialize(std::stringstream& stream) const override;
  44   std::string to_string() const override;
  45   int get_max_consider() const override;
  46   void prepare(int times_considered) override;
  47   const std::vector<activity::ActivityImpl*>& get_activities() const { return activities_; }
  48   int get_value() const { return next_value_; }
  49 };
  50
  51 class ActivityWaitSimcall final : public ResultingSimcall<bool> {
  52   activity::ActivityImpl* activity_;
  53   const double timeout_;
  54   std::string fun_call_;
  55
  56 public:
  57   ActivityWaitSimcall(ActorImpl* actor, activity::ActivityImpl* activity, double timeout, std::string_view fun_call)
  58       : ResultingSimcall(actor, false), activity_(activity), timeout_(timeout), fun_call_(fun_call)
  59   {
  60   }
  61   void serialize(std::stringstream& stream) const override;
  62   std::string to_string() const override;
  63   bool is_enabled() override;
  64   activity::ActivityImpl* get_activity() const { return activity_; }
  65   void set_activity(activity::ActivityImpl* activity) { activity_ = activity; }
  66   double get_timeout() const { return timeout_; }
  67 };
  68
  69 class ActivityWaitanySimcall final : public ResultingSimcall<ssize_t> {
  70   const std::vector<activity::ActivityImpl*>& activities_;
  71   std::vector<int> indexes_; // indexes in activities_ pointing to ready activities (=whose test() is positive)
  72   const double timeout_;
  73   int next_value_ = 0;
  74   std::string fun_call_;
  75
  76 public:
  77   ActivityWaitanySimcall(ActorImpl* actor, const std::vector<activity::ActivityImpl*>& activities, double timeout,
  78                          std::string_view fun_call);
  79   bool is_enabled() override;
  80   void serialize(std::stringstream& stream) const override;
  81   std::string to_string() const override;
  82   void prepare(int times_considered) override;
  83   int get_max_consider() const override;
  84   const std::vector<activity::ActivityImpl*>& get_activities() const { return activities_; }
  85   double get_timeout() const { return timeout_; }
  86   int get_value() const { return next_value_; }
  87 };
  88
  89 class CommIsendSimcall final : public SimcallObserver {
  90   activity::MailboxImpl* mbox_;
  91   double payload_size_;
  92   double rate_;
  93   unsigned char* src_buff_;
  94   size_t src_buff_size_;
  95   void* payload_;
  96   bool detached_;
  97   activity::CommImpl* comm_ = {};
  98   int tag_                  = {};
  99
 100   std::function<bool(void*, void*, activity::CommImpl*)> match_fun_;
 101   std::function<void(void*)> clean_fun_; // used to free the synchro in case of problem after a detached send
 102   std::function<void(activity::CommImpl*, void*, size_t)> copy_data_fun_; // used to copy data if not default one
 103
 104   std::string fun_call_;
 105
 106 public:
 107   CommIsendSimcall(
 108       ActorImpl* actor, activity::MailboxImpl* mbox, double payload_size, double rate, unsigned char* src_buff,
 109       size_t src_buff_size, const std::function<bool(void*, void*, activity::CommImpl*)>& match_fun,
 110       const std::function<void(void*)>& clean_fun, // used to free the synchro in case of problem after a detached send
 111       const std::function<void(activity::CommImpl*, void*, size_t)>&
 112           copy_data_fun, // used to copy data if not default one
 113       void* payload, bool detached, std::string_view fun_call)
 114       : SimcallObserver(actor)
 115       , mbox_(mbox)
 116       , payload_size_(payload_size)
 117       , rate_(rate)
 118       , src_buff_(src_buff)
 119       , src_buff_size_(src_buff_size)
 120       , payload_(payload)
 121       , detached_(detached)
 122       , match_fun_(match_fun)
 123       , clean_fun_(clean_fun)
 124       , copy_data_fun_(copy_data_fun)
 125       , fun_call_(fun_call)
 126   {
 127   }
 128   void serialize(std::stringstream& stream) const override;
 129   std::string to_string() const override;
 130   activity::MailboxImpl* get_mailbox() const { return mbox_; }
 131   double get_payload_size() const { return payload_size_; }
 132   double get_rate() const { return rate_; }
 133   unsigned char* get_src_buff() const { return src_buff_; }
 134   size_t get_src_buff_size() const { return src_buff_size_; }
 135   void* get_payload() const { return payload_; }
 136   bool is_detached() const { return detached_; }
 137   void set_comm(activity::CommImpl* comm) { comm_ = comm; }
 138   void set_tag(int tag) { tag_ = tag; }
 139
 140   auto const& get_match_fun() const { return match_fun_; }
 141   auto const& get_clean_fun() const { return clean_fun_; }
 142   auto const& get_copy_data_fun() const { return copy_data_fun_; }
 143 };
 144
 145 class CommIrecvSimcall final : public SimcallObserver {
 146   activity::MailboxImpl* mbox_;
 147   unsigned char* dst_buff_;
 148   size_t* dst_buff_size_;
 149   void* payload_;
 150   double rate_;
 151   activity::CommImpl* comm_ = {};
 152   int tag_                  = {};
 153
 154   std::function<bool(void*, void*, activity::CommImpl*)> match_fun_;
 155   std::function<void(activity::CommImpl*, void*, size_t)> copy_data_fun_; // used to copy data if not default one
 156
 157   std::string fun_call_;
 158
 159 public:
 160   CommIrecvSimcall(ActorImpl* actor, activity::MailboxImpl* mbox, unsigned char* dst_buff, size_t* dst_buff_size,
 161                    const std::function<bool(void*, void*, activity::CommImpl*)>& match_fun,
 162                    const std::function<void(activity::CommImpl*, void*, size_t)>& copy_data_fun, void* payload,
 163                    double rate, std::string_view fun_call)
 164       : SimcallObserver(actor)
 165       , mbox_(mbox)
 166       , dst_buff_(dst_buff)
 167       , dst_buff_size_(dst_buff_size)
 168       , payload_(payload)
 169       , rate_(rate)
 170       , match_fun_(match_fun)
 171       , copy_data_fun_(copy_data_fun)
 172       , fun_call_(fun_call)
 173   {
 174   }
 175   void serialize(std::stringstream& stream) const override;
 176   std::string to_string() const override;
 177   activity::MailboxImpl* get_mailbox() const { return mbox_; }
 178   double get_rate() const { return rate_; }
 179   unsigned char* get_dst_buff() const { return dst_buff_; }
 180   size_t* get_dst_buff_size() const { return dst_buff_size_; }
 181   void* get_payload() const { return payload_; }
 182   void set_comm(activity::CommImpl* comm) { comm_ = comm; }
 183   void set_tag(int tag) { tag_ = tag; }
 184
 185   auto const& get_match_fun() const { return match_fun_; };
 186   auto const& get_copy_data_fun() const { return copy_data_fun_; }
 187 };
 188
 189 class MessIputSimcall final : public SimcallObserver {
 190   activity::MessageQueueImpl* queue_;
 191   void* payload_;
 192   activity::MessImpl* mess_ = {};
 193
 194 public:
 195   MessIputSimcall(
 196       ActorImpl* actor, activity::MessageQueueImpl* queue, void* payload)
 197       : SimcallObserver(actor)
 198       , queue_(queue)
 199       , payload_(payload)
 200   {
 201   }
 202   void serialize(std::stringstream& stream) const override;
 203   std::string to_string() const override;
 204   activity::MessageQueueImpl* get_queue() const { return queue_; }
 205   void* get_payload() const { return payload_; }
 206   void set_message(activity::MessImpl* mess) { mess_ = mess; }
 207 };
 208
 209 class MessIgetSimcall final : public SimcallObserver {
 210   activity::MessageQueueImpl* queue_;
 211   unsigned char* dst_buff_;
 212   size_t* dst_buff_size_;
 213   void* payload_;
 214   activity::MessImpl* mess_ = {};
 215
 216 public:
 217   MessIgetSimcall(ActorImpl* actor, activity::MessageQueueImpl* queue, unsigned char* dst_buff, size_t* dst_buff_size,
 218                   void* payload)
 219       : SimcallObserver(actor)
 220       , queue_(queue)
 221       , dst_buff_(dst_buff)
 222       , dst_buff_size_(dst_buff_size)
 223       , payload_(payload)
 224   {
 225   }
 226   void serialize(std::stringstream& stream) const override;
 227   std::string to_string() const override;
 228   activity::MessageQueueImpl* get_queue() const { return queue_; }
 229   unsigned char* get_dst_buff() const { return dst_buff_; }
 230   size_t* get_dst_buff_size() const { return dst_buff_size_; }
 231   void* get_payload() const { return payload_; }
 232   void set_message(activity::MessImpl* mess) { mess_ = mess; }
 233 };
 234
 235 } // namespace simgrid::kernel::actor
 236
 237 #endif