src/s4u/s4u_Barrier.cpp

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