src/s4u/s4u_Barrier.cpp

   1 /* Copyright (c) 2018-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 #include <simgrid/barrier.h>
   7 #include <simgrid/modelchecker.h>
   8 #include <simgrid/s4u/Barrier.hpp>
   9
  10 #include "src/kernel/activity/BarrierImpl.hpp"
  11 #include "src/kernel/actor/SynchroObserver.hpp"
  12 #include "src/mc/mc_replay.hpp"
  13
  14 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(s4u_barrier, s4u, "S4U barrier");
  15
  16 namespace simgrid::s4u {
  17
  18 /** @brief Create a new barrier
  19  *
  20  * See @ref s4u_raii.
  21  */
  22 BarrierPtr Barrier::create(unsigned int expected_actors)
  23 {
  24   auto* res = new kernel::activity::BarrierImpl(expected_actors);
  25   return BarrierPtr(&res->piface_, false);
  26 }
  27
  28 /** @brief Block the current actor until all expected actors reach the barrier.
  29  *
  30  * This method is meant to be somewhat consistent with the pthread_barrier_wait function.
  31  *
  32  * @return false for all actors but one: exactly one actor will get true as a return value.
  33  */
  34 int Barrier::wait()
  35 {
  36   kernel::actor::ActorImpl* issuer = kernel::actor::ActorImpl::self();
  37
  38   if (MC_is_active() || MC_record_replay_is_active()) { // Split in 2 simcalls for transition persistency
  39     kernel::actor::BarrierObserver lock_observer{issuer, mc::Transition::Type::BARRIER_ASYNC_LOCK, pimpl_};
  40     auto acquisition =
  41         kernel::actor::simcall_answered([issuer, this] { return pimpl_->acquire_async(issuer); }, &lock_observer);
  42
  43     kernel::actor::BarrierObserver wait_observer{issuer, mc::Transition::Type::BARRIER_WAIT, acquisition.get()};
  44     return kernel::actor::simcall_blocking([issuer, acquisition] { acquisition->wait_for(issuer, -1); },
  45                                            &wait_observer);
  46
  47   } else { // Do it in one simcall only
  48     kernel::activity::BarrierAcquisitionImpl* acqui = nullptr; // unused here, but must be typed to pick the right ctor
  49     kernel::actor::BarrierObserver observer{issuer, mc::Transition::Type::BARRIER_WAIT, acqui};
  50     return kernel::actor::simcall_blocking([issuer, this] { pimpl_->acquire_async(issuer)->wait_for(issuer, -1); },
  51                                            &observer);
  52   }
  53 }
  54
  55 std::string Barrier::to_string() const
  56 {
  57   return pimpl_->to_string();
  58 }
  59
  60 void intrusive_ptr_add_ref(Barrier* barrier)
  61 {
  62   intrusive_ptr_add_ref(barrier->pimpl_);
  63 }
  64
  65 void intrusive_ptr_release(Barrier* barrier)
  66 {
  67   intrusive_ptr_release(barrier->pimpl_);
  68 }
  69 } // namespace simgrid::s4u
  70
  71 /* **************************** Public C interface *************************** */
  72
  73 sg_bar_t sg_barrier_init(unsigned int count)
  74 {
  75   simgrid::s4u::BarrierPtr bar = simgrid::s4u::Barrier::create(count);
  76   intrusive_ptr_add_ref(bar.get());
  77   return bar.get();
  78 }
  79
  80 /** @brief Initializes a barrier, with count elements */
  81 void sg_barrier_destroy(sg_bar_t bar)
  82 {
  83   intrusive_ptr_release(bar);
  84 }
  85
  86 /** @brief Performs a barrier already initialized.
  87  *
  88  * @return 0 for all actors but one: exactly one actor will get SG_BARRIER_SERIAL_THREAD as a return value. */
  89 int sg_barrier_wait(sg_bar_t bar)
  90 {
  91   if (bar->wait())
  92     return SG_BARRIER_SERIAL_THREAD;
  93   return 0;
  94 }