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-2021. 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/ExecImpl.hpp"
  17 #include "src/kernel/activity/IoImpl.hpp"
  18 #include "src/kernel/activity/MailboxImpl.hpp"
  19 #include "src/kernel/activity/MutexImpl.hpp"
  20 #include "src/kernel/activity/SemaphoreImpl.hpp"
  21 #include "src/kernel/actor/SimcallObserver.hpp"
  22 #include "src/mc/mc_replay.hpp"
  23 #include "src/plugins/vm/VirtualMachineImpl.hpp"
  24 #include "xbt/random.hpp"
  25
  26 #include "popping_bodies.cpp"
  27
  28 /**
  29  * @ingroup simix_host_management
  30  * @brief Waits for the completion of an execution synchro and destroy it.
  31  *
  32  * @param execution The execution synchro
  33  */
  34 simgrid::kernel::activity::State simcall_execution_wait(simgrid::kernel::activity::ActivityImpl* execution,
  35                                                         double timeout) // XBT_ATTRIB_DEPRECATED_v330
  36 {
  37   simgrid::kernel::actor::ActorImpl* issuer = simgrid::kernel::actor::ActorImpl::self();
  38   simgrid::kernel::actor::simcall_blocking([execution, issuer, timeout] { execution->wait_for(issuer, timeout); });
  39   return simgrid::kernel::activity::State::DONE;
  40 }
  41
  42 simgrid::kernel::activity::State simcall_execution_wait(const simgrid::kernel::activity::ActivityImplPtr& execution,
  43                                                         double timeout) // XBT_ATTRIB_DEPRECATED_v330
  44 {
  45   simgrid::kernel::actor::ActorImpl* issuer = simgrid::kernel::actor::ActorImpl::self();
  46   simgrid::kernel::actor::simcall_blocking([execution, issuer, timeout] { execution->wait_for(issuer, timeout); });
  47   return simgrid::kernel::activity::State::DONE;
  48 }
  49
  50 bool simcall_execution_test(simgrid::kernel::activity::ActivityImpl* execution) // XBT_ATTRIB_DEPRECATED_v330
  51 {
  52   return simgrid::kernel::actor::simcall([execution] { return execution->test(); });
  53 }
  54
  55 bool simcall_execution_test(const simgrid::kernel::activity::ActivityImplPtr& execution) // XBT_ATTRIB_DEPRECATED_v330
  56 {
  57   return simgrid::kernel::actor::simcall([execution] { return execution->test(); });
  58 }
  59
  60 unsigned int simcall_execution_waitany_for(simgrid::kernel::activity::ExecImpl* execs[], size_t count,
  61                                            double timeout) // XBT_ATTRIB_DEPRECATED_v331
  62 {
  63   std::vector<simgrid::kernel::activity::ExecImpl*> execs_vec(execs, execs + count);
  64   simgrid::kernel::actor::ActorImpl* issuer = simgrid::kernel::actor::ActorImpl::self();
  65   simgrid::kernel::actor::ExecutionWaitanySimcall observer{issuer, execs_vec, timeout};
  66   return simgrid::kernel::actor::simcall_blocking(
  67       [&observer] {
  68         simgrid::kernel::activity::ExecImpl::wait_any_for(observer.get_issuer(), observer.get_execs(),
  69                                                           observer.get_timeout());
  70       },
  71       &observer);
  72 }
  73
  74 simgrid::kernel::activity::State simcall_process_sleep(double duration) // XBT_ATTRIB_DEPRECATED_v329
  75 {
  76   simgrid::kernel::actor::ActorImpl::self()->sleep(duration);
  77   return simgrid::kernel::activity::State::DONE;
  78 }
  79
  80 /**
  81  * @ingroup simix_comm_management
  82  */
  83 void simcall_comm_send(smx_actor_t sender, smx_mailbox_t mbox, double task_size, double rate, void* src_buff,
  84                        size_t src_buff_size, bool (*match_fun)(void*, void*, simgrid::kernel::activity::CommImpl*),
  85                        void (*copy_data_fun)(simgrid::kernel::activity::CommImpl*, void*, size_t), void* data,
  86                        double timeout)
  87 {
  88   /* checking for infinite values */
  89   xbt_assert(std::isfinite(task_size), "task_size is not finite!");
  90   xbt_assert(std::isfinite(rate), "rate is not finite!");
  91   xbt_assert(std::isfinite(timeout), "timeout is not finite!");
  92
  93   xbt_assert(mbox, "No rendez-vous point defined for send");
  94
  95   if (MC_is_active() || MC_record_replay_is_active()) {
  96     /* the model-checker wants two separate simcalls */
  97     simgrid::kernel::activity::ActivityImplPtr comm =
  98         nullptr; /* MC needs the comm to be set to nullptr during the simcall */
  99     comm = simcall_comm_isend(sender, mbox, task_size, rate, src_buff, src_buff_size, match_fun, nullptr, copy_data_fun,
 100                               data, false);
 101     simcall_comm_wait(comm.get(), timeout);
 102     comm = nullptr;
 103   }
 104   else {
 105     simcall_BODY_comm_send(sender, mbox, task_size, rate, static_cast<unsigned char*>(src_buff), src_buff_size,
 106                            match_fun, copy_data_fun, data, timeout);
 107   }
 108 }
 109
 110 /**
 111  * @ingroup simix_comm_management
 112  */
 113 simgrid::kernel::activity::ActivityImplPtr
 114 simcall_comm_isend(smx_actor_t sender, smx_mailbox_t mbox, double task_size, double rate, void* src_buff,
 115                    size_t src_buff_size, bool (*match_fun)(void*, void*, simgrid::kernel::activity::CommImpl*),
 116                    void (*clean_fun)(void*), void (*copy_data_fun)(simgrid::kernel::activity::CommImpl*, void*, size_t),
 117                    void* data, bool detached)
 118 {
 119   /* checking for infinite values */
 120   xbt_assert(std::isfinite(task_size), "task_size is not finite!");
 121   xbt_assert(std::isfinite(rate), "rate is not finite!");
 122
 123   xbt_assert(mbox, "No rendez-vous point defined for isend");
 124
 125   return simcall_BODY_comm_isend(sender, mbox, task_size, rate, static_cast<unsigned char*>(src_buff), src_buff_size,
 126                                  match_fun, clean_fun, copy_data_fun, data, detached);
 127 }
 128
 129 /**
 130  * @ingroup simix_comm_management
 131  */
 132 void simcall_comm_recv(smx_actor_t receiver, smx_mailbox_t mbox, void* dst_buff, size_t* dst_buff_size,
 133                        bool (*match_fun)(void*, void*, simgrid::kernel::activity::CommImpl*),
 134                        void (*copy_data_fun)(simgrid::kernel::activity::CommImpl*, void*, size_t), void* data,
 135                        double timeout, double rate)
 136 {
 137   xbt_assert(std::isfinite(timeout), "timeout is not finite!");
 138   xbt_assert(mbox, "No rendez-vous point defined for recv");
 139
 140   if (MC_is_active() || MC_record_replay_is_active()) {
 141     /* the model-checker wants two separate simcalls */
 142     simgrid::kernel::activity::ActivityImplPtr comm =
 143         nullptr; /* MC needs the comm to be set to nullptr during the simcall */
 144     comm = simcall_comm_irecv(receiver, mbox, dst_buff, dst_buff_size,
 145                               match_fun, copy_data_fun, data, rate);
 146     simcall_comm_wait(comm.get(), timeout);
 147     comm = nullptr;
 148   }
 149   else {
 150     simcall_BODY_comm_recv(receiver, mbox, static_cast<unsigned char*>(dst_buff), dst_buff_size, match_fun,
 151                            copy_data_fun, data, timeout, rate);
 152   }
 153 }
 154 /**
 155  * @ingroup simix_comm_management
 156  */
 157 simgrid::kernel::activity::ActivityImplPtr
 158 simcall_comm_irecv(smx_actor_t receiver, smx_mailbox_t mbox, void* dst_buff, size_t* dst_buff_size,
 159                    bool (*match_fun)(void*, void*, simgrid::kernel::activity::CommImpl*),
 160                    void (*copy_data_fun)(simgrid::kernel::activity::CommImpl*, void*, size_t), void* data, double rate)
 161 {
 162   xbt_assert(mbox, "No rendez-vous point defined for irecv");
 163
 164   return simcall_BODY_comm_irecv(receiver, mbox, static_cast<unsigned char*>(dst_buff), dst_buff_size, match_fun,
 165                                  copy_data_fun, data, rate);
 166 }
 167
 168 /**
 169  * @ingroup simix_comm_management
 170  */
 171 simgrid::kernel::activity::ActivityImplPtr
 172 simcall_comm_iprobe(smx_mailbox_t mbox, int type, bool (*match_fun)(void*, void*, simgrid::kernel::activity::CommImpl*),
 173                     void* data) // XBT_ATTRIB_DEPRECATED_v330
 174 {
 175   xbt_assert(mbox, "No rendez-vous point defined for iprobe");
 176
 177   return simgrid::kernel::actor::simcall([mbox, type, match_fun, data] { return mbox->iprobe(type, match_fun, data); });
 178 }
 179
 180 /**
 181  * @ingroup simix_comm_management
 182  */
 183 unsigned int simcall_comm_waitany(simgrid::kernel::activity::ActivityImplPtr comms[], size_t count,
 184                                   double timeout) // XBT_ATTRIB_DEPRECATED_v330
 185 {
 186   std::vector<simgrid::kernel::activity::CommImpl*> rcomms(count);
 187   std::transform(comms, comms + count, begin(rcomms), [](const simgrid::kernel::activity::ActivityImplPtr& comm) {
 188     return static_cast<simgrid::kernel::activity::CommImpl*>(comm.get());
 189   });
 190   return simcall_BODY_comm_waitany(rcomms.data(), rcomms.size(), timeout);
 191 }
 192
 193 unsigned int simcall_comm_waitany(simgrid::kernel::activity::CommImpl* comms[], size_t count, double timeout)
 194 {
 195   return simcall_BODY_comm_waitany(comms, count, timeout);
 196 }
 197
 198 /**
 199  * @ingroup simix_comm_management
 200  */
 201 int simcall_comm_testany(simgrid::kernel::activity::ActivityImplPtr comms[], size_t count) // XBT_ATTRIB_DEPRECATED_v330
 202 {
 203   if (count == 0)
 204     return -1;
 205   std::vector<simgrid::kernel::activity::CommImpl*> rcomms(count);
 206   std::transform(comms, comms + count, begin(rcomms), [](const simgrid::kernel::activity::ActivityImplPtr& comm) {
 207     return static_cast<simgrid::kernel::activity::CommImpl*>(comm.get());
 208   });
 209   return simcall_BODY_comm_testany(rcomms.data(), rcomms.size());
 210 }
 211
 212 int simcall_comm_testany(simgrid::kernel::activity::CommImpl* comms[], size_t count)
 213 {
 214   if (count == 0)
 215     return -1;
 216   return simcall_BODY_comm_testany(comms, count);
 217 }
 218
 219 /**
 220  * @ingroup simix_comm_management
 221  */
 222 void simcall_comm_wait(simgrid::kernel::activity::ActivityImpl* comm, double timeout)
 223 {
 224   xbt_assert(std::isfinite(timeout), "timeout is not finite!");
 225   simcall_BODY_comm_wait(static_cast<simgrid::kernel::activity::CommImpl*>(comm), timeout);
 226 }
 227
 228 /**
 229  * @ingroup simix_comm_management
 230  *
 231  */
 232 bool simcall_comm_test(simgrid::kernel::activity::ActivityImpl* comm)
 233 {
 234   return simcall_BODY_comm_test(static_cast<simgrid::kernel::activity::CommImpl*>(comm));
 235 }
 236
 237 /**
 238  * @ingroup simix_synchro_management
 239  *
 240  */
 241 smx_mutex_t simcall_mutex_init() // XBT_ATTRIB_DEPRECATED_v330
 242 {
 243   if (simix_global == nullptr) {
 244     fprintf(stderr, "You must initialize the SimGrid engine before using it\n"); // We can't use xbt_die since we may
 245                                                                                  // get there before the initialization
 246     xbt_abort();
 247   }
 248   return simgrid::kernel::actor::simcall([] { return new simgrid::kernel::activity::MutexImpl(); });
 249 }
 250
 251 /**
 252  * @ingroup simix_synchro_management
 253  *
 254  */
 255 void simcall_mutex_lock(smx_mutex_t mutex) // XBT_ATTRIB_DEPRECATD_v331
 256 {
 257   mutex->mutex().lock();
 258 }
 259
 260 /**
 261  * @ingroup simix_synchro_management
 262  *
 263  */
 264 int simcall_mutex_trylock(smx_mutex_t mutex) // XBT_ATTRIB_DEPRECATD_v331
 265 {
 266   return mutex->mutex().try_lock();
 267 }
 268
 269 /**
 270  * @ingroup simix_synchro_management
 271  *
 272  */
 273 void simcall_mutex_unlock(smx_mutex_t mutex) // XBT_ATTRIB_DEPRECATD_v331
 274 {
 275   mutex->mutex().unlock();
 276 }
 277
 278 /**
 279  * @ingroup simix_synchro_management
 280  *
 281  */
 282 smx_cond_t simcall_cond_init() // XBT_ATTRIB_DEPRECATED_v330
 283 {
 284   return simgrid::kernel::actor::simcall([] { return new simgrid::kernel::activity::ConditionVariableImpl(); });
 285 }
 286
 287 /**
 288  * @ingroup simix_synchro_management
 289  *
 290  */
 291 void simcall_cond_wait(smx_cond_t cond, smx_mutex_t mutex) // XBT_ATTRIB_DEPRECATED_v331
 292 {
 293   cond->get_iface()->wait(std::unique_lock<simgrid::s4u::Mutex>(mutex->mutex()));
 294 }
 295
 296 /**
 297  * @ingroup simix_synchro_management
 298  *
 299  */
 300 int simcall_cond_wait_timeout(smx_cond_t cond, smx_mutex_t mutex, double timeout) // XBT_ATTRIB_DEPRECATD_v331
 301 {
 302   return cond->get_iface()->wait_for(std::unique_lock<simgrid::s4u::Mutex>(mutex->mutex()), timeout) ==
 303          std::cv_status::timeout;
 304 }
 305
 306 /**
 307  * @ingroup simix_synchro_management
 308  *
 309  */
 310 void simcall_sem_acquire(smx_sem_t sem) // XBT_ATTRIB_DEPRECATD_v331
 311 {
 312   return sem->sem().acquire();
 313 }
 314
 315 /**
 316  * @ingroup simix_synchro_management
 317  *
 318  */
 319 int simcall_sem_acquire_timeout(smx_sem_t sem, double timeout) // XBT_ATTRIB_DEPRECATD_v331
 320 {
 321   return sem->sem().acquire_timeout(timeout);
 322 }
 323
 324 simgrid::kernel::activity::State simcall_io_wait(simgrid::kernel::activity::ActivityImpl* io,
 325                                                  double timeout) // XBT_ATTRIB_DEPRECATED_v330
 326 {
 327   simgrid::kernel::actor::ActorImpl* issuer = simgrid::kernel::actor::ActorImpl::self();
 328   simgrid::kernel::actor::simcall_blocking([io, issuer, timeout] { io->wait_for(issuer, timeout); });
 329   return simgrid::kernel::activity::State::DONE;
 330 }
 331
 332 simgrid::kernel::activity::State simcall_io_wait(const simgrid::kernel::activity::ActivityImplPtr& io,
 333                                                  double timeout) // XBT_ATTRIB_DEPRECATED_v330
 334 {
 335   simgrid::kernel::actor::ActorImpl* issuer = simgrid::kernel::actor::ActorImpl::self();
 336   simgrid::kernel::actor::simcall_blocking([io, issuer, timeout] { io->wait_for(issuer, timeout); });
 337   return simgrid::kernel::activity::State::DONE;
 338 }
 339
 340 bool simcall_io_test(simgrid::kernel::activity::ActivityImpl* io) // XBT_ATTRIB_DEPRECATED_v330
 341 {
 342   return simgrid::kernel::actor::simcall([io] { return io->test(); });
 343 }
 344
 345 bool simcall_io_test(const simgrid::kernel::activity::ActivityImplPtr& io) // XBT_ATTRIB_DEPRECATD_v330
 346 {
 347   return simgrid::kernel::actor::simcall([io] { return io->test(); });
 348 }
 349
 350 void simcall_run_kernel(std::function<void()> const& code, simgrid::kernel::actor::SimcallObserver* observer)
 351 {
 352   simgrid::kernel::actor::ActorImpl::self()->simcall_.observer_ = observer;
 353   simcall_BODY_run_kernel(&code);
 354   simgrid::kernel::actor::ActorImpl::self()->simcall_.observer_ = nullptr;
 355 }
 356
 357 void simcall_run_blocking(std::function<void()> const& code, simgrid::kernel::actor::SimcallObserver* observer)
 358 {
 359   simgrid::kernel::actor::ActorImpl::self()->simcall_.observer_ = observer;
 360   simcall_BODY_run_blocking(&code);
 361   simgrid::kernel::actor::ActorImpl::self()->simcall_.observer_ = nullptr;
 362 }
 363
 364 int simcall_mc_random(int min, int max) // XBT_ATTRIB_DEPRECATD_v331
 365 {
 366   return MC_random(min, max);
 367 }
 368
 369 /* ************************************************************************** */
 370
 371 /** @brief returns a printable string representing a simcall */
 372 const char* SIMIX_simcall_name(Simcall kind)
 373 {
 374   return simcall_names[static_cast<int>(kind)];
 375 }
 376
 377 namespace simgrid {
 378 namespace simix {
 379
 380 void unblock(smx_actor_t actor)
 381 {
 382   xbt_assert(SIMIX_is_maestro());
 383   actor->simcall_answer();
 384 }
 385 } // namespace simix
 386 } // namespace simgrid