MultiThreaded.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
#pragma once
 
#include <atomic>
#include <mutex>
 
namespace Mantid {
namespace Kernel {
 
template <typename Arg>
inline typename std::enable_if<std::is_pointer<Arg>::value, bool>::type threadSafe(Arg workspace) {
  return !workspace || workspace->threadSafe();
}
 
template <typename Arg, typename... Args>
inline typename std::enable_if<std::is_pointer<Arg>::value, bool>::type threadSafe(Arg workspace, Args &&...others) {
  return (!workspace || workspace->threadSafe()) && threadSafe(std::forward<Args>(others)...);
}
 
template <typename Arg>
inline typename std::enable_if<!std::is_pointer<Arg>::value, bool>::type threadSafe(const Arg &workspace) {
  return workspace.threadSafe();
}
 
template <typename Arg, typename... Args>
inline typename std::enable_if<!std::is_pointer<Arg>::value, bool>::type threadSafe(const Arg &workspace,
                                                                                    Args &&...others) {
  return workspace.threadSafe() && threadSafe(std::forward<Args>(others)...);
}
 
template <typename T, typename BinaryOp> void AtomicOp(std::atomic<T> &f, T d, BinaryOp op) {
  T old = f.load();
  T desired;
  do {
    desired = op(old, d);
  } while (!f.compare_exchange_weak(old, desired));
}
 
} // namespace Kernel
} // namespace Mantid
 
// The syntax used to define a pragma within a macro is different on windows and
// GCC
#ifdef _MSC_VER
#define PRAGMA __pragma
#define PARALLEL_SET_CONFIG_THREADS
#else //_MSC_VER
#define PRAGMA(x) _Pragma(#x)
#define PARALLEL_SET_CONFIG_THREADS                                                                                    \
  setMaxCoresToConfig();                                                                                               \
  PARALLEL_SET_DYNAMIC(false);
#endif //_MSC_VER
 
#define PARALLEL_START_INTERRUPT_REGION                                                                                \
  if (!m_parallelException && !m_cancel) {                                                                             \
    try {
 
#define PARALLEL_END_INTERRUPT_REGION                                                                                  \
  } /* End of try block in PARALLEL_START_INTERRUPT_REGION */                                                          \
  catch (std::exception & ex) {                                                                                        \
    if (!m_parallelException) {                                                                                        \
      m_parallelException = true;                                                                                      \
      g_log.error() << this->name() << ": " << ex.what() << "\n";                                                      \
    }                                                                                                                  \
  }                                                                                                                    \
  catch (...) {                                                                                                        \
    m_parallelException = true;                                                                                        \
  }                                                                                                                    \
  } // End of if block in PARALLEL_START_INTERRUPT_REGION
 
#define PARALLEL_CHECK_INTERRUPT_REGION                                                                                \
  if (m_parallelException) {                                                                                           \
    g_log.debug("Exception thrown in parallel region");                                                                \
    throw std::runtime_error(this->name() + ": error (see log)");                                                      \
  }                                                                                                                    \
  interruption_point();
 
// _OPENMP is automatically defined if openMP support is enabled in the
// compiler.
#ifdef _OPENMP
 
#include "MantidKernel/ConfigService.h"
#include <omp.h>
 
#define PARALLEL_FOR_IF(condition)                                                                                     \
  PARALLEL_SET_CONFIG_THREADS                                                                                          \
  PRAGMA(omp parallel for if (condition) )
 
#define PARALLEL_FOR_NO_WSP_CHECK()                                                                                    \
  PARALLEL_SET_CONFIG_THREADS                                                                                          \
  PRAGMA(omp parallel for)
 
#define PARALLEL_FOR_NOWS_CHECK_FIRSTPRIVATE(variable)                                                                 \
  PARALLEL_SET_CONFIG_THREADS                                                                                          \
  PRAGMA(omp parallel for firstprivate(variable) )
 
#define PARALLEL_FOR_NO_WSP_CHECK_FIRSTPRIVATE2(variable1, variable2)                                                  \
  PARALLEL_SET_CONFIG_THREADS                                                                                          \
  PRAGMA(omp parallel for firstprivate(variable1, variable2) )
 
#define IF_PARALLEL if (omp_get_num_threads() > 1)
 
#define IF_NOT_PARALLEL if (omp_get_num_threads() == 1)
 
#define PARALLEL_CRITICAL(name) PRAGMA(omp critical(name))
 
#define PARALLEL_ATOMIC PRAGMA(omp atomic)
 
#define PARALLEL_SET_NUM_THREADS(MaxCores) omp_set_num_threads(MaxCores);
 
#define PARALLEL_SET_DYNAMIC(val) omp_set_dynamic(val)
 
#define PARALLEL_NUMBER_OF_THREADS omp_get_num_threads()
 
#define PARALLEL_GET_MAX_THREADS omp_get_max_threads()
 
#define PARALLEL_THREAD_NUMBER omp_get_thread_num()
 
#define PARALLEL PRAGMA(omp parallel)
 
#define PARALLEL_SECTIONS PRAGMA(omp sections nowait)
 
#define PARALLEL_SECTION PRAGMA(omp section)
 
inline void setMaxCoresToConfig() {
  const auto maxCores = Mantid::Kernel::ConfigService::Instance().getValue<int>("MultiThreaded.MaxCores");
  if (maxCores.get_value_or(0) > 0) {
    PARALLEL_SET_NUM_THREADS(maxCores.get());
  }
}
 
#define PRAGMA_OMP(expression) PRAGMA(omp expression)
 
#else //_OPENMP
 
#define PARALLEL_FOR_IF(condition)
#define PARALLEL_FOR_NO_WSP_CHECK()
#define PARALLEL_FOR_NOWS_CHECK_FIRSTPRIVATE(variable)
#define PARALLEL_FOR_NO_WSP_CHECK_FIRSTPRIVATE2(variable1, variable2)
#define IF_PARALLEL if (false)
#define IF_NOT_PARALLEL
#define PARALLEL_CRITICAL(name)
#define PARALLEL_ATOMIC
#define PARALLEL_THREAD_NUMBER 0
#define PARALLEL_SET_NUM_THREADS(MaxCores)
#define PARALLEL_SET_DYNAMIC(val)
#define PARALLEL_NUMBER_OF_THREADS 1
#define PARALLEL_GET_MAX_THREADS 1
#define PARALLEL
#define PARALLEL_SECTIONS
#define PARALLEL_SECTION
#define PRAGMA_OMP(expression)
#endif //_OPENMP