1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
|
// (C) Copyright 2005 Matthias Troyer
// (C) 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: Matthias Troyer
// Douglas Gregor
/** @file packed_iarchive.hpp
*
* This header provides the facilities for packing Serializable data
* types into a buffer using @c MPI_Pack. The buffers can then be
* transmitted via MPI and then be unpacked either via the facilities
* in @c packed_oarchive.hpp or @c MPI_Unpack.
*/
#ifndef BOOST_MPI_PACKED_IARCHIVE_HPP
#define BOOST_MPI_PACKED_IARCHIVE_HPP
#include <boost/mpi/datatype.hpp>
#include <boost/archive/detail/auto_link_archive.hpp>
#include <boost/archive/detail/common_iarchive.hpp>
#include <boost/archive/basic_archive.hpp>
#include <boost/mpi/detail/packed_iprimitive.hpp>
#include <boost/mpi/detail/binary_buffer_iprimitive.hpp>
#include <boost/serialization/string.hpp>
#include <boost/serialization/collection_size_type.hpp>
#include <boost/serialization/item_version_type.hpp>
#include <boost/assert.hpp>
namespace boost { namespace mpi {
#ifdef BOOST_MPI_HOMOGENEOUS
typedef binary_buffer_iprimitive iprimitive;
#else
typedef packed_iprimitive iprimitive;
#endif
/** @brief An archive that unpacks binary data from an MPI buffer.
*
* The @c packed_oarchive class is an Archiver (as in the
* Boost.Serialization library) that unpacks binary data from a
* buffer received via MPI. It can operate on any Serializable data
* type and will use the @c MPI_Unpack function of the underlying MPI
* implementation to perform deserialization.
*/
class BOOST_MPI_DECL packed_iarchive
: public iprimitive
, public archive::detail::common_iarchive<packed_iarchive>
{
public:
/**
* Construct a @c packed_iarchive to receive data over the given
* MPI communicator and with an initial buffer.
*
* @param comm The communicator over which this archive will be
* received.
*
* @param b A user-defined buffer that contains the binary
* representation of serialized objects.
*
* @param flags Control the serialization of the data types. Refer
* to the Boost.Serialization documentation before changing the
* default flags.
*/
packed_iarchive(MPI_Comm const & comm, buffer_type & b, unsigned int flags = boost::archive::no_header, int position = 0)
: iprimitive(b,comm,position),
archive::detail::common_iarchive<packed_iarchive>(flags)
{}
/**
* Construct a @c packed_iarchive to receive data over the given
* MPI communicator.
*
* @param comm The communicator over which this archive will be
* received.
*
* @param flags Control the serialization of the data types. Refer
* to the Boost.Serialization documentation before changing the
* default flags.
*/
packed_iarchive
( MPI_Comm const & comm , std::size_t s=0,
unsigned int flags = boost::archive::no_header)
: iprimitive(internal_buffer_,comm)
, archive::detail::common_iarchive<packed_iarchive>(flags)
, internal_buffer_(s)
{}
// Load everything else in the usual way, forwarding on to the Base class
template<class T>
void load_override(T& x, int version, mpl::false_)
{
archive::detail::common_iarchive<packed_iarchive>::load_override(x,version);
}
// Load it directly using the primnivites
template<class T>
void load_override(T& x, int /*version*/, mpl::true_)
{
iprimitive::load(x);
}
// Load all supported datatypes directly
template<class T>
void load_override(T& x, int version)
{
typedef typename mpl::apply1<use_array_optimization
, BOOST_DEDUCED_TYPENAME remove_const<T>::type
>::type use_optimized;
load_override(x, version, use_optimized());
}
// input archives need to ignore the optional information
void load_override(archive::class_id_optional_type & /*t*/, int){}
void load_override(archive::class_id_type & t, int version){
int_least16_t x=0;
* this->This() >> x;
t = boost::archive::class_id_type(x);
}
void load_override(archive::version_type & t, int version){
int_least8_t x=0;
* this->This() >> x;
t = boost::archive::version_type(x);
}
void load_override(archive::class_id_reference_type & t, int version){
load_override(static_cast<archive::class_id_type &>(t), version);
}
void load_override(archive::class_name_type & t, int)
{
std::string cn;
cn.reserve(BOOST_SERIALIZATION_MAX_KEY_SIZE);
* this->This() >> cn;
std::memcpy(t, cn.data(), cn.size());
// borland tweak
t.t[cn.size()] = '\0';
}
private:
/// An internal buffer to be used when the user does not supply his
/// own buffer.
buffer_type internal_buffer_;
};
} } // end namespace boost::mpi
BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::mpi::packed_iarchive)
BOOST_SERIALIZATION_USE_ARRAY_OPTIMIZATION(boost::mpi::packed_iarchive)
#endif // BOOST_MPI_PACKED_IARCHIVE_HPP
|
