openmp.h

Go to the documentation of this file.

//
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// Copyright (C) 2020 - 2023 by the ryujin authors
//
 
#pragma once
 
#include <compile_time_options.h>
 
#include <deal.II/base/config.h>
 
#ifdef WITH_OPENMP
#include <omp.h>
#endif
 
#include <atomic>
#include <future>
 
 
#define RYUJIN_PRAGMA(x) _Pragma(#x)
 
#define RYUJIN_PARALLEL_REGION_BEGIN                                           \
  RYUJIN_PRAGMA(omp parallel default(shared))                                  \
  {
 
#define RYUJIN_PARALLEL_REGION_END }
 
#define RYUJIN_OMP_FOR RYUJIN_PRAGMA(omp for)
 
#define RYUJIN_OMP_FOR_NOWAIT RYUJIN_PRAGMA(omp for nowait)
 
#define RYUJIN_OMP_BARRIER RYUJIN_PRAGMA(omp barrier)
 
#define RYUJIN_OMP_CRITICAL RYUJIN_PRAGMA(omp critical)
 
#define RYUJIN_OMP_SINGLE RYUJIN_PRAGMA(omp single)
 
#define RYUJIN_LIKELY(x) (__builtin_expect(!!(x), 1))
 
#define RYUJIN_UNLIKELY(x) (__builtin_expect(!!(x), 0))
 
namespace ryujin
{
  class SynchronizationDispatch
  {
  public:
    SynchronizationDispatch(const std::function<void()> &async_payload)
        : async_payload_(async_payload)
        , n_threads_ready_(0)
    {
    }
 
    ~SynchronizationDispatch()
    {
      /* Executes in serial, non thread-parallel context: */
 
      if (payload_status_.valid()) {
        payload_status_.wait();
      } else {
        async_payload_();
      }
    }
 
#ifdef ASYNC_MPI_EXCHANGE
    DEAL_II_ALWAYS_INLINE inline void check(bool &thread_ready,
                                            const bool condition)
    {
      /* Executes in concurrent, thread-parallel context: */
      if (RYUJIN_UNLIKELY(thread_ready == false && condition)) {
        thread_ready = true;
#ifdef WITH_OPENMP
        if (++n_threads_ready_ == omp_get_num_threads())
#endif
          payload_status_ = std::async(std::launch::async, async_payload_);
      }
    }
#else
    DEAL_II_ALWAYS_INLINE inline void check(bool &, const bool) {}
#endif
 
  private:
    const std::function<void()> async_payload_;
    std::future<void> payload_status_;
    std::atomic_int n_threads_ready_;
  };
} // namespace ryujin