Homec4science
Diffusion Poisson code for introduction to parallelism (implementation/c++) Browse

rSCINTROPARALLEL/grid.hh
aa5131b29e15implementation/c++

Last Change
Raw File

grid.hh
View Options

#ifndef GRID_HH
#define GRID_HH
/* -------------------------------------------------------------------------- */
#include <array>
#include <vector>
#if defined(_MPI)
#include <mpi.h>
#endif
#if defined(_OPENMP)
#include <omp.h>
#endif
#if defined(_DEBUG)
#include <iostream>
#endif
/* -------------------------------------------------------------------------- */
namespace {
#if not defined(_DEBUG)
std::size_t thread_id() __attribute__((unused));
std::size_t nb_threads() __attribute__((unused));
#endif
std::size_t thread_id() {
#if defined(_OPENMP)
return omp_get_thread_num();
#else
return 0;
#endif
}
std::size_t nb_threads() {
#if defined(_OPENMP)
return omp_get_max_threads();
#else
return 1;
#endif
}
} // namespace
namespace {
struct DEBUG {
#if defined(_DEBUG)
static void print(const std::string & func) {
auto nthreads = nb_threads();
auto nthread = thread_id();
#pragma omp critical
std::cerr << nthread << "/" << nthreads << ": " << func << "\n";
}
#else
static void print(const std::string & /*func*/) {}
#endif
};
} // namespace
/* -------------------------------------------------------------------------- */
class Grid {
public:
Grid(int m = 0, int n = 0);
~Grid();
/// access the value [i][j] of the grid
inline float & operator()(int i, int j) { return m_storage[i * m_n + j]; }
inline const float & operator()(int i, int j) const {
return m_storage[i * m_n + j];
}
void resize(int m, int n);
/// set the grid to 0
void clear();
int m() const;
int n() const;
#if defined(_MPI)
void initializeHaloCommunications(MPI_Comm & m_communicator,
const std::array<int, 2> & ghosts);
void startSynchronization() {
MPI_Request * requests = m_requests.data();
#pragma omp task depend(in : requests [0:8])
{
DEBUG::print(__PRETTY_FUNCTION__);
MPI_Startall(8, requests);
}
}
void waitReceives() {
auto requests = m_requests.data();
#pragma omp task depend(out : requests [0:4])
{
DEBUG::print(__PRETTY_FUNCTION__);
MPI_Waitall(4, requests, MPI_STATUS_IGNORE);
}
}
void waitSends() {
auto requests = m_requests.data();
#pragma omp task depend(out : requests [4:4])
{
DEBUG::print(__PRETTY_FUNCTION__);
MPI_Waitall(4, requests + 4, MPI_STATUS_IGNORE);
}
}
#else
void startSynchronization() {
#pragma omp task
DEBUG::print(__PRETTY_FUNCTION__);
}
void waitReceives() {
#pragma omp task
DEBUG::print(__PRETTY_FUNCTION__);
}
void waitSends() {
#pragma omp task
DEBUG::print(__PRETTY_FUNCTION__);
}
#endif
private:
int m_m, m_n;
std::vector<float> m_storage;
#if defined(_MPI)
/// request for asynchronous communications
std::array<MPI_Request, 8> m_requests;
/// communication types
MPI_Datatype column_t, line_t;
#endif
};
#endif /* GRID_HH */
c4science · Help