ompMacros.hpp

#ifndef DM_OMP_MACROS_HPP_INCLUDED
#define DM_OMP_MACROS_HPP_INCLUDED

#pragma once

//openMP
#include <omp.h>

//boost
#include <boost/throw_exception.hpp>
#include <boost/exception/exception.hpp>
#include <boost/exception_ptr.hpp>
#include <boost/preprocessor/seq/for_each.hpp>

#include "config.hpp"

// Exception handling is not straight forward in multi-thread applications.
// Use the following macros to transport the first thrown exception from within an OpenMP loop to the main thread.
//
// example:
//
//  #define EXCEPTION_SEQUENCE (exception_class1) (exception_class2)  [...]
//
//  DM_OMP_OUTSIDE_LOOP_PREFIX
//
//  #pragma omp parallel for
//  for(int i=0; i<1000; i++)
//  {
//    DM_OMP_INSIDE_LOOP_PREFIX
//
//    //loop code
//                                                   /* optionally, replace do_nothing with your own function */
//    DM_OMP_INSIDE_LOOP_SUFFIX( EXCEPTION_SEQUENCE, DM::OpenMP::do_nothing )
//  }
//
//  DM_OMP_OUTSIDE_LOOP_SUFFIX(EXCEPTION_SEQUENCE)
//


#define DM_OMP_OUTSIDE_LOOP_PREFIX  \
  ::boost::exception_ptr omp_error; \
  ::omp_lock_t omp_lock;            \
  ::omp_init_lock(&omp_lock);       \


#define DM_OMP_HAS_EXCEPTION_OCCURED() \
  DM::OpenMP::has_exception_occured(omp_lock,omp_error) \

#define DM_OMP_INSIDE_LOOP_PREFIX  \
try                                \
{                                  \
  ::omp_set_lock(&omp_lock);       \
  bool occured = omp_error;        \
  ::omp_unset_lock(&omp_lock);     \
  if( occured )                    \
    continue;                      \
  try                              \
  {                                \


#define DM_OMP_CATCH_BLOCK(r, FUNCTION, EXCEPTION)                            \
  catch(const EXCEPTION &exc)                                                 \
  {                                                                           \
    FUNCTION(exc);                                                            \
    throw ::boost::enable_current_exception(::boost::enable_error_info(exc)); \
  }                                                                           \


#define DM_OMP_INSIDE_LOOP_SUFFIX(EXCEPTION_SEQUENCE, FUNCTION)             \
  }                                                                         \
  BOOST_PP_SEQ_FOR_EACH( DM_OMP_CATCH_BLOCK, FUNCTION, EXCEPTION_SEQUENCE ) \
  catch (...)                                                               \
  {                                                                         \
    FUNCTION();                                                             \
    ::boost::throw_exception( ::std::exception() );                         \
  }                                                                         \
}                                                                           \
catch( ... )                                                                \
{                                                                           \
  ::omp_set_lock(&omp_lock);                                                \
  if(!omp_error)                                                            \
    omp_error = ::boost::current_exception();                               \
  ::omp_unset_lock(&omp_lock);                                              \
}                                                                           \


#define DM_OMP_OUTSIDE_LOOP_SUFFIX(EXCEPTION_SEQUENCE)           \
  ::omp_destroy_lock(&omp_lock);                                 \
  if( omp_error )                                                \
    ::boost::rethrow_exception(omp_error);                       \

DM_NAMESPACE_BEGIN

namespace OpenMP
{
  template<typename ExceptionT>
  inline void do_nothing(ExceptionT &e)  {}
  inline void do_nothing()               {}

  inline bool has_exception_occured(::omp_lock_t &omp_lock, ::boost::exception_ptr &omp_error) {
    ::omp_set_lock(&omp_lock);       
    bool occured = omp_error;      
    ::omp_unset_lock(&omp_lock);     
    return occured;
  }

}

DM_NAMESPACE_END

#endif //DM_OMP_MACROS_HPP_INCLUDED