mpi_utils.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// openCARP is an open cardiac electrophysiology simulator.
//
// Copyright (C) 2020 openCARP project
//
// This program is licensed under the openCARP Academic Public License (APL)
// v1.0: You can use and redistribute it and/or modify it in non-commercial
// academic environments under the terms of APL as published by the openCARP
// project v1.0, or (at your option) any later version. Commercial use requires
// a commercial license (info@opencarp.org).
//
// This program is distributed without any warranty; see the openCARP APL for
// more details.
//
// You should have received a copy of the openCARP APL along with this program
// and can find it online: http://www.opencarp.org/license
// ----------------------------------------------------------------------------
 
#ifndef _OPENCARP_MPI_UTILS_H
#define _OPENCARP_MPI_UTILS_H
 
#include <cassert>
#include <cstdint>
#include <limits>
#include <type_traits>
 
#include <mpi.h>
 
namespace opencarp {
 
namespace detail {
template<typename>
struct always_false : std::false_type {};
}
 
template<typename T> inline
MPI_Datatype mpi_datatype()
{
  using value_t = std::remove_cv_t<T>;
 
  if constexpr (std::is_same_v<value_t, char>) {
    return MPI_CHAR;
  }
#ifdef MPI_INT8_T
  else if constexpr (std::is_same_v<value_t, std::int8_t>) {
    return MPI_INT8_T;
  }
#endif
#ifdef MPI_UINT8_T
  else if constexpr (std::is_same_v<value_t, std::uint8_t>) {
    return MPI_UINT8_T;
  }
#endif
#ifdef MPI_INT16_T
  else if constexpr (std::is_same_v<value_t, std::int16_t>) {
    return MPI_INT16_T;
  }
#endif
#ifdef MPI_UINT16_T
  else if constexpr (std::is_same_v<value_t, std::uint16_t>) {
    return MPI_UINT16_T;
  }
#endif
#ifdef MPI_INT32_T
  else if constexpr (std::is_same_v<value_t, std::int32_t>) {
    return MPI_INT32_T;
  }
#endif
#ifdef MPI_UINT32_T
  else if constexpr (std::is_same_v<value_t, std::uint32_t>) {
    return MPI_UINT32_T;
  }
#endif
#ifdef MPI_INT64_T
  else if constexpr (std::is_same_v<value_t, std::int64_t>) {
    return MPI_INT64_T;
  }
#endif
#ifdef MPI_UINT64_T
  else if constexpr (std::is_same_v<value_t, std::uint64_t>) {
    return MPI_UINT64_T;
  }
#endif
  else if constexpr (std::is_same_v<value_t, signed char>) {
    return MPI_SIGNED_CHAR;
  }
  else if constexpr (std::is_same_v<value_t, unsigned char>) {
    return MPI_UNSIGNED_CHAR;
  }
  else if constexpr (std::is_same_v<value_t, short>) {
    return MPI_SHORT;
  }
  else if constexpr (std::is_same_v<value_t, unsigned short>) {
    return MPI_UNSIGNED_SHORT;
  }
  else if constexpr (std::is_same_v<value_t, int>) {
    return MPI_INT;
  }
  else if constexpr (std::is_same_v<value_t, unsigned int>) {
    return MPI_UNSIGNED;
  }
  else if constexpr (std::is_same_v<value_t, long>) {
    return MPI_LONG;
  }
  else if constexpr (std::is_same_v<value_t, unsigned long>) {
    return MPI_UNSIGNED_LONG;
  }
  else if constexpr (std::is_same_v<value_t, long long>) {
    return MPI_LONG_LONG;
  }
  else if constexpr (std::is_same_v<value_t, unsigned long long>) {
    return MPI_UNSIGNED_LONG_LONG;
  }
  else if constexpr (std::is_same_v<value_t, float>) {
    return MPI_FLOAT;
  }
  else if constexpr (std::is_same_v<value_t, double>) {
    return MPI_DOUBLE;
  }
  else if constexpr (std::is_same_v<value_t, long double>) {
    return MPI_LONG_DOUBLE;
  }
  else {
    static_assert(detail::always_false<value_t>::value,
                  "Unsupported MPI datatype");
  }
}
 
template<typename T> inline
std::intmax_t printable_int(T value)
{
  static_assert(std::is_integral_v<T>, "printable_int requires an integral type");
 
  if constexpr (std::is_signed_v<T>) {
    return static_cast<std::intmax_t>(value);
  } else {
    assert(value <= static_cast<T>(std::numeric_limits<std::intmax_t>::max()));
    return static_cast<std::intmax_t>(value);
  }
}
 
template<typename T> inline
std::uintmax_t printable_uint(T value)
{
  static_assert(std::is_integral_v<T>, "printable_uint requires an integral type");
  return static_cast<std::uintmax_t>(value);
}
 
}  // namespace opencarp
 
#endif