src/simix/libsmx.cpp

   1 /* libsmx.c - public interface to simix                                       */
   2 /* --------                                                                   */
   3 /* These functions are the only ones that are visible from the higher levels  */
   4 /* (most of them simply add some documentation to the generated simcall body) */
   5 /*                                                                            */
   6 /* This is somehow the "libc" of SimGrid                                      */
   7
   8 /* Copyright (c) 2010-2022. The SimGrid Team. All rights reserved.          */
   9
  10 /* This program is free software; you can redistribute it and/or modify it
  11  * under the terms of the license (GNU LGPL) which comes with this package. */
  12
  13 #include "mc/mc.h"
  14 #include "src/kernel/activity/CommImpl.hpp"
  15 #include "src/kernel/activity/ConditionVariableImpl.hpp"
  16 #include "src/kernel/activity/MutexImpl.hpp"
  17 #include "src/kernel/activity/SemaphoreImpl.hpp"
  18 #include "src/kernel/actor/SimcallObserver.hpp"
  19 #include "src/mc/mc_replay.hpp"
  20 #include "xbt/random.hpp"
  21
  22 #include "popping_bodies.cpp"
  23
  24 #include <boost/core/demangle.hpp>
  25 #include <string>
  26 #include <typeinfo>
  27 XBT_LOG_NEW_CATEGORY(simix, "All SIMIX categories");
  28
  29 unsigned int simcall_execution_waitany_for(simgrid::kernel::activity::ExecImpl* execs[], size_t count,
  30                                            double timeout) // XBT_ATTRIB_DEPRECATED_v331
  31 {
  32   std::vector<simgrid::kernel::activity::ExecImpl*> execs_vec(execs, execs + count);
  33   simgrid::kernel::actor::ActorImpl* issuer = simgrid::kernel::actor::ActorImpl::self();
  34   simgrid::kernel::actor::ExecutionWaitanySimcall observer{issuer, execs_vec, timeout};
  35   return simgrid::kernel::actor::simcall_blocking(
  36       [&observer] {
  37         simgrid::kernel::activity::ExecImpl::wait_any_for(observer.get_issuer(), observer.get_execs(),
  38                                                           observer.get_timeout());
  39       },
  40       &observer);
  41 }
  42
  43 /**
  44  * @ingroup simix_comm_management
  45  */
  46 void simcall_comm_send(smx_actor_t sender, smx_mailbox_t mbox, double task_size, double rate, void* src_buff,
  47                        size_t src_buff_size, bool (*match_fun)(void*, void*, simgrid::kernel::activity::CommImpl*),
  48                        void (*copy_data_fun)(simgrid::kernel::activity::CommImpl*, void*, size_t), void* data,
  49                        double timeout)
  50 {
  51   /* checking for infinite values */
  52   xbt_assert(std::isfinite(task_size), "task_size is not finite!");
  53   xbt_assert(std::isfinite(rate), "rate is not finite!");
  54   xbt_assert(std::isfinite(timeout), "timeout is not finite!");
  55
  56   xbt_assert(mbox, "No rendez-vous point defined for send");
  57
  58   if (MC_is_active() || MC_record_replay_is_active()) {
  59     /* the model-checker wants two separate simcalls */
  60     simgrid::kernel::activity::ActivityImplPtr comm =
  61         nullptr; /* MC needs the comm to be set to nullptr during the simcall */
  62     comm = simcall_comm_isend(sender, mbox, task_size, rate, src_buff, src_buff_size, match_fun, nullptr, copy_data_fun,
  63                               data, false);
  64     simcall_comm_wait(comm.get(), timeout);
  65     comm = nullptr;
  66   }
  67   else {
  68     simcall_BODY_comm_send(sender, mbox, task_size, rate, static_cast<unsigned char*>(src_buff), src_buff_size,
  69                            match_fun, copy_data_fun, data, timeout);
  70   }
  71 }
  72
  73 /**
  74  * @ingroup simix_comm_management
  75  */
  76 simgrid::kernel::activity::ActivityImplPtr
  77 simcall_comm_isend(smx_actor_t sender, smx_mailbox_t mbox, double task_size, double rate, void* src_buff,
  78                    size_t src_buff_size, bool (*match_fun)(void*, void*, simgrid::kernel::activity::CommImpl*),
  79                    void (*clean_fun)(void*), void (*copy_data_fun)(simgrid::kernel::activity::CommImpl*, void*, size_t),
  80                    void* data, bool detached)
  81 {
  82   /* checking for infinite values */
  83   xbt_assert(std::isfinite(task_size), "task_size is not finite!");
  84   xbt_assert(std::isfinite(rate), "rate is not finite!");
  85
  86   xbt_assert(mbox, "No rendez-vous point defined for isend");
  87
  88   return simcall_BODY_comm_isend(sender, mbox, task_size, rate, static_cast<unsigned char*>(src_buff), src_buff_size,
  89                                  match_fun, clean_fun, copy_data_fun, data, detached);
  90 }
  91
  92 /**
  93  * @ingroup simix_comm_management
  94  */
  95 void simcall_comm_recv(smx_actor_t receiver, smx_mailbox_t mbox, void* dst_buff, size_t* dst_buff_size,
  96                        bool (*match_fun)(void*, void*, simgrid::kernel::activity::CommImpl*),
  97                        void (*copy_data_fun)(simgrid::kernel::activity::CommImpl*, void*, size_t), void* data,
  98                        double timeout, double rate)
  99 {
 100   xbt_assert(std::isfinite(timeout), "timeout is not finite!");
 101   xbt_assert(mbox, "No rendez-vous point defined for recv");
 102
 103   if (MC_is_active() || MC_record_replay_is_active()) {
 104     /* the model-checker wants two separate simcalls */
 105     simgrid::kernel::activity::ActivityImplPtr comm =
 106         nullptr; /* MC needs the comm to be set to nullptr during the simcall */
 107     comm = simcall_comm_irecv(receiver, mbox, dst_buff, dst_buff_size,
 108                               match_fun, copy_data_fun, data, rate);
 109     simcall_comm_wait(comm.get(), timeout);
 110     comm = nullptr;
 111   }
 112   else {
 113     simcall_BODY_comm_recv(receiver, mbox, static_cast<unsigned char*>(dst_buff), dst_buff_size, match_fun,
 114                            copy_data_fun, data, timeout, rate);
 115   }
 116 }
 117 /**
 118  * @ingroup simix_comm_management
 119  */
 120 simgrid::kernel::activity::ActivityImplPtr
 121 simcall_comm_irecv(smx_actor_t receiver, smx_mailbox_t mbox, void* dst_buff, size_t* dst_buff_size,
 122                    bool (*match_fun)(void*, void*, simgrid::kernel::activity::CommImpl*),
 123                    void (*copy_data_fun)(simgrid::kernel::activity::CommImpl*, void*, size_t), void* data, double rate)
 124 {
 125   xbt_assert(mbox, "No rendez-vous point defined for irecv");
 126
 127   return simcall_BODY_comm_irecv(receiver, mbox, static_cast<unsigned char*>(dst_buff), dst_buff_size, match_fun,
 128                                  copy_data_fun, data, rate);
 129 }
 130
 131 /**
 132  * @ingroup simix_comm_management
 133  */
 134 ssize_t simcall_comm_waitany(simgrid::kernel::activity::CommImpl* comms[], size_t count, double timeout)
 135 {
 136   return simcall_BODY_comm_waitany(comms, count, timeout);
 137 }
 138
 139 /**
 140  * @ingroup simix_comm_management
 141  */
 142 ssize_t simcall_comm_testany(simgrid::kernel::activity::CommImpl* comms[], size_t count)
 143 {
 144   if (count == 0)
 145     return -1;
 146   return simcall_BODY_comm_testany(comms, count);
 147 }
 148
 149 /**
 150  * @ingroup simix_comm_management
 151  */
 152 void simcall_comm_wait(simgrid::kernel::activity::ActivityImpl* comm, double timeout)
 153 {
 154   xbt_assert(std::isfinite(timeout), "timeout is not finite!");
 155   simcall_BODY_comm_wait(static_cast<simgrid::kernel::activity::CommImpl*>(comm), timeout);
 156 }
 157
 158 /**
 159  * @ingroup simix_comm_management
 160  *
 161  */
 162 bool simcall_comm_test(simgrid::kernel::activity::ActivityImpl* comm)
 163 {
 164   return simcall_BODY_comm_test(static_cast<simgrid::kernel::activity::CommImpl*>(comm));
 165 }
 166
 167 /**
 168  * @ingroup simix_synchro_management
 169  *
 170  */
 171 void simcall_mutex_lock(smx_mutex_t mutex) // XBT_ATTRIB_DEPRECATD_v331
 172 {
 173   mutex->mutex().lock();
 174 }
 175
 176 /**
 177  * @ingroup simix_synchro_management
 178  *
 179  */
 180 int simcall_mutex_trylock(smx_mutex_t mutex) // XBT_ATTRIB_DEPRECATD_v331
 181 {
 182   return mutex->mutex().try_lock();
 183 }
 184
 185 /**
 186  * @ingroup simix_synchro_management
 187  *
 188  */
 189 void simcall_mutex_unlock(smx_mutex_t mutex) // XBT_ATTRIB_DEPRECATD_v331
 190 {
 191   mutex->mutex().unlock();
 192 }
 193
 194 /**
 195  * @ingroup simix_synchro_management
 196  *
 197  */
 198 void simcall_cond_wait(smx_cond_t cond, smx_mutex_t mutex) // XBT_ATTRIB_DEPRECATED_v331
 199 {
 200   cond->get_iface()->wait(std::unique_lock<simgrid::s4u::Mutex>(mutex->mutex()));
 201 }
 202
 203 /**
 204  * @ingroup simix_synchro_management
 205  *
 206  */
 207 int simcall_cond_wait_timeout(smx_cond_t cond, smx_mutex_t mutex, double timeout) // XBT_ATTRIB_DEPRECATD_v331
 208 {
 209   return cond->get_iface()->wait_for(std::unique_lock<simgrid::s4u::Mutex>(mutex->mutex()), timeout) ==
 210          std::cv_status::timeout;
 211 }
 212
 213 /**
 214  * @ingroup simix_synchro_management
 215  *
 216  */
 217 void simcall_sem_acquire(smx_sem_t sem) // XBT_ATTRIB_DEPRECATD_v331
 218 {
 219   return sem->sem().acquire();
 220 }
 221
 222 /**
 223  * @ingroup simix_synchro_management
 224  *
 225  */
 226 int simcall_sem_acquire_timeout(smx_sem_t sem, double timeout) // XBT_ATTRIB_DEPRECATD_v331
 227 {
 228   return sem->sem().acquire_timeout(timeout);
 229 }
 230
 231 void simcall_run_kernel(std::function<void()> const& code, simgrid::kernel::actor::SimcallObserver* observer)
 232 {
 233   simgrid::kernel::actor::ActorImpl::self()->simcall_.observer_ = observer;
 234   simcall_BODY_run_kernel(&code);
 235   simgrid::kernel::actor::ActorImpl::self()->simcall_.observer_ = nullptr;
 236 }
 237
 238 void simcall_run_blocking(std::function<void()> const& code, simgrid::kernel::actor::SimcallObserver* observer)
 239 {
 240   simgrid::kernel::actor::ActorImpl::self()->simcall_.observer_ = observer;
 241   simcall_BODY_run_blocking(&code);
 242   simgrid::kernel::actor::ActorImpl::self()->simcall_.observer_ = nullptr;
 243 }
 244
 245 int simcall_mc_random(int min, int max) // XBT_ATTRIB_DEPRECATD_v331
 246 {
 247   return MC_random(min, max);
 248 }
 249
 250 /* ************************************************************************** */
 251
 252 /** @brief returns a printable string representing a simcall */
 253 const char* SIMIX_simcall_name(const s_smx_simcall& simcall)
 254 {
 255   if (simcall.observer_ != nullptr) {
 256     static std::string name;
 257     name              = boost::core::demangle(typeid(*simcall.observer_).name());
 258     const char* cname = name.c_str();
 259     if (name.rfind("simgrid::kernel::", 0) == 0)
 260       cname += 17; // strip prefix "simgrid::kernel::"
 261     return cname;
 262   } else {
 263     return simcall_names[static_cast<int>(simcall.call_)];
 264   }
 265 }
 266
 267 namespace simgrid {
 268 namespace simix {
 269
 270 void unblock(smx_actor_t actor)
 271 {
 272   xbt_assert(s4u::Actor::is_maestro());
 273   actor->simcall_answer();
 274 }
 275 } // namespace simix
 276 } // namespace simgrid