heffte_utils.h

/*
    -- heFFTe --
       Univ. of Tennessee, Knoxville
       @date
*/
 
#ifndef HEFFTE_UTILS_H
#define HEFFTE_UTILS_H
 
#include <algorithm>
#include <vector>
#include <complex>
#include <memory>
#include <numeric>
#include <algorithm>
#include <functional>
#include <cassert>
#include <utility>
#include <iostream>
#include <ostream>
#include <iomanip>
#include <string>
#include <deque>
#include <fstream>
#include <mpi.h>
 
#include "heffte_config.h"
 
namespace heffte {
 
template<class T, class U = T>
T c11_exchange(T& obj, U&& new_value)
{
    T old_value = std::move(obj);
    obj = std::forward<U>(new_value);
    return old_value;
}
 
namespace mpi {
 
inline int comm_rank(MPI_Comm const comm){
    int me;
    MPI_Comm_rank(comm, &me);
    return me;
}
inline bool world_rank(int rank){ return (comm_rank(MPI_COMM_WORLD) == rank); }
inline int world_rank(){ return comm_rank(MPI_COMM_WORLD); }
 
template<typename vector_like>
void dump(int me, vector_like const &x, std::string const &message){
    if (me < 0 or world_rank(me)){
        std::cout << message << "\n";
        for(auto i : x) std::cout << i << "  ";
        std::cout << std::endl;
    }
}
 
inline int comm_size(MPI_Comm const comm){
    int nprocs;
    MPI_Comm_size(comm, &nprocs);
    return nprocs;
}
inline MPI_Comm new_comm_from_group(std::vector<int> const &ranks, MPI_Comm const comm){
    MPI_Group orig_group, new_group;
    MPI_Comm_group(comm, &orig_group);
    MPI_Group_incl(orig_group, (int) ranks.size(), ranks.data(), &new_group);
    MPI_Comm result;
    MPI_Comm_create(comm, new_group, &result);
    MPI_Group_free(&orig_group);
    MPI_Group_free(&new_group);
    return result;
}
 
inline void comm_free(MPI_Comm const comm){
    if (MPI_Comm_free(const_cast<MPI_Comm*>(&comm)) != MPI_SUCCESS)
        throw std::runtime_error("Could not free a communicator.");
}
 
template<typename scalar> inline MPI_Datatype type_from(){
    // note that "!std::is_same<scalar, scalar>::value" is always false,
    // but will not be checked until the template is instantiated
    static_assert(!std::is_same<scalar, scalar>::value, "The C++ type has unknown MPI equivalent.");
    return MPI_BYTE; // some compilers complain about lack of return statement.
}
template<> inline MPI_Datatype type_from<int>(){ return MPI_INT; }
template<> inline MPI_Datatype type_from<float>(){ return MPI_FLOAT; }
template<> inline MPI_Datatype type_from<double>(){ return MPI_DOUBLE; }
template<> inline MPI_Datatype type_from<std::complex<float>>(){ return MPI_C_COMPLEX; }
template<> inline MPI_Datatype type_from<std::complex<double>>(){ return MPI_C_DOUBLE_COMPLEX; }
 
}
 
template<typename scalar_type> struct is_ccomplex : std::false_type{};
template<typename scalar_type> struct is_zcomplex : std::false_type{};
 
template<> struct is_ccomplex<std::complex<float>> : std::true_type{};
template<> struct is_zcomplex<std::complex<double>> : std::true_type{};
 
template<typename, typename = void> struct define_standard_type{};
 
template<> struct define_standard_type<float, void>{
    using type = float;
};
template<> struct define_standard_type<double, void>{
    using type = double;
};
 
template<typename scalar_type> struct define_standard_type<scalar_type, typename std::enable_if<is_ccomplex<scalar_type>::value>::type>{
    using type =  std::complex<float>;
};
template<typename scalar_type> struct define_standard_type<scalar_type, typename std::enable_if<is_zcomplex<scalar_type>::value>::type>{
    using type =  std::complex<double>;
};
 
template<typename scalar_type>
typename define_standard_type<scalar_type>::type* convert_to_standard(scalar_type input[]){
    return reinterpret_cast<typename define_standard_type<scalar_type>::type*>(input);
}
template<typename scalar_type>
typename define_standard_type<scalar_type>::type const* convert_to_standard(scalar_type const input[]){
    return reinterpret_cast<typename define_standard_type<scalar_type>::type const*>(input);
}
 
template<typename some_class>
int get_last_active(std::array<std::unique_ptr<some_class>, 4> const &shaper){
    int last = -1;
    for(int i=0; i<4; i++) if (shaper[i]) last = i;
    return last;
}
 
template<typename some_class>
int count_active(std::array<std::unique_ptr<some_class>, 4> const &shaper){
    int num = 0;
    for(int i=0; i<4; i++) if (shaper[i]) num++;
    return num;
}
 
template<typename some_class>
size_t get_max_box_size(std::array<some_class, 3> const &executors){
    size_t max_size = (executors[0]) ? executors[0]->box_size() : 0;
    max_size = std::max(max_size, (executors[1]) ? executors[1]->box_size() : static_cast<size_t>(0));
    return std::max(max_size, (executors[2]) ? executors[2]->box_size() : static_cast<size_t>(0));
}
 
template<typename some_class>
size_t get_max_box_size_r2c(std::array<some_class, 3> const &executors){
    size_t max_size = (executors[0]) ? executors[0]->complex_size() : 0;
    max_size = std::max(max_size, (executors[1]) ? executors[1]->box_size() : static_cast<size_t>(0));
    return std::max(max_size, (executors[2]) ? executors[2]->box_size() : static_cast<size_t>(0));
}
template<typename some_class>
size_t get_max_work_size(std::array<some_class, 3> const &executors){
    size_t max_size = (executors[0]) ? executors[0]->workspace_size() : 0;
    max_size = std::max(max_size, (executors[1]) ? executors[1]->workspace_size() : static_cast<size_t>(0));
    return std::max(max_size, (executors[2]) ? executors[2]->workspace_size() : static_cast<size_t>(0));
}
 
template<typename some_class_r2c, typename some_class>
size_t get_max_work_size(some_class_r2c const &executors_r2c, std::array<some_class, 2> const &executors){
    return std::max(executors_r2c->workspace_size(), std::max(executors[0]->workspace_size(), executors[1]->workspace_size()));
}
 
}
 
#endif /* HEFFTE_UTILS_H */