// Copyright 2004 The Trustees of Indiana University. | |
// Copyright 2005 Matthias Troyer. | |
// Copyright 2006 Douglas Gregor <doug.gregor -at- gmail.com>. | |
// Use, modification and distribution is subject to the Boost Software | |
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at | |
// http://www.boost.org/LICENSE_1_0.txt) | |
// Authors: Douglas Gregor | |
// Andrew Lumsdaine | |
// Matthias Troyer | |
/** @file datatype.hpp | |
* | |
* This header provides the mapping from C++ types to MPI data types. | |
*/ | |
#ifndef BOOST_MPI_DATATYPE_HPP | |
#define BOOST_MPI_DATATYPE_HPP | |
#include <boost/mpi/config.hpp> | |
#include <boost/mpi/datatype_fwd.hpp> | |
#include <mpi.h> | |
#include <boost/config.hpp> | |
#include <boost/mpl/bool.hpp> | |
#include <boost/mpl/or.hpp> | |
#include <boost/mpl/and.hpp> | |
#include <boost/mpi/detail/mpi_datatype_cache.hpp> | |
#include <boost/mpl/assert.hpp> | |
#include <boost/archive/basic_archive.hpp> | |
#include <boost/serialization/item_version_type.hpp> | |
#include <utility> // for std::pair | |
namespace boost { namespace mpi { | |
/** | |
* @brief Type trait that determines if there exists a built-in | |
* integer MPI data type for a given C++ type. | |
* | |
* This ytpe trait determines when there is a direct mapping from a | |
* C++ type to an MPI data type that is classified as an integer data | |
* type. See @c is_mpi_builtin_datatype for general information about | |
* built-in MPI data types. | |
*/ | |
template<typename T> | |
struct is_mpi_integer_datatype | |
: public boost::mpl::false_ { }; | |
/** | |
* @brief Type trait that determines if there exists a built-in | |
* floating point MPI data type for a given C++ type. | |
* | |
* This ytpe trait determines when there is a direct mapping from a | |
* C++ type to an MPI data type that is classified as a floating | |
* point data type. See @c is_mpi_builtin_datatype for general | |
* information about built-in MPI data types. | |
*/ | |
template<typename T> | |
struct is_mpi_floating_point_datatype | |
: public boost::mpl::false_ { }; | |
/** | |
* @brief Type trait that determines if there exists a built-in | |
* logical MPI data type for a given C++ type. | |
* | |
* This ytpe trait determines when there is a direct mapping from a | |
* C++ type to an MPI data type that is classified as an logical data | |
* type. See @c is_mpi_builtin_datatype for general information about | |
* built-in MPI data types. | |
*/ | |
template<typename T> | |
struct is_mpi_logical_datatype | |
: public boost::mpl::false_ { }; | |
/** | |
* @brief Type trait that determines if there exists a built-in | |
* complex MPI data type for a given C++ type. | |
* | |
* This ytpe trait determines when there is a direct mapping from a | |
* C++ type to an MPI data type that is classified as an complex data | |
* type. See @c is_mpi_builtin_datatype for general information about | |
* built-in MPI data types. | |
*/ | |
template<typename T> | |
struct is_mpi_complex_datatype | |
: public boost::mpl::false_ { }; | |
/** | |
* @brief Type trait that determines if there exists a built-in | |
* byte MPI data type for a given C++ type. | |
* | |
* This ytpe trait determines when there is a direct mapping from a | |
* C++ type to an MPI data type that is classified as an byte data | |
* type. See @c is_mpi_builtin_datatype for general information about | |
* built-in MPI data types. | |
*/ | |
template<typename T> | |
struct is_mpi_byte_datatype | |
: public boost::mpl::false_ { }; | |
/** @brief Type trait that determines if there exists a built-in MPI | |
* data type for a given C++ type. | |
* | |
* This type trait determines when there is a direct mapping from a | |
* C++ type to an MPI type. For instance, the C++ @c int type maps | |
* directly to the MPI type @c MPI_INT. When there is a direct | |
* mapping from the type @c T to an MPI type, @c | |
* is_mpi_builtin_datatype will derive from @c mpl::true_ and the MPI | |
* data type will be accessible via @c get_mpi_datatype. | |
* | |
* In general, users should not need to specialize this | |
* trait. However, if you have an additional C++ type that can map | |
* directly to only of MPI's built-in types, specialize either this | |
* trait or one of the traits corresponding to categories of MPI data | |
* types (@c is_mpi_integer_datatype, @c | |
* is_mpi_floating_point_datatype, @c is_mpi_logical_datatype, @c | |
* is_mpi_complex_datatype, or @c is_mpi_builtin_datatype). @c | |
* is_mpi_builtin_datatype derives @c mpl::true_ if any of the traits | |
* corresponding to MPI data type categories derived @c mpl::true_. | |
*/ | |
template<typename T> | |
struct is_mpi_builtin_datatype | |
: boost::mpl::or_<is_mpi_integer_datatype<T>, | |
is_mpi_floating_point_datatype<T>, | |
is_mpi_logical_datatype<T>, | |
is_mpi_complex_datatype<T>, | |
is_mpi_byte_datatype<T> > | |
{ | |
}; | |
/** @brief Type trait that determines if a C++ type can be mapped to | |
* an MPI data type. | |
* | |
* This type trait determines if it is possible to build an MPI data | |
* type that represents a C++ data type. When this is the case, @c | |
* is_mpi_datatype derives @c mpl::true_ and the MPI data type will | |
* be accessible via @c get_mpi_datatype. | |
* For any C++ type that maps to a built-in MPI data type (see @c | |
* is_mpi_builtin_datatype), @c is_mpi_data_type is trivially | |
* true. However, any POD ("Plain Old Data") type containing types | |
* that themselves can be represented by MPI data types can itself be | |
* represented as an MPI data type. For instance, a @c point3d class | |
* containing three @c double values can be represented as an MPI | |
* data type. To do so, first make the data type Serializable (using | |
* the Boost.Serialization library); then, specialize the @c | |
* is_mpi_datatype trait for the point type so that it will derive @c | |
* mpl::true_: | |
* | |
* @code | |
* namespace boost { namespace mpi { | |
* template<> struct is_mpi_datatype<point> | |
* : public mpl::true_ { }; | |
* } } | |
* @endcode | |
*/ | |
template<typename T> | |
struct is_mpi_datatype | |
: public is_mpi_builtin_datatype<T> | |
{ | |
}; | |
/** @brief Returns an MPI data type for a C++ type. | |
* | |
* The function creates an MPI data type for the given object @c | |
* x. The first time it is called for a class @c T, the MPI data type | |
* is created and cached. Subsequent calls for objects of the same | |
* type @c T return the cached MPI data type. The type @c T must | |
* allow creation of an MPI data type. That is, it must be | |
* Serializable and @c is_mpi_datatype<T> must derive @c mpl::true_. | |
* | |
* For fundamental MPI types, a copy of the MPI data type of the MPI | |
* library is returned. | |
* | |
* Note that since the data types are cached, the caller should never | |
* call @c MPI_Type_free() for the MPI data type returned by this | |
* call. | |
* | |
* @param x for an optimized call, a constructed object of the type | |
* should be passed; otherwise, an object will be | |
* default-constructed. | |
* | |
* @returns The MPI data type corresponding to type @c T. | |
*/ | |
template<typename T> MPI_Datatype get_mpi_datatype(const T& x) | |
{ | |
BOOST_MPL_ASSERT((is_mpi_datatype<T>)); | |
return detail::mpi_datatype_cache().datatype(x); | |
} | |
// Don't parse this part when we're generating Doxygen documentation. | |
#ifndef BOOST_MPI_DOXYGEN | |
/// INTERNAL ONLY | |
#define BOOST_MPI_DATATYPE(CppType, MPIType, Kind) \ | |
template<> \ | |
inline MPI_Datatype \ | |
get_mpi_datatype< CppType >(const CppType&) { return MPIType; } \ | |
\ | |
template<> \ | |
struct BOOST_JOIN(is_mpi_,BOOST_JOIN(Kind,_datatype))< CppType > \ | |
: boost::mpl::bool_<true> \ | |
{} | |
/// INTERNAL ONLY | |
BOOST_MPI_DATATYPE(packed, MPI_PACKED, builtin); | |
/// INTERNAL ONLY | |
BOOST_MPI_DATATYPE(char, MPI_CHAR, builtin); | |
/// INTERNAL ONLY | |
BOOST_MPI_DATATYPE(short, MPI_SHORT, integer); | |
/// INTERNAL ONLY | |
BOOST_MPI_DATATYPE(int, MPI_INT, integer); | |
/// INTERNAL ONLY | |
BOOST_MPI_DATATYPE(long, MPI_LONG, integer); | |
/// INTERNAL ONLY | |
BOOST_MPI_DATATYPE(float, MPI_FLOAT, floating_point); | |
/// INTERNAL ONLY | |
BOOST_MPI_DATATYPE(double, MPI_DOUBLE, floating_point); | |
/// INTERNAL ONLY | |
BOOST_MPI_DATATYPE(long double, MPI_LONG_DOUBLE, floating_point); | |
/// INTERNAL ONLY | |
BOOST_MPI_DATATYPE(unsigned char, MPI_UNSIGNED_CHAR, builtin); | |
/// INTERNAL ONLY | |
BOOST_MPI_DATATYPE(unsigned short, MPI_UNSIGNED_SHORT, integer); | |
/// INTERNAL ONLY | |
BOOST_MPI_DATATYPE(unsigned, MPI_UNSIGNED, integer); | |
/// INTERNAL ONLY | |
BOOST_MPI_DATATYPE(unsigned long, MPI_UNSIGNED_LONG, integer); | |
/// INTERNAL ONLY | |
#define BOOST_MPI_LIST2(A, B) A, B | |
/// INTERNAL ONLY | |
BOOST_MPI_DATATYPE(std::pair<BOOST_MPI_LIST2(float, int)>, MPI_FLOAT_INT, | |
builtin); | |
/// INTERNAL ONLY | |
BOOST_MPI_DATATYPE(std::pair<BOOST_MPI_LIST2(double, int)>, MPI_DOUBLE_INT, | |
builtin); | |
/// INTERNAL ONLY | |
BOOST_MPI_DATATYPE(std::pair<BOOST_MPI_LIST2(long double, int)>, | |
MPI_LONG_DOUBLE_INT, builtin); | |
/// INTERNAL ONLY | |
BOOST_MPI_DATATYPE(std::pair<BOOST_MPI_LIST2(long, int>), MPI_LONG_INT, | |
builtin); | |
/// INTERNAL ONLY | |
BOOST_MPI_DATATYPE(std::pair<BOOST_MPI_LIST2(short, int>), MPI_SHORT_INT, | |
builtin); | |
/// INTERNAL ONLY | |
BOOST_MPI_DATATYPE(std::pair<BOOST_MPI_LIST2(int, int>), MPI_2INT, builtin); | |
#undef BOOST_MPI_LIST2 | |
/// specialization of is_mpi_datatype for pairs | |
template <class T, class U> | |
struct is_mpi_datatype<std::pair<T,U> > | |
: public mpl::and_<is_mpi_datatype<T>,is_mpi_datatype<U> > | |
{ | |
}; | |
// Define wchar_t specialization of is_mpi_datatype, if possible. | |
#if !defined(BOOST_NO_INTRINSIC_WCHAR_T) && \ | |
(defined(MPI_WCHAR) || (defined(MPI_VERSION) && MPI_VERSION >= 2)) | |
BOOST_MPI_DATATYPE(wchar_t, MPI_WCHAR, builtin); | |
#endif | |
// Define long long or __int64 specialization of is_mpi_datatype, if possible. | |
#if defined(BOOST_HAS_LONG_LONG) && \ | |
(defined(MPI_LONG_LONG_INT) || (defined(MPI_VERSION) && MPI_VERSION >= 2)) | |
BOOST_MPI_DATATYPE(long long, MPI_LONG_LONG_INT, builtin); | |
#elif defined(BOOST_HAS_MS_INT64) && \ | |
(defined(MPI_LONG_LONG_INT) || (defined(MPI_VERSION) && MPI_VERSION >= 2)) | |
BOOST_MPI_DATATYPE(__int64, MPI_LONG_LONG_INT, builtin); | |
#endif | |
// Define unsigned long long or unsigned __int64 specialization of | |
// is_mpi_datatype, if possible. We separate this from the check for | |
// the (signed) long long/__int64 because some MPI implementations | |
// (e.g., MPICH-MX) have MPI_LONG_LONG_INT but not | |
// MPI_UNSIGNED_LONG_LONG. | |
#if defined(BOOST_HAS_LONG_LONG) && \ | |
(defined(MPI_UNSIGNED_LONG_LONG) \ | |
|| (defined(MPI_VERSION) && MPI_VERSION >= 2)) | |
BOOST_MPI_DATATYPE(unsigned long long, MPI_UNSIGNED_LONG_LONG, builtin); | |
#elif defined(BOOST_HAS_MS_INT64) && \ | |
(defined(MPI_UNSIGNED_LONG_LONG) \ | |
|| (defined(MPI_VERSION) && MPI_VERSION >= 2)) | |
BOOST_MPI_DATATYPE(unsigned __int64, MPI_UNSIGNED_LONG_LONG, builtin); | |
#endif | |
// Define signed char specialization of is_mpi_datatype, if possible. | |
#if defined(MPI_SIGNED_CHAR) || (defined(MPI_VERSION) && MPI_VERSION >= 2) | |
BOOST_MPI_DATATYPE(signed char, MPI_SIGNED_CHAR, builtin); | |
#endif | |
#endif // Doxygen | |
namespace detail { | |
inline MPI_Datatype build_mpi_datatype_for_bool() | |
{ | |
MPI_Datatype type; | |
MPI_Type_contiguous(sizeof(bool), MPI_BYTE, &type); | |
MPI_Type_commit(&type); | |
return type; | |
} | |
} | |
/// Support for bool. There is no corresponding MPI_BOOL. | |
/// INTERNAL ONLY | |
template<> | |
inline MPI_Datatype get_mpi_datatype<bool>(const bool&) | |
{ | |
static MPI_Datatype type = detail::build_mpi_datatype_for_bool(); | |
return type; | |
} | |
/// INTERNAL ONLY | |
template<> | |
struct is_mpi_datatype<bool> | |
: boost::mpl::bool_<true> | |
{}; | |
#ifndef BOOST_MPI_DOXYGEN | |
// direct support for special primitive data types of the serialization library | |
BOOST_MPI_DATATYPE(boost::archive::library_version_type, get_mpi_datatype(uint_least16_t()), integer); | |
BOOST_MPI_DATATYPE(boost::archive::version_type, get_mpi_datatype(uint_least8_t()), integer); | |
BOOST_MPI_DATATYPE(boost::archive::class_id_type, get_mpi_datatype(int_least16_t()), integer); | |
BOOST_MPI_DATATYPE(boost::archive::class_id_reference_type, get_mpi_datatype(int_least16_t()), integer); | |
BOOST_MPI_DATATYPE(boost::archive::class_id_optional_type, get_mpi_datatype(int_least16_t()), integer); | |
BOOST_MPI_DATATYPE(boost::archive::object_id_type, get_mpi_datatype(uint_least32_t()), integer); | |
BOOST_MPI_DATATYPE(boost::archive::object_reference_type, get_mpi_datatype(uint_least32_t()), integer); | |
BOOST_MPI_DATATYPE(boost::archive::tracking_type, get_mpi_datatype(bool()), builtin); | |
BOOST_MPI_DATATYPE(boost::serialization::collection_size_type, get_mpi_datatype(std::size_t()), integer); | |
BOOST_MPI_DATATYPE(boost::serialization::item_version_type, get_mpi_datatype(uint_least8_t()), integer); | |
#endif // Doxygen | |
} } // end namespace boost::mpi | |
// direct support for special primitive data types of the serialization library | |
// in the case of homogeneous systems | |
// define a macro to make explicit designation of this more transparent | |
#define BOOST_IS_MPI_DATATYPE(T) \ | |
namespace boost { \ | |
namespace mpi { \ | |
template<> \ | |
struct is_mpi_datatype< T > : mpl::true_ {}; \ | |
}} \ | |
/**/ | |
#endif // BOOST_MPI_MPI_DATATYPE_HPP |