barrier.hh

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright © DUNE Project contributors, see file AUTHORS.md
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception OR LGPL-3.0-or-later
 
#ifndef DUNE_ASSEMBLER_PARALLEL_BARRIER_HH
#define DUNE_ASSEMBLER_PARALLEL_BARRIER_HH
 
#include <condition_variable>
#include <cstddef>
#include <mutex>
 
namespace Dune::Assembler::Experimental {
 
 
class Barrier {
public:
 
  Barrier (std::size_t count)
    : safedCount_(count)
    , waitingForCount_(count)
    , currentPhase_(0)
  {}
 
  void arrive_and_wait ()
  {
    // Acquire lock for writing to shared counter waitingForCount_.
    auto lock = std::unique_lock(mutex_);
    --waitingForCount_;
    if (waitingForCount_ != 0)
    {
      // If we're not the last thread to arrive:
      // Wait until all thread have been notified by the last one.
      // To avoid lost or spurious wake-ups one should always use
      // a condition. Notice that we deliberately check b-a <= 0
      // instead of b<=a. In the (unlikely) case of an overflow b
      // becomes negative such that b<=a evaluates to true even
      // if a was not incremented. In contrast, b-a will correctly
      // be computed as 1 or 0 since two overflow events cancel out.
      auto myPhase = currentPhase_+1;
      cv_.wait(lock, [&] { return myPhase - currentPhase_ <= 0; });
    }
    else
    {
      // If we're the last thread to arrive:
      // Reset counter, proceed to next phase to provide a checkable condition
      // for the other threads and notify them that we're done.
      waitingForCount_ = safedCount_;
      ++currentPhase_;
      cv_.notify_all();
    }
  }
 
private:
  std::mutex mutex_;
  std::condition_variable cv_;
  std::size_t safedCount_;
  std::ptrdiff_t waitingForCount_;
  std::ptrdiff_t currentPhase_;
};
 
 
 
 
} // end namespace Dune::Assembler::Experimental
 
#endif // DUNE_ASSEMBLER_PARALLEL_BARRIER_HH