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