threadManager_OpenMP.cpp

Go to the documentation of this file.

#include "threadManager_OpenMP.h"

#include <omp.h>

#include "communicator.h"
#include "bridgeIO.h"
using Bridge::vout;

//====================================================================
// initialization of static member variables.

int ThreadManager_OpenMP::m_Nthread             = 0;
Bridge::VerboseLevel ThreadManager_OpenMP::m_vl = Bridge::CRUCIAL;
valarray<double>     ThreadManager_OpenMP::m_darray_reduction(0);

const std::string ThreadManager_OpenMP::class_name = "ThreadManager_OpenMP";

//====================================================================
void ThreadManager_OpenMP::init(int nthread)
{
  m_vl = CommonParameters::Vlevel();

  vout.general(m_vl, "%s: initialization\n", class_name.c_str());

  int nthread_env = 0;

#pragma omp parallel
  {
    if (omp_get_thread_num() == 0) {
      nthread_env = omp_get_num_threads();
    }
  }


  if ((nthread == nthread_env) || (nthread == 0)) {
    m_Nthread = nthread_env;
  } else {
    vout.general(m_vl, "  Number of threads(env)   = %d\n", nthread_env);
    vout.general(m_vl, "  Number of threads(input) = %d\n", nthread);
    vout.general(m_vl, "  resetting Number of threads.\n");
    omp_set_num_threads(nthread);
    m_Nthread = nthread;
  }

  vout.general(m_vl, "  Number of thread = %d\n", m_Nthread);

  m_darray_reduction.resize(m_Nthread);
}


//====================================================================
void ThreadManager_OpenMP::finalize()
{
  vout.paranoiac(m_vl, "%s: finalize.\n", class_name.c_str());
}


//====================================================================
int ThreadManager_OpenMP::get_num_threads()
{
  return omp_get_num_threads();
}


//====================================================================
int ThreadManager_OpenMP::get_thread_id()
{
  return omp_get_thread_num();
}


//====================================================================
void ThreadManager_OpenMP::wait()
{
  int nth = get_num_threads();

  barrier(nth);
}


//====================================================================
void ThreadManager_OpenMP::barrier(int nth)
{
#pragma omp barrier
}


//====================================================================
void ThreadManager_OpenMP::sync_barrier_all()
{
#pragma omp barrier

#pragma omp master
  {
    Communicator::sync();
  }

#pragma omp barrier
}


//====================================================================
void ThreadManager_OpenMP::reduce_sum_global(double& a,
                                             const int ith, const int nth)
{
  m_darray_reduction[ith] = a;
  barrier(nth);
#pragma omp barrier
  // #pragma omp flush (m_darray_reduction)

#pragma omp master
  {
    double b = 0.0;

#pragma omp flush (m_darray_reduction)
    for (int i = 0; i < nth; ++i) {
      b += m_darray_reduction[i];
    }
    // m_darray_reduction[0] = Communicator::reduce_sum(b);
    b = Communicator::reduce_sum(b);

#pragma omp flush (m_darray_reduction)
    m_darray_reduction[0] = b;
    // #pragma omp flush (m_darray_reduction)
  }

  //  barrier(nth);
#pragma omp barrier

  // #pragma omp flush (m_darray_reduction)
  a = m_darray_reduction[0];

#pragma omp barrier
}


//====================================================================
void ThreadManager_OpenMP::assert_single_thread(const std::string& name)
{
  int nth = get_num_threads();

  if (nth != 1) {
#pragma omp master
    {
      vout.crucial(m_vl, "\n");
      vout.crucial(m_vl, "##### Caution #####\n");
      vout.crucial(m_vl, "Single-thread %s is called in parallel region.\n", name.c_str());
      vout.crucial(m_vl, "Current number of thread = %d.\n", nth);
    }
#pragma omp barrier

    abort();
  }
}


//====================================================================
//============================================================END=====