src/kernel/actor/SimcallObserver.hpp

   1 /* Copyright (c) 2019-2022. 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_OBSERVER_HPP
   7 #define SIMGRID_MC_SIMCALL_OBSERVER_HPP
   8
   9 #include "simgrid/forward.h"
  10 #include "src/mc/api/Transition.hpp"
  11 #include "xbt/asserts.h"
  12
  13 #include <string>
  14
  15 namespace simgrid {
  16 namespace kernel {
  17 namespace actor {
  18
  19 class SimcallObserver {
  20   ActorImpl* const issuer_;
  21
  22 public:
  23   explicit SimcallObserver(ActorImpl* issuer) : issuer_(issuer) {}
  24   ActorImpl* get_issuer() const { return issuer_; }
  25   /** Whether this transition can currently be taken without blocking.
  26    *
  27    * For example, a mutex_lock is not enabled when the mutex is not free.
  28    * A comm_receive is not enabled before the corresponding send has been issued.
  29    */
  30   virtual bool is_enabled() const { return true; }
  31
  32   /** Returns the amount of time that this transition can be used.
  33    *
  34    * If it's 1 (as with send/wait), there is no need to fork the state space exploration on this point.
  35    * If it's more than one (as with mc_random or waitany), we need to consider this transition several times to start
  36    * differing branches
  37    */
  38   virtual int get_max_consider() const { return 1; }
  39
  40   /** Prepares the simcall to be used.
  41    *
  42    * For most simcalls, this does nothing. Once enabled, there is nothing to do to prepare a send().
  43    *
  44    * It is useful only for the simcalls that can be used several times, such as waitany() or random().
  45    * For them, prepare() selects the right outcome for the time being considered.
  46    *
  47    * The first time a simcall is considered, times_considered is 0, not 1.
  48    */
  49   virtual void prepare(int times_considered)
  50   { /* Nothing to do by default */
  51   }
  52
  53   /** Computes the dependency relation */
  54   virtual bool depends(SimcallObserver* other);
  55
  56   /** Serialize to the given string buffer */
  57   virtual void serialize(std::stringstream& stream) const;
  58
  59   /** Some simcalls may only be observable under some conditions.
  60    * Most simcalls are not visible from the MC because they don't have an observer at all. */
  61   virtual bool is_visible() const { return true; }
  62 };
  63
  64 template <class T> class ResultingSimcall : public SimcallObserver {
  65   T result_;
  66
  67 public:
  68   ResultingSimcall() = default;
  69   ResultingSimcall(ActorImpl* actor, T default_result) : SimcallObserver(actor), result_(default_result) {}
  70   void set_result(T res) { result_ = res; }
  71   T get_result() const { return result_; }
  72 };
  73
  74 class RandomSimcall : public SimcallObserver {
  75   const int min_;
  76   const int max_;
  77   int next_value_ = 0;
  78
  79 public:
  80   RandomSimcall(ActorImpl* actor, int min, int max) : SimcallObserver(actor), min_(min), max_(max)
  81   {
  82     xbt_assert(min < max);
  83   }
  84   void serialize(std::stringstream& stream) const override;
  85   int get_max_consider() const override;
  86   void prepare(int times_considered) override;
  87   int get_value() const { return next_value_; }
  88   bool depends(SimcallObserver* other) override;
  89 };
  90
  91 class MutexSimcall : public SimcallObserver {
  92   activity::MutexImpl* const mutex_;
  93
  94 public:
  95   MutexSimcall(ActorImpl* actor, activity::MutexImpl* mutex) : SimcallObserver(actor), mutex_(mutex) {}
  96   activity::MutexImpl* get_mutex() const { return mutex_; }
  97   bool depends(SimcallObserver* other) override;
  98 };
  99
 100 class MutexUnlockSimcall : public MutexSimcall {
 101   using MutexSimcall::MutexSimcall;
 102 };
 103
 104 class MutexLockSimcall : public MutexSimcall {
 105   const bool blocking_;
 106
 107 public:
 108   MutexLockSimcall(ActorImpl* actor, activity::MutexImpl* mutex, bool blocking = true)
 109       : MutexSimcall(actor, mutex), blocking_(blocking)
 110   {
 111   }
 112   bool is_enabled() const override;
 113 };
 114
 115 class ConditionWaitSimcall : public ResultingSimcall<bool> {
 116   activity::ConditionVariableImpl* const cond_;
 117   activity::MutexImpl* const mutex_;
 118   const double timeout_;
 119
 120 public:
 121   ConditionWaitSimcall(ActorImpl* actor, activity::ConditionVariableImpl* cond, activity::MutexImpl* mutex,
 122                        double timeout = -1.0)
 123       : ResultingSimcall(actor, false), cond_(cond), mutex_(mutex), timeout_(timeout)
 124   {
 125   }
 126   bool is_enabled() const override;
 127   bool is_visible() const override { return false; }
 128   activity::ConditionVariableImpl* get_cond() const { return cond_; }
 129   activity::MutexImpl* get_mutex() const { return mutex_; }
 130   double get_timeout() const { return timeout_; }
 131 };
 132
 133 class SemAcquireSimcall : public ResultingSimcall<bool> {
 134   activity::SemaphoreImpl* const sem_;
 135   const double timeout_;
 136
 137 public:
 138   SemAcquireSimcall(ActorImpl* actor, activity::SemaphoreImpl* sem, double timeout = -1.0)
 139       : ResultingSimcall(actor, false), sem_(sem), timeout_(timeout)
 140   {
 141   }
 142   bool is_enabled() const override;
 143   bool is_visible() const override { return false; }
 144   activity::SemaphoreImpl* get_sem() const { return sem_; }
 145   double get_timeout() const { return timeout_; }
 146 };
 147
 148 class ActivityTestSimcall : public ResultingSimcall<bool> {
 149   activity::ActivityImpl* const activity_;
 150
 151 public:
 152   ActivityTestSimcall(ActorImpl* actor, activity::ActivityImpl* activity)
 153       : ResultingSimcall(actor, true), activity_(activity)
 154   {
 155   }
 156   bool is_visible() const override { return true; }
 157   activity::ActivityImpl* get_activity() const { return activity_; }
 158   void serialize(std::stringstream& stream) const override;
 159 };
 160
 161 class ActivityTestanySimcall : public ResultingSimcall<ssize_t> {
 162   const std::vector<activity::ActivityImpl*>& activities_;
 163   int next_value_ = 0;
 164
 165 public:
 166   ActivityTestanySimcall(ActorImpl* actor, const std::vector<activity::ActivityImpl*>& activities)
 167       : ResultingSimcall(actor, -1), activities_(activities)
 168   {
 169   }
 170   bool is_visible() const override { return true; }
 171   int get_max_consider() const override;
 172   void prepare(int times_considered) override;
 173   const std::vector<activity::ActivityImpl*>& get_activities() const { return activities_; }
 174   int get_value() const { return next_value_; }
 175 };
 176
 177 class ActivityWaitSimcall : public ResultingSimcall<bool> {
 178   activity::ActivityImpl* activity_;
 179   const double timeout_;
 180
 181 public:
 182   ActivityWaitSimcall(ActorImpl* actor, activity::ActivityImpl* activity, double timeout)
 183       : ResultingSimcall(actor, false), activity_(activity), timeout_(timeout)
 184   {
 185   }
 186   void serialize(std::stringstream& stream) const override;
 187   bool is_visible() const override { return true; }
 188   bool is_enabled() const override;
 189   activity::ActivityImpl* get_activity() const { return activity_; }
 190   void set_activity(activity::ActivityImpl* activity) { activity_ = activity; }
 191   double get_timeout() const { return timeout_; }
 192 };
 193
 194 class ActivityWaitanySimcall : public ResultingSimcall<ssize_t> {
 195   const std::vector<activity::ActivityImpl*>& activities_;
 196   const double timeout_;
 197   int next_value_ = 0;
 198
 199 public:
 200   ActivityWaitanySimcall(ActorImpl* actor, const std::vector<activity::ActivityImpl*>& activities, double timeout)
 201       : ResultingSimcall(actor, -1), activities_(activities), timeout_(timeout)
 202   {
 203   }
 204   bool is_enabled() const override;
 205   bool is_visible() const override { return true; }
 206   void prepare(int times_considered) override;
 207   int get_max_consider() const override;
 208   const std::vector<activity::ActivityImpl*>& get_activities() const { return activities_; }
 209   double get_timeout() const { return timeout_; }
 210   int get_value() const { return next_value_; }
 211 };
 212
 213 class CommIsendSimcall : public SimcallObserver {
 214   activity::MailboxImpl* mbox_;
 215   double payload_size_;
 216   double rate_;
 217   unsigned char* src_buff_;
 218   size_t src_buff_size_;
 219   void* payload_;
 220   bool detached_;
 221
 222 public:
 223   bool (*match_fun_)(void*, void*, activity::CommImpl*);
 224   void (*clean_fun_)(void*); // used to free the synchro in case of problem after a detached send
 225   void (*copy_data_fun_)(activity::CommImpl*, void*, size_t); // used to copy data if not default one
 226
 227   CommIsendSimcall(ActorImpl* actor, activity::MailboxImpl* mbox, double payload_size, double rate,
 228                    unsigned char* src_buff, size_t src_buff_size, bool (*match_fun)(void*, void*, activity::CommImpl*),
 229                    void (*clean_fun)(void*), // used to free the synchro in case of problem after a detached send
 230                    void (*copy_data_fun)(activity::CommImpl*, void*, size_t), // used to copy data if not default one
 231                    void* payload, bool detached)
 232       : SimcallObserver(actor)
 233       , mbox_(mbox)
 234       , payload_size_(payload_size)
 235       , rate_(rate)
 236       , src_buff_(src_buff)
 237       , src_buff_size_(src_buff_size)
 238       , payload_(payload)
 239       , detached_(detached)
 240       , match_fun_(match_fun)
 241       , clean_fun_(clean_fun)
 242       , copy_data_fun_(copy_data_fun)
 243   {
 244   }
 245   void serialize(std::stringstream& stream) const override;
 246   bool is_visible() const override { return true; }
 247   activity::MailboxImpl* get_mailbox() const { return mbox_; }
 248   double get_payload_size() const { return payload_size_; }
 249   double get_rate() const { return rate_; }
 250   unsigned char* get_src_buff() const { return src_buff_; }
 251   size_t get_src_buff_size() const { return src_buff_size_; }
 252   void* get_payload() const { return payload_; }
 253   bool is_detached() const { return detached_; }
 254 };
 255
 256 class CommIrecvSimcall : public SimcallObserver {
 257   activity::MailboxImpl* mbox_;
 258   unsigned char* dst_buff_;
 259   size_t* dst_buff_size_;
 260   void* payload_;
 261   double rate_;
 262
 263 public:
 264   bool (*match_fun_)(void*, void*, activity::CommImpl*);
 265   void (*copy_data_fun_)(activity::CommImpl*, void*, size_t); // used to copy data if not default one
 266
 267   CommIrecvSimcall(ActorImpl* actor, activity::MailboxImpl* mbox, unsigned char* dst_buff, size_t* dst_buff_size,
 268                    bool (*match_fun)(void*, void*, activity::CommImpl*),
 269                    void (*copy_data_fun)(activity::CommImpl*, void*, size_t), void* payload, double rate)
 270       : SimcallObserver(actor)
 271       , mbox_(mbox)
 272       , dst_buff_(dst_buff)
 273       , dst_buff_size_(dst_buff_size)
 274       , payload_(payload)
 275       , rate_(rate)
 276       , match_fun_(match_fun)
 277       , copy_data_fun_(copy_data_fun)
 278   {
 279   }
 280   void serialize(std::stringstream& stream) const override;
 281   bool is_visible() const override { return true; }
 282   activity::MailboxImpl* get_mailbox() const { return mbox_; }
 283   double get_rate() const { return rate_; }
 284   unsigned char* get_dst_buff() const { return dst_buff_; }
 285   size_t* get_dst_buff_size() const { return dst_buff_size_; }
 286   void* get_payload() const { return payload_; }
 287 };
 288
 289 } // namespace actor
 290 } // namespace kernel
 291 } // namespace simgrid
 292
 293 #endif