diff options
Diffstat (limited to 'src/boost/libs/mpi')
102 files changed, 9395 insertions, 0 deletions
diff --git a/src/boost/libs/mpi/build/Jamfile.v2 b/src/boost/libs/mpi/build/Jamfile.v2 new file mode 100644 index 000000000..084838458 --- /dev/null +++ b/src/boost/libs/mpi/build/Jamfile.v2 @@ -0,0 +1,139 @@ +# Copyright (C) 2005, 2006 The Trustees of Indiana University. +# Copyright (C) 2005 Douglas Gregor <doug.gregor -at- gmail.com> +# Copyright (c) 2018 Stefan Seefeld + +# 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 + +import mpi ; +import indirect ; +import python ; +import option ; +import regex ; + +# +# The `version-suffix` rule really belongs into python.jam, and +# should be moved there. `split-version` is only duplicated here +# as a prerequisite. (See https://github.com/boostorg/build/pull/290) +# + + +mpi_python_libs = ; + +if [ mpi.configured ] +{ + +project boost/mpi + : source-location ../src + ; + +lib boost_mpi + : + broadcast.cpp + cartesian_communicator.cpp + communicator.cpp + computation_tree.cpp + content_oarchive.cpp + environment.cpp + error_string.cpp + exception.cpp + graph_communicator.cpp + group.cpp + intercommunicator.cpp + mpi_datatype_cache.cpp + mpi_datatype_oarchive.cpp + packed_iarchive.cpp + packed_oarchive.cpp + packed_skeleton_iarchive.cpp + packed_skeleton_oarchive.cpp + point_to_point.cpp + request.cpp + text_skeleton_oarchive.cpp + timer.cpp + offsets.cpp + : # Requirements + <library>../../serialization/build//boost_serialization + <library>/mpi//mpi [ mpi.extra-requirements ] + <define>BOOST_MPI_SOURCE=1 + <link>shared:<define>BOOST_MPI_DYN_LINK=1 + <local-visibility>global + : # Default build + <link>shared + : # Usage requirements + <library>../../serialization/build//boost_serialization + <library>/mpi//mpi [ mpi.extra-requirements ] + ; + + if [ python.configured ] + { + lib boost_mpi_python + : # Sources + python/serialize.cpp + : # Requirements + <library>boost_mpi + <library>/mpi//mpi [ mpi.extra-requirements ] + <library>/boost/python//boost_python + <link>shared:<define>BOOST_MPI_DYN_LINK=1 + <link>shared:<define>BOOST_MPI_PYTHON_DYN_LINK=1 + <link>shared:<define>BOOST_PYTHON_DYN_LINK=1 + <define>BOOST_MPI_PYTHON_SOURCE=1 + <python-debugging>on:<define>BOOST_DEBUG_PYTHON + -<tag>@$(BOOST_JAMROOT_MODULE)%$(BOOST_JAMROOT_MODULE).tag + <tag>@python-tag + <conditional>@python.require-py + <local-visibility>global + + : # Default build + <link>shared + : # Usage requirements + <library>/mpi//mpi [ mpi.extra-requirements ] + ; + + python-extension mpi + : # Sources + python/collectives.cpp + python/py_communicator.cpp + python/datatypes.cpp + python/documentation.cpp + python/py_environment.cpp + python/py_nonblocking.cpp + python/py_exception.cpp + python/module.cpp + python/py_request.cpp + python/skeleton_and_content.cpp + python/status.cpp + python/py_timer.cpp + : # Requirements + <library>/boost/python//boost_python + <library>boost_mpi_python + <library>boost_mpi + <library>/mpi//mpi [ mpi.extra-requirements ] + <link>shared:<define>BOOST_MPI_DYN_LINK=1 + <link>shared:<define>BOOST_MPI_PYTHON_DYN_LINK=1 + <link>shared:<define>BOOST_PYTHON_DYN_LINK=1 + <link>shared <runtime-link>shared + <python-debugging>on:<define>BOOST_DEBUG_PYTHON + ; + + mpi_python_libs = boost_mpi_python mpi ; + } +} +else if ! ( --without-mpi in [ modules.peek : ARGV ] ) +{ + message boost_mpi + : "warning: skipping optional Message Passing Interface (MPI) library." + : "note: to enable MPI support, add \"using mpi ;\" to user-config.jam." + : "note: to suppress this message, pass \"--without-mpi\" to bjam." + : "note: otherwise, you can safely ignore this message." + ; +} +else +{ + alias boost_mpi ; +} + +boost-install boost_mpi $(mpi_python_libs) ; diff --git a/src/boost/libs/mpi/build/__init__.py b/src/boost/libs/mpi/build/__init__.py new file mode 100644 index 000000000..ffd3862ea --- /dev/null +++ b/src/boost/libs/mpi/build/__init__.py @@ -0,0 +1,10 @@ +import sys +if sys.platform == 'linux2': + import DLFCN as dl + flags = sys.getdlopenflags() + sys.setdlopenflags(dl.RTLD_NOW|dl.RTLD_GLOBAL) + import mpi + sys.setdlopenflags(flags) +else: + import mpi + diff --git a/src/boost/libs/mpi/example/cartesian_communicator.cpp b/src/boost/libs/mpi/example/cartesian_communicator.cpp new file mode 100644 index 000000000..7b011041d --- /dev/null +++ b/src/boost/libs/mpi/example/cartesian_communicator.cpp @@ -0,0 +1,42 @@ +// Copyright Alain Miniussi 2014. +// Distributed under 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: Alain Miniussi + +#include <vector> +#include <iostream> + +#include <boost/mpi/communicator.hpp> +#include <boost/mpi/collectives.hpp> +#include <boost/mpi/environment.hpp> +#include <boost/mpi/cartesian_communicator.hpp> + +namespace mpi = boost::mpi; +// Curly brace init make this useless, but +// - Need to support obsolete like g++ 4.3.x. for some reason +// - Can't conditionnaly compile with bjam (unless you find +// the doc, and read it, which would only make sense if you +// actually wan't to use bjam, which does not (make sense)) +typedef mpi::cartesian_dimension cd; + +int main(int argc, char* argv[]) +{ + mpi::environment env; + mpi::communicator world; + + if (world.size() != 24) return -1; + mpi::cartesian_dimension dims[] = {cd(2, true), cd(3,true), cd(4,true)}; + mpi::cartesian_communicator cart(world, mpi::cartesian_topology(dims)); + for (int r = 0; r < cart.size(); ++r) { + cart.barrier(); + if (r == cart.rank()) { + std::vector<int> c = cart.coordinates(r); + std::cout << "rk :" << r << " coords: " + << c[0] << ' ' << c[1] << ' ' << c[2] << '\n'; + } + } + return 0; +} + diff --git a/src/boost/libs/mpi/example/generate_collect.cpp b/src/boost/libs/mpi/example/generate_collect.cpp new file mode 100644 index 000000000..5579d50d2 --- /dev/null +++ b/src/boost/libs/mpi/example/generate_collect.cpp @@ -0,0 +1,129 @@ +// Copyright (C) 2006 Douglas Gregor <doug.gregor@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) + +// An example using Boost.MPI's split() operation on communicators to +// create separate data-generating processes and data-collecting +// processes. +#include <boost/mpi.hpp> +#include <iostream> +#include <cstdlib> +#include <boost/serialization/vector.hpp> +namespace mpi = boost::mpi; + +enum message_tags { msg_data_packet, msg_broadcast_data, msg_finished }; + +void generate_data(mpi::communicator local, mpi::communicator world) +{ + using std::srand; + using std::rand; + + // The rank of the collector within the world communicator + int master_collector = local.size(); + + srand(time(0) + world.rank()); + + // Send out several blocks of random data to the collectors. + int num_data_blocks = rand() % 3 + 1; + for (int block = 0; block < num_data_blocks; ++block) { + // Generate some random data + int num_samples = rand() % 1000; + std::vector<int> data; + for (int i = 0; i < num_samples; ++i) { + data.push_back(rand()); + } + + // Send our data to the master collector process. + std::cout << "Generator #" << local.rank() << " sends some data..." + << std::endl; + world.send(master_collector, msg_data_packet, data); + } + + // Wait for all of the generators to complete + (local.barrier)(); + + // The first generator will send the message to the master collector + // indicating that we're done. + if (local.rank() == 0) + world.send(master_collector, msg_finished); +} + +void collect_data(mpi::communicator local, mpi::communicator world) +{ + // The rank of the collector within the world communicator + int master_collector = world.size() - local.size(); + + if (world.rank() == master_collector) { + while (true) { + // Wait for a message + mpi::status msg = world.probe(); + if (msg.tag() == msg_data_packet) { + // Receive the packet of data + std::vector<int> data; + world.recv(msg.source(), msg.tag(), data); + + // Tell each of the collectors that we'll be broadcasting some data + for (int dest = 1; dest < local.size(); ++dest) + local.send(dest, msg_broadcast_data, msg.source()); + + // Broadcast the actual data. + broadcast(local, data, 0); + } else if (msg.tag() == msg_finished) { + // Receive the message + world.recv(msg.source(), msg.tag()); + + // Tell each of the collectors that we're finished + for (int dest = 1; dest < local.size(); ++dest) + local.send(dest, msg_finished); + + break; + } + } + } else { + while (true) { + // Wait for a message from the master collector + mpi::status msg = local.probe(); + if (msg.tag() == msg_broadcast_data) { + // Receive the broadcast message + int originator; + local.recv(msg.source(), msg.tag(), originator); + + // Receive the data broadcasted from the master collector + std::vector<int> data; + broadcast(local, data, 0); + + std::cout << "Collector #" << local.rank() + << " is processing data from generator #" << originator + << "." << std::endl; + } else if (msg.tag() == msg_finished) { + // Receive the message + local.recv(msg.source(), msg.tag()); + + break; + } + } + } +} + +int main(int argc, char* argv[]) +{ + mpi::environment env(argc, argv); + mpi::communicator world; + + if (world.size() < 3) { + if (world.rank() == 0) { + std::cerr << "Error: this example requires at least 3 processes." + << std::endl; + } + env.abort(-1); + } + + bool is_generator = world.rank() < 2 * world.size() / 3; + mpi::communicator local = world.split(is_generator? 0 : 1); + if (is_generator) generate_data(local, world); + else collect_data(local, world); + + return 0; +} diff --git a/src/boost/libs/mpi/example/generate_collect_optional.cpp b/src/boost/libs/mpi/example/generate_collect_optional.cpp new file mode 100644 index 000000000..3aa3888c4 --- /dev/null +++ b/src/boost/libs/mpi/example/generate_collect_optional.cpp @@ -0,0 +1,113 @@ +// Copyright (C) 2006 Douglas Gregor <doug.gregor@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) + +// An example using Boost.MPI's split() operation on communicators to +// create separate data-generating processes and data-collecting +// processes using boost::optional for broadcasting. +#include <boost/mpi.hpp> +#include <iostream> +#include <cstdlib> +#include <boost/serialization/vector.hpp> +#include <boost/serialization/optional.hpp> +namespace mpi = boost::mpi; + +enum message_tags { msg_data_packet, msg_finished }; + +void generate_data(mpi::communicator local, mpi::communicator world) +{ + using std::srand; + using std::rand; + + // The rank of the collector within the world communicator + int master_collector = local.size(); + + srand(time(0) + world.rank()); + + // Send out several blocks of random data to the collectors. + int num_data_blocks = rand() % 3 + 1; + for (int block = 0; block < num_data_blocks; ++block) { + // Generate some random dataa + int num_samples = rand() % 1000; + std::vector<int> data; + for (int i = 0; i < num_samples; ++i) { + data.push_back(rand()); + } + + // Send our data to the master collector process. + std::cout << "Generator #" << local.rank() << " sends some data..." + << std::endl; + world.send(master_collector, msg_data_packet, data); + } + + // Wait for all of the generators to complete + (local.barrier)(); + + // The first generator will send the message to the master collector + // indicating that we're done. + if (local.rank() == 0) + world.send(master_collector, msg_finished); +} + +void collect_data(mpi::communicator local, mpi::communicator world) +{ + // The rank of the collector within the world communicator + int master_collector = world.size() - local.size(); + + if (world.rank() == master_collector) { + while (true) { + // Wait for a message + mpi::status msg = world.probe(); + if (msg.tag() == msg_data_packet) { + // Receive the packet of data into a boost::optional + boost::optional<std::vector<int> > data; + data = std::vector<int>(); + world.recv(msg.source(), msg.source(), *data); + + // Broadcast the actual data. + broadcast(local, data, 0); + } else if (msg.tag() == msg_finished) { + // Receive the message + world.recv(msg.source(), msg.tag()); + + // Broadcast to each collector to tell them we've finished. + boost::optional<std::vector<int> > data; + broadcast(local, data, 0); + break; + } + } + } else { + boost::optional<std::vector<int> > data; + do { + // Wait for a broadcast from the master collector + broadcast(local, data, 0); + if (data) { + std::cout << "Collector #" << local.rank() + << " is processing data." << std::endl; + } + } while (data); + } +} + +int main(int argc, char* argv[]) +{ + mpi::environment env(argc, argv); + mpi::communicator world; + + if (world.size() < 4) { + if (world.rank() == 0) { + std::cerr << "Error: this example requires at least 4 processes." + << std::endl; + } + env.abort(-1); + } + + bool is_generator = world.rank() < 2 * world.size() / 3; + mpi::communicator local = world.split(is_generator? 0 : 1); + if (is_generator) generate_data(local, world); + else collect_data(local, world); + + return 0; +} diff --git a/src/boost/libs/mpi/example/global_min.cpp b/src/boost/libs/mpi/example/global_min.cpp new file mode 100644 index 000000000..68de57dff --- /dev/null +++ b/src/boost/libs/mpi/example/global_min.cpp @@ -0,0 +1,31 @@ +// Copyright (C) 2013 Alain Miniussi <alain.miniussi@oca.eu> + +// 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) + +// An example using Boost.MPI's all_reduce() that compute the minimum +// of each process's value and broadcast the result to all the processes. + +#include <boost/mpi.hpp> +#include <iostream> +#include <cstdlib> +namespace mpi = boost::mpi; + +int main(int argc, char* argv[]) +{ + mpi::environment env(argc, argv); + mpi::communicator world; + + std::srand(world.rank()); + int my_number = std::rand(); + int minimum; + + all_reduce(world, my_number, minimum, mpi::minimum<int>()); + + if (world.rank() == 0) { + std::cout << "The minimum value is " << minimum << std::endl; + } + + return 0; +} diff --git a/src/boost/libs/mpi/example/hello_world.cpp b/src/boost/libs/mpi/example/hello_world.cpp new file mode 100644 index 000000000..7095c1724 --- /dev/null +++ b/src/boost/libs/mpi/example/hello_world.cpp @@ -0,0 +1,33 @@ +// Copyright (C) 2006 Douglas Gregor <doug.gregor@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) + +// A simple Hello, world! example using Boost.MPI message passing. + +#include <boost/mpi.hpp> +#include <iostream> +#include <boost/serialization/string.hpp> // Needed to send/receive strings! +namespace mpi = boost::mpi; + +int main(int argc, char* argv[]) +{ + mpi::environment env(argc, argv); + mpi::communicator world; + + if (world.rank() == 0) { + world.send(1, 0, std::string("Hello")); + std::string msg; + world.recv(1, 1, msg); + std::cout << msg << "!" << std::endl; + } else { + std::string msg; + world.recv(0, 0, msg); + std::cout << msg << ", "; + std::cout.flush(); + world.send(0, 1, std::string("world")); + } + + return 0; +} diff --git a/src/boost/libs/mpi/example/hello_world_broadcast.cpp b/src/boost/libs/mpi/example/hello_world_broadcast.cpp new file mode 100644 index 000000000..4ffe239ea --- /dev/null +++ b/src/boost/libs/mpi/example/hello_world_broadcast.cpp @@ -0,0 +1,28 @@ +// Copyright (C) 2006 Douglas Gregor <doug.gregor@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) + +// A simple Hello, world! example using Boost.MPI broadcast() + +#include <boost/mpi.hpp> +#include <iostream> +#include <boost/serialization/string.hpp> // Needed to send/receive strings! +namespace mpi = boost::mpi; + +int main(int argc, char* argv[]) +{ + mpi::environment env(argc, argv); + mpi::communicator world; + + std::string value; + if (world.rank() == 0) { + value = "Hello, World!"; + } + + broadcast(world, value, 0); + + std::cout << "Process #" << world.rank() << " says " << value << std::endl; + return 0; +} diff --git a/src/boost/libs/mpi/example/hello_world_groups.cpp b/src/boost/libs/mpi/example/hello_world_groups.cpp new file mode 100644 index 000000000..7493aa4a3 --- /dev/null +++ b/src/boost/libs/mpi/example/hello_world_groups.cpp @@ -0,0 +1,46 @@ +// Copyright (C) 2013 Andreas Hehn <hehn@phys.ethz.ch>, ETH Zurich +// based on +// hellp-world_broadcast.cpp (C) 2006 Douglas Gregor <doug.gregor@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) + +// A simple Hello world! example +// using boost::mpi::group and boost::mpi::broadcast() + +#include <stdexcept> +#include <boost/mpi/environment.hpp> +#include <boost/mpi/communicator.hpp> +#include <boost/mpi/group.hpp> +#include <boost/mpi/collectives.hpp> + +#include <boost/serialization/string.hpp> + +namespace mpi = boost::mpi; + +int main(int argc, char* argv[]) +{ + mpi::environment env(argc, argv); + mpi::communicator world; + if(world.size() < 2) + throw std::runtime_error("Please run with at least 2 MPI processes!"); + + int group_a_ranks[2] = {0,1}; + + mpi::group world_group = world.group(); + mpi::group group_a = world_group.include(group_a_ranks,group_a_ranks+2); + + mpi::communicator comm_a(world,group_a); + + std::string value("Hello world!"); + if(comm_a) + { + if(comm_a.rank() == 0) { + value = "Hello group a!"; + } + mpi::broadcast(comm_a, value, 0); + } + std::cout << "Process #" << world.rank() << " says " << value << std::endl; + return 0; +} diff --git a/src/boost/libs/mpi/example/hello_world_nonblocking.cpp b/src/boost/libs/mpi/example/hello_world_nonblocking.cpp new file mode 100644 index 000000000..c65247b99 --- /dev/null +++ b/src/boost/libs/mpi/example/hello_world_nonblocking.cpp @@ -0,0 +1,36 @@ +// Copyright (C) 2006 Douglas Gregor <doug.gregor@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) + +// A simple Hello, world! example using Boost.MPI message passing. + +#include <boost/mpi.hpp> +#include <iostream> +#include <boost/serialization/string.hpp> // Needed to send/receive strings! +namespace mpi = boost::mpi; + +int main(int argc, char* argv[]) +{ + mpi::environment env(argc, argv); + mpi::communicator world; + + if (world.rank() == 0) { + mpi::request reqs[2]; + std::string msg, out_msg = "Hello"; + reqs[0] = world.isend(1, 0, out_msg); + reqs[1] = world.irecv(1, 1, msg); + mpi::wait_all(reqs, reqs + 2); + std::cout << msg << "!" << std::endl; + } else { + mpi::request reqs[2]; + std::string msg, out_msg = "world"; + reqs[0] = world.isend(0, 1, out_msg); + reqs[1] = world.irecv(0, 0, msg); + mpi::wait_all(reqs, reqs + 2); + std::cout << msg << ", "; + } + + return 0; +} diff --git a/src/boost/libs/mpi/example/in_place_global_min.cpp b/src/boost/libs/mpi/example/in_place_global_min.cpp new file mode 100644 index 000000000..7da2cf2bf --- /dev/null +++ b/src/boost/libs/mpi/example/in_place_global_min.cpp @@ -0,0 +1,29 @@ +// Copyright (C) 2013 Alain Miniussi <alain.miniussi@oca.eu> + +// 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) + +// An example using Boost.MPI's all_reduce() that compute the minimum +// of each process's value and broadcast the result to all the processes. +#include <boost/mpi.hpp> +#include <iostream> +#include <cstdlib> +namespace mpi = boost::mpi; + +int main(int argc, char* argv[]) +{ + mpi::environment env(argc, argv); + mpi::communicator world; + + std::srand(world.rank()); + int my_number = std::rand(); + + all_reduce(world, my_number, mpi::minimum<int>()); + + if (world.rank() == 0) { + std::cout << "The minimum value is " << my_number << std::endl; + } + + return 0; +} diff --git a/src/boost/libs/mpi/example/parallel_example.cpp b/src/boost/libs/mpi/example/parallel_example.cpp new file mode 100644 index 000000000..00347d51c --- /dev/null +++ b/src/boost/libs/mpi/example/parallel_example.cpp @@ -0,0 +1,196 @@ +// Copyright (C) 2005-2006 Matthias Troyer + +// 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) + +// An example of a parallel Monte Carlo simulation using some nodes to produce +// data and others to aggregate the data +#include <iostream> + +#include <boost/mpi.hpp> +#include <boost/random/parallel.hpp> +#include <boost/random.hpp> +#include <boost/foreach.hpp> +#include <iostream> +#include <cstdlib> + +namespace mpi = boost::mpi; + +enum {sample_tag, sample_skeleton_tag, sample_broadcast_tag, quit_tag}; + + +void calculate_samples(int sample_length) +{ + int num_samples = 100; + std::vector<double> sample(sample_length); + + // setup communicator by splitting + + mpi::communicator world; + mpi::communicator calculate_communicator = world.split(0); + + unsigned int num_calculate_ranks = calculate_communicator.size(); + + // the master of the accumulaion ranks is the first of them, hence + // with a rank just one after the last calculation rank + int master_accumulate_rank = num_calculate_ranks; + + // the master of the calculation ranks sends the skeleton of the sample + // to the master of the accumulation ranks + + if (world.rank()==0) + world.send(master_accumulate_rank,sample_skeleton_tag,mpi::skeleton(sample)); + + // next we extract the content of the sample vector, to be used in sending + // the content later on + + mpi::content sample_content = mpi::get_content(sample); + + // now intialize the parallel random number generator + + boost::lcg64 engine( + boost::random::stream_number = calculate_communicator.rank(), + boost::random::total_streams = calculate_communicator.size() + ); + + boost::variate_generator<boost::lcg64&,boost::uniform_real<> > + rng(engine,boost::uniform_real<>()); + + for (unsigned int i=0; i<num_samples/num_calculate_ranks+1;++i) { + + // calculate sample by filling the vector with random numbers + // note that std::generate will not work since it takes the generator + // by value, and boost::ref cannot be used as a generator. + // boost::ref should be fixed so that it can be used as generator + + BOOST_FOREACH(double& x, sample) + x = rng(); + + // send sample to accumulation ranks + // Ideally we want to do this as a broadcast with an inter-communicator + // between the calculation and accumulation ranks. MPI2 should support + // this, but here we present an MPI1 compatible solution. + + // send content of sample to first (master) accumulation process + + world.send(master_accumulate_rank,sample_tag,sample_content); + + // gather some results from all calculation ranks + + double local_result = sample[0]; + std::vector<double> gathered_results(calculate_communicator.size()); + mpi::all_gather(calculate_communicator,local_result,gathered_results); + } + + // we are done: the master tells the accumulation ranks to quit + if (world.rank()==0) + world.send(master_accumulate_rank,quit_tag); +} + + + +void accumulate_samples() +{ + std::vector<double> sample; + + // setup the communicator for all accumulation ranks by splitting + + mpi::communicator world; + mpi::communicator accumulate_communicator = world.split(1); + + bool is_master_accumulate_rank = accumulate_communicator.rank()==0; + + // the master receives the sample skeleton + + if (is_master_accumulate_rank) + world.recv(0,sample_skeleton_tag,mpi::skeleton(sample)); + + // and broadcasts it to all accumulation ranks + mpi::broadcast(accumulate_communicator,mpi::skeleton(sample),0); + + // next we extract the content of the sample vector, to be used in receiving + // the content later on + + mpi::content sample_content = mpi::get_content(sample); + + // accumulate until quit is called + double sum=0.; + while (true) { + + + // the accumulation master checks whether we should quit + if (world.iprobe(0,quit_tag)) { + world.recv(0,quit_tag); + for (int i=1; i<accumulate_communicator.size();++i) + accumulate_communicator.send(i,quit_tag); + std::cout << sum << "\n"; + break; // We're done + } + + // the otehr accumulation ranks check whether we should quit + if (accumulate_communicator.iprobe(0,quit_tag)) { + accumulate_communicator.recv(0,quit_tag); + std::cout << sum << "\n"; + break; // We're done + } + + // check whether the master accumulation rank has received a sample + if (world.iprobe(mpi::any_source,sample_tag)) { + BOOST_ASSERT(is_master_accumulate_rank); + + // receive the content + world.recv(mpi::any_source,sample_tag,sample_content); + + // now we need to braodcast + // the problam is we do not have a non-blocking broadcast that we could + // abort if we receive a quit message from the master. We thus need to + // first tell all accumulation ranks to start a broadcast. If the sample + // is small, we could just send the sample in this message, but here we + // optimize the code for large samples, so that the overhead of these + // sends can be ignored, and we count on an optimized broadcast + // implementation with O(log N) complexity + + for (int i=1; i<accumulate_communicator.size();++i) + accumulate_communicator.send(i,sample_broadcast_tag); + + // now broadcast the contents of the sample to all accumulate ranks + mpi::broadcast(accumulate_communicator,sample_content,0); + + // and handle the sample by summing the appropriate value + sum += sample[0]; + } + + // the other accumulation ranks wait for a mesage to start the broadcast + if (accumulate_communicator.iprobe(0,sample_broadcast_tag)) { + BOOST_ASSERT(!is_master_accumulate_rank); + + accumulate_communicator.recv(0,sample_broadcast_tag); + + // receive broadcast of the sample contents + mpi::broadcast(accumulate_communicator,sample_content,0); + + // and handle the sample + + // and handle the sample by summing the appropriate value + sum += sample[accumulate_communicator.rank()]; + } + } +} + +int main(int argc, char** argv) +{ + mpi::environment env(argc, argv); + mpi::communicator world; + + // half of the processes generate, the others accumulate + // the sample size is just the number of accumulation ranks + if (world.rank() < world.size()/2) + calculate_samples(world.size()-world.size()/2); + else + accumulate_samples(); + + return 0; +} + + diff --git a/src/boost/libs/mpi/example/python/hello_world.py b/src/boost/libs/mpi/example/python/hello_world.py new file mode 100644 index 000000000..73312483b --- /dev/null +++ b/src/boost/libs/mpi/example/python/hello_world.py @@ -0,0 +1,16 @@ +# Copyright (C) 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) + +import boost.parallel.mpi as mpi + +if mpi.world.rank == 0: + mpi.world.send(1, 0, 'Hello') + msg = mpi.world.recv(1, 1) + print msg,'!' +else: + msg = mpi.world.recv(0, 0) + print msg,', ', + mpi.world.send(0, 1, 'world') diff --git a/src/boost/libs/mpi/example/random_content.cpp b/src/boost/libs/mpi/example/random_content.cpp new file mode 100644 index 000000000..22fd06d87 --- /dev/null +++ b/src/boost/libs/mpi/example/random_content.cpp @@ -0,0 +1,98 @@ +// Copyright (C) 2006 Douglas Gregor <doug.gregor@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) + +// An example using Boost.MPI's skeletons and content to optimize +// communication. +#include <boost/mpi.hpp> +#include <boost/serialization/list.hpp> +#include <algorithm> +#include <functional> +#include <numeric> +#include <iostream> +#include <stdlib.h> +namespace mpi = boost::mpi; + +int main(int argc, char* argv[]) +{ + mpi::environment env(argc, argv); + mpi::communicator world; + + if (world.size() < 2 || world.size() > 4) { + if (world.rank() == 0) + std::cerr << "error: please execute this program with 2-4 processes.\n"; + world.abort(-1); + } + + if (world.rank() == 0) { + int list_len = 50; + int iterations = 10; + + if (argc > 1) list_len = atoi(argv[1]); + if (argc > 2) iterations = atoi(argv[2]); + + if (list_len <= 0) { + std::cerr << "error: please specific a list length greater than zero.\n"; + world.abort(-1); + } + + // Generate the list and broadcast its structure + std::list<int> l(list_len); + broadcast(world, mpi::skeleton(l), 0); + + // Generate content several times and broadcast out that content + mpi::content c = mpi::get_content(l); + for (int i = 0; i < iterations; ++i) { + do { + std::generate(l.begin(), l.end(), &random); + } while (std::find_if(l.begin(), l.end(), + std::bind1st(std::not_equal_to<int>(), 0)) + == l.end()); + + + std::cout << "Iteration #" << i << ": sending content" + << " (min = " << *std::min_element(l.begin(), l.end()) + << ", max = " << *std::max_element(l.begin(), l.end()) + << ", avg = " + << std::accumulate(l.begin(), l.end(), 0)/l.size() + << ").\n"; + + broadcast(world, c, 0); + } + + // Notify the slaves that we're done by sending all zeroes + std::fill(l.begin(), l.end(), 0); + broadcast(world, c, 0); + + } else { + // Receive the content and build up our own list + std::list<int> l; + broadcast(world, mpi::skeleton(l), 0); + + mpi::content c = mpi::get_content(l); + int i = 0; + do { + broadcast(world, c, 0); + + if (std::find_if(l.begin(), l.end(), + std::bind1st(std::not_equal_to<int>(), 0)) == l.end()) + break; + + if (world.rank() == 1) + std::cout << "Iteration #" << i << ": max value = " + << *std::max_element(l.begin(), l.end()) << ".\n"; + else if (world.rank() == 2) + std::cout << "Iteration #" << i << ": min value = " + << *std::min_element(l.begin(), l.end()) << ".\n"; + else if (world.rank() == 3) + std::cout << "Iteration #" << i << ": avg value = " + << std::accumulate(l.begin(), l.end(), 0)/l.size() + << ".\n"; + ++i; + } while (true); + } + + return 0; +} diff --git a/src/boost/libs/mpi/example/random_gather.cpp b/src/boost/libs/mpi/example/random_gather.cpp new file mode 100644 index 000000000..17825f157 --- /dev/null +++ b/src/boost/libs/mpi/example/random_gather.cpp @@ -0,0 +1,31 @@ +// Copyright (C) 2006 Douglas Gregor <doug.gregor@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) + +// An example using Boost.MPI's gather(): [main] + +#include <boost/mpi.hpp> +#include <iostream> +#include <cstdlib> +namespace mpi = boost::mpi; + +int main(int argc, char* argv[]) +{ + mpi::environment env(argc, argv); + mpi::communicator world; + + std::srand(time(0) + world.rank()); + int my_number = std::rand(); + if (world.rank() == 0) { + std::vector<int> all_numbers; + gather(world, my_number, all_numbers, 0); + for (int proc = 0; proc < world.size(); ++proc) + std::cout << "Process #" << proc << " thought of " << all_numbers[proc] + << std::endl; + } else { + gather(world, my_number, 0); + } + return 0; +} diff --git a/src/boost/libs/mpi/example/random_min.cpp b/src/boost/libs/mpi/example/random_min.cpp new file mode 100644 index 000000000..d0a67ee02 --- /dev/null +++ b/src/boost/libs/mpi/example/random_min.cpp @@ -0,0 +1,30 @@ +// Copyright (C) 2006 Douglas Gregor <doug.gregor@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) + +// An example using Boost.MPI's reduce() to compute a minimum value. +#include <boost/mpi.hpp> +#include <iostream> +#include <cstdlib> +namespace mpi = boost::mpi; + +int main(int argc, char* argv[]) +{ + mpi::environment env(argc, argv); + mpi::communicator world; + + std::srand(time(0) + world.rank()); + int my_number = std::rand(); + + if (world.rank() == 0) { + int minimum; + reduce(world, my_number, minimum, mpi::minimum<int>(), 0); + std::cout << "The minimum value is " << minimum << std::endl; + } else { + reduce(world, my_number, mpi::minimum<int>(), 0); + } + + return 0; +} diff --git a/src/boost/libs/mpi/example/random_scatter.cpp b/src/boost/libs/mpi/example/random_scatter.cpp new file mode 100644 index 000000000..fc8879e4e --- /dev/null +++ b/src/boost/libs/mpi/example/random_scatter.cpp @@ -0,0 +1,37 @@ +// Copyright (C) 2006 Douglas Gregor <doug.gregor@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) + +// An example using Boost.MPI's gather(): [main] + +#include <boost/mpi.hpp> +#include <boost/mpi/collectives.hpp> +#include <iostream> +#include <cstdlib> +#include <vector> + +namespace mpi = boost::mpi; + +int main(int argc, char* argv[]) +{ + mpi::environment env(argc, argv); + mpi::communicator world; + + std::srand(time(0) + world.rank()); + std::vector<int> all; + int mine = -1; + if (world.rank() == 0) { + all.resize(world.size()); + std::generate(all.begin(), all.end(), std::rand); + } + mpi::scatter(world, all, mine, 0); + for (int r = 0; r < world.size(); ++r) { + world.barrier(); + if (r == world.rank()) { + std::cout << "Rank " << r << " got " << mine << '\n'; + } + } + return 0; +} diff --git a/src/boost/libs/mpi/example/reduce_performance_test.cpp b/src/boost/libs/mpi/example/reduce_performance_test.cpp new file mode 100644 index 000000000..40411b14a --- /dev/null +++ b/src/boost/libs/mpi/example/reduce_performance_test.cpp @@ -0,0 +1,138 @@ +// Copyright (C) 2006 Trustees of Indiana University +// +// Authors: Douglas Gregor +// Andrew Lumsdaine + +// 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) + +// Performance test of the reduce() collective +#include <boost/mpi.hpp> +#include <boost/lexical_cast.hpp> + +namespace mpi = boost::mpi; + +struct add_int { + int operator()(int x, int y) const { return x + y; } +}; + +struct wrapped_int +{ + wrapped_int() : value(0) { } + wrapped_int(int value) : value(value) { } + + template<typename Archiver> + void serialize(Archiver& ar, const unsigned int /*version*/) { + ar & value; + } + + int value; +}; + +inline wrapped_int operator+(wrapped_int x, wrapped_int y) +{ + return wrapped_int(x.value + y.value); +} + +namespace boost { namespace mpi { + template<> struct is_mpi_datatype<wrapped_int> : mpl::true_ { }; +} } + +struct serialized_int +{ + serialized_int() : value(0) { } + serialized_int(int value) : value(value) { } + + template<typename Archiver> + void serialize(Archiver& ar, const unsigned int /*version*/) { + ar & value; + } + + int value; +}; + +inline serialized_int operator+(serialized_int x, serialized_int y) +{ + return serialized_int(x.value + y.value); +} + +int main(int argc, char* argv[]) +{ + mpi::environment env(argc, argv); + mpi::communicator world; + + int repeat_count = 100; + int outer_repeat_count = 2; + + if (argc > 1) repeat_count = boost::lexical_cast<int>(argv[1]); + if (argc > 2) outer_repeat_count = boost::lexical_cast<int>(argv[2]); + + if (world.rank() == 0) + std::cout << "# of processors: " << world.size() << std::endl + << "# of iterations: " << repeat_count << std::endl; + + int value = world.rank(); + int result; + wrapped_int wi_value = world.rank(); + wrapped_int wi_result; + serialized_int si_value = world.rank(); + serialized_int si_result; + + // Spin for a while... + for (int i = 0; i < repeat_count/10; ++i) { + reduce(world, value, result, std::plus<int>(), 0); + reduce(world, value, result, add_int(), 0); + reduce(world, wi_value, wi_result, std::plus<wrapped_int>(), 0); + reduce(world, si_value, si_result, std::plus<serialized_int>(), 0); + } + + for (int outer = 0; outer < outer_repeat_count; ++outer) { + // Raw MPI + mpi::timer time; + for (int i = 0; i < repeat_count; ++i) { + MPI_Reduce(&value, &result, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD); + } + double reduce_raw_mpi_total_time = time.elapsed(); + + // MPI_INT/MPI_SUM case + time.restart(); + for (int i = 0; i < repeat_count; ++i) { + reduce(world, value, result, std::plus<int>(), 0); + } + double reduce_int_sum_total_time = time.elapsed(); + + // MPI_INT/MPI_Op case + time.restart(); + for (int i = 0; i < repeat_count; ++i) { + reduce(world, value, result, add_int(), 0); + } + double reduce_int_op_total_time = time.elapsed(); + + // MPI_Datatype/MPI_Op case + time.restart(); + for (int i = 0; i < repeat_count; ++i) { + reduce(world, wi_value, wi_result, std::plus<wrapped_int>(), 0); + } + double reduce_type_op_total_time = time.elapsed(); + + // Serialized/MPI_Op case + time.restart(); + for (int i = 0; i < repeat_count; ++i) { + reduce(world, si_value, si_result, std::plus<serialized_int>(), 0); + } + double reduce_ser_op_total_time = time.elapsed(); + + + if (world.rank() == 0) + std::cout << "\nInvocation\tElapsed Time (seconds)" + << "\nRaw MPI\t\t\t" << reduce_raw_mpi_total_time + << "\nMPI_INT/MPI_SUM\t\t" << reduce_int_sum_total_time + << "\nMPI_INT/MPI_Op\t\t" << reduce_int_op_total_time + << "\nMPI_Datatype/MPI_Op\t" << reduce_type_op_total_time + << "\nSerialized/MPI_Op\t" << reduce_ser_op_total_time + << std::endl; + } + + return 0; +} diff --git a/src/boost/libs/mpi/example/string_cat.cpp b/src/boost/libs/mpi/example/string_cat.cpp new file mode 100644 index 000000000..5602d5964 --- /dev/null +++ b/src/boost/libs/mpi/example/string_cat.cpp @@ -0,0 +1,46 @@ +// Copyright (C) 2006 Douglas Gregor <doug.gregor@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) + +// An example using Boost.MPI's reduce() to concatenate strings. +#include <boost/mpi.hpp> +#include <iostream> +#include <string> +#include <boost/serialization/string.hpp> // Important for sending strings! +namespace mpi = boost::mpi; + +/* Defining STRING_CONCAT_COMMUTATIVE lies to Boost.MPI by forcing it + * to assume that string concatenation is commutative, which it is + * not. However, doing so illustrates how the results of a reduction + * can change when a non-commutative operator is assumed to be + * commutative. + */ +#ifdef STRING_CONCAT_COMMUTATIVE +namespace boost { namespace mpi { + +template<> +struct is_commutative<std::plus<std::string>, std::string> : mpl::true_ { }; + +} } // end namespace boost::mpi +#endif + +int main(int argc, char* argv[]) +{ + mpi::environment env(argc, argv); + mpi::communicator world; + + std::string names[10] = { "zero ", "one ", "two ", "three ", "four ", + "five ", "six ", "seven ", "eight ", "nine " }; + + std::string result; + reduce(world, + world.rank() < 10? names[world.rank()] : std::string("many "), + result, std::plus<std::string>(), 0); + + if (world.rank() == 0) + std::cout << "The result is " << result << std::endl; + + return 0; +} diff --git a/src/boost/libs/mpi/index.html b/src/boost/libs/mpi/index.html new file mode 100644 index 000000000..5dad703a1 --- /dev/null +++ b/src/boost/libs/mpi/index.html @@ -0,0 +1,16 @@ + +<!-- +Copyright 2005-2007 Daniel James. +Distributed under 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) +--> + +<html> +<head> + <meta http-equiv="refresh" content="0; URL=../../doc/html/mpi.html"> +</head> +<body> +Automatic redirection failed, please go to +<a href="../../doc/html/mpi.html">../../doc/html/mpi.html</a> +</body> +</html> diff --git a/src/boost/libs/mpi/meta/libraries.json b/src/boost/libs/mpi/meta/libraries.json new file mode 100644 index 000000000..ab1e98fb7 --- /dev/null +++ b/src/boost/libs/mpi/meta/libraries.json @@ -0,0 +1,16 @@ +{ + "key": "mpi", + "name": "MPI", + "authors": [ + "Douglas Gregor", + "Matthias Troyer" + ], + "description": "Message Passing Interface library, for use in distributed-memory parallel application programming.", + "category": [ + "Concurrent" + ], + "maintainers": [ + "K. Noel Belcourt <kbelco -at- sandia.gov>", + "Alain Miniussi <alain.miniussi -at- oca.eu>" + ] +} diff --git a/src/boost/libs/mpi/src/broadcast.cpp b/src/boost/libs/mpi/src/broadcast.cpp new file mode 100644 index 000000000..e171b4865 --- /dev/null +++ b/src/boost/libs/mpi/src/broadcast.cpp @@ -0,0 +1,142 @@ +// Copyright 2005 Douglas Gregor. + +// 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) + +// Message Passing Interface 1.1 -- Section 4.4. Broadcast + +#include <boost/mpi/config.hpp> +#include <boost/mpi/collectives/broadcast.hpp> +#include <boost/mpi/skeleton_and_content.hpp> +#include <boost/mpi/detail/point_to_point.hpp> +#include <boost/mpi/environment.hpp> +#include <cassert> + +namespace boost { namespace mpi { + +template<> +void +broadcast<const packed_oarchive>(const communicator& comm, + const packed_oarchive& oa, + int root) +{ + // Only the root can broadcast the packed_oarchive + assert(comm.rank() == root); + + int size = comm.size(); + if (size < 2) return; + + // Determine maximum tag value + int tag = environment::collectives_tag(); + + // Broadcast data to all nodes + std::vector<request> requests(size-1); + std::vector<request>::iterator it = requests.begin(); + for (int dest = 0; dest < size; ++dest) { + if (dest != root) { + *it++ = detail::packed_archive_isend(comm, dest, tag, oa); + } + } + wait_all(requests.begin(), requests.end()); +} + +template<> +void +broadcast<packed_oarchive>(const communicator& comm, packed_oarchive& oa, + int root) +{ + broadcast(comm, const_cast<const packed_oarchive&>(oa), root); +} + +template<> +void +broadcast<packed_iarchive>(const communicator& comm, packed_iarchive& ia, + int root) +{ + int size = comm.size(); + if (size < 2) return; + + // Determine maximum tag value + int tag = environment::collectives_tag(); + + // Receive data from the root. + if (comm.rank() != root) { + MPI_Status status; + detail::packed_archive_recv(comm, root, tag, ia, status); + } else { + // Broadcast data to all nodes + std::vector<request> requests(size-1); + std::vector<request>::iterator it = requests.begin(); + for (int dest = 0; dest < size; ++dest) { + if (dest != root) { + *it++ = detail::packed_archive_isend(comm, dest, tag, ia); + } + } + wait_all(requests.begin(), requests.end()); + } +} + +template<> +void +broadcast<const packed_skeleton_oarchive>(const communicator& comm, + const packed_skeleton_oarchive& oa, + int root) +{ + broadcast(comm, oa.get_skeleton(), root); +} + +template<> +void +broadcast<packed_skeleton_oarchive>(const communicator& comm, + packed_skeleton_oarchive& oa, int root) +{ + broadcast(comm, oa.get_skeleton(), root); +} + +template<> +void +broadcast<packed_skeleton_iarchive>(const communicator& comm, + packed_skeleton_iarchive& ia, int root) +{ + broadcast(comm, ia.get_skeleton(), root); +} + +template<> +void broadcast<content>(const communicator& comm, content& c, int root) +{ + broadcast(comm, const_cast<const content&>(c), root); +} + +template<> +void broadcast<const content>(const communicator& comm, const content& c, + int root) +{ +#if defined(BOOST_MPI_BCAST_BOTTOM_WORKS_FINE) + BOOST_MPI_CHECK_RESULT(MPI_Bcast, + (MPI_BOTTOM, 1, c.get_mpi_datatype(), + root, comm)); +#else + if (comm.size() < 2) + return; + + // Some versions of LAM/MPI behave badly when broadcasting using + // MPI_BOTTOM, so we'll instead use manual send/recv operations. + if (comm.rank() == root) { + for (int p = 0; p < comm.size(); ++p) { + if (p != root) { + BOOST_MPI_CHECK_RESULT(MPI_Send, + (MPI_BOTTOM, 1, c.get_mpi_datatype(), + p, environment::collectives_tag(), comm)); + } + } + } else { + BOOST_MPI_CHECK_RESULT(MPI_Recv, + (MPI_BOTTOM, 1, c.get_mpi_datatype(), + root, environment::collectives_tag(), + comm, MPI_STATUS_IGNORE)); + } +#endif +} + +} } // end namespace boost::mpi diff --git a/src/boost/libs/mpi/src/cartesian_communicator.cpp b/src/boost/libs/mpi/src/cartesian_communicator.cpp new file mode 100644 index 000000000..a46f0bc2e --- /dev/null +++ b/src/boost/libs/mpi/src/cartesian_communicator.cpp @@ -0,0 +1,179 @@ + +// Copyright Alain Miniussi 2014. +// Distributed under 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: Alain Miniussi + +#include <algorithm> +#include <cassert> + +#include <boost/mpi/cartesian_communicator.hpp> + +namespace boost { namespace mpi { + +namespace { + template <typename T, typename A> + T* c_data(std::vector<T,A>& v) { return &(v[0]); } +} + +std::ostream& +operator<<(std::ostream& out, cartesian_dimension const& d) { + out << '(' << d.size << ','; + if (d.periodic) { + out << "periodic"; + } else { + out << "bounded"; + } + out << ')'; + return out; +} + +std::ostream& +operator<<(std::ostream& out, cartesian_topology const& topo) { + out << '{'; + int const sz = topo.size(); + for (int i = 0; i < sz; ++i) { + out << topo[i]; + if ( i < (sz-1) ) { + out << ','; + } + } + out << '}'; + return out; +} + +cartesian_communicator::cartesian_communicator(const communicator& comm, + const cartesian_topology& topology, + bool reorder ) + : communicator(MPI_COMM_NULL, comm_attach) +{ + std::vector<int> dims(topology.size()); + std::vector<int> periodic(topology.size()); + int tsz = topology.size(); + for(int i = 0; i < tsz; ++i) { + dims[i] = topology[i].size; + periodic[i] = topology[i].periodic; + } + // Fill the gaps, if any + if (std::count(dims.begin(), dims.end(), 0) > 0) { + cartesian_dimensions(comm, dims); + } + MPI_Comm newcomm; + BOOST_MPI_CHECK_RESULT(MPI_Cart_create, + ((MPI_Comm)comm, dims.size(), + c_data(dims), c_data(periodic), + int(reorder), &newcomm)); + if(newcomm != MPI_COMM_NULL) { + comm_ptr.reset(new MPI_Comm(newcomm), comm_free()); + } +} + +cartesian_communicator::cartesian_communicator(const cartesian_communicator& comm, + const std::vector<int>& keep ) + : communicator(MPI_COMM_NULL, comm_attach) +{ + int const max_dims = comm.ndims(); + int const nbkept = keep.size(); + assert(nbkept <= max_dims); + std::vector<int> bitset(max_dims, int(false)); + for(int i = 0; i < nbkept; ++i) { + assert(keep[i] < max_dims); + bitset[keep[i]] = true; + } + + MPI_Comm newcomm; + BOOST_MPI_CHECK_RESULT(MPI_Cart_sub, + ((MPI_Comm)comm, c_data(bitset), &newcomm)); + if(newcomm != MPI_COMM_NULL) { + comm_ptr.reset(new MPI_Comm(newcomm), comm_free()); + } +} + +int +cartesian_communicator::ndims() const { + int n = -1; + BOOST_MPI_CHECK_RESULT(MPI_Cartdim_get, + (MPI_Comm(*this), &n)); + return n; +} + +int +cartesian_communicator::rank(const std::vector<int>& coords ) const { + int r = -1; + assert(int(coords.size()) == ndims()); + BOOST_MPI_CHECK_RESULT(MPI_Cart_rank, + (MPI_Comm(*this), c_data(const_cast<std::vector<int>&>(coords)), + &r)); + return r; +} + +std::pair<int, int> +cartesian_communicator::shifted_ranks(int dim, int disp) const { + std::pair<int, int> r(-1,-1); + assert(0 <= dim && dim < ndims()); + BOOST_MPI_CHECK_RESULT(MPI_Cart_shift, + (MPI_Comm(*this), dim, disp, &(r.first), &(r.second))); + return r; +} + +std::vector<int> +cartesian_communicator::coordinates(int rk) const { + std::vector<int> cbuf(ndims()); + BOOST_MPI_CHECK_RESULT(MPI_Cart_coords, + (MPI_Comm(*this), rk, cbuf.size(), c_data(cbuf) )); + return cbuf; +} + +void +cartesian_communicator::topology( cartesian_topology& topo, + std::vector<int>& coords ) const { + int ndims = this->ndims(); + topo.resize(ndims); + coords.resize(ndims); + std::vector<int> cdims(ndims); + std::vector<int> cperiods(ndims); + BOOST_MPI_CHECK_RESULT(MPI_Cart_get, + (MPI_Comm(*this), ndims, c_data(cdims), c_data(cperiods), c_data(coords))); + cartesian_topology res(cdims.begin(), cperiods.begin(), ndims); + topo.swap(res); +} + +cartesian_topology +cartesian_communicator::topology() const { + cartesian_topology topo(ndims()); + std::vector<int> coords; + topology(topo, coords); + return topo; +} + +void +cartesian_topology::split(std::vector<int>& dims, std::vector<bool>& periodics) const { + int ndims = size(); + dims.resize(ndims); + periodics.resize(ndims); + for(int i = 0; i < ndims; ++i) { + cartesian_dimension const& d = (*this)[i]; + dims[i] = d.size; + periodics[i] = d.periodic; + } +} + +std::vector<int>& +cartesian_dimensions(int sz, std::vector<int>& dims) { + int min = 1; + int const dimsz = dims.size(); + for(int i = 0; i < dimsz; ++i) { + if (dims[i] > 0) { + min *= dims[i]; + } + } + int leftover = sz % min; + + BOOST_MPI_CHECK_RESULT(MPI_Dims_create, + (sz-leftover, dims.size(), c_data(dims))); + return dims; +} + +} } // end namespace boost::mpi diff --git a/src/boost/libs/mpi/src/communicator.cpp b/src/boost/libs/mpi/src/communicator.cpp new file mode 100644 index 000000000..016c6af41 --- /dev/null +++ b/src/boost/libs/mpi/src/communicator.cpp @@ -0,0 +1,328 @@ +// Copyright (C) 2005, 2006 Douglas Gregor. + +// 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) +#include <boost/mpi/communicator.hpp> +#include <boost/mpi/group.hpp> +#include <boost/mpi/intercommunicator.hpp> +#include <boost/mpi/graph_communicator.hpp> +#include <boost/mpi/cartesian_communicator.hpp> +#include <boost/mpi/skeleton_and_content.hpp> +#include <boost/mpi/detail/point_to_point.hpp> + +namespace boost { namespace mpi { + +/*************************************************************************** + * status * + ***************************************************************************/ +bool status::cancelled() const +{ + int flag = 0; + BOOST_MPI_CHECK_RESULT(MPI_Test_cancelled, (&m_status, &flag)); + return flag != 0; +} + +/*************************************************************************** + * communicator * + ***************************************************************************/ + +communicator::communicator() +{ + comm_ptr.reset(new MPI_Comm(MPI_COMM_WORLD)); +} + +communicator::communicator(const MPI_Comm& comm, comm_create_kind kind) +{ + if (comm == MPI_COMM_NULL) + /* MPI_COMM_NULL indicates that the communicator is not usable. */ + return; + + switch (kind) { + case comm_duplicate: + { + MPI_Comm newcomm; + BOOST_MPI_CHECK_RESULT(MPI_Comm_dup, (comm, &newcomm)); + comm_ptr.reset(new MPI_Comm(newcomm), comm_free()); + MPI_Comm_set_errhandler(newcomm, MPI_ERRORS_RETURN); + break; + } + + case comm_take_ownership: + comm_ptr.reset(new MPI_Comm(comm), comm_free()); + break; + + case comm_attach: + comm_ptr.reset(new MPI_Comm(comm)); + break; + } +} + +communicator::communicator(const communicator& comm, + const boost::mpi::group& subgroup) +{ + MPI_Comm newcomm; + BOOST_MPI_CHECK_RESULT(MPI_Comm_create, + ((MPI_Comm)comm, (MPI_Group)subgroup, &newcomm)); + if(newcomm != MPI_COMM_NULL) + comm_ptr.reset(new MPI_Comm(newcomm), comm_free()); +} + +int communicator::size() const +{ + int size_; + BOOST_MPI_CHECK_RESULT(MPI_Comm_size, (MPI_Comm(*this), &size_)); + return size_; +} + +int communicator::rank() const +{ + int rank_; + BOOST_MPI_CHECK_RESULT(MPI_Comm_rank, (MPI_Comm(*this), &rank_)); + return rank_; +} + +boost::mpi::group communicator::group() const +{ + MPI_Group gr; + BOOST_MPI_CHECK_RESULT(MPI_Comm_group, ((MPI_Comm)*this, &gr)); + return boost::mpi::group(gr, /*adopt=*/true); +} + +void communicator::send(int dest, int tag) const +{ + BOOST_MPI_CHECK_RESULT(MPI_Send, + (MPI_BOTTOM, 0, MPI_PACKED, + dest, tag, MPI_Comm(*this))); +} + +status communicator::recv(int source, int tag) const +{ + status stat; + BOOST_MPI_CHECK_RESULT(MPI_Recv, + (MPI_BOTTOM, 0, MPI_PACKED, + source, tag, MPI_Comm(*this), &stat.m_status)); + return stat; +} + +optional<status> communicator::iprobe(int source, int tag) const +{ + typedef optional<status> result_type; + + status stat; + int flag; + BOOST_MPI_CHECK_RESULT(MPI_Iprobe, + (source, tag, MPI_Comm(*this), &flag, + &stat.m_status)); + if (flag) return stat; + else return result_type(); +} + +status communicator::probe(int source, int tag) const +{ + status stat; + BOOST_MPI_CHECK_RESULT(MPI_Probe, + (source, tag, MPI_Comm(*this), &stat.m_status)); + return stat; +} + +void (communicator::barrier)() const +{ + BOOST_MPI_CHECK_RESULT(MPI_Barrier, (MPI_Comm(*this))); +} + + +communicator::operator MPI_Comm() const +{ + if (comm_ptr) return *comm_ptr; + else return MPI_COMM_NULL; +} + +communicator communicator::split(int color) const +{ + return split(color, rank()); +} + +communicator communicator::split(int color, int key) const +{ + MPI_Comm newcomm; + BOOST_MPI_CHECK_RESULT(MPI_Comm_split, + (MPI_Comm(*this), color, key, &newcomm)); + return communicator(newcomm, comm_take_ownership); +} + +optional<intercommunicator> communicator::as_intercommunicator() const +{ + int flag; + BOOST_MPI_CHECK_RESULT(MPI_Comm_test_inter, ((MPI_Comm)*this, &flag)); + if (flag) + return intercommunicator(comm_ptr); + else + return optional<intercommunicator>(); +} + +bool communicator::has_graph_topology() const +{ + bool is_graph = false; + // topology test not allowed on MPI_NULL_COMM + if (bool(*this)) { + int status; + BOOST_MPI_CHECK_RESULT(MPI_Topo_test, ((MPI_Comm)*this, &status)); + is_graph = status == MPI_GRAPH; + } + return is_graph; +} + +optional<graph_communicator> communicator::as_graph_communicator() const +{ + if (has_graph_topology()) { + return graph_communicator(comm_ptr); + } else { + return optional<graph_communicator>(); + } +} + +bool communicator::has_cartesian_topology() const +{ + bool is_cart = false; + // topology test not allowed on MPI_NULL_COM + if (bool(*this)) { + int status; + BOOST_MPI_CHECK_RESULT(MPI_Topo_test, ((MPI_Comm)*this, &status)); + is_cart = status == MPI_CART; + } + return is_cart; +} + +optional<cartesian_communicator> communicator::as_cartesian_communicator() const +{ + if (has_cartesian_topology()) { + return cartesian_communicator(comm_ptr); + } else { + return optional<cartesian_communicator>(); + } +} + +void communicator::abort(int errcode) const +{ + BOOST_MPI_CHECK_RESULT(MPI_Abort, (MPI_Comm(*this), errcode)); + std::abort(); +} + +/************************************************************* + * archived send/recv * + *************************************************************/ +template<> +void +communicator::send<packed_oarchive>(int dest, int tag, + const packed_oarchive& ar) const +{ + detail::packed_archive_send(*this, dest, tag, ar); +} + +template<> +void +communicator::send<packed_skeleton_oarchive> + (int dest, int tag, const packed_skeleton_oarchive& ar) const +{ + this->send(dest, tag, ar.get_skeleton()); +} + +template<> +void communicator::send<content>(int dest, int tag, const content& c) const +{ + BOOST_MPI_CHECK_RESULT(MPI_Send, + (MPI_BOTTOM, 1, c.get_mpi_datatype(), + dest, tag, MPI_Comm(*this))); +} + +template<> +status +communicator::recv<packed_iarchive>(int source, int tag, + packed_iarchive& ar) const +{ + status stat; + detail::packed_archive_recv(*this, source, tag, ar, + stat.m_status); + return stat; +} + +template<> +status +communicator::recv<packed_skeleton_iarchive> + (int source, int tag, packed_skeleton_iarchive& ar) const +{ + return this->recv(source, tag, ar.get_skeleton()); +} + +template<> +status +communicator::recv<const content>(int source, int tag, const content& c) const +{ + status stat; + BOOST_MPI_CHECK_RESULT(MPI_Recv, + (MPI_BOTTOM, 1, c.get_mpi_datatype(), + source, tag, MPI_Comm(*this), &stat.m_status)); + return stat; +} + +/************************************************************* + * non-blocking send/recv * + *************************************************************/ +template<> +request +communicator::isend<packed_oarchive>(int dest, int tag, + const packed_oarchive& ar) const +{ + return detail::packed_archive_isend(*this, dest, tag, ar); +} + +template<> +request +communicator::isend<packed_skeleton_oarchive> + (int dest, int tag, const packed_skeleton_oarchive& ar) const +{ + return this->isend(dest, tag, ar.get_skeleton()); +} + +template<> +request communicator::isend<content>(int dest, int tag, const content& c) const +{ + return request::make_bottom_send(*this, dest, tag, c.get_mpi_datatype()); +} + +request communicator::isend(int dest, int tag) const +{ + return request::make_empty_send(*this, dest, tag); +} + +template<> +request +communicator::irecv<packed_skeleton_iarchive> + (int source, int tag, packed_skeleton_iarchive& ar) const +{ + return this->irecv(source, tag, ar.get_skeleton()); +} + +template<> +request +communicator::irecv<const content>(int source, int tag, + const content& c) const +{ + return request::make_bottom_recv(*this, source, tag, c.get_mpi_datatype()); +} + +request communicator::irecv(int source, int tag) const +{ + return request::make_empty_recv(*this, source, tag); +} + +bool operator==(const communicator& comm1, const communicator& comm2) +{ + int result; + BOOST_MPI_CHECK_RESULT(MPI_Comm_compare, + (MPI_Comm(comm1), MPI_Comm(comm2), &result)); + return result == MPI_IDENT; +} + +} } // end namespace boost::mpi diff --git a/src/boost/libs/mpi/src/computation_tree.cpp b/src/boost/libs/mpi/src/computation_tree.cpp new file mode 100644 index 000000000..60de534d1 --- /dev/null +++ b/src/boost/libs/mpi/src/computation_tree.cpp @@ -0,0 +1,72 @@ +// Copyright (C) 2005 Douglas Gregor. + +// 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) + +// Compute parents, children, levels, etc. to effect a parallel +// computation tree. + +#include <boost/mpi/detail/computation_tree.hpp> + +namespace boost { namespace mpi { namespace detail { + +int computation_tree::default_branching_factor = 3; + +computation_tree +::computation_tree(int rank, int size, int root, int branching_factor) + : rank(rank), size(size), root(root), + branching_factor_(branching_factor > 1? branching_factor + /* default */: default_branching_factor), + level_(0) +{ + // The position in the tree, once we've adjusted for non-zero + // roots. + int n = (rank + size - root) % size; + int sum = 0; + int term = 1; + + /* The level is the smallest value of k such that + + f^0 + f^1 + ... + f^k > n + + for branching factor f and index n in the tree. */ + while (sum <= n) { + ++level_; + term *= branching_factor_; + sum += term; + } +} + +int computation_tree::level_index(int n) const +{ + int sum = 0; + int term = 1; + while (n--) { + sum += term; + term *= branching_factor_; + } + return sum; +} + +int computation_tree::parent() const +{ + if (rank == root) return rank; + int n = rank + size - 1 - root; + return ((n % size / branching_factor_) + root) % size ; +} + +int computation_tree::child_begin() const +{ + // Zero-based index of this node + int n = (rank + size - root) % size; + + // Compute the index of the child (in a zero-based tree) + int child_index = level_index(level_ + 1) + + branching_factor_ * (n - level_index(level_)); + + if (child_index >= size) return root; + else return (child_index + root) % size; +} + +} } } // end namespace boost::mpi::detail diff --git a/src/boost/libs/mpi/src/content_oarchive.cpp b/src/boost/libs/mpi/src/content_oarchive.cpp new file mode 100644 index 000000000..0ec1ece37 --- /dev/null +++ b/src/boost/libs/mpi/src/content_oarchive.cpp @@ -0,0 +1,20 @@ +// (C) Copyright 2005 Matthias Troyer + +// 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 + +#define BOOST_ARCHIVE_SOURCE +#include <boost/archive/detail/archive_serializer_map.hpp> +#include <boost/archive/impl/archive_serializer_map.ipp> +#include <boost/mpi/skeleton_and_content.hpp> + +namespace boost { namespace archive { namespace detail { +// explicitly instantiate all required template functions + +template class archive_serializer_map<mpi::detail::content_oarchive> ; +template class archive_serializer_map<boost::mpi::detail::ignore_skeleton_oarchive<boost::mpi::detail::content_oarchive> >; +template class archive_serializer_map<boost::mpi::detail::ignore_skeleton_oarchive<boost::mpi::detail::mpi_datatype_oarchive> >; +} } } diff --git a/src/boost/libs/mpi/src/environment.cpp b/src/boost/libs/mpi/src/environment.cpp new file mode 100644 index 000000000..72b0359fd --- /dev/null +++ b/src/boost/libs/mpi/src/environment.cpp @@ -0,0 +1,258 @@ +// Copyright (C) 2005-2006 Douglas Gregor <doug.gregor@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) + +// Message Passing Interface 1.1 -- 7.1.1. Environmental Inquiries +#include <boost/mpi/environment.hpp> +#include <boost/mpi/exception.hpp> +#include <boost/mpi/detail/mpi_datatype_cache.hpp> +#include <boost/core/uncaught_exceptions.hpp> +#include <cassert> +#include <string> +#include <exception> +#include <stdexcept> +#include <ostream> + +namespace boost { namespace mpi { +namespace threading { +std::istream& operator>>(std::istream& in, level& l) +{ + std::string tk; + in >> tk; + if (!in.bad()) { + if (tk == "single") { + l = single; + } else if (tk == "funneled") { + l = funneled; + } else if (tk == "serialized") { + l = serialized; + } else if (tk == "multiple") { + l = multiple; + } else { + in.setstate(std::ios::badbit); + } + } + return in; +} + +std::ostream& operator<<(std::ostream& out, level l) +{ + switch(l) { + case single: + out << "single"; + break; + case funneled: + out << "funneled"; + break; + case serialized: + out << "serialized"; + break; + case multiple: + out << "multiple"; + break; + default: + out << "<level error>[" << int(l) << ']'; + out.setstate(std::ios::badbit); + break; + } + return out; +} + +} // namespace threading + +#ifdef BOOST_MPI_HAS_NOARG_INITIALIZATION +environment::environment(bool abrt) + : i_initialized(false), + abort_on_exception(abrt) +{ + if (!initialized()) { + BOOST_MPI_CHECK_RESULT(MPI_Init, (0, 0)); + i_initialized = true; + } + +#if (2 <= MPI_VERSION) + MPI_Comm_set_errhandler(MPI_COMM_WORLD, MPI_ERRORS_RETURN); +#else + MPI_Errhandler_set(MPI_COMM_WORLD, MPI_ERRORS_RETURN); +#endif +} + +environment::environment(threading::level mt_level, bool abrt) + : i_initialized(false), + abort_on_exception(abrt) +{ + // It is not clear that we can pass null in MPI_Init_thread. + int dummy_thread_level = 0; + if (!initialized()) { + BOOST_MPI_CHECK_RESULT(MPI_Init_thread, + (0, 0, int(mt_level), &dummy_thread_level )); + i_initialized = true; + } + +#if (2 <= MPI_VERSION) + MPI_Comm_set_errhandler(MPI_COMM_WORLD, MPI_ERRORS_RETURN); +#else + MPI_Errhandler_set(MPI_COMM_WORLD, MPI_ERRORS_RETURN); +#endif +} +#endif + +environment::environment(int& argc, char** &argv, bool abrt) + : i_initialized(false), + abort_on_exception(abrt) +{ + if (!initialized()) { + BOOST_MPI_CHECK_RESULT(MPI_Init, (&argc, &argv)); + i_initialized = true; + } + +#if (2 <= MPI_VERSION) + MPI_Comm_set_errhandler(MPI_COMM_WORLD, MPI_ERRORS_RETURN); +#else + MPI_Errhandler_set(MPI_COMM_WORLD, MPI_ERRORS_RETURN); +#endif +} + +environment::environment(int& argc, char** &argv, threading::level mt_level, + bool abrt) + : i_initialized(false), + abort_on_exception(abrt) +{ + // It is not clear that we can pass null in MPI_Init_thread. + int dummy_thread_level = 0; + if (!initialized()) { + BOOST_MPI_CHECK_RESULT(MPI_Init_thread, + (&argc, &argv, int(mt_level), &dummy_thread_level)); + i_initialized = true; + } + +#if (2 <= MPI_VERSION) + MPI_Comm_set_errhandler(MPI_COMM_WORLD, MPI_ERRORS_RETURN); +#else + MPI_Errhandler_set(MPI_COMM_WORLD, MPI_ERRORS_RETURN); +#endif +} + +environment::~environment() +{ + if (i_initialized) { + if (boost::core::uncaught_exceptions() > 0 && abort_on_exception) { + abort(-1); + } else if (!finalized()) { + detail::mpi_datatype_cache().clear(); + BOOST_MPI_CHECK_RESULT(MPI_Finalize, ()); + } + } +} + +void environment::abort(int errcode) +{ + BOOST_MPI_CHECK_RESULT(MPI_Abort, (MPI_COMM_WORLD, errcode)); +} + +bool environment::initialized() +{ + int flag; + BOOST_MPI_CHECK_RESULT(MPI_Initialized, (&flag)); + return flag != 0; +} + +bool environment::finalized() +{ + int flag; + BOOST_MPI_CHECK_RESULT(MPI_Finalized, (&flag)); + return flag != 0; +} + +int environment::max_tag() +{ + int* max_tag_value; + int found = 0; + +#if (2 <= MPI_VERSION) + BOOST_MPI_CHECK_RESULT(MPI_Comm_get_attr, + (MPI_COMM_WORLD, MPI_TAG_UB, &max_tag_value, &found)); +#else + BOOST_MPI_CHECK_RESULT(MPI_Attr_get, + (MPI_COMM_WORLD, MPI_TAG_UB, &max_tag_value, &found)); +#endif + assert(found != 0); + return *max_tag_value - num_reserved_tags; +} + +int environment::collectives_tag() +{ + return max_tag() + 1; +} + +optional<int> environment::host_rank() +{ + int* host; + int found = 0; + +#if (2 <= MPI_VERSION) + BOOST_MPI_CHECK_RESULT(MPI_Comm_get_attr, + (MPI_COMM_WORLD, MPI_HOST, &host, &found)); +#else + BOOST_MPI_CHECK_RESULT(MPI_Attr_get, + (MPI_COMM_WORLD, MPI_HOST, &host, &found)); +#endif + if (!found || *host == MPI_PROC_NULL) + return optional<int>(); + else + return *host; +} + +optional<int> environment::io_rank() +{ + int* io; + int found = 0; + +#if (2 <= MPI_VERSION) + BOOST_MPI_CHECK_RESULT(MPI_Comm_get_attr, + (MPI_COMM_WORLD, MPI_IO, &io, &found)); +#else + BOOST_MPI_CHECK_RESULT(MPI_Attr_get, + (MPI_COMM_WORLD, MPI_IO, &io, &found)); +#endif + if (!found || *io == MPI_PROC_NULL) + return optional<int>(); + else + return *io; +} + +std::string environment::processor_name() +{ + char name[MPI_MAX_PROCESSOR_NAME]; + int len; + + BOOST_MPI_CHECK_RESULT(MPI_Get_processor_name, (name, &len)); + return std::string(name, len); +} + +threading::level environment::thread_level() +{ + int level; + + BOOST_MPI_CHECK_RESULT(MPI_Query_thread, (&level)); + return static_cast<threading::level>(level); +} + +bool environment::is_main_thread() +{ + int isit; + + BOOST_MPI_CHECK_RESULT(MPI_Is_thread_main, (&isit)); + return static_cast<bool>(isit); +} + +std::pair<int, int> environment::version() +{ + int major, minor; + BOOST_MPI_CHECK_RESULT(MPI_Get_version, (&major, &minor)); + return std::make_pair(major, minor); +} + +} } // end namespace boost::mpi diff --git a/src/boost/libs/mpi/src/error_string.cpp b/src/boost/libs/mpi/src/error_string.cpp new file mode 100644 index 000000000..a6db48a6f --- /dev/null +++ b/src/boost/libs/mpi/src/error_string.cpp @@ -0,0 +1,31 @@ +// Copyright (C) 2018 Alain Miniussi <alain.miniussi -at- oca.eu>. + +// 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) + +#include <sstream> +#include <boost/mpi/error_string.hpp> + +namespace boost { namespace mpi { + +std::string error_string(int err) +{ + char buffer[MPI_MAX_ERROR_STRING]; + int len; + int status = MPI_Error_string(err, buffer, &len); + if (status == MPI_SUCCESS) { + return std::string(buffer); + } else { + std::ostringstream out; + if (status == MPI_ERR_ARG) { + out << "<invalid MPI error code " << err << ">"; + } else { + out << "<got error " << status + << " while probing MPI error " << err << ">"; + } + return out.str(); + } +} + +} } diff --git a/src/boost/libs/mpi/src/exception.cpp b/src/boost/libs/mpi/src/exception.cpp new file mode 100644 index 000000000..aaae9e377 --- /dev/null +++ b/src/boost/libs/mpi/src/exception.cpp @@ -0,0 +1,24 @@ +// Copyright (C) 2007 Trustees of Indiana University + +// Authors: Douglas Gregor +// Andrew Lumsdaine + +// 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) +#include <boost/mpi/exception.hpp> +#include <boost/mpi/error_string.hpp> + +namespace boost { namespace mpi { + +exception::exception(const char* routine, int result_code) + : routine_(routine), result_code_(result_code) +{ + message.append(routine_); + message.append(": "); + message.append(error_string(result_code)); +} + +exception::~exception() throw() { } + +} } // end namespace boost::mpi diff --git a/src/boost/libs/mpi/src/graph_communicator.cpp b/src/boost/libs/mpi/src/graph_communicator.cpp new file mode 100644 index 000000000..586b57bf9 --- /dev/null +++ b/src/boost/libs/mpi/src/graph_communicator.cpp @@ -0,0 +1,73 @@ +// Copyright (C) 2007 Trustees of Indiana University + +// Authors: Douglas Gregor +// Andrew Lumsdaine + +// 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) +#include <boost/mpi/graph_communicator.hpp> + +namespace boost { namespace mpi { + +// Incidence Graph requirements +std::pair<detail::comm_out_edge_iterator, detail::comm_out_edge_iterator> +out_edges(int vertex, const graph_communicator& comm) +{ + int nneighbors = out_degree(vertex, comm); + shared_array<int> neighbors(new int[nneighbors]); + BOOST_MPI_CHECK_RESULT(MPI_Graph_neighbors, + ((MPI_Comm)comm, vertex, nneighbors, neighbors.get())); + return std::make_pair(detail::comm_out_edge_iterator(vertex, neighbors, 0), + detail::comm_out_edge_iterator(vertex, neighbors, + nneighbors)); +} + +int out_degree(int vertex, const graph_communicator& comm) +{ + int nneighbors; + BOOST_MPI_CHECK_RESULT(MPI_Graph_neighbors_count, + ((MPI_Comm)comm, vertex, &nneighbors)); + return nneighbors; +} + +// Adjacency Graph requirements +std::pair<detail::comm_adj_iterator, detail::comm_adj_iterator> +adjacent_vertices(int vertex, const graph_communicator& comm) +{ + int nneighbors = out_degree(vertex, comm); + shared_array<int> neighbors(new int[nneighbors]); + BOOST_MPI_CHECK_RESULT(MPI_Graph_neighbors, + ((MPI_Comm)comm, vertex, nneighbors, neighbors.get())); + return std::make_pair(detail::comm_adj_iterator(neighbors, 0), + detail::comm_adj_iterator(neighbors, nneighbors)); +} + +// Edge List Graph requirements +std::pair<detail::comm_edge_iterator, detail::comm_edge_iterator> +edges(const graph_communicator& comm); + +std::pair<detail::comm_edge_iterator, detail::comm_edge_iterator> +edges(const graph_communicator& comm) +{ + int nnodes, nedges; + BOOST_MPI_CHECK_RESULT(MPI_Graphdims_get, ((MPI_Comm)comm, &nnodes, &nedges)); + + shared_array<int> indices(new int[nnodes]); + shared_array<int> edges(new int[nedges]); + BOOST_MPI_CHECK_RESULT(MPI_Graph_get, + ((MPI_Comm)comm, nnodes, nedges, + indices.get(), edges.get())); + return std::make_pair(detail::comm_edge_iterator(indices, edges), + detail::comm_edge_iterator(nedges)); +} + + +int num_edges(const graph_communicator& comm) +{ + int nnodes, nedges; + BOOST_MPI_CHECK_RESULT(MPI_Graphdims_get, ((MPI_Comm)comm, &nnodes, &nedges)); + return nedges; +} + +} } // end namespace boost::mpi diff --git a/src/boost/libs/mpi/src/group.cpp b/src/boost/libs/mpi/src/group.cpp new file mode 100644 index 000000000..034d08f78 --- /dev/null +++ b/src/boost/libs/mpi/src/group.cpp @@ -0,0 +1,106 @@ +// Copyright (C) 2007 Trustees of Indiana University + +// Authors: Douglas Gregor +// Andrew Lumsdaine + +// 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) +#include <boost/mpi/group.hpp> +#include <boost/mpi/communicator.hpp> + +namespace boost { namespace mpi { + +group::group(const MPI_Group& in_group, bool adopt) +{ + if (in_group != MPI_GROUP_EMPTY) { + if (adopt) group_ptr.reset(new MPI_Group(in_group), group_free()); + else group_ptr.reset(new MPI_Group(in_group)); + } +} + +optional<int> group::rank() const +{ + if (!group_ptr) + return optional<int>(); + + int rank; + BOOST_MPI_CHECK_RESULT(MPI_Group_rank, (*group_ptr, &rank)); + if (rank == MPI_UNDEFINED) + return optional<int>(); + else + return rank; +} + +int group::size() const +{ + if (!group_ptr) + return 0; + + int size; + BOOST_MPI_CHECK_RESULT(MPI_Group_size, (*group_ptr, &size)); + return size; +} + +bool operator==(const group& g1, const group& g2) +{ + int result; + BOOST_MPI_CHECK_RESULT(MPI_Group_compare, + ((MPI_Group)g1, (MPI_Group)g2, &result)); + return result == MPI_IDENT; +} + +group operator|(const group& g1, const group& g2) +{ + MPI_Group result; + BOOST_MPI_CHECK_RESULT(MPI_Group_union, + ((MPI_Group)g1, (MPI_Group)g2, &result)); + return group(result, /*adopt=*/true); +} + +group operator&(const group& g1, const group& g2) +{ + MPI_Group result; + BOOST_MPI_CHECK_RESULT(MPI_Group_intersection, + ((MPI_Group)g1, (MPI_Group)g2, &result)); + return group(result, /*adopt=*/true); +} + +group operator-(const group& g1, const group& g2) +{ + MPI_Group result; + BOOST_MPI_CHECK_RESULT(MPI_Group_difference, + ((MPI_Group)g1, (MPI_Group)g2, &result)); + return group(result, /*adopt=*/true); +} + +template<> +int* +group::translate_ranks(int* first, int* last, const group& to_group, int* out) +{ + BOOST_MPI_CHECK_RESULT(MPI_Group_translate_ranks, + ((MPI_Group)*this, + last-first, + first, + (MPI_Group)to_group, + out)); + return out + (last - first); +} + +template<> group group::include(int* first, int* last) +{ + MPI_Group result; + BOOST_MPI_CHECK_RESULT(MPI_Group_incl, + ((MPI_Group)*this, last - first, first, &result)); + return group(result, /*adopt=*/true); +} + +template<> group group::exclude(int* first, int* last) +{ + MPI_Group result; + BOOST_MPI_CHECK_RESULT(MPI_Group_excl, + ((MPI_Group)*this, last - first, first, &result)); + return group(result, /*adopt=*/true); +} + +} } // end namespace boost::mpi diff --git a/src/boost/libs/mpi/src/intercommunicator.cpp b/src/boost/libs/mpi/src/intercommunicator.cpp new file mode 100644 index 000000000..6b072853c --- /dev/null +++ b/src/boost/libs/mpi/src/intercommunicator.cpp @@ -0,0 +1,54 @@ +// Copyright (C) 2007 Trustees of Indiana University + +// Authors: Douglas Gregor +// Andrew Lumsdaine + +// 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) +#include <boost/mpi/intercommunicator.hpp> +#include <boost/mpi/environment.hpp> +#include <boost/mpi/group.hpp> + +namespace boost { namespace mpi { + +intercommunicator::intercommunicator(const communicator& local, + int local_leader, + const communicator& peer, + int remote_leader) +{ + MPI_Comm comm; + BOOST_MPI_CHECK_RESULT(MPI_Intercomm_create, + ((MPI_Comm)local, local_leader, + (MPI_Comm)peer, remote_leader, + environment::collectives_tag(), &comm)); + comm_ptr.reset(new MPI_Comm(comm), comm_free()); +} + +boost::mpi::group intercommunicator::local_group() const +{ + return this->group(); +} + +int intercommunicator::remote_size() const +{ + int size; + BOOST_MPI_CHECK_RESULT(MPI_Comm_remote_size, ((MPI_Comm)*this, &size)); + return size; +} + +boost::mpi::group intercommunicator::remote_group() const +{ + MPI_Group gr; + BOOST_MPI_CHECK_RESULT(MPI_Comm_remote_group, ((MPI_Comm)*this, &gr)); + return boost::mpi::group(gr, /*adopt=*/true); +} + +communicator intercommunicator::merge(bool high) const +{ + MPI_Comm comm; + BOOST_MPI_CHECK_RESULT(MPI_Intercomm_merge, ((MPI_Comm)*this, high, &comm)); + return communicator(comm, comm_take_ownership); +} + +} } // end namespace boost::mpi diff --git a/src/boost/libs/mpi/src/mpi_datatype_cache.cpp b/src/boost/libs/mpi/src/mpi_datatype_cache.cpp new file mode 100644 index 000000000..8437e9d02 --- /dev/null +++ b/src/boost/libs/mpi/src/mpi_datatype_cache.cpp @@ -0,0 +1,66 @@ +// (C) Copyright 2005 Matthias Troyer + +// 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 + +#include <boost/archive/detail/archive_serializer_map.hpp> +#include <boost/mpi/detail/mpi_datatype_cache.hpp> +#include <map> + +namespace boost { namespace mpi { namespace detail { + + typedef std::map<std::type_info const*,MPI_Datatype,type_info_compare> + stored_map_type; + + struct mpi_datatype_map::implementation + { + stored_map_type map; + }; + + mpi_datatype_map::mpi_datatype_map() + { + impl = new implementation(); + } + + void mpi_datatype_map::clear() + { + // do not free after call to MPI_FInalize + int finalized=0; + BOOST_MPI_CHECK_RESULT(MPI_Finalized,(&finalized)); + if (!finalized) { + // ignore errors in the destructor + for (stored_map_type::iterator it=impl->map.begin(); it != impl->map.end(); ++it) + MPI_Type_free(&(it->second)); + } + } + + + mpi_datatype_map::~mpi_datatype_map() + { + clear(); + delete impl; + } + + MPI_Datatype mpi_datatype_map::get(const std::type_info* t) + { + stored_map_type::iterator pos = impl->map.find(t); + if (pos != impl->map.end()) + return pos->second; + else + return MPI_DATATYPE_NULL; + } + + void mpi_datatype_map::set(const std::type_info* t, MPI_Datatype datatype) + { + impl->map[t] = datatype; + } + + mpi_datatype_map& mpi_datatype_cache() + { + static mpi_datatype_map cache; + return cache; + } +} } } diff --git a/src/boost/libs/mpi/src/mpi_datatype_oarchive.cpp b/src/boost/libs/mpi/src/mpi_datatype_oarchive.cpp new file mode 100644 index 000000000..05d58427c --- /dev/null +++ b/src/boost/libs/mpi/src/mpi_datatype_oarchive.cpp @@ -0,0 +1,19 @@ +// (C) Copyright 2005 Matthias Troyer + +// 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 + +#define BOOST_ARCHIVE_SOURCE +#include <boost/archive/detail/archive_serializer_map.hpp> +#include <boost/archive/impl/archive_serializer_map.ipp> +#include <boost/mpi/detail/mpi_datatype_oarchive.hpp> + +namespace boost { namespace archive { namespace detail { +// explicitly instantiate all required template functions + +template class archive_serializer_map<mpi::detail::mpi_datatype_oarchive> ; + +} } } diff --git a/src/boost/libs/mpi/src/offsets.cpp b/src/boost/libs/mpi/src/offsets.cpp new file mode 100644 index 000000000..2382d456f --- /dev/null +++ b/src/boost/libs/mpi/src/offsets.cpp @@ -0,0 +1,96 @@ +// Copyright Alain Miniussi 2014. +// Distributed under 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: Alain Miniussi + +#include <boost/mpi/detail/offsets.hpp> +#include <boost/mpi/detail/antiques.hpp> + +namespace boost { namespace mpi { +namespace detail { + +// Convert a sequence of sizes [S0..Sn] to a sequence displacement +// [O0..On] where O[0] = 0 and O[k+1] = O[k]+S[k]. +void +sizes2offsets(int const* sizes, int* offsets, int n) +{ + offsets[0] = 0; + for(int i = 1; i < n; ++i) { + offsets[i] = offsets[i-1] + sizes[i-1]; + } +} + +// Convert a sequence of sizes [S0..Sn] to a sequence displacement +// [O0..On] where O[0] = 0 and O[k+1] = O[k]+S[k]. +void +sizes2offsets(std::vector<int> const& sizes, std::vector<int>& offsets) +{ + int sz = sizes.size(); + offsets.resize(sz); + sizes2offsets(c_data(sizes), c_data(offsets), sz); +} + +// Given a sequence of sizes (typically the number of records dispatched +// to each process in a scater) and a sequence of displacements (typically the +// slot index at with those record starts), convert the later to a number +// of skipped slots. +void +offsets2skipped(int const* sizes, int const* offsets, int* skipped, int n) +{ + skipped[0] = 0; + for(int i = 1; i < n; ++i) { + skipped[i] -= offsets[i-1] + sizes[i-1]; + } +} + +// Reconstruct offsets from sizes assuming no padding. +// Only takes place if on the root process and if +// displs are not already provided. +// If memory was allocated, returns a pointer to it +// otherwise null. +int* +make_offsets(communicator const& comm, int const* sizes, int const* displs, int root) +{ + if (root == -1 || root == comm.rank()) { + assert(sizes); + if (!displs) { + int nproc = comm.size(); + int* offsets = new int[nproc]; + displs = offsets; + sizes2offsets(sizes, offsets, nproc); + return offsets; + } else { + return 0; + } + } else { + return 0; + } +} + +// Reconstruct skip slots from sizes and offsets. +// Only takes place if on the root process and if +// displs are provided. +// If memory was allocated, returns a pointer to it +// otherwise null. +int* +make_skipped_slots(communicator const& comm, int const* sizes, int const* displs, int root) +{ + if (root == -1 || root == comm.rank()) { + assert(sizes); + if (displs) { + int nproc = comm.size(); + int* skipped = new int[nproc]; + std::copy(displs, displs+nproc, skipped); + offsets2skipped(sizes, displs, skipped, nproc); + return skipped; + } else { + return 0; + } + } else { + return 0; + } +} +} +}} diff --git a/src/boost/libs/mpi/src/packed_iarchive.cpp b/src/boost/libs/mpi/src/packed_iarchive.cpp new file mode 100644 index 000000000..a0ea5a6b5 --- /dev/null +++ b/src/boost/libs/mpi/src/packed_iarchive.cpp @@ -0,0 +1,21 @@ +// (C) Copyright 2005 Matthias Troyer + +// 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 + +#define BOOST_ARCHIVE_SOURCE +#include <boost/mpi/packed_iarchive.hpp> + +#include <boost/archive/detail/archive_serializer_map.hpp> +#include <boost/archive/impl/archive_serializer_map.ipp> + +namespace boost { namespace archive { + +// explicitly instantiate all required templates + +template class detail::archive_serializer_map<mpi::packed_iarchive> ; + +} } // end namespace boost::archive diff --git a/src/boost/libs/mpi/src/packed_oarchive.cpp b/src/boost/libs/mpi/src/packed_oarchive.cpp new file mode 100644 index 000000000..d340a40f9 --- /dev/null +++ b/src/boost/libs/mpi/src/packed_oarchive.cpp @@ -0,0 +1,19 @@ +// (C) Copyright 2005 Matthias Troyer + +// 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 + +#define BOOST_ARCHIVE_SOURCE +#include <boost/mpi/packed_oarchive.hpp> +#include <boost/archive/detail/archive_serializer_map.hpp> +#include <boost/archive/impl/archive_serializer_map.ipp> + +namespace boost { namespace archive { +// explicitly instantiate all required templates + +template class detail::archive_serializer_map<mpi::packed_oarchive> ; + +} } // end namespace boost::archive diff --git a/src/boost/libs/mpi/src/packed_skeleton_iarchive.cpp b/src/boost/libs/mpi/src/packed_skeleton_iarchive.cpp new file mode 100644 index 000000000..97115c20c --- /dev/null +++ b/src/boost/libs/mpi/src/packed_skeleton_iarchive.cpp @@ -0,0 +1,25 @@ +// (C) Copyright 2005 Matthias Troyer + +// 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 + +#define BOOST_ARCHIVE_SOURCE + +#include <boost/archive/detail/archive_serializer_map.hpp> +#include <boost/archive/impl/archive_serializer_map.ipp> +#include <boost/mpi/skeleton_and_content.hpp> + +namespace boost { namespace archive { + +// explicitly instantiate all required templates + +// template class basic_binary_iarchive<mpi::packed_skeleton_iarchive> ; +template class detail::archive_serializer_map<mpi::packed_skeleton_iarchive> ; +template class detail::archive_serializer_map< + mpi::detail::forward_skeleton_iarchive< + boost::mpi::packed_skeleton_iarchive, boost::mpi::packed_iarchive> > ; + +} } // end namespace boost::archive diff --git a/src/boost/libs/mpi/src/packed_skeleton_oarchive.cpp b/src/boost/libs/mpi/src/packed_skeleton_oarchive.cpp new file mode 100644 index 000000000..5cfecc077 --- /dev/null +++ b/src/boost/libs/mpi/src/packed_skeleton_oarchive.cpp @@ -0,0 +1,22 @@ +// (C) Copyright 2005 Matthias Troyer + +// 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 + +#define BOOST_ARCHIVE_SOURCE +#include <boost/mpi/skeleton_and_content.hpp> +#include <boost/archive/detail/archive_serializer_map.hpp> +#include <boost/archive/impl/archive_serializer_map.ipp> + +namespace boost { namespace archive { +// explicitly instantiate all required templates + +template class detail::archive_serializer_map<mpi::packed_skeleton_oarchive> ; +template class detail::archive_serializer_map< + mpi::detail::forward_skeleton_oarchive< + boost::mpi::packed_skeleton_oarchive, boost::mpi::packed_oarchive> > ; + +} } // end namespace boost::archive diff --git a/src/boost/libs/mpi/src/point_to_point.cpp b/src/boost/libs/mpi/src/point_to_point.cpp new file mode 100644 index 000000000..6fc0ad175 --- /dev/null +++ b/src/boost/libs/mpi/src/point_to_point.cpp @@ -0,0 +1,102 @@ +// Copyright 2005 Douglas Gregor. + +// 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) + +// Message Passing Interface 1.1 -- Section 3. MPI Point-to-point + +/* There is the potential for optimization here. We could keep around + a "small message" buffer of size N that we just receive into by + default. If the message is N - sizeof(int) bytes or smaller, it can + just be sent with that buffer. If it's larger, we send the first N + - sizeof(int) bytes in the first packet followed by another + packet. The size of the second packet will be stored in an integer + at the end of the first packet. + + We will introduce this optimization later, when we have more + performance test cases and have met our functionality goals. */ + +#include <boost/mpi/detail/point_to_point.hpp> +#include <boost/mpi/datatype.hpp> +#include <boost/mpi/exception.hpp> +#include <boost/mpi/request.hpp> +#include <boost/mpi/communicator.hpp> +#include <boost/mpi/detail/antiques.hpp> +#include <cassert> + +namespace boost { namespace mpi { namespace detail { + +void +packed_archive_send(communicator const& comm, int dest, int tag, + const packed_oarchive& ar) +{ +#if defined(BOOST_MPI_USE_IMPROBE) + { + void *buf = detail::unconst(ar.address()); + BOOST_MPI_CHECK_RESULT(MPI_Send, + (buf, ar.size(), MPI_PACKED, + dest, tag, comm)); + } +#else + { + std::size_t const& size = ar.size(); + BOOST_MPI_CHECK_RESULT(MPI_Send, + (detail::unconst(&size), 1, + get_mpi_datatype(size), + dest, tag, comm)); + BOOST_MPI_CHECK_RESULT(MPI_Send, + (detail::unconst(ar.address()), size, + MPI_PACKED, + dest, tag, comm)); + } +#endif +} + +request +packed_archive_isend(communicator const& comm, int dest, int tag, + const packed_oarchive& ar) +{ + return request::make_packed_send(comm, dest, tag, + detail::unconst(ar.address()), ar.size()); +} + +request +packed_archive_isend(communicator const& comm, int dest, int tag, + const packed_iarchive& ar) +{ + return request::make_packed_send(comm, dest, tag, + detail::unconst(ar.address()), ar.size()); +} + +void +packed_archive_recv(communicator const& comm, int source, int tag, packed_iarchive& ar, + MPI_Status& status) +{ +#if defined(BOOST_MPI_USE_IMPROBE) + { + MPI_Message msg; + BOOST_MPI_CHECK_RESULT(MPI_Mprobe, (source, tag, comm, &msg, &status)); + int count; + BOOST_MPI_CHECK_RESULT(MPI_Get_count, (&status, MPI_PACKED, &count)); + ar.resize(count); + BOOST_MPI_CHECK_RESULT(MPI_Mrecv, (ar.address(), count, MPI_PACKED, &msg, &status)); + } +#else + { + std::size_t count; + BOOST_MPI_CHECK_RESULT(MPI_Recv, + (&count, 1, get_mpi_datatype(count), + source, tag, comm, &status)); + + // Prepare input buffer and receive the message + ar.resize(count); + BOOST_MPI_CHECK_RESULT(MPI_Recv, + (ar.address(), count, MPI_PACKED, + status.MPI_SOURCE, status.MPI_TAG, + comm, &status)); + } +#endif +} + +} } } // end namespace boost::mpi::detail diff --git a/src/boost/libs/mpi/src/python/collectives.cpp b/src/boost/libs/mpi/src/python/collectives.cpp new file mode 100644 index 000000000..fc4bf7b4c --- /dev/null +++ b/src/boost/libs/mpi/src/python/collectives.cpp @@ -0,0 +1,144 @@ +// (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: Douglas Gregor + +/** @file status.cpp + * + * This file reflects the Boost.MPI @c status class into + * Python. + */ +#include <boost/python.hpp> +#include <boost/mpi.hpp> +#include <boost/mpi/python/serialize.hpp> + +using namespace boost::python; +using namespace boost::mpi; + +namespace boost { namespace mpi { namespace python { + +extern const char* all_gather_docstring; +extern const char* all_reduce_docstring; +extern const char* all_to_all_docstring; +extern const char* broadcast_docstring; +extern const char* gather_docstring; +extern const char* reduce_docstring; +extern const char* scan_docstring; +extern const char* scatter_docstring; + +object all_gather(const communicator& comm, object value) +{ + std::vector<object> values; + boost::mpi::all_gather(comm, value, values); + + boost::python::list l; + for (int i = 0; i < comm.size(); ++i) + l.append(values[i]); + return boost::python::tuple(l); +} + +object all_to_all(const communicator& comm, object in_values) +{ + // Build input values + std::vector<object> in_values_vec(comm.size()); + object iterator = object(handle<>(PyObject_GetIter(in_values.ptr()))); + for (int i = 0; i < comm.size(); ++i) + in_values_vec[i] = object(handle<>(PyIter_Next(iterator.ptr()))); + + std::vector<object> out_values_vec(comm.size()); + boost::mpi::all_to_all(comm, in_values_vec, out_values_vec); + + boost::python::list l; + for (int i = 0; i < comm.size(); ++i) + l.append(out_values_vec[i]); + return boost::python::tuple(l); +} + +object broadcast(const communicator& comm, object value, int root) +{ + boost::mpi::broadcast(comm, value, root); + return value; +} + +object gather(const communicator& comm, object value, int root) +{ + if (comm.rank() == root) { + std::vector<object> values; + boost::mpi::gather(comm, value, values, root); + + boost::python::list l; + for (int i = 0; i < comm.size(); ++i) + l.append(values[i]); + return boost::python::tuple(l); + } else { + boost::mpi::gather(comm, value, root); + return object(); + } +} + +object reduce(const communicator& comm, object value, object op, int root) +{ + if (comm.rank() == root) { + object out_value; + boost::mpi::reduce(comm, value, out_value, op, root); + return out_value; + } else { + boost::mpi::reduce(comm, value, op, root); + return object(); + } +} + +object scatter(const communicator& comm, object values, int root) +{ + object result; + + if (comm.rank() == root) { + std::vector<object> values_vec(comm.size()); + object iterator = object(handle<>(PyObject_GetIter(values.ptr()))); + for (int i = 0; i < comm.size(); ++i) + values_vec[i] = object(handle<>(PyIter_Next(iterator.ptr()))); + + boost::mpi::scatter(comm, values_vec, result, root); + } else { + boost::mpi::scatter(comm, result, root); + } + return result; +} + +void export_collectives() +{ + using boost::python::arg; + + def("all_reduce", + (object (*)(const communicator&, const object&, object))&all_reduce, + (arg("comm") = communicator(), arg("value"), arg("op")), + all_reduce_docstring); + def("all_gather", &all_gather, + (arg("comm") = communicator(), arg("value") = object()), + all_gather_docstring); + def("all_to_all", &all_to_all, + (arg("comm") = communicator(), arg("values") = object()), + all_to_all_docstring); + def("broadcast", &broadcast, + (arg("comm") = communicator(), arg("value") = object(), arg("root")), + broadcast_docstring); + def("gather", &gather, + (arg("comm") = communicator(), arg("value") = object(), arg("root")), + gather_docstring); + def("reduce", &reduce, + (arg("comm") = communicator(), arg("value"), arg("op"), + arg("root")), + reduce_docstring); + def("scan", + (object (*)(const communicator&, const object&, object))&scan, + (arg("comm") = communicator(), arg("value"), arg("op")), + scan_docstring); + def("scatter", &scatter, + (arg("comm") = communicator(), arg("values") = object(), arg("root")), + scatter_docstring); +} + +} } } // end namespace boost::mpi::python diff --git a/src/boost/libs/mpi/src/python/datatypes.cpp b/src/boost/libs/mpi/src/python/datatypes.cpp new file mode 100644 index 000000000..48d7f6f74 --- /dev/null +++ b/src/boost/libs/mpi/src/python/datatypes.cpp @@ -0,0 +1,27 @@ +// (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: Douglas Gregor + +/** @file datatypes.cpp + * + * This file provides datatypes support for Boost.MPI in Python. + */ +#include <boost/mpi/python/serialize.hpp> +#include <boost/mpi.hpp> + +namespace boost { namespace mpi { namespace python { + +void export_datatypes() +{ +#if PY_MAJOR_VERSION < 3 + register_serialized(long(0), &PyInt_Type); +#endif + register_serialized(false, &PyBool_Type); + register_serialized(double(0.0), &PyFloat_Type); +} + +} } } // end namespace boost::mpi::python diff --git a/src/boost/libs/mpi/src/python/documentation.cpp b/src/boost/libs/mpi/src/python/documentation.cpp new file mode 100644 index 000000000..ef28fb3b5 --- /dev/null +++ b/src/boost/libs/mpi/src/python/documentation.cpp @@ -0,0 +1,671 @@ +// (C) Copyright 2005 The Trustees of Indiana University. +// (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: Douglas Gregor + +/** @file documentation.cpp + * + * This file contains all of the documentation strings for the + * Boost.MPI Python bindings. + */ +namespace boost { namespace mpi { namespace python { + +const char* module_docstring = + "The boost.mpi module contains Python wrappers for Boost.MPI.\n" + "Boost.MPI is a C++ interface to the Message Passing Interface 1.1,\n" + "a high-performance message passing library for parallel programming.\n" + "\n" + "This module supports the most commonly used subset of MPI 1.1. All\n" + "communication operations can transmit any Python object that can be\n" + "pickled and unpickled, along with C++-serialized data types and\n" + "separation of the structure of a data type from its content.\n" + "Collectives that have a user-supplied functions,\n" + "such as reduce() or scan(), accept arbitrary Python functions, and\n" + "all collectives can operate on any serializable or picklable data type.\n" + "\n" + "IMPORTANT MODULE DATA\n" + " any_source This constant may be used for the source parameter of\n" + " receive and probe operations to indicate that a\n" + " message may be received from any source.\n" + "\n" + " any_tag This constant may be used for the tag parameter of\n" + " receive or probe operations to indicate that a send\n" + " with any tag will be matched.\n" + "\n" + " collectives_tag Returns the reserved tag value used by the Boost.MPI\n" + " implementation for collective operations. Although\n" + " users are not permitted to use this tag to send or\n" + " receive messages with this tag, it may be useful when\n" + " monitoring communication patterns.\n" + "\n" + " host_rank If there is a host process, this is the rank of that\n" + " that process. Otherwise, this value will be None. MPI\n" + " does not define the meaning of a \"host\" process: \n" + " consult the documentation for your MPI implementation.\n" + "\n" + " io_rank The rank of a process that can perform input/output\n" + " via the standard facilities. If every process can\n" + " perform I/O using the standard facilities, this value\n" + " will be the same as any_source. If no process can\n" + " perform I/O, this value will be None.\n" + "\n" + " max_tag The maximum value that may be used for the tag\n" + " parameter of send/receive operations. This value will\n" + " be somewhat smaller than the value of MPI_TAG_UB,\n" + " because the Boost.MPI implementation reserves some\n" + " tags for collective operations.\n" + "\n" + " processor_name The name of this processor. The actual form of the\n" + " of the name is unspecified, but may be documented by\n" + " the underlying MPI implementation.\n" + "\n" + " rank The rank of this process in the \"world\" communicator.\n" + "\n" + " size The number of processes in the \"world\" communicator.\n" + " that process. Otherwise, this value will be None. MPI\n" + " does not define the meaning of a \"host\" process: \n" + "\n" + " world The \"world\" communicator from which all other\n" + " communicators will be derived. This is the equivalent\n" + " of MPI_COMM_WORLD.\n" + "\n" + "TRANSMITTING USER-DEFINED DATA\n" + " Boost.MPI can transmit user-defined data in several different ways.\n" + " Most importantly, it can transmit arbitrary Python objects by pickling\n" + " them at the sender and unpickling them at the receiver, allowing\n" + " arbitrarily complex Python data structures to interoperate with MPI.\n" + "\n" + " Boost.MPI also supports efficient serialization and transmission of\n" + " C++ objects (that have been exposed to Python) through its C++\n" + " interface. Any C++ type that provides (de-)serialization routines that\n" + " meet the requirements of the Boost.Serialization library is eligible\n" + " for this optimization, but the type must be registered in advance. To\n" + " register a C++ type, invoke the C++ function:\n" + " boost::mpi::python::register_serialized\n" + "\n" + " Finally, Boost.MPI supports separation of the structure of an object\n" + " from the data it stores, allowing the two pieces to be transmitted\n" + " separately. This \"skeleton/content\" mechanism, described in more\n" + " detail in a later section, is a communication optimization suitable\n" + " for problems with fixed data structures whose internal data changes\n" + " frequently.\n" + "\n" + "COLLECTIVES\n" + " Boost.MPI supports all of the MPI collectives (scatter, reduce, scan,\n" + " broadcast, etc.) for any type of data that can be transmitted with the\n" + " point-to-point communication operations. For the MPI collectives that\n" + " require a user-specified operation (e.g., reduce and scan), the\n" + " operation can be an arbitrary Python function. For instance, one could\n" + " concatenate strings with all_reduce:\n\n" + " mpi.all_reduce(my_string, lambda x,y: x + y)\n\n" + " The following module-level functions implement MPI collectives:\n" + " all_gather Gather the values from all processes.\n" + " all_reduce Combine the results from all processes.\n" + " all_to_all Every process sends data to every other process.\n" + " broadcast Broadcast data from one process to all other processes.\n" + " gather Gather the values from all processes to the root.\n" + " reduce Combine the results from all processes to the root.\n" + " scan Prefix reduction of the values from all processes.\n" + " scatter Scatter the values stored at the root to all processes.\n" + "\n" + "SKELETON/CONTENT MECHANISM\n" + " Boost.MPI provides a skeleton/content mechanism that allows the\n" + " transfer of large data structures to be split into two separate stages,\n" + " with the `skeleton' (or, `shape') of the data structure sent first and\n" + " the content (or, `data') of the data structure sent later, potentially\n" + " several times, so long as the structure has not changed since the\n" + " skeleton was transferred. The skeleton/content mechanism can improve\n" + " performance when the data structure is large and its shape is fixed,\n" + " because while the skeleton requires serialization (it has an unknown\n" + " size), the content transfer is fixed-size and can be done without\n" + " extra copies.\n" + "\n" + " To use the skeleton/content mechanism from Python, you must first\n" + " register the type of your data structure with the skeleton/content\n" + " mechanism *from C++*. The registration function is\n" + " boost::mpi::python::register_skeleton_and_content\n" + " and resides in the <boost/mpi/python.hpp> header.\n" + "\n" + " Once you have registered your C++ data structures, you can extract\n" + " the skeleton for an instance of that data structure with skeleton().\n" + " The resulting SkeletonProxy can be transmitted via the normal send\n" + " routine, e.g.,\n\n" + " mpi.world.send(1, 0, skeleton(my_data_structure))\n\n" + " SkeletonProxy objects can be received on the other end via recv(),\n" + " which stores a newly-created instance of your data structure with the\n" + " same `shape' as the sender in its `object' attribute:\n\n" + " shape = mpi.world.recv(0, 0)\n" + " my_data_structure = shape.object\n\n" + " Once the skeleton has been transmitted, the content (accessed via \n" + " get_content) can be transmitted in much the same way. Note, however,\n" + " that the receiver also specifies get_content(my_data_structure) in its\n" + " call to receive:\n\n" + " if mpi.rank == 0:\n" + " mpi.world.send(1, 0, get_content(my_data_structure))\n" + " else:\n" + " mpi.world.recv(0, 0, get_content(my_data_structure))\n\n" + " Of course, this transmission of content can occur repeatedly, if the\n" + " values in the data structure--but not its shape--changes.\n" + "\n" + " The skeleton/content mechanism is a structured way to exploit the\n" + " interaction between custom-built MPI datatypes and MPI_BOTTOM, to\n" + " eliminate extra buffer copies.\n" + "\n" + "C++/PYTHON MPI COMPATIBILITY\n" + " Boost.MPI is a C++ library whose facilities have been exposed to Python\n" + " via the Boost.Python library. Since the Boost.MPI Python bindings are\n" + " build directly on top of the C++ library, and nearly every feature of\n" + " C++ library is available in Python, hybrid C++/Python programs using\n" + " Boost.MPI can interact, e.g., sending a value from Python but receiving\n" + " that value in C++ (or vice versa). However, doing so requires some\n" + " care. Because Python objects are dynamically typed, Boost.MPI transfers\n" + " type information along with the serialized form of the object, so that\n" + " the object can be received even when its type is not known. This\n" + " mechanism differs from its C++ counterpart, where the static types of\n" + " transmitted values are always known.\n" + "\n" + " The only way to communicate between the C++ and Python views on \n" + " Boost.MPI is to traffic entirely in Python objects. For Python, this is\n" + " the normal state of affairs, so nothing will change. For C++, this\n" + " means sending and receiving values of type boost::python::object, from\n" + " the Boost.Python library. For instance, say we want to transmit an\n" + " integer value from Python:\n\n" + " comm.send(1, 0, 17)\n\n" + " In C++, we would receive that value into a Python object and then\n" + " `extract' an integer value:\n\n" + " boost::python::object value;\n" + " comm.recv(0, 0, value);\n" + " int int_value = boost::python::extract<int>(value);\n\n" + " In the future, Boost.MPI will be extended to allow improved\n" + " interoperability with the C++ Boost.MPI and the C MPI bindings.\n" + ; + +/*********************************************************** + * environment documentation * + ***********************************************************/ +const char* environment_init_docstring = + "Initialize the MPI environment. Users should not need to call\n" + "this function directly, because the MPI environment will be\n" + "automatically initialized when the Boost.MPI module is loaded.\n"; + +const char* environment_finalize_docstring = + "Finalize (shut down) the MPI environment. Users only need to\n" + "invoke this function if MPI should be shut down before program\n" + "termination. Boost.MPI will automatically finalize the MPI\n" + "environment when the program exits.\n"; + +const char* environment_abort_docstring = + "Aborts all MPI processes and returns to the environment. The\n" + "precise behavior will be defined by the underlying MPI\n" + "implementation. This is equivalent to a call to MPI_Abort with\n" + "MPI_COMM_WORLD.\n" + "errcode is the error code to return from aborted processes.\n"; + +const char* environment_initialized_docstring = + "Determine if the MPI environment has already been initialized.\n"; + +const char* environment_finalized_docstring = + "Determine if the MPI environment has already been finalized.\n"; + +/*********************************************************** + * nonblocking documentation * + ***********************************************************/ +const char* request_list_init_docstring= + "Without arguments, constructs an empty RequestList.\n" + "With one argument `iterable', copies request objects from this\n" + "iterable to the new RequestList.\n"; + +const char* nonblocking_wait_any_docstring = + "Waits until any of the given requests has been completed. It provides\n" + "functionality equivalent to MPI_Waitany.\n" + "\n" + "requests must be a RequestList instance.\n" + "\n" + "Returns a triple (value, status, index) consisting of received value\n" + "(or None), the Status object for the completed request, and its index\n" + "in the RequestList.\n"; + +const char* nonblocking_test_any_docstring = + "Tests if any of the given requests have been completed, but does not wait\n" + "for completion. It provides functionality equivalent to MPI_Testany.\n" + "\n" + "requests must be a RequestList instance.\n" + "\n" + "Returns a triple (value, status, index) like wait_any or None if no request\n" + "is complete.\n"; + +const char* nonblocking_wait_all_docstring = + "Waits until all of the given requests have been completed. It provides\n" + "functionality equivalent to MPI_Waitall.\n" + "\n" + "requests must be a RequestList instance.\n" + "\n" + "If the second parameter `callable' is provided, it is called with each\n" + "completed request's received value (or None) and it s Status object as\n" + "its arguments. The calls occur in the order given by the `requests' list.\n"; + +const char* nonblocking_test_all_docstring = + "Tests if all of the given requests have been completed. It provides\n" + "functionality equivalent to MPI_Testall.\n" + "\n" + "Returns True if all requests have been completed.\n" + "\n" + "requests must be a RequestList instance.\n" + "\n" + "If the second parameter `callable' is provided, it is called with each\n" + "completed request's received value (or None) and it s Status object as\n" + "its arguments. The calls occur in the order given by the `requests' list.\n"; + +const char* nonblocking_wait_some_docstring = + "Waits until at least one of the given requests has completed. It\n" + "then completes all of the requests it can, partitioning the input\n" + "sequence into pending requests followed by completed requests.\n" + "\n" + "This routine provides functionality equivalent to MPI_Waitsome.\n" + "\n" + "Returns the index of the first completed request." + "\n" + "requests must be a RequestList instance.\n" + "\n" + "If the second parameter `callable' is provided, it is called with each\n" + "completed request's received value (or None) and it s Status object as\n" + "its arguments. The calls occur in the order given by the `requests' list.\n"; + +const char* nonblocking_test_some_docstring = + "Tests to see if any of the given requests has completed. It completes\n" + "all of the requests it can, partitioning the input sequence into pending\n" + "requests followed by completed requests. This routine is similar to\n" + "wait_some, but does not wait until any requests have completed.\n" + "\n" + "This routine provides functionality equivalent to MPI_Testsome.\n" + "\n" + "Returns the index of the first completed request." + "\n" + "requests must be a RequestList instance.\n" + "\n" + "If the second parameter `callable' is provided, it is called with each\n" + "completed request's received value (or None) and it s Status object as\n" + "its arguments. The calls occur in the order given by the `requests' list.\n"; + +/*********************************************************** + * exception documentation * + ***********************************************************/ +const char* exception_docstring = + "Instances of this class will be thrown when an MPI error\n" + "occurs. MPI failures that trigger these exceptions may or may not\n" + "be recoverable, depending on the underlying MPI implementation.\n" + "Consult the documentation for your MPI implementation to determine\n" + "the effect of MPI errors.\n"; + +const char* exception_what_docstring = + "A description of the error that occured. At present, this refers\n" + "only to the name of the MPI routine that failed.\n"; + +const char* exception_routine_docstring = + "The name of the MPI routine that reported the error.\n"; + +const char* exception_result_code_docstring = + "The result code returned from the MPI routine that reported the\n" + "error.\n"; + +/*********************************************************** + * collectives documentation * + ***********************************************************/ +const char* all_gather_docstring = + "all_gather is a collective algorithm that collects the values\n" + "stored at each process into a tuple of values indexed by the\n" + "process number they came from. all_gather is (semantically) a\n" + "gather followed by a broadcast. The same tuple of values is\n" + "returned to all processes.\n"; + +const char* all_reduce_docstring = + "all_reduce is a collective algorithm that combines the values\n" + "stored by each process into a single value. The values can be\n" + "combined arbitrarily, specified via any function. The values\n" + "a1, a2, .., ap provided by p processors will be combined by the\n" + "binary function op into the result\n" + " op(a1, op(a2, ... op(ap-1,ap)))\n" + "that will be returned to all processes. This function is the\n" + "equivalent of calling all_gather() and then applying the built-in\n" + "reduce() function to the returned sequence. op is assumed to be\n" + "associative.\n"; + +const char* all_to_all_docstring = + "all_to_all is a collective algorithm that transmits values from\n" + "every process to every other process. On process i, the jth value\n" + "of the values sequence is sent to process j and placed in the ith\n" + "position of the tuple that will be returned from all_to_all.\n"; + +const char* broadcast_docstring = + "broadcast is a collective algorithm that transfers a value from an\n" + "arbitrary root process to every other process that is part of the\n" + "given communicator (comm). The root parameter must be the same for\n" + "every process. The value parameter need only be specified at the root\n" + "root. broadcast() returns the same broadcasted value to every process.\n"; + +const char* gather_docstring = + "gather is a collective algorithm that collects the values\n" + "stored at each process into a tuple of values at the root\n" + "process. This tuple is indexed by the process number that the\n" + "value came from, and will be returned only by the root process.\n" + "All other processes return None.\n"; + +const char* reduce_docstring = + "reduce is a collective algorithm that combines the values\n" + "stored by each process into a single value at the root. The\n" + "values can be combined arbitrarily, specified via any function.\n" + "The values a1, a2, .., ap provided by p processors will be\n" + "combined by the binary function op into the result\n" + " op(a1, op(a2, ... op(ap-1,ap)))\n" + "that will be returned on the root process. This function is the\n" + "equivalent of calling gather() to the root and then applying the\n" + "built-in reduce() function to the returned sequence. All non-root\n" + "processes return None. op is assumed to be associative.\n"; + +const char* scan_docstring = + "@c scan computes a prefix reduction of values from all processes.\n" + "It is a collective algorithm that combines the values stored by\n" + "each process with the values of all processes with a smaller rank.\n" + "The values can be arbitrarily combined, specified via a binary\n" + "function op. If each process i provides the value ai, then scan\n" + "returns op(a1, op(a2, ... op(ai-1, ai))) to the ith process. op is\n" + "assumed to be associative. This routine is the equivalent of an\n" + "all_gather(), followed by a built-in reduce() on the first i+1\n" + "values in the resulting sequence on processor i. op is assumed\n" + "to be associative.\n"; + +const char* scatter_docstring = + "scatter is a collective algorithm that scatters the values stored\n" + "in the root process (as a container with comm.size elements) to\n" + "all of the processes in the communicator. The values parameter \n" + "(only significant at the root) is indexed by the process number to\n" + "which the corresponding value will be sent. The value received by \n" + "each process is returned from scatter.\n"; + +/*********************************************************** + * communicator documentation * + ***********************************************************/ +const char* communicator_docstring = + "The Communicator class abstracts a set of communicating\n" + "processes in MPI. All of the processes that belong to a certain\n" + "communicator can determine the size of the communicator, their rank\n" + "within the communicator, and communicate with any other processes\n" + "in the communicator.\n"; + +const char* communicator_default_constructor_docstring = + "Build a new Boost.MPI Communicator instance for MPI_COMM_WORLD.\n"; + +const char* communicator_rank_docstring = + "Returns the rank of the process in the communicator, which will be a\n" + "value in [0, size).\n"; + +const char* communicator_size_docstring = + "Returns the number of processes in the communicator.\n"; + +const char* communicator_send_docstring = + "This routine executes a potentially blocking send with the given\n" + "tag to the process with rank dest. It can be received by the\n" + "destination process with a matching recv call. The value will be\n" + "transmitted in one of several ways:\n" + "\n" + " - For C++ objects registered via register_serialized(), the value\n" + " will be serialized and transmitted.\n" + "\n" + " - For SkeletonProxy objects, the skeleton of the object will be\n" + " serialized and transmitted.\n" + "\n" + " - For Content objects, the content will be transmitted directly.\n" + " This content can be received by a matching recv/irecv call that\n" + " provides a suitable `buffer' argument.\n" + "\n" + " - For all other Python objects, the value will be pickled and\n" + " transmitted.\n"; + +const char* communicator_recv_docstring = + "This routine blocks until it receives a message from the process\n" + "source with the given tag. If the source parameter is not specified,\n" + "the message can be received from any process. Likewise, if the tag\n" + "parameter is not specified, a message with any tag can be received.\n" + "If return_status is True, returns a tuple containing the received\n" + "object followed by a Status object describing the communication.\n" + "Otherwise, recv() returns just the received object.\n" + "\n" + "When receiving the content of a data type that has been sent separately\n" + "from its skeleton, user code must provide a value for the `buffer'\n" + "argument. This value should be the Content object returned from\n" + "get_content().\n"; + +const char* communicator_isend_docstring = + "This routine executes a nonblocking send with the given\n" + "tag to the process with rank dest. It can be received by the\n" + "destination process with a matching recv call. The value will be\n" + "transmitted in the same way as with send().\n" + "This routine returns a Request object, which can be used to query\n" + "when the transmission has completed, wait for its completion, or\n" + "cancel the transmission.\n"; + +const char* communicator_irecv_docstring = + "This routine initiates a non-blocking receive from the process\n" + "source with the given tag. If the source parameter is not specified,\n" + "the message can be received from any process. Likewise, if the tag\n" + "parameter is not specified, a message with any tag can be received.\n" + "This routine returns a Request object, which can be used to query\n" + "when the transmission has completed, wait for its completion, or\n" + "cancel the transmission. The received value be accessible\n" + "through the `value' attribute of the Request object once transmission\n" + "has completed.\n" + "\n" + "As with the recv() routine, when receiving the content of a data type\n" + "that has been sent separately from its skeleton, user code must provide\n" + "a value for the `buffer' argument. This value should be the Content\n" + "object returned from get_content().\n"; + + const char* communicator_probe_docstring = + "This operation waits until a message matching (source, tag)\n" + "is available to be received. It then returns information about\n" + "that message. If source is omitted, a message from any process\n" + "will match. If tag is omitted, a message with any tag will match.\n" + "The actual source and tag can be retrieved from the returned Status\n" + "object. To check if a message is available without blocking, use\n" + "iprobe.\n"; + +const char* communicator_iprobe_docstring = + "This operation determines if a message matching (source, tag) is\n" + "available to be received. If so, it returns information about that\n" + "message; otherwise, it returns None. If source is omitted, a message\n" + "from any process will match. If tag is omitted, a message with any\n" + "tag will match. The actual source and tag can be retrieved from the\n" + "returned Status object. To wait for a message to become available, use\n" + "probe.\n"; + +const char* communicator_barrier_docstring = + "Wait for all processes within a communicator to reach the\n" + "barrier.\n"; + +const char* communicator_split_docstring = + "Split the communicator into multiple, disjoint communicators\n" + "each of which is based on a particular color. This is a\n" + "collective operation that returns a new communicator that is a\n" + "subgroup of this. This routine is functionally equivalent to\n" + "MPI_Comm_split.\n\n" + "color is the color of this process. All processes with the\n" + "same color value will be placed into the same group.\n\n" + "If provided, key is a key value that will be used to determine\n" + "the ordering of processes with the same color in the resulting\n" + "communicator. If omitted, the key will default to the rank of\n" + "the process in the current communicator.\n\n" + "Returns a new Communicator instance containing all of the \n" + "processes in this communicator that have the same color.\n"; + +const char* communicator_abort_docstring = + "Makes a \"best attempt\" to abort all of the tasks in the group of\n" + "this communicator. Depending on the underlying MPI\n" + "implementation, this may either abort the entire program (and\n" + "possibly return errcode to the environment) or only abort\n" + "some processes, allowing the others to continue. Consult the\n" + "documentation for your MPI implementation. This is equivalent to\n" + "a call to MPI_Abort\n\n" + "errcode is the error code to return from aborted processes.\n"; + +/*********************************************************** + * request documentation * + ***********************************************************/ +const char* request_docstring = + "The Request class contains information about a non-blocking send\n" + "or receive and will be returned from isend or irecv, respectively.\n" + "When a Request object represents a completed irecv, the `value' \n" + "attribute will contain the received value.\n"; + +const char* request_with_value_docstring = + "This class is an implementation detail. Any call that accepts a\n" + "Request also accepts a RequestWithValue, and vice versa.\n"; + +const char* request_wait_docstring = + "Wait until the communication associated with this request has\n" + "completed. For a request that is associated with an isend(), returns\n" + "a Status object describing the communication. For an irecv()\n" + "operation, returns the received value by default. However, when\n" + "return_status=True, a (value, status) pair is returned by a\n" + "completed irecv request.\n"; + +const char* request_test_docstring = + "Determine whether the communication associated with this request\n" + "has completed successfully. If so, returns the Status object\n" + "describing the communication (for an isend request) or a tuple\n" + "containing the received value and a Status object (for an irecv\n" + "request). Note that once test() returns a Status object, the\n" + "request has completed and wait() should not be called.\n"; + +const char* request_cancel_docstring = + "Cancel a pending communication, assuming it has not already been\n" + "completed.\n"; + +const char* request_value_docstring = + "If this request originated in an irecv(), this property makes the" + "sent value accessible once the request completes.\n" + "\n" + "If no value is available, ValueError is raised.\n"; + +/*********************************************************** + * skeleton/content documentation * + ***********************************************************/ +const char* object_without_skeleton_docstring = + "The ObjectWithoutSkeleton class is an exception class used only\n" + "when the skeleton() or get_content() function is called with an\n" + "object that is not supported by the skeleton/content mechanism.\n" + "All C++ types for which skeletons and content can be transmitted\n" + "must be registered with the C++ routine:\n" + " boost::mpi::python::register_skeleton_and_content\n"; + +const char* object_without_skeleton_object_docstring = + "The object on which skeleton() or get_content() was invoked.\n"; + +const char* skeleton_proxy_docstring = + "The SkeletonProxy class is used to represent the skeleton of an\n" + "object. The SkeletonProxy can be used as the value parameter of\n" + "send() or isend() operations, but instead of transmitting the\n" + "entire object, only its skeleton (\"shape\") will be sent, without\n" + "the actual data. Its content can then be transmitted, separately.\n" + "\n" + "User code cannot generate SkeletonProxy instances directly. To\n" + "refer to the skeleton of an object, use skeleton(object). Skeletons\n" + "can also be received with the recv() and irecv() methods.\n" + "\n" + "Note that the skeleton/content mechanism can only be used with C++\n" + "types that have been explicitly registered.\n"; + +const char* skeleton_proxy_object_docstring = + "The actual object whose skeleton is represented by this proxy object.\n"; + +const char* content_docstring = + "The content is a proxy class that represents the content of an object,\n" + "which can be separately sent or received from its skeleton.\n" + "\n" + "User code cannot generate content instances directly. Call the\n" + "get_content() routine to retrieve the content proxy for a particular\n" + "object. The content instance can be used with any of the send() or\n" + "recv() variants. Note that get_content() can only be used with C++\n" + "data types that have been explicitly registered with the Python\n" + "skeleton/content mechanism.\n"; + +const char* skeleton_docstring = + "The skeleton function retrieves the SkeletonProxy for its object\n" + "parameter, allowing the transmission of the skeleton (or \"shape\")\n" + "of the object separately from its data. The skeleton/content mechanism\n" + "is useful when a large data structure remains structurally the same\n" + "throughout a computation, but its content (i.e., the values in the\n" + "structure) changes several times. Tranmission of the content part does\n" + "not require any serialization or unnecessary buffer copies, so it is\n" + "very efficient for large data structures.\n" + "\n" + "Only C++ types that have been explicitly registered with the Boost.MPI\n" + "Python library can be used with the skeleton/content mechanism. Use:\b" + " boost::mpi::python::register_skeleton_and_content\n"; + +const char* get_content_docstring = + "The get_content function retrieves the content for its object parameter,\n" + "allowing the transmission of the data in a data structure separately\n" + "from its skeleton (or \"shape\"). The skeleton/content mechanism\n" + "is useful when a large data structure remains structurally the same\n" + "throughout a computation, but its content (i.e., the values in the\n" + "structure) changes several times. Tranmission of the content part does\n" + "not require any serialization or unnecessary buffer copies, so it is\n" + "very efficient for large data structures.\n" + "\n" + "Only C++ types that have been explicitly registered with the Boost.MPI\n" + "Python library can be used with the skeleton/content mechanism. Use:\b" + " boost::mpi::python::register_skeleton_and_content\n"; + +/*********************************************************** + * status documentation * + ***********************************************************/ +const char* status_docstring = + "The Status class stores information about a given message, including\n" + "its source, tag, and whether the message transmission was cancelled\n" + "or resulted in an error.\n"; + +const char* status_source_docstring = + "The source of the incoming message.\n"; + +const char* status_tag_docstring = + "The tag of the incoming message.\n"; + +const char* status_error_docstring = + "The error code associated with this transmission.\n"; + +const char* status_cancelled_docstring = + "Whether this transmission was cancelled.\n"; + +/*********************************************************** + * timer documentation * + ***********************************************************/ +const char* timer_docstring = + "The Timer class is a simple wrapper around the MPI timing facilities.\n"; + +const char* timer_default_constructor_docstring = + "Initializes the timer. After this call, elapsed == 0.\n"; + +const char* timer_restart_docstring = + "Restart the timer, after which elapsed == 0.\n"; + +const char* timer_elapsed_docstring = + "The time elapsed since initialization or the last restart(),\n" + "whichever is more recent.\n"; + +const char* timer_elapsed_min_docstring = + "Returns the minimum non-zero value that elapsed may return\n" + "This is the resolution of the timer.\n"; + +const char* timer_elapsed_max_docstring = + "Return an estimate of the maximum possible value of elapsed. Note\n" + "that this routine may return too high a value on some systems.\n"; + +const char* timer_time_is_global_docstring = + "Determines whether the elapsed time values are global times or\n" + "local processor times.\n"; + +} } } // end namespace boost::mpi::python diff --git a/src/boost/libs/mpi/src/python/module.cpp b/src/boost/libs/mpi/src/python/module.cpp new file mode 100644 index 000000000..ec3696843 --- /dev/null +++ b/src/boost/libs/mpi/src/python/module.cpp @@ -0,0 +1,55 @@ +// (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: Douglas Gregor + +/** @file module.cpp + * + * This file provides the top-level module for the Boost.MPI Python + * bindings. + */ +#include <boost/python.hpp> +#include <boost/mpi.hpp> + +using namespace boost::python; +using namespace boost::mpi; + +namespace boost { namespace mpi { namespace python { + +extern void export_environment(); +extern void export_exception(); +extern void export_collectives(); +extern void export_communicator(); +extern void export_datatypes(); +extern void export_request(); +extern void export_status(); +extern void export_timer(); +extern void export_nonblocking(); + +extern const char* module_docstring; + +BOOST_PYTHON_MODULE(mpi) +{ + // Setup module documentation + scope().attr("__doc__") = module_docstring; + scope().attr("__author__") = "Douglas Gregor <doug.gregor@gmail.com>"; + scope().attr("__date__") = "$LastChangedDate$"; + scope().attr("__version__") = "$Revision$"; + scope().attr("__copyright__") = "Copyright (C) 2006 Douglas Gregor"; + scope().attr("__license__") = "http://www.boost.org/LICENSE_1_0.txt"; + + export_environment(); + export_exception(); + export_communicator(); + export_collectives(); + export_datatypes(); + export_request(); + export_status(); + export_timer(); + export_nonblocking(); +} + +} } } // end namespace boost::mpi::python diff --git a/src/boost/libs/mpi/src/python/py_communicator.cpp b/src/boost/libs/mpi/src/python/py_communicator.cpp new file mode 100644 index 000000000..6e53f56f9 --- /dev/null +++ b/src/boost/libs/mpi/src/python/py_communicator.cpp @@ -0,0 +1,133 @@ +// (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: Douglas Gregor + +/** @file communicator.cpp + * + * This file reflects the Boost.MPI @c communicator class into + * Python. + */ +#include <boost/python.hpp> +#include <boost/mpi.hpp> +#include <boost/mpi/python/serialize.hpp> +#include "request_with_value.hpp" + +using namespace boost::python; +using namespace boost::mpi; + +namespace boost { namespace mpi { namespace python { + +extern const char* communicator_docstring; +extern const char* communicator_default_constructor_docstring; +extern const char* communicator_rank_docstring; +extern const char* communicator_size_docstring; +extern const char* communicator_send_docstring; +extern const char* communicator_recv_docstring; +extern const char* communicator_isend_docstring; +extern const char* communicator_irecv_docstring; +extern const char* communicator_probe_docstring; +extern const char* communicator_iprobe_docstring; +extern const char* communicator_barrier_docstring; +extern const char* communicator_split_docstring; +extern const char* communicator_split_key_docstring; +extern const char* communicator_abort_docstring; + +object +communicator_recv(const communicator& comm, int source, int tag, + bool return_status) +{ + using boost::python::make_tuple; + + object result; + status stat = comm.recv(source, tag, result); + if (return_status) + return make_tuple(result, stat); + else + return result; +} + +request_with_value +communicator_irecv(const communicator& comm, int source, int tag) +{ + boost::shared_ptr<object> result(new object()); + request_with_value req(comm.irecv(source, tag, *result)); + req.m_internal_value = result; + return req; +} + +object +communicator_iprobe(const communicator& comm, int source, int tag) +{ + if (boost::optional<status> result = comm.iprobe(source, tag)) + return object(*result); + else + return object(); +} + +extern void export_skeleton_and_content(class_<communicator>&); + +void export_communicator() +{ + using boost::python::arg; + using boost::python::object; + + class_<communicator> comm("Communicator", communicator_docstring); + comm + .def(init<>()) + .add_property("rank", &communicator::rank, communicator_rank_docstring) + .add_property("size", &communicator::size, communicator_size_docstring) + .def("send", + (void (communicator::*)(int, int, const object&) const) + &communicator::send<object>, + (arg("dest"), arg("tag") = 0, arg("value") = object()), + communicator_send_docstring) + .def("recv", &communicator_recv, + (arg("source") = any_source, arg("tag") = any_tag, + arg("return_status") = false), + communicator_recv_docstring) + .def("isend", + (request (communicator::*)(int, int, const object&) const) + &communicator::isend<object>, + (arg("dest"), arg("tag") = 0, arg("value") = object()), + communicator_isend_docstring) + .def("irecv", &communicator_irecv, + (arg("source") = any_source, arg("tag") = any_tag), + communicator_irecv_docstring) + .def("probe", &communicator::probe, + (arg("source") = any_source, arg("tag") = any_tag), + communicator_probe_docstring) + .def("iprobe", &communicator_iprobe, + (arg("source") = any_source, arg("tag") = any_tag), + communicator_iprobe_docstring) + .def("barrier", &communicator::barrier, communicator_barrier_docstring) + .def("__nonzero__", &communicator::operator bool) + .def("split", + (communicator (communicator::*)(int) const)&communicator::split, + (arg("color")), communicator_split_docstring) + .def("split", + (communicator (communicator::*)(int, int) const)&communicator::split, + (arg("color"), arg("key"))) + .def("abort", &communicator::abort, arg("errcode"), + communicator_abort_docstring) + ; + + // Module-level attributes + scope().attr("any_source") = any_source; + scope().attr("any_tag") = any_tag; + + { + communicator world; + scope().attr("world") = world; + scope().attr("rank") = world.rank(); + scope().attr("size") = world.size(); + } + + // Export skeleton and content + export_skeleton_and_content(comm); +} + +} } } // end namespace boost::mpi::python diff --git a/src/boost/libs/mpi/src/python/py_environment.cpp b/src/boost/libs/mpi/src/python/py_environment.cpp new file mode 100644 index 000000000..27af7804a --- /dev/null +++ b/src/boost/libs/mpi/src/python/py_environment.cpp @@ -0,0 +1,123 @@ +// (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: Douglas Gregor + +/** @file environment.cpp + * + * This file reflects the Boost.MPI "environment" class into Python + * methods at module level. + */ + +#include <locale> +#include <string> +#include <boost/python.hpp> +#include <boost/mpi.hpp> + +using namespace boost::python; +using namespace boost::mpi; + +namespace boost { namespace mpi { namespace python { + +extern const char* environment_init_docstring; +extern const char* environment_finalize_docstring; +extern const char* environment_abort_docstring; +extern const char* environment_initialized_docstring; +extern const char* environment_finalized_docstring; + +/** + * The environment used by the Boost.MPI Python module. This will be + * zero-initialized before it is used. + */ +static environment* env; + +bool mpi_init(list python_argv, bool abort_on_exception) +{ + // If MPI is already initialized, do nothing. + if (environment::initialized()) + return false; + +#if PY_MAJOR_VERSION >= 3 + #ifdef BOOST_MPI_HAS_NOARG_INITIALIZATION + env = new environment(abort_on_exception); + #else + #error No argument initialization, supported from MPI 1.2 and up, is needed when using Boost.MPI with Python 3.x + #endif +#else + + // Convert Python argv into C-style argc/argv. + int my_argc = extract<int>(python_argv.attr("__len__")()); + char** my_argv = new char*[my_argc]; + for (int arg = 0; arg < my_argc; ++arg) + my_argv[arg] = strdup(extract<const char*>(python_argv[arg])); + + // Initialize MPI + int mpi_argc = my_argc; + char** mpi_argv = my_argv; + env = new environment(mpi_argc, mpi_argv, abort_on_exception); + + // If anything changed, convert C-style argc/argv into Python argv + if (mpi_argv != my_argv) + PySys_SetArgv(mpi_argc, mpi_argv); + + for (int arg = 0; arg < mpi_argc; ++arg) + free(mpi_argv[arg]); + delete [] mpi_argv; +#endif + + return true; +} + +void mpi_finalize() +{ + if (env) { + delete env; + env = 0; + } +} + +void export_environment() +{ + using boost::python::arg; + + def("init", mpi_init, (arg("argv"), arg("abort_on_exception") = true), + environment_init_docstring); + def("finalize", mpi_finalize, environment_finalize_docstring); + + // Setup initialization and finalization code + if (!environment::initialized()) { + // MPI_Init from sys.argv + object sys = object(handle<>(PyImport_ImportModule("sys"))); + mpi_init(extract<list>(sys.attr("argv")), true); + + // Setup MPI_Finalize call when the program exits + object atexit = object(handle<>(PyImport_ImportModule("atexit"))); + object finalize = scope().attr("finalize"); + atexit.attr("register")(finalize); + } + + def("abort", &environment::abort, arg("errcode"), + environment_abort_docstring); + def("initialized", &environment::initialized, + environment_initialized_docstring); + def("finalized", &environment::finalized, + environment_finalized_docstring); + scope().attr("max_tag") = environment::max_tag(); + scope().attr("collectives_tag") = environment::collectives_tag(); + scope().attr("processor_name") = environment::processor_name(); + + if (optional<int> host_rank = environment::host_rank()) + scope().attr("host_rank") = *host_rank; + else + scope().attr("host_rank") = object(); + + if (optional<int> io_rank = environment::io_rank()) + scope().attr("io_rank") = *io_rank; + else + scope().attr("io_rank") = object(); +} + +} } } // end namespace boost::mpi::python diff --git a/src/boost/libs/mpi/src/python/py_exception.cpp b/src/boost/libs/mpi/src/python/py_exception.cpp new file mode 100644 index 000000000..fee48c4d1 --- /dev/null +++ b/src/boost/libs/mpi/src/python/py_exception.cpp @@ -0,0 +1,54 @@ +// Copyright (C) 2006 Douglas Gregor <doug.gregor -at- gmail.com> +// Copyright (C) 2005 The Trustees of Indiana University. + +// 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 + +/** @file exception.cpp + * + * This file reflects the Boost.MPI @c mpi_error class into + * Python. + */ +#include <boost/python.hpp> +#include <boost/mpi/exception.hpp> +#include <string> +#include <boost/lexical_cast.hpp> +#include "utility.hpp" + +using namespace boost::python; +using namespace boost::mpi; + +namespace boost { namespace mpi { namespace python { + +extern const char* exception_docstring; +extern const char* exception_what_docstring; +extern const char* exception_routine_docstring; +extern const char* exception_result_code_docstring; + +str exception_str(const exception& e) +{ + return str(std::string(e.what()) + + " (code " + lexical_cast<std::string>(e.result_code())+")"); +} + +void export_exception() +{ + using boost::python::arg; + using boost::python::object; + + object type = + class_<exception> + ("Exception", exception_docstring, no_init) + .add_property("what", &exception::what, exception_what_docstring) + .add_property("routine", &exception::what, exception_routine_docstring) + .add_property("result_code", &exception::result_code, + exception_result_code_docstring) + .def("__str__", &exception_str) + ; + translate_exception<exception>::declare(type); +} + +} } } // end namespace boost::mpi::python diff --git a/src/boost/libs/mpi/src/python/py_nonblocking.cpp b/src/boost/libs/mpi/src/python/py_nonblocking.cpp new file mode 100644 index 000000000..8666c0499 --- /dev/null +++ b/src/boost/libs/mpi/src/python/py_nonblocking.cpp @@ -0,0 +1,250 @@ +// (C) Copyright 2007 +// Douglas Gregor <doug.gregor -at- gmail.com> +// Andreas Kloeckner <inform -at- tiker.net> + +// 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, Andreas Kloeckner + +/** @file py_nonblocking.cpp + * + * This file reflects the Boost.MPI nonblocking operations into Python + * functions. + */ + +#include <vector> +#include <iterator> +#include <algorithm> +#include <boost/operators.hpp> +#include <boost/python.hpp> +#include <boost/python/stl_iterator.hpp> +#include <boost/python/suite/indexing/vector_indexing_suite.hpp> +#include <boost/mpi.hpp> +#include <boost/shared_ptr.hpp> +#include "request_with_value.hpp" + +using namespace std; +using namespace boost::python; +using namespace boost::mpi; + +namespace +{ + template <class ValueType, class RequestIterator> + class py_call_output_iterator : + public boost::output_iterator_helper< + py_call_output_iterator<ValueType, RequestIterator> > + { + private: + object m_callable; + RequestIterator m_request_iterator; + + public: + explicit py_call_output_iterator(object callable, + const RequestIterator &req_it) + : m_callable(callable), m_request_iterator(req_it) + { } + + py_call_output_iterator &operator=(ValueType const &v) + { + m_callable((m_request_iterator++)->get_value_or_none(), v); + return *this; + } + }; + + + + typedef std::vector<python::request_with_value> request_list; + typedef py_call_output_iterator<status, request_list::iterator> + status_value_iterator; + + + boost::shared_ptr<request_list> make_request_list_from_py_list(object iterable) + { + boost::shared_ptr<request_list> result(new request_list); + std::copy( + stl_input_iterator<python::request_with_value>(iterable), + stl_input_iterator<python::request_with_value>(), + back_inserter(*result)); + return result; + } + + + + + class request_list_indexing_suite : + public vector_indexing_suite<request_list, false, request_list_indexing_suite> + { + public: + // FIXME: requests are not comparable, thus __contains__ makes no sense. + // Unfortunately, indexing_suites insist on having __contains__ available. + // Just make it error out for now. + + static bool + contains(request_list& container, request const& key) + { + PyErr_SetString(PyExc_NotImplementedError, "mpi requests are not comparable"); + throw error_already_set(); + } + }; + + + + + void check_request_list_not_empty(const request_list &requests) + { + if (requests.size() == 0) + { + PyErr_SetString(PyExc_ValueError, "cannot wait on an empty request vector"); + throw error_already_set(); + } + + } + + + + + + object wrap_wait_any(request_list &requests) + { + check_request_list_not_empty(requests); + + pair<status, request_list::iterator> result = + wait_any(requests.begin(), requests.end()); + + return boost::python::make_tuple( + result.second->get_value_or_none(), + result.first, + distance(requests.begin(), result.second)); + } + + + + + object wrap_test_any(request_list &requests) + { + check_request_list_not_empty(requests); + ::boost::optional<pair<status, request_list::iterator> > result = + test_any(requests.begin(), requests.end()); + + if (result) + return boost::python::make_tuple( + result->second->get_value_or_none(), + result->first, + distance(requests.begin(), result->second)); + else + return object(); + } + + + + + + void wrap_wait_all(request_list &requests, object py_callable) + { + check_request_list_not_empty(requests); + if (py_callable != object()) + wait_all(requests.begin(), requests.end(), + status_value_iterator(py_callable, requests.begin())); + else + wait_all(requests.begin(), requests.end()); + } + + + + + bool wrap_test_all(request_list &requests, object py_callable) + { + check_request_list_not_empty(requests); + if (py_callable != object()) + return bool(test_all(requests.begin(), requests.end(), + status_value_iterator(py_callable, requests.begin()))); + else + return bool(test_all(requests.begin(), requests.end())); + } + + + + + int wrap_wait_some(request_list &requests, object py_callable) + { + check_request_list_not_empty(requests); + request_list::iterator first_completed; + if (py_callable != object()) + first_completed = wait_some(requests.begin(), requests.end(), + status_value_iterator(py_callable, requests.begin())).second; + else + first_completed = wait_some(requests.begin(), requests.end()); + + return distance(requests.begin(), first_completed); + } + + + + + int wrap_test_some(request_list &requests, object py_callable) + { + check_request_list_not_empty(requests); + request_list::iterator first_completed; + if (py_callable != object()) + first_completed = test_some(requests.begin(), requests.end(), + status_value_iterator(py_callable, requests.begin())).second; + else + first_completed = test_some(requests.begin(), requests.end()); + + return distance(requests.begin(), first_completed); + } +} + + + + +namespace boost { namespace mpi { namespace python { + +extern const char* request_list_init_docstring; +extern const char* request_list_append_docstring; + +extern const char* nonblocking_wait_any_docstring; +extern const char* nonblocking_test_any_docstring; +extern const char* nonblocking_wait_all_docstring; +extern const char* nonblocking_test_all_docstring; +extern const char* nonblocking_wait_some_docstring; +extern const char* nonblocking_test_some_docstring; + +void export_nonblocking() +{ + using boost::python::arg; + + { + typedef request_list cl; + class_<cl>("RequestList", "A list of Request objects.") + .def("__init__", make_constructor(make_request_list_from_py_list), + /*arg("iterable"),*/ request_list_init_docstring) + .def(request_list_indexing_suite()) + ; + } + + def("wait_any", wrap_wait_any, + (arg("requests")), + nonblocking_wait_any_docstring); + def("test_any", wrap_test_any, + (arg("requests")), + nonblocking_test_any_docstring); + + def("wait_all", wrap_wait_all, + (arg("requests"), arg("callable") = object()), + nonblocking_wait_all_docstring); + def("test_all", wrap_test_all, + (arg("requests"), arg("callable") = object()), + nonblocking_test_all_docstring); + + def("wait_some", wrap_wait_some, + (arg("requests"), arg("callable") = object()), + nonblocking_wait_some_docstring); + def("test_some", wrap_test_some, + (arg("requests"), arg("callable") = object()), + nonblocking_test_some_docstring); +} + +} } } diff --git a/src/boost/libs/mpi/src/python/py_request.cpp b/src/boost/libs/mpi/src/python/py_request.cpp new file mode 100644 index 000000000..55b2b5aec --- /dev/null +++ b/src/boost/libs/mpi/src/python/py_request.cpp @@ -0,0 +1,111 @@ +// (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: Douglas Gregor + +/** @file request.cpp + * + * This file reflects the Boost.MPI @c request class into + * Python. + */ +#include <boost/python.hpp> +#include <boost/mpi.hpp> +#include "request_with_value.hpp" + +using namespace boost::python; +using namespace boost::mpi; + +const object python::request_with_value::get_value() const +{ + if (m_internal_value.get()) + return *m_internal_value; + else if (m_external_value) + return *m_external_value; + else + { + PyErr_SetString(PyExc_ValueError, "request value not available"); + throw boost::python::error_already_set(); + } +} + +const object python::request_with_value::get_value_or_none() const +{ + if (m_internal_value.get()) + return *m_internal_value; + else if (m_external_value) + return *m_external_value; + else + return object(); +} + +const object python::request_with_value::wrap_wait() +{ + status stat = request::wait(); + if (m_internal_value.get() || m_external_value) + return boost::python::make_tuple(get_value(), stat); + else + return object(stat); +} + +const object python::request_with_value::wrap_test() +{ + ::boost::optional<status> stat = request::test(); + if (stat) + { + if (m_internal_value.get() || m_external_value) + return boost::python::make_tuple(get_value(), *stat); + else + return object(*stat); + } + else + return object(); +} + + +namespace boost { namespace mpi { namespace python { + +const object request_test(request &req) +{ + ::boost::optional<status> stat = req.test(); + if (stat) + return object(*stat); + else + return object(); +} + +extern const char* request_docstring; +extern const char* request_with_value_docstring; +extern const char* request_wait_docstring; +extern const char* request_test_docstring; +extern const char* request_cancel_docstring; +extern const char* request_value_docstring; + +void export_request() +{ + using boost::python::arg; + using boost::python::object; + + { + typedef request cl; + class_<cl>("Request", request_docstring, no_init) + .def("wait", &cl::wait, request_wait_docstring) + .def("test", &request_test, request_test_docstring) + .def("cancel", &cl::cancel, request_cancel_docstring) + ; + } + { + typedef request_with_value cl; + class_<cl, bases<request> >( + "RequestWithValue", request_with_value_docstring, no_init) + .def("wait", &cl::wrap_wait, request_wait_docstring) + .def("test", &cl::wrap_test, request_test_docstring) + ; + } + + implicitly_convertible<request, request_with_value>(); +} + +} } } // end namespace boost::mpi::python diff --git a/src/boost/libs/mpi/src/python/py_timer.cpp b/src/boost/libs/mpi/src/python/py_timer.cpp new file mode 100644 index 000000000..88b1b4062 --- /dev/null +++ b/src/boost/libs/mpi/src/python/py_timer.cpp @@ -0,0 +1,48 @@ +// (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: Douglas Gregor + +/** @file timer.cpp + * + * This file reflects the Boost.MPI @c timer class into + * Python. + */ +#include <boost/python.hpp> +#include <boost/mpi/timer.hpp> + +using namespace boost::python; +using namespace boost::mpi; + +namespace boost { namespace mpi { namespace python { + +extern const char* timer_docstring; +extern const char* timer_default_constructor_docstring; +extern const char* timer_restart_docstring; +extern const char* timer_elapsed_docstring; +extern const char* timer_elapsed_min_docstring; +extern const char* timer_elapsed_max_docstring; +extern const char* timer_time_is_global_docstring; + +void export_timer() +{ + using boost::python::arg; + using boost::python::object; + + class_<timer>("Timer", timer_docstring) + .def(init<>()) + .def("restart", &timer::restart, timer_restart_docstring) + .add_property("elapsed", &timer::elapsed, timer_elapsed_docstring) + .add_property("elapsed_min", &timer::elapsed_min, + timer_elapsed_min_docstring) + .add_property("elapsed_max", &timer::elapsed_max, + timer_elapsed_max_docstring) + .add_property("time_is_global", &timer::time_is_global, + timer_time_is_global_docstring) + ; +} + +} } } // end namespace boost::mpi::python diff --git a/src/boost/libs/mpi/src/python/request_with_value.hpp b/src/boost/libs/mpi/src/python/request_with_value.hpp new file mode 100644 index 000000000..04d0c53e9 --- /dev/null +++ b/src/boost/libs/mpi/src/python/request_with_value.hpp @@ -0,0 +1,71 @@ +// (C) Copyright 2006 +// Douglas Gregor <doug.gregor -at- gmail.com> +// Andreas Kloeckner <inform -at- tiker.net> + +// 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, Andreas Kloeckner + +#ifndef BOOST_MPI_PYTHON_REQUEST_WITH_VALUE_HPP +#define BOOST_MPI_PYTHON_REQUEST_WITH_VALUE_HPP + +#include <boost/python.hpp> +#include <boost/mpi.hpp> + +namespace boost { namespace mpi { namespace python { + + /** This wrapper adds a @c boost::python::object value to the @c + * boost::mpi::request structure, for the benefit of @c irecv() requests. + * + * In order to be able to return the value of his requests to the user, we + * need a handle that we can update to contain the transmitted value once the + * request completes. Since we're passing the address on to irecv to fill at + * any time in the future, this address may not change over time. + * + * There are two possible cases: + * - plain irecv() + * - skeleton-content irecv() + * + * In the first case, we need to own the storage from this object, the + * m_internal_value is used for this. In the second case, the updated + * python::object is part of a boost::mpi::python::content object: the + * m_external_value field handles this case. Furthermore, in the latter case, + * we now have a lifetime dependency on that content object; this can be + * handled with the BPL's with_custodian_and_ward facility. + * + * Since requests and request_with_value are supposed to be copyconstructible, + * we can't put the handle immediately inside this instance. Moreover, since + * we need to be able to put request_with_value inside request_vectors, any + * values we own must be held in a shared_ptr instance. + */ + + class request_with_value : public request + { + private: + boost::shared_ptr<boost::python::object> m_internal_value; + boost::python::object *m_external_value; + + public: + request_with_value() + : m_external_value(0) + { } + request_with_value(const request &req) + : request(req), m_external_value(0) + { } + + const boost::python::object get_value() const; + const boost::python::object get_value_or_none() const; + + const boost::python::object wrap_wait(); + const boost::python::object wrap_test(); + + friend request_with_value communicator_irecv(const communicator &, int, int); + friend request_with_value communicator_irecv_content( + const communicator&, int, int, content&); + }; + +} } } + +#endif diff --git a/src/boost/libs/mpi/src/python/serialize.cpp b/src/boost/libs/mpi/src/python/serialize.cpp new file mode 100644 index 000000000..92004a340 --- /dev/null +++ b/src/boost/libs/mpi/src/python/serialize.cpp @@ -0,0 +1,79 @@ +// (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: Douglas Gregor + +/** @file serialize.cpp + * + * This file provides Boost.Serialization support for Python objects. + */ +#include <boost/mpi/python/serialize.hpp> +#include <boost/mpi/python/skeleton_and_content.hpp> +#include <boost/mpi.hpp> + +namespace boost { namespace python { + +struct pickle::data_t { + object module; + object dumps; + object loads; +}; + + +/// Data used for communicating with the Python `pickle' module. +pickle::data_t* pickle::data; + +str pickle::dumps(object obj, int protocol) +{ + if (!data) initialize_data(); + return extract<str>((data->dumps)(obj, protocol)); +} + +object pickle::loads(str s) +{ + if (!data) initialize_data(); + return ((data->loads)(s)); +} + +void pickle::initialize_data() +{ + data = new data_t; + data->module = object(handle<>(PyImport_ImportModule("pickle"))); + data->dumps = data->module.attr("dumps"); + data->loads = data->module.attr("loads"); +} + +} } // end namespace boost::python + +BOOST_PYTHON_DIRECT_SERIALIZATION_ARCHIVE_IMPL( + ::boost::mpi::packed_iarchive, + ::boost::mpi::packed_oarchive) + +namespace boost { namespace mpi { namespace python { namespace detail { + + boost::python::object skeleton_proxy_base_type; + + // A map from Python type objects to skeleton/content handlers + typedef std::map<PyTypeObject*, skeleton_content_handler> + skeleton_content_handlers_type; + + BOOST_MPI_PYTHON_DECL skeleton_content_handlers_type skeleton_content_handlers; + + bool + skeleton_and_content_handler_registered(PyTypeObject* type) + { + return + skeleton_content_handlers.find(type) != skeleton_content_handlers.end(); + } + + void + register_skeleton_and_content_handler(PyTypeObject* type, + const skeleton_content_handler& handler) + { + skeleton_content_handlers[type] = handler; + } + +} } } } // end namespace boost::mpi::python::detail diff --git a/src/boost/libs/mpi/src/python/skeleton_and_content.cpp b/src/boost/libs/mpi/src/python/skeleton_and_content.cpp new file mode 100644 index 000000000..d5376c14f --- /dev/null +++ b/src/boost/libs/mpi/src/python/skeleton_and_content.cpp @@ -0,0 +1,173 @@ +// (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: Douglas Gregor + +/** @file skeleton_and_content.cpp + * + * This file reflects the skeleton/content facilities into Python. + */ +#include <boost/mpi/python/skeleton_and_content.hpp> +#include <boost/mpi/python/serialize.hpp> +#include <boost/python/list.hpp> +#include <typeinfo> +#include <list> +#include "utility.hpp" +#include "request_with_value.hpp" + +using namespace boost::python; +using namespace boost::mpi; + +namespace boost { namespace mpi { namespace python { + +namespace detail { + typedef std::map<PyTypeObject*, skeleton_content_handler> + skeleton_content_handlers_type; + +// We're actually importing skeleton_content_handlers from skeleton_and_content.cpp. +#if defined(BOOST_HAS_DECLSPEC) && (defined(BOOST_MPI_PYTHON_DYN_LINK) || defined(BOOST_ALL_DYN_LINK)) +# define BOOST_SC_DECL __declspec(dllimport) +#else +# define BOOST_SC_DECL +#endif + + extern BOOST_SC_DECL skeleton_content_handlers_type skeleton_content_handlers; +} + +/** + * An exception that will be thrown when the object passed to the + * Python version of skeleton() does not have a skeleton. + */ +struct object_without_skeleton : public std::exception { + explicit object_without_skeleton(object value) : value(value) { } + virtual ~object_without_skeleton() throw() { } + + object value; +}; + +str object_without_skeleton_str(const object_without_skeleton& e) +{ + return str("\nThe skeleton() or get_content() function was invoked for a Python\n" + "object that is not supported by the Boost.MPI skeleton/content\n" + "mechanism. To transfer objects via skeleton/content, you must\n" + "register the C++ type of this object with the C++ function:\n" + " boost::mpi::python::register_skeleton_and_content()\n" + "Object: " + str(e.value) + "\n"); +} + +/** + * Extract the "skeleton" from a Python object. In truth, all we're + * doing at this point is verifying that the object is a C++ type that + * has been registered for the skeleton/content mechanism. + */ +object skeleton(object value) +{ + PyTypeObject* type = value.ptr()->ob_type; + detail::skeleton_content_handlers_type::iterator pos = + detail::skeleton_content_handlers.find(type); + if (pos == detail::skeleton_content_handlers.end()) + throw object_without_skeleton(value); + else + return pos->second.get_skeleton_proxy(value); +} + +/** + * Extract the "content" from a Python object, which must be a C++ + * type that has been registered for the skeleton/content mechanism. + */ +content get_content(object value) +{ + PyTypeObject* type = value.ptr()->ob_type; + detail::skeleton_content_handlers_type::iterator pos = + detail::skeleton_content_handlers.find(type); + if (pos == detail::skeleton_content_handlers.end()) + throw object_without_skeleton(value); + else + return pos->second.get_content(value); +} + +/// Send the content part of a Python object. +void +communicator_send_content(const communicator& comm, int dest, int tag, + const content& c) +{ + comm.send(dest, tag, c.base()); +} + +/// Receive the content of a Python object. We return the object +/// received, not the content wrapper. +object +communicator_recv_content(const communicator& comm, int source, int tag, + const content& c, bool return_status) +{ + using boost::python::make_tuple; + + status stat = comm.recv(source, tag, c.base()); + if (return_status) + return make_tuple(c.object, stat); + else + return c.object; +} + +/// Receive the content of a Python object. The request object's value +/// attribute will reference the object whose content is being +/// received, not the content wrapper. +request_with_value +communicator_irecv_content(const communicator& comm, int source, int tag, + content& c) +{ + request_with_value req(comm.irecv(source, tag, c.base())); + req.m_external_value = &c.object; + return req; +} + +extern const char* object_without_skeleton_docstring; +extern const char* object_without_skeleton_object_docstring; +extern const char* skeleton_proxy_docstring; +extern const char* skeleton_proxy_object_docstring; +extern const char* content_docstring; +extern const char* skeleton_docstring; +extern const char* get_content_docstring; + +void export_skeleton_and_content(class_<communicator>& comm) +{ + using boost::python::arg; + + // Expose the object_without_skeleton exception + object type = + class_<object_without_skeleton> + ("ObjectWithoutSkeleton", object_without_skeleton_docstring, no_init) + .def_readonly("object", &object_without_skeleton::value, + object_without_skeleton_object_docstring) + .def("__str__", &object_without_skeleton_str) + ; + translate_exception<object_without_skeleton>::declare(type); + + // Expose the Python variants of "skeleton_proxy" and "content", and + // their generator functions. + detail::skeleton_proxy_base_type = + class_<skeleton_proxy_base>("SkeletonProxy", skeleton_proxy_docstring, + no_init) + .def_readonly("object", &skeleton_proxy_base::object, + skeleton_proxy_object_docstring); + class_<content>("Content", content_docstring, no_init); + def("skeleton", &skeleton, arg("object"), skeleton_docstring); + def("get_content", &get_content, arg("object"), get_content_docstring); + + // Expose communicator send/recv operations for content. + comm + .def("send", communicator_send_content, + (arg("dest"), arg("tag") = 0, arg("value"))) + .def("recv", communicator_recv_content, + (arg("source") = any_source, arg("tag") = any_tag, arg("buffer"), + arg("return_status") = false)) + .def("irecv", communicator_irecv_content, + (arg("source") = any_source, arg("tag") = any_tag, arg("buffer")), + with_custodian_and_ward_postcall<0, 4>() + ); +} + +} } } // end namespace boost::mpi::python diff --git a/src/boost/libs/mpi/src/python/status.cpp b/src/boost/libs/mpi/src/python/status.cpp new file mode 100644 index 000000000..a74221a7a --- /dev/null +++ b/src/boost/libs/mpi/src/python/status.cpp @@ -0,0 +1,41 @@ +// (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: Douglas Gregor + +/** @file status.cpp + * + * This file reflects the Boost.MPI @c status class into + * Python. + */ +#include <boost/python.hpp> +#include <boost/mpi.hpp> + +using namespace boost::python; +using namespace boost::mpi; + +namespace boost { namespace mpi { namespace python { + +extern const char* status_docstring; +extern const char* status_source_docstring; +extern const char* status_tag_docstring; +extern const char* status_error_docstring; +extern const char* status_cancelled_docstring; + +void export_status() +{ + using boost::python::arg; + using boost::python::object; + + class_<status>("Status", status_docstring, no_init) + .add_property("source", &status::source, status_source_docstring) + .add_property("tag", &status::tag, status_tag_docstring) + .add_property("error", &status::error, status_error_docstring) + .add_property("cancelled", &status::cancelled, status_cancelled_docstring) + ; +} + +} } } // end namespace boost::mpi::python diff --git a/src/boost/libs/mpi/src/python/utility.hpp b/src/boost/libs/mpi/src/python/utility.hpp new file mode 100644 index 000000000..ed0016761 --- /dev/null +++ b/src/boost/libs/mpi/src/python/utility.hpp @@ -0,0 +1,43 @@ +// (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: Douglas Gregor +#ifndef BOOST_MPI_PYTHON_UTILITY_HPP +#define BOOST_MPI_PYTHON_UTILITY_HPP + +/** @file utility.hpp + * + * This file is a utility header for the Boost.MPI Python bindings. + */ +#include <boost/python.hpp> + +namespace boost { namespace mpi { namespace python { + +template<typename E> +class translate_exception +{ + explicit translate_exception(boost::python::object type) : type(type) { } + +public: + static void declare(boost::python::object type) + { + using boost::python::register_exception_translator; + register_exception_translator<E>(translate_exception(type)); + } + + void operator()(const E& e) const + { + using boost::python::object; + PyErr_SetObject(type.ptr(), object(e).ptr()); + } + +private: + boost::python::object type; +}; + +} } } // end namespace boost::mpi::python + +#endif // BOOST_MPI_PYTHON_UTILITY_HPP diff --git a/src/boost/libs/mpi/src/request.cpp b/src/boost/libs/mpi/src/request.cpp new file mode 100644 index 000000000..3ba5695aa --- /dev/null +++ b/src/boost/libs/mpi/src/request.cpp @@ -0,0 +1,239 @@ +// Copyright (C) 2006 Douglas Gregor. + +// 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) +#include <boost/mpi/request.hpp> +#include <boost/mpi/status.hpp> +#include <boost/mpi/communicator.hpp> +#include <boost/mpi/detail/request_handlers.hpp> + +namespace boost { namespace mpi { + +request::request() + : m_handler() {} + +void +request::preserve(boost::shared_ptr<void> d) { + if (!m_preserved) { + m_preserved = d; + } else { + boost::shared_ptr<void> cdr = m_preserved; + typedef std::pair<boost::shared_ptr<void>, boost::shared_ptr<void> > cons; + boost::shared_ptr<cons> p(new cons(d, cdr)); + m_preserved = p; + } +} +request request::make_dynamic() { return request(new dynamic_handler()); } + +request +request::make_bottom_send(communicator const& comm, int dest, int tag, MPI_Datatype tp) { + trivial_handler* handler = new trivial_handler; + BOOST_MPI_CHECK_RESULT(MPI_Isend, + (MPI_BOTTOM, 1, tp, + dest, tag, comm, &handler->m_request)); + return request(handler); +} + +request +request::make_empty_send(communicator const& comm, int dest, int tag) { + trivial_handler* handler = new trivial_handler; + BOOST_MPI_CHECK_RESULT(MPI_Isend, + (MPI_BOTTOM, 0, MPI_PACKED, + dest, tag, comm, &handler->m_request)); + return request(handler); +} + +request +request::make_bottom_recv(communicator const& comm, int dest, int tag, MPI_Datatype tp) { + trivial_handler* handler = new trivial_handler; + BOOST_MPI_CHECK_RESULT(MPI_Irecv, + (MPI_BOTTOM, 1, tp, + dest, tag, comm, &handler->m_request)); + return request(handler); +} + +request +request::make_empty_recv(communicator const& comm, int dest, int tag) { + trivial_handler* handler = new trivial_handler; + BOOST_MPI_CHECK_RESULT(MPI_Irecv, + (MPI_BOTTOM, 0, MPI_PACKED, + dest, tag, comm, &handler->m_request)); + return request(handler); +} + +request +request::make_packed_send(communicator const& comm, int dest, int tag, void const* buffer, std::size_t n) { +#if defined(BOOST_MPI_USE_IMPROBE) + { + trivial_handler* handler = new trivial_handler; + BOOST_MPI_CHECK_RESULT(MPI_Isend, + (const_cast<void*>(buffer), n, MPI_PACKED, + dest, tag, comm, &handler->m_request)); + return request(handler); + } +#else + { + dynamic_handler *handler = new dynamic_handler; + request req(handler); + shared_ptr<std::size_t> size(new std::size_t(n)); + req.preserve(size); + BOOST_MPI_CHECK_RESULT(MPI_Isend, + (size.get(), 1, + get_mpi_datatype(*size), + dest, tag, comm, handler->m_requests)); + BOOST_MPI_CHECK_RESULT(MPI_Isend, + (const_cast<void*>(buffer), *size, + MPI_PACKED, + dest, tag, comm, handler->m_requests+1)); + return req; + } +#endif +} + +/*************************************************************************** + * handlers * + ***************************************************************************/ + +request::handler::~handler() {} + +optional<MPI_Request&> +request::legacy_handler::trivial() { + return boost::none; +} + +bool +request::legacy_handler::active() const { + return m_requests[0] != MPI_REQUEST_NULL || m_requests[1] != MPI_REQUEST_NULL; +} + +// trivial handler + +request::trivial_handler::trivial_handler() + : m_request(MPI_REQUEST_NULL) {} + +status +request::trivial_handler::wait() +{ + status result; + BOOST_MPI_CHECK_RESULT(MPI_Wait, (&m_request, &result.m_status)); + return result; +} + + +optional<status> +request::trivial_handler::test() +{ + status result; + int flag = 0; + BOOST_MPI_CHECK_RESULT(MPI_Test, + (&m_request, &flag, &result.m_status)); + return flag != 0? optional<status>(result) : optional<status>(); +} + +void +request::trivial_handler::cancel() +{ + BOOST_MPI_CHECK_RESULT(MPI_Cancel, (&m_request)); +} + +bool +request::trivial_handler::active() const +{ + return m_request != MPI_REQUEST_NULL; +} + +optional<MPI_Request&> +request::trivial_handler::trivial() +{ + return m_request; +} + +// dynamic handler + +request::dynamic_handler::dynamic_handler() +{ + m_requests[0] = MPI_REQUEST_NULL; + m_requests[1] = MPI_REQUEST_NULL; +} + +status +request::dynamic_handler::wait() +{ + // This request is a send of a serialized type, broken into two + // separate messages. Complete both sends at once. + MPI_Status stats[2]; + int error_code = MPI_Waitall(2, m_requests, stats); + if (error_code == MPI_ERR_IN_STATUS) { + // Dig out which status structure has the error, and use that + // one when throwing the exception. + if (stats[0].MPI_ERROR == MPI_SUCCESS + || stats[0].MPI_ERROR == MPI_ERR_PENDING) + boost::throw_exception(exception("MPI_Waitall", stats[1].MPI_ERROR)); + else + boost::throw_exception(exception("MPI_Waitall", stats[0].MPI_ERROR)); + } else if (error_code != MPI_SUCCESS) { + // There was an error somewhere in the MPI_Waitall call; throw + // an exception for it. + boost::throw_exception(exception("MPI_Waitall", error_code)); + } + + // No errors. Returns the first status structure. + status result; + result.m_status = stats[0]; + return result; +} + +optional<status> +request::dynamic_handler::test() +{ + // This request is a send of a serialized type, broken into two + // separate messages. We only get a result if both complete. + MPI_Status stats[2]; + int flag = 0; + int error_code = MPI_Testall(2, m_requests, &flag, stats); + if (error_code == MPI_ERR_IN_STATUS) { + // Dig out which status structure has the error, and use that + // one when throwing the exception. + if (stats[0].MPI_ERROR == MPI_SUCCESS + || stats[0].MPI_ERROR == MPI_ERR_PENDING) + boost::throw_exception(exception("MPI_Testall", stats[1].MPI_ERROR)); + else + boost::throw_exception(exception("MPI_Testall", stats[0].MPI_ERROR)); + } else if (error_code != MPI_SUCCESS) { + // There was an error somewhere in the MPI_Testall call; throw + // an exception for it. + boost::throw_exception(exception("MPI_Testall", error_code)); + } + + // No errors. Returns the second status structure if the send has + // completed. + if (flag != 0) { + status result; + result.m_status = stats[1]; + return result; + } else { + return optional<status>(); + } +} + +void +request::dynamic_handler::cancel() +{ + BOOST_MPI_CHECK_RESULT(MPI_Cancel, (&m_requests[0])); + BOOST_MPI_CHECK_RESULT(MPI_Cancel, (&m_requests[1])); +} + +bool +request::dynamic_handler::active() const +{ + return (m_requests[0] != MPI_REQUEST_NULL + || m_requests[1] != MPI_REQUEST_NULL); +} + +optional<MPI_Request&> +request::dynamic_handler::trivial() { + return boost::none; +} + +} } // end namespace boost::mpi diff --git a/src/boost/libs/mpi/src/text_skeleton_oarchive.cpp b/src/boost/libs/mpi/src/text_skeleton_oarchive.cpp new file mode 100644 index 000000000..7817ea785 --- /dev/null +++ b/src/boost/libs/mpi/src/text_skeleton_oarchive.cpp @@ -0,0 +1,20 @@ +// (C) Copyright 2005 Matthias Troyer + +// 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 + +#define BOOST_ARCHIVE_SOURCE +#include <boost/mpi/detail/text_skeleton_oarchive.hpp> + +#include <boost/archive/detail/archive_serializer_map.hpp> +#include <boost/archive/impl/archive_serializer_map.ipp> + +namespace boost { namespace archive { +// explicitly instantiate all required templates + +// template class detail::archive_serializer_map<text_oarchive>; + +} } // end namespace boost::archive diff --git a/src/boost/libs/mpi/src/timer.cpp b/src/boost/libs/mpi/src/timer.cpp new file mode 100644 index 000000000..e3a7dfc43 --- /dev/null +++ b/src/boost/libs/mpi/src/timer.cpp @@ -0,0 +1,25 @@ +// Copyright (C) 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) +#include <boost/mpi/timer.hpp> +#include <boost/mpi/exception.hpp> + +namespace boost { namespace mpi { + +bool timer::time_is_global() +{ + int* is_global; + int found = 0; + + BOOST_MPI_CHECK_RESULT(MPI_Comm_get_attr, + (MPI_COMM_WORLD, MPI_WTIME_IS_GLOBAL, &is_global, + &found)); + if (!found) + return false; + else + return *is_global != 0; +} + +} } // end namespace boost::mpi diff --git a/src/boost/libs/mpi/test/Jamfile.v2 b/src/boost/libs/mpi/test/Jamfile.v2 new file mode 100644 index 000000000..ac9ac2539 --- /dev/null +++ b/src/boost/libs/mpi/test/Jamfile.v2 @@ -0,0 +1,55 @@ +# Support for the Message Passing Interface (MPI) +# +# (C) Copyright 2005, 2006 Trustees of Indiana University +# (C) Copyright 2005 Douglas Gregor +# +# Distributed under 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 + +project : requirements <library>/boost//mpi ; +import mpi : mpi-test ; + +if [ mpi.configured ] +{ +test-suite mpi + : + [ mpi-test version_test : : : 1 ] + [ mpi-test block_nonblock_test-b2nb : block_nonblock_test.cpp : : 2 ] + [ mpi-test block_nonblock_test-nb2b : block_nonblock_test.cpp : : 2 ] + [ mpi-test random_gather : ../example/random_gather.cpp : : 2 ] + [ mpi-test random_scatter : ../example/random_scatter.cpp : : 2 ] + [ mpi-test cartesian_communicator : ../example/cartesian_communicator.cpp : : 24 ] + [ mpi-test cartesian_topology_init_test : : : 1 ] + [ mpi-test broadcast_stl_test : : : 2 ] + [ mpi-test all_gather_test : : : 1 2 11 ] + [ mpi-test all_reduce_test : : : 1 2 11 ] + [ mpi-test all_to_all_test : : : 1 2 11 ] + [ mpi-test broadcast_test : : : 2 17 ] + [ mpi-test gather_test : : : 1 2 11 ] + [ mpi-test is_mpi_op_test : : : 1 ] + [ mpi-test mt_level_test : : : 1 ] + [ mpi-test mt_init_test : : : 1 4 ] + # Note: Microsoft MPI fails nonblocking_test on 1 processor + [ mpi-test nonblocking_test : : : 2 11 24 ] + [ mpi-test reduce_test ] + [ mpi-test ring_test : : : 2 3 4 7 8 13 17 ] + [ mpi-test sendrecv_test : : : 1 4 7 48 ] + [ mpi-test wait_any_test : : : 1 4 7 20 ] + [ mpi-test wait_all_vector_test : : : 2 ] + [ mpi-test scan_test ] + [ mpi-test scatter_test ] + # Note: Microsoft MPI fails all skeleton-content tests + [ mpi-test skeleton_content_test : : : 2 3 4 7 8 13 17 ] + [ mpi-test graph_topology_test : : : 2 7 13 ] + [ mpi-test cartesian_topology_test : : : 24 ] + [ mpi-test pointer_test : : : 2 ] + [ mpi-test groups_test ] + # tests that require -std=c++11 + [ mpi-test sendrecv_vector : : : 2 ] + # Intel MPI 2018 and older are axtected to fail: + [ mpi-test non_blocking_any_source : : : 2 17 ] + ; +} diff --git a/src/boost/libs/mpi/test/all_gather_test.cpp b/src/boost/libs/mpi/test/all_gather_test.cpp new file mode 100644 index 000000000..c2385f61e --- /dev/null +++ b/src/boost/libs/mpi/test/all_gather_test.cpp @@ -0,0 +1,148 @@ +// Copyright (C) 2005-2006 Douglas Gregor <doug.gregor@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) + +// A test of the all_gather() collective. + +#include <algorithm> + +#include <boost/mpi/collectives/all_gather.hpp> +#include <boost/mpi/collectives/all_gatherv.hpp> +#include <boost/mpi/environment.hpp> +#include <boost/mpi/communicator.hpp> +#include <boost/serialization/string.hpp> +#include <boost/serialization/list.hpp> +#include <boost/iterator/counting_iterator.hpp> +#include <boost/lexical_cast.hpp> + +#define BOOST_TEST_MODULE mpi_all_gather +#include <boost/test/included/unit_test.hpp> + +#include "gps_position.hpp" + +namespace mpi = boost::mpi; + +template<typename Generator> +void +all_gather_test(const mpi::communicator& comm, Generator generator, + std::string kind) +{ + typedef typename Generator::result_type value_type; + value_type value = generator(comm.rank()); + + std::vector<value_type> values; + if (comm.rank() == 0) { + std::cout << "Gathering " << kind << "..."; + std::cout.flush(); + } + + mpi::all_gather(comm, value, values); + + std::vector<value_type> expected_values; + for (int p = 0; p < comm.size(); ++p) + expected_values.push_back(generator(p)); + BOOST_CHECK(values == expected_values); + if (comm.rank() == 0 && values == expected_values) + std::cout << "OK." << std::endl; + + (comm.barrier)(); +} + +template<typename Generator> +void +all_gatherv_test(const mpi::communicator& comm, Generator generator, + std::string kind) +{ + typedef typename Generator::result_type value_type; + using boost::mpi::all_gatherv; + + std::vector<value_type> myvalues, expected, values; + std::vector<int> sizes; + for(int r = 0; r < comm.size(); ++r) { + value_type value = generator(r); + sizes.push_back(r+1); + for (int k=0; k < r+1; ++k) { + expected.push_back(value); + if(comm.rank() == r) { + myvalues.push_back(value); + } + } + } + if (comm.rank() == 0) { + std::cout << "Gathering " << kind << "..."; + std::cout.flush(); + } + + mpi::all_gatherv(comm, myvalues, values, sizes); + + BOOST_CHECK(values == expected); + + if (comm.rank() == 0 && values == expected) + std::cout << "OK." << std::endl; + + (comm.barrier)(); +} + +// Generates integers to test with gather() +struct int_generator +{ + typedef int result_type; + + int operator()(int p) const { return 17 + p; } +}; + +// Generates GPS positions to test with gather() +struct gps_generator +{ + typedef gps_position result_type; + + gps_position operator()(int p) const + { + return gps_position(39 + p, 16, 20.2799); + } +}; + +struct string_generator +{ + typedef std::string result_type; + + std::string operator()(int p) const + { + std::string result = boost::lexical_cast<std::string>(p); + result += " rosebud"; + if (p != 1) result += 's'; + return result; + } +}; + +struct string_list_generator +{ + typedef std::list<std::string> result_type; + + std::list<std::string> operator()(int p) const + { + std::list<std::string> result; + for (int i = 0; i <= p; ++i) { + std::string value = boost::lexical_cast<std::string>(i); + result.push_back(value); + } + return result; + } +}; + +BOOST_AUTO_TEST_CASE(all_gather) +{ + boost::mpi::environment env; + mpi::communicator comm; + all_gather_test(comm, int_generator(), "integers"); + all_gather_test(comm, gps_generator(), "GPS positions"); + all_gather_test(comm, string_generator(), "string"); + all_gather_test(comm, string_list_generator(), "list of strings"); + + all_gatherv_test(comm, int_generator(), "integers"); + all_gatherv_test(comm, gps_generator(), "GPS positions"); + all_gatherv_test(comm, string_generator(), "string"); + all_gatherv_test(comm, string_list_generator(), "list of strings"); +} diff --git a/src/boost/libs/mpi/test/all_reduce_test.cpp b/src/boost/libs/mpi/test/all_reduce_test.cpp new file mode 100644 index 000000000..99fee9b8a --- /dev/null +++ b/src/boost/libs/mpi/test/all_reduce_test.cpp @@ -0,0 +1,309 @@ +// Copyright (C) 2005, 2006 Douglas Gregor. + +// 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) + +// A test of the all_reduce() collective. +#include <boost/mpi/collectives/all_reduce.hpp> +#include <boost/mpi/communicator.hpp> +#include <boost/mpi/environment.hpp> +#include <vector> +#include <algorithm> +#include <boost/serialization/string.hpp> +#include <boost/iterator/counting_iterator.hpp> +#include <boost/lexical_cast.hpp> +#include <numeric> + +#define BOOST_TEST_MODULE mpi_all_reduce +#include <boost/test/included/unit_test.hpp> + +using boost::mpi::communicator; + +// A simple point class that we can build, add, compare, and +// serialize. +struct point +{ + point() : x(0), y(0), z(0) { } + point(int x, int y, int z) : x(x), y(y), z(z) { } + + int x; + int y; + int z; + + private: + template<typename Archiver> + void serialize(Archiver& ar, unsigned int /*version*/) + { + ar & x & y & z; + } + + friend class boost::serialization::access; +}; + +std::ostream& operator<<(std::ostream& out, const point& p) +{ + return out << p.x << ' ' << p.y << ' ' << p.z; +} + +bool operator==(const point& p1, const point& p2) +{ + return p1.x == p2.x && p1.y == p2.y && p1.z == p2.z; +} + +bool operator!=(const point& p1, const point& p2) +{ + return !(p1 == p2); +} + +point operator+(const point& p1, const point& p2) +{ + return point(p1.x + p2.x, p1.y + p2.y, p1.z + p2.z); +} + +// test lexical order +bool operator<(const point& p1, const point& p2) +{ + return (p1.x < p2.x + ? true + : (p1.x > p2.x + ? false + : p1.y < p2.y )); +} + +namespace boost { namespace mpi { + + template <> + struct is_mpi_datatype<point> : public mpl::true_ { }; + +} } // end namespace boost::mpi + +template<typename Generator, typename Op> +void +all_reduce_one_test(const communicator& comm, Generator generator, + const char* type_kind, Op op, const char* op_kind, + typename Generator::result_type init, bool in_place) +{ + typedef typename Generator::result_type value_type; + value_type value = generator(comm.rank()); + + using boost::mpi::all_reduce; + using boost::mpi::inplace; + + if (comm.rank() == 0) { + std::cout << "Reducing to " << op_kind << " of " << type_kind << "..."; + std::cout.flush(); + } + + value_type result_value; + if (in_place) { + all_reduce(comm, inplace(value), op); + result_value = value; + } else { + result_value = all_reduce(comm, value, op); + } + + // Compute expected result + std::vector<value_type> generated_values; + for (int p = 0; p < comm.size(); ++p) + generated_values.push_back(generator(p)); + value_type expected_result = std::accumulate(generated_values.begin(), + generated_values.end(), + init, op); + BOOST_CHECK(result_value == expected_result); + if (result_value == expected_result && comm.rank() == 0) + std::cout << "OK." << std::endl; + + (comm.barrier)(); +} + +template<typename Generator, typename Op> +void +all_reduce_array_test(const communicator& comm, Generator generator, + const char* type_kind, Op op, const char* op_kind, + typename Generator::result_type init, bool in_place) +{ + typedef typename Generator::result_type value_type; + value_type value = generator(comm.rank()); + std::vector<value_type> send(10, value); + + using boost::mpi::all_reduce; + using boost::mpi::inplace; + + if (comm.rank() == 0) { + char const* place = in_place ? "in place" : "out of place"; + std::cout << "Reducing (" << place << ") array to " << op_kind << " of " << type_kind << "..."; + std::cout.flush(); + } + std::vector<value_type> result; + if (in_place) { + all_reduce(comm, inplace(&(send[0])), send.size(), op); + result.swap(send); + } else { + std::vector<value_type> recv(10, value_type()); + all_reduce(comm, &(send[0]), send.size(), &(recv[0]), op); + result.swap(recv); + } + + // Compute expected result + std::vector<value_type> generated_values; + for (int p = 0; p < comm.size(); ++p) + generated_values.push_back(generator(p)); + value_type expected_result = std::accumulate(generated_values.begin(), + generated_values.end(), + init, op); + + bool got_expected_result = (std::equal_range(result.begin(), result.end(), + expected_result) + == std::make_pair(result.begin(), result.end())); + BOOST_CHECK(got_expected_result); + if (got_expected_result && comm.rank() == 0) + std::cout << "OK." << std::endl; + + (comm.barrier)(); +} + +// Test the 4 families of all reduce: (value, array) X (in place, out of place) +template<typename Generator, typename Op> +void +all_reduce_test(const communicator& comm, Generator generator, + const char* type_kind, Op op, const char* op_kind, + typename Generator::result_type init) +{ + const bool in_place = true; + const bool out_of_place = false; + all_reduce_one_test(comm, generator, type_kind, op, op_kind, init, in_place); + all_reduce_one_test(comm, generator, type_kind, op, op_kind, init, out_of_place); + all_reduce_array_test(comm, generator, type_kind, op, op_kind, + init, in_place); + all_reduce_array_test(comm, generator, type_kind, op, op_kind, + init, out_of_place); +} + +// Generates integers to test with all_reduce() +struct int_generator +{ + typedef int result_type; + + int_generator(int base = 1) : base(base) { } + + int operator()(int p) const { return base + p; } + + private: + int base; +}; + +// Generate points to test with all_reduce() +struct point_generator +{ + typedef point result_type; + + point_generator(point origin) : origin(origin) { } + + point operator()(int p) const + { + return point(origin.x + 1, origin.y + 1, origin.z + 1); + } + + private: + point origin; +}; + +struct string_generator +{ + typedef std::string result_type; + + std::string operator()(int p) const + { + std::string result = boost::lexical_cast<std::string>(p); + result += " rosebud"; + if (p != 1) result += 's'; + return result; + } +}; + +struct secret_int_bit_and +{ + int operator()(int x, int y) const { return x & y; } +}; + +struct wrapped_int +{ + wrapped_int() : value(0) { } + explicit wrapped_int(int value) : value(value) { } + + template<typename Archive> + void serialize(Archive& ar, unsigned int /* version */) + { + ar & value; + } + + int value; +}; + +wrapped_int operator+(const wrapped_int& x, const wrapped_int& y) +{ + return wrapped_int(x.value + y.value); +} + +bool operator==(const wrapped_int& x, const wrapped_int& y) +{ + return x.value == y.value; +} + +bool operator<(const wrapped_int& x, const wrapped_int& y) +{ + return x.value < y.value; +} + +// Generates wrapped_its to test with all_reduce() +struct wrapped_int_generator +{ + typedef wrapped_int result_type; + + wrapped_int_generator(int base = 1) : base(base) { } + + wrapped_int operator()(int p) const { return wrapped_int(base + p); } + + private: + int base; +}; + +namespace boost { namespace mpi { + +// Make std::plus<wrapped_int> commutative. +template<> +struct is_commutative<std::plus<wrapped_int>, wrapped_int> + : mpl::true_ { }; + +} } // end namespace boost::mpi + +BOOST_AUTO_TEST_CASE(test_all_reduce) +{ + using namespace boost::mpi; + environment env; + communicator comm; + + // Built-in MPI datatypes with built-in MPI operations + all_reduce_test(comm, int_generator(), "integers", std::plus<int>(), "sum", 0); + all_reduce_test(comm, int_generator(), "integers", std::multiplies<int>(), "product", 1); + all_reduce_test(comm, int_generator(), "integers", maximum<int>(), "maximum", 0); + all_reduce_test(comm, int_generator(), "integers", minimum<int>(), "minimum", 2); + + // User-defined MPI datatypes with operations that have the + // same name as built-in operations. + all_reduce_test(comm, point_generator(point(0,0,0)), "points", std::plus<point>(), + "sum", point()); + + // Built-in MPI datatypes with user-defined operations + all_reduce_test(comm, int_generator(17), "integers", secret_int_bit_and(), + "bitwise and", -1); + + // Arbitrary types with user-defined, commutative operations. + all_reduce_test(comm, wrapped_int_generator(17), "wrapped integers", + std::plus<wrapped_int>(), "sum", wrapped_int(0)); + + // Arbitrary types with (non-commutative) user-defined operations + all_reduce_test(comm, string_generator(), "strings", + std::plus<std::string>(), "concatenation", std::string()); +} diff --git a/src/boost/libs/mpi/test/all_to_all_test.cpp b/src/boost/libs/mpi/test/all_to_all_test.cpp new file mode 100644 index 000000000..0e27dcf05 --- /dev/null +++ b/src/boost/libs/mpi/test/all_to_all_test.cpp @@ -0,0 +1,113 @@ +// Copyright (C) 2005, 2006 Douglas Gregor. + +// 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) + +// A test of the all_to_all() collective. +#include <boost/mpi/collectives/all_to_all.hpp> +#include <boost/mpi/communicator.hpp> +#include <boost/mpi/environment.hpp> +#include <algorithm> +#include "gps_position.hpp" +#include <boost/serialization/string.hpp> +#include <boost/serialization/list.hpp> +#include <boost/iterator/counting_iterator.hpp> +#include <boost/lexical_cast.hpp> + +#define BOOST_TEST_MODULE mpi_all_to_all +#include <boost/test/included/unit_test.hpp> + +using boost::mpi::communicator; + +using boost::mpi::packed_skeleton_iarchive; +using boost::mpi::packed_skeleton_oarchive; + +template<typename Generator> +void +all_to_all_test(const communicator& comm, Generator generator, + const char* kind) +{ + typedef typename Generator::result_type value_type; + + using boost::mpi::all_to_all; + + std::vector<value_type> in_values; + for (int p = 0; p < comm.size(); ++p) + in_values.push_back(generator((p + 1) * (comm.rank() + 1))); + + if (comm.rank() == 0) { + std::cout << "Performing all-to-all operation on " << kind << "..."; + std::cout.flush(); + } + std::vector<value_type> out_values; + all_to_all(comm, in_values, out_values); + + for (int p = 0; p < comm.size(); ++p) { + BOOST_CHECK(out_values[p] == generator((p + 1) * (comm.rank() + 1))); + } + + if (comm.rank() == 0) { + std::cout << " done." << std::endl; + } + + (comm.barrier)(); +} + +// Generates integers to test with all_to_all() +struct int_generator +{ + typedef int result_type; + + int operator()(int p) const { return 17 + p; } +}; + +// Generates GPS positions to test with all_to_all() +struct gps_generator +{ + typedef gps_position result_type; + + gps_position operator()(int p) const + { + return gps_position(39 + p, 16, 20.2799); + } +}; + +struct string_generator +{ + typedef std::string result_type; + + std::string operator()(int p) const + { + std::string result = boost::lexical_cast<std::string>(p); + result += " rosebud"; + if (p != 1) result += 's'; + return result; + } +}; + +struct string_list_generator +{ + typedef std::list<std::string> result_type; + + std::list<std::string> operator()(int p) const + { + std::list<std::string> result; + for (int i = 0; i <= p; ++i) { + std::string value = boost::lexical_cast<std::string>(i); + result.push_back(value); + } + return result; + } +}; + +BOOST_AUTO_TEST_CASE(all_to_all_check) +{ + boost::mpi::environment env; + communicator comm; + + all_to_all_test(comm, int_generator(), "integers"); + all_to_all_test(comm, gps_generator(), "GPS positions"); + all_to_all_test(comm, string_generator(), "string"); + all_to_all_test(comm, string_list_generator(), "list of strings"); +} diff --git a/src/boost/libs/mpi/test/block_nonblock_test.cpp b/src/boost/libs/mpi/test/block_nonblock_test.cpp new file mode 100644 index 000000000..3088b6559 --- /dev/null +++ b/src/boost/libs/mpi/test/block_nonblock_test.cpp @@ -0,0 +1,95 @@ +#include <vector> +#include <iostream> +#include <iterator> +#include <typeinfo> + +#include <boost/mpi.hpp> +#include <boost/serialization/vector.hpp> +#include <boost/core/demangle.hpp> + +//#include "debugger.cpp" + +#define BOOST_TEST_MODULE mpi_nonblocking +#include <boost/test/included/unit_test.hpp> + +namespace mpi = boost::mpi; + +template<typename T> +bool test(mpi::communicator const& comm, std::vector<T> const& ref, bool iswap, bool alloc) +{ + + int rank = comm.rank(); + if (rank == 0) { + std::cout << "Testing with type " << boost::core::demangle(typeid(T).name()) << '\n'; + if (iswap) { + std::cout << "Blockin send, non blocking receive.\n"; + } else { + std::cout << "Non blockin send, blocking receive.\n"; + } + if (alloc) { + std::cout << "Explicitly allocate space for the receiver.\n"; + } else { + std::cout << "Do not explicitly allocate space for the receiver.\n"; + } + } + if (rank == 0) { + std::vector<T> data; + if (alloc) { + data.resize(ref.size()); + } + if (iswap) { + mpi::request req = comm.irecv(1, 0, data); + req.wait(); + } else { + comm.recv(1, 0, data); + } + std::cout << "Process 0 received " << data.size() << " elements :" << std::endl; + std::copy(data.begin(), data.end(), std::ostream_iterator<T>(std::cout, " ")); + std::cout << std::endl; + std::cout << "While expecting " << ref.size() << " elements :" << std::endl; + std::copy(ref.begin(), ref.end(), std::ostream_iterator<T>(std::cout, " ")); + std::cout << std::endl; + return (data == ref); + } else { + if (rank == 1) { + std::vector<T> vec = ref; + if (iswap) { + comm.send(0, 0, vec); + } else { + mpi::request req = comm.isend(0, 0, vec); + req.wait(); + } + } + return true; + } +} + +BOOST_AUTO_TEST_CASE(non_blocking) +{ + mpi::environment env; + mpi::communicator world; + + BOOST_TEST_REQUIRE(world.size() > 1); + + std::vector<int> integers(13); // don't assume we're lucky + for(int i = 0; i < int(integers.size()); ++i) { + integers[i] = i; + } + + std::vector<std::string> strings(13); // don't assume we're lucky + for(int i = 0; i < int(strings.size()); ++i) { + std::ostringstream fmt; + fmt << "S" << i; + strings[i] = fmt.str(); + } + + BOOST_CHECK(test(world, integers, true, true)); + BOOST_CHECK(test(world, integers, true, false)); + BOOST_CHECK(test(world, strings, true, true)); + BOOST_CHECK(test(world, strings, true, false)); + + BOOST_CHECK(test(world, integers, false, true)); + BOOST_CHECK(test(world, integers, false, false)); + BOOST_CHECK(test(world, strings, false, true)); + BOOST_CHECK(test(world, strings, false, false)); +} diff --git a/src/boost/libs/mpi/test/broadcast_stl_test.cpp b/src/boost/libs/mpi/test/broadcast_stl_test.cpp new file mode 100644 index 000000000..705d6ccb9 --- /dev/null +++ b/src/boost/libs/mpi/test/broadcast_stl_test.cpp @@ -0,0 +1,75 @@ +// Copyright (C) 2005, 2006 Douglas Gregor. + +// 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) + +// A test of the broadcast() collective. +#include <algorithm> +#include <vector> +#include <map> + +#include <boost/mpi/collectives/broadcast.hpp> +#include <boost/mpi/communicator.hpp> +#include <boost/mpi/environment.hpp> + +#include <boost/serialization/string.hpp> +#include <boost/serialization/vector.hpp> +#include <boost/serialization/map.hpp> + +#define BOOST_TEST_MODULE mpi_broadcast_stl +#include <boost/test/included/unit_test.hpp> + +namespace mpi = boost::mpi; + +typedef std::vector<std::map<int, double> > sparse; + +template<typename T> +void +broadcast_test(const mpi::communicator& comm, const T& bc_value, + std::string const& kind, int root) { + using boost::mpi::broadcast; + + T value; + if (comm.rank() == root) { + value = bc_value; + std::cout << "Broadcasting " << kind << " from root " << root << "..."; + std::cout.flush(); + } + + + broadcast(comm, value, root); + BOOST_CHECK(value == bc_value); + if (comm.rank() == root) { + if (value == bc_value) { + std::cout << "OK." << std::endl; + } else { + std::cout << "FAIL." << std::endl; + } + } + comm.barrier(); +} + +template<typename T> +void +broadcast_test(const mpi::communicator& comm, const T& bc_value, + std::string const& kind) +{ + for (int root = 0; root < comm.size(); ++root) { + broadcast_test(comm, bc_value, kind, root); + } +} + +BOOST_AUTO_TEST_CASE(broadcast_stl) +{ + boost::mpi::environment env; + + mpi::communicator comm; + BOOST_TEST_REQUIRE(comm.size() > 1); + + sparse s; + s.resize(2); + s[0][12] = 0.12; + s[1][13] = 1.13; + broadcast_test(comm, s, "sparse"); +} diff --git a/src/boost/libs/mpi/test/broadcast_test.cpp b/src/boost/libs/mpi/test/broadcast_test.cpp new file mode 100644 index 000000000..50081aad9 --- /dev/null +++ b/src/boost/libs/mpi/test/broadcast_test.cpp @@ -0,0 +1,159 @@ +// Copyright (C) 2005, 2006 Douglas Gregor. + +// 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) + +// A test of the broadcast() collective. +#include <boost/mpi/collectives/broadcast.hpp> +#include <boost/mpi/communicator.hpp> +#include <boost/mpi/environment.hpp> +#include <algorithm> +#include "gps_position.hpp" +#include <boost/serialization/string.hpp> +#include <boost/serialization/list.hpp> +#include <boost/mpi/skeleton_and_content.hpp> +#include <boost/iterator/counting_iterator.hpp> +//#include "debugger.hpp" + +#define BOOST_TEST_MODULE mpi_broadcast +#include <boost/test/included/unit_test.hpp> + +using boost::mpi::communicator; + +using boost::mpi::packed_skeleton_iarchive; +using boost::mpi::packed_skeleton_oarchive; + +template<typename T> +void +broadcast_test(const communicator& comm, const T& bc_value, + const char* kind, int root = -1) +{ + if (root == -1) { + for (root = 0; root < comm.size(); ++root) + broadcast_test(comm, bc_value, kind, root); + } else { + using boost::mpi::broadcast; + + T value; + if (comm.rank() == root) { + value = bc_value; + std::cout << "Broadcasting " << kind << " from root " << root << "..."; + std::cout.flush(); + } + + broadcast(comm, value, root); + BOOST_CHECK(value == bc_value); + if (comm.rank() == root && value == bc_value) + std::cout << "OK." << std::endl; + } + + (comm.barrier)(); +} + +void +test_skeleton_and_content(const communicator& comm, int root = 0) +{ + using boost::mpi::content; + using boost::mpi::get_content; + using boost::make_counting_iterator; + using boost::mpi::broadcast; + + int list_size = comm.size() + 7; + if (comm.rank() == root) { + // Fill in the seed data + std::list<int> original_list; + for (int i = 0; i < list_size; ++i) + original_list.push_back(i); + + // Build up the skeleton + packed_skeleton_oarchive oa(comm); + oa << original_list; + + // Broadcast the skeleton + std::cout << "Broadcasting integer list skeleton from root " << root + << "..." << std::flush; + broadcast(comm, oa, root); + std::cout << "OK." << std::endl; + + // Broadcast the content + std::cout << "Broadcasting integer list content from root " << root + << "..." << std::flush; + { + content c = get_content(original_list); + broadcast(comm, c, root); + } + std::cout << "OK." << std::endl; + + // Reverse the list, broadcast the content again + std::reverse(original_list.begin(), original_list.end()); + std::cout << "Broadcasting reversed integer list content from root " + << root << "..." << std::flush; + { + content c = get_content(original_list); + broadcast(comm, c, root); + } + std::cout << "OK." << std::endl; + + } else { + // Allocate some useless data, to try to get the addresses of the + // list<int>'s used later to be different across processes. + std::list<int> junk_list(comm.rank() * 3 + 1, 17); + + // Receive the skeleton + packed_skeleton_iarchive ia(comm); + broadcast(comm, ia, root); + + // Build up a list to match the skeleton, and make sure it has the + // right structure (we have no idea what the data will be). + std::list<int> transferred_list; + ia >> transferred_list; + BOOST_CHECK((int)transferred_list.size() == list_size); + + // Receive the content and check it + broadcast(comm, get_content(transferred_list), root); + bool list_content_ok = std::equal(make_counting_iterator(0), + make_counting_iterator(list_size), + transferred_list.begin()); + BOOST_CHECK(list_content_ok); + + // Receive the reversed content and check it + broadcast(comm, get_content(transferred_list), root); + bool rlist_content_ok = std::equal(make_counting_iterator(0), + make_counting_iterator(list_size), + transferred_list.rbegin()); + BOOST_CHECK(rlist_content_ok); + if (!(list_content_ok && rlist_content_ok)) { + if (comm.rank() == 1) { + std::cout + << "\n##### You might want to check for BOOST_MPI_BCAST_BOTTOM_WORKS_FINE " + << "in boost/mpi/config.hpp.\n\n"; + } + } + } + + (comm.barrier)(); +} + +BOOST_AUTO_TEST_CASE(broadcast_check) +{ + boost::mpi::environment env; + communicator comm; + + BOOST_TEST_REQUIRE(comm.size() > 1); + + // Check transfer of individual objects + broadcast_test(comm, 17, "integers"); + broadcast_test(comm, gps_position(39,16,20.2799), "GPS positions"); + broadcast_test(comm, gps_position(26,25,30.0), "GPS positions"); + broadcast_test(comm, std::string("Rosie"), "string"); + + std::list<std::string> strings; + strings.push_back("Hello"); + strings.push_back("MPI"); + strings.push_back("World"); + broadcast_test(comm, strings, "list of strings"); + + test_skeleton_and_content(comm, 0); + test_skeleton_and_content(comm, 1); +} diff --git a/src/boost/libs/mpi/test/cartesian_topology_init_test.cpp b/src/boost/libs/mpi/test/cartesian_topology_init_test.cpp new file mode 100644 index 000000000..6138a2e6c --- /dev/null +++ b/src/boost/libs/mpi/test/cartesian_topology_init_test.cpp @@ -0,0 +1,88 @@ + +// Copyright Alain Miniussi 2014. +// Distributed under 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: Alain Miniussi + +#include <vector> +#include <list> +#include <iostream> +#include <sstream> +#include <iterator> +#include <algorithm> +#include <functional> + +#include <boost/mpi/communicator.hpp> +#include <boost/mpi/collectives.hpp> +#include <boost/array.hpp> +#include <boost/mpi/environment.hpp> +#include <boost/mpi/cartesian_communicator.hpp> + +#define BOOST_TEST_MODULE mpi_cartesian_topology_init +#include <boost/test/included/unit_test.hpp> + +namespace mpi = boost::mpi; + +BOOST_AUTO_TEST_CASE(cartesian_dimension_init) +{ + // Curly brace initialization syntax not supported on (very) old gnu + // This typedef keeps things shorter + typedef mpi::cartesian_dimension cd; + + { + // Check the basic ctor + mpi::cartesian_dimension def; + mpi::cartesian_topology t1(10); + BOOST_CHECK(t1.stl() == std::vector<mpi::cartesian_dimension>(10, def)); + } +#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) + { + // Intializer list ctor vs range based + int dims[] = {2,3,4}; + bool per[] = {true, false, true}; + mpi::cartesian_topology t1(dims, per); + mpi::cartesian_topology t2({{2,true},{3, false},{4, true}}); + BOOST_CHECK(t1.size() == 3); + BOOST_CHECK(t1 == t2); + } +#endif + // Container based ctor only available as a replacement for initializer list ctor + { + // seq ctor vs C array ctor + mpi::cartesian_dimension d[] = {cd(2,true),cd(3, false),cd(4, true)}; + std::list<mpi::cartesian_dimension> seq; + std::copy(d, d+3, std::back_inserter(seq)); + mpi::cartesian_topology t1(seq); + mpi::cartesian_topology t2(d); + BOOST_CHECK(t1 == t2); + } + { + // Check range based with array based ctor. + boost::array<mpi::cartesian_dimension, 3> d = {{cd(2,true),cd(3, false),cd(4, true)}}; + int dims[] = {2,3,4}; + bool per[] = {true, false, true}; + mpi::cartesian_topology t1(dims, per); + mpi::cartesian_topology t2(d); + BOOST_CHECK(t1.size() == 3); + BOOST_CHECK(t1 == t2); + } + { + // Iterator based ctor vs C array based ctor + mpi::cartesian_dimension d[] = {cd(2,true),cd(3, false),cd(4, true)}; + std::vector<mpi::cartesian_dimension> vdims(d, d+3); + mpi::cartesian_topology t1(vdims); + mpi::cartesian_topology t2(d); + BOOST_CHECK(t1.size() == 3); + BOOST_CHECK(t1 == t2); + BOOST_CHECK(!(t1 != t2)); + t1[1].periodic = true; + BOOST_CHECK(t1 != t2); + t1[2].periodic = false; + t1[2].size = 0; + vdims.push_back(mpi::cartesian_dimension(3, false)); + mpi::cartesian_topology t3(vdims); + BOOST_CHECK(t1 != t3); + } +} diff --git a/src/boost/libs/mpi/test/cartesian_topology_test.cpp b/src/boost/libs/mpi/test/cartesian_topology_test.cpp new file mode 100644 index 000000000..d63fc5003 --- /dev/null +++ b/src/boost/libs/mpi/test/cartesian_topology_test.cpp @@ -0,0 +1,193 @@ +// Copyright Alain Miniussi 2014. +// Distributed under 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: Alain Miniussi + +#include <vector> +#include <iostream> +#include <sstream> +#include <iterator> +#include <algorithm> +#include <functional> + +#include <boost/mpi/communicator.hpp> +#include <boost/mpi/collectives.hpp> +#include <boost/mpi/environment.hpp> +#include <boost/mpi/cartesian_communicator.hpp> + +#define BOOST_TEST_MODULE mpi_cartesian_topolohy +#include <boost/test/included/unit_test.hpp> + +namespace mpi = boost::mpi; + +struct topo_minimum { + mpi::cartesian_dimension + operator()(mpi::cartesian_dimension const& d1, + mpi::cartesian_dimension const& d2 ) const { + return mpi::cartesian_dimension(std::min(d1.size, d2.size), + d1.periodic && d2.periodic); + } +}; + +std::string topology_description( mpi::cartesian_topology const& topo ) { + std::ostringstream out; + std::copy(topo.begin(), topo.end(), std::ostream_iterator<mpi::cartesian_dimension>(out, " ")); + out << std::flush; + return out.str(); +} + +// Check that everyone agrees on the coordinates +void test_coordinates_consistency( mpi::cartesian_communicator const& cc, + std::vector<int> const& coords ) +{ + cc.barrier(); // flush IOs for nice printing + bool master = cc.rank() == 0; + if (master) { + std::cout << "Test coordinates consistency.\n"; + } + for(int p = 0; p < cc.size(); ++p) { + std::vector<int> min(cc.ndims()); + std::vector<int> local(cc.coordinates(p)); + mpi::reduce(cc, &local.front(), local.size(), + &(min[0]), mpi::minimum<int>(), p); + cc.barrier(); + if (p == cc.rank()) { + BOOST_CHECK(std::equal(coords.begin(), coords.end(), min.begin())); + std::ostringstream out; + out << "proc " << p << " at ("; + std::copy(min.begin(), min.end(), std::ostream_iterator<int>(out, " ")); + out << ")\n"; + std::cout << out.str(); + } + } +} + +void test_shifted_coords( mpi::cartesian_communicator const& cc, int pos, mpi::cartesian_dimension desc, int dim ) +{ + if (desc.periodic) { + for (int i = -(desc.size); i < desc.size; ++i) { + std::pair<int,int> rks = cc.shifted_ranks(dim, i); + int src = cc.coordinates(rks.first)[dim]; + int dst = cc.coordinates(rks.second)[dim]; + if (pos == (dim/2)) { + std::ostringstream out; + out << "Rank " << cc.rank() << ", dim. " << dim << ", pos " << pos << ", in " << desc << ' '; + out << "shifted pos: " << src << ", " << dst << '\n'; + std::cout << out.str(); + } + } + } +} + +void test_shifted_coords( mpi::cartesian_communicator const& cc) +{ + cc.barrier(); // flush IOs for nice printing + std::vector<int> coords; + mpi::cartesian_topology topo(cc.ndims()); + cc.topology(topo, coords); + bool master = cc.rank() == 0; + if (master) { + std::cout << "Testing shifts with topology " << topo << '\n'; + } + for(int i = 0; i < cc.ndims(); ++i) { + if (master) { + std::cout << " for dimension " << i << ": " << topo[i] << '\n'; + } + test_shifted_coords( cc, coords[i], topo[i], i ); + } +} + +void test_topology_consistency( mpi::cartesian_communicator const& cc) +{ + cc.barrier(); // flush IOs for nice printing + mpi::cartesian_topology itopo(cc.ndims()); + mpi::cartesian_topology otopo(cc.ndims()); + std::vector<int> coords(cc.ndims()); + cc.topology(itopo, coords); + bool master = cc.rank() == 0; + if (master) { + std::cout << "Test topology consistency of" << itopo << "(on master)\n"; + std::cout << "Check that everyone agrees on the dimensions.\n"; + } + mpi::all_reduce(cc, + &(itopo[0]), itopo.size(), &(otopo[0]), + topo_minimum()); + BOOST_CHECK(std::equal(itopo.begin(), itopo.end(), otopo.begin())); + if (master) { + std::cout << "We agree on " << topology_description(otopo) << '\n'; + } + test_coordinates_consistency( cc, coords ); +} + +void test_cartesian_topology( mpi::cartesian_communicator const& cc) +{ + BOOST_CHECK(cc.has_cartesian_topology()); + for( int r = 0; r < cc.size(); ++r) { + cc.barrier(); + if (r == cc.rank()) { + std::vector<int> coords = cc.coordinates(r); + std::cout << "Process of cartesian rank " << cc.rank() + << " has coordinates ("; + std::copy(coords.begin(), coords.end(), std::ostream_iterator<int>(std::cout," ")); + std::cout << ")\n"; + } + } + test_topology_consistency(cc); + test_shifted_coords(cc); + std::vector<int> even; + for(int i = 0; i < cc.ndims(); i += 2) { + even.push_back(i); + } + cc.barrier(); + mpi::cartesian_communicator cce(cc, even); +} + +void test_cartesian_topology( mpi::communicator const& world, mpi::cartesian_topology const& topo) +{ + mpi::cartesian_communicator cc(world, topo, true); + if (cc) { + BOOST_CHECK(cc.has_cartesian_topology()); + BOOST_CHECK(cc.ndims() == int(topo.size())); + if (cc.rank() == 0) { + std::cout << "Asked topology " << topo << ", got " << cc.topology() << '\n'; + } + test_cartesian_topology(cc); + } else { + std::ostringstream out; + out << world.rank() << " was left outside the cartesian grid\n"; + std::cout << out.str(); + } +} + +BOOST_AUTO_TEST_CASE(cartesian_topology) +{ + mpi::environment env; + mpi::communicator world; + + int const ndim = world.size() >= 24 ? 3 : 2; + mpi::cartesian_topology topo(ndim); + typedef mpi::cartesian_dimension cd; + if (topo.size() == 3) { + topo[0] = cd(2,true); + topo[1] = cd(3,false); + topo[2] = cd(4, true); + } else { + if (world.size() >= 6) { + topo[0] = cd(2,true); + topo[1] = cd(3, false); + } else { + topo[0] = cd(1,true); + topo[1] = cd(1, false); + } + } + test_cartesian_topology( world, topo); +#if !defined(BOOST_NO_CXX11_DEFAULTED_MOVES) + world.barrier(); + if (world.rank()==0) { + std::cout << "Testing move constructor.\n"; + } + test_cartesian_topology( world, std::move(topo)); +#endif +} diff --git a/src/boost/libs/mpi/test/debugger.cpp b/src/boost/libs/mpi/test/debugger.cpp new file mode 100644 index 000000000..90093e79f --- /dev/null +++ b/src/boost/libs/mpi/test/debugger.cpp @@ -0,0 +1,48 @@ +// Copyright AlainMiniussi 20014 - 20015. +// Distributed under 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) + +#include <cstdlib> + +#include "debugger.hpp" + +std::vector<int> extract_paused_ranks(int argc, char** argv) { + std::vector<int> paused; + for (int i=1; i < argc; ++i) { + paused.push_back(std::atoi(argv[i])); + } + return paused; +} + +void wait_for_debugger(std::vector<int> const& processes, boost::mpi::communicator const& comm) +{ + int i = 1; + bool waiting = std::find(processes.begin(), processes.end(), comm.rank()) != processes.end(); + for (int r = 0; r < comm.size(); ++r) { + if (comm.rank() == r) { + std::cout << "Rank " << comm.rank() << " has PID " << getpid(); + if (waiting) { + std::cout << " and is waiting."; + } + std::cout << std::endl; + } + comm.barrier(); + } + if (std::find(processes.begin(), processes.end(), comm.rank()) != processes.end()) { + while (i != 0) { + sleep(5); + } + } + std::cout << "Rank " << comm.rank() << " will proceed.\n"; +} + +void wait_for_debugger(boost::mpi::communicator const& comm) +{ + std::vector<int> all; + for (int r = 0; r < comm.size(); ++r) { + all.push_back(r); + } + wait_for_debugger(all, comm); +} + diff --git a/src/boost/libs/mpi/test/debugger.hpp b/src/boost/libs/mpi/test/debugger.hpp new file mode 100644 index 000000000..71abf51d0 --- /dev/null +++ b/src/boost/libs/mpi/test/debugger.hpp @@ -0,0 +1,26 @@ +// Copyright AlainMiniussi 20014 - 20015. +// Distributed under 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) + +#include <vector> +#include "boost/mpi/communicator.hpp" + +/** + * @brief Extract the MPI rank to pause. + * + * Right now, just atois alla the parameters in argv.... + */ +std::vector<int> extract_paused_ranks(int argc, char** argv); + +/** + * @print Print rank pid map and wait if requested. + * @param processes Wait if our rank is in there. + * @param comm The communicator to consider. + * + * Once the debugger has attached to the process, it is expected to + * set the local variable 'i' to 0 to let the process restarts. + */ +void wait_for_debugger(std::vector<int> const& processes, boost::mpi::communicator const& comm); +/** @override */ +void wait_for_debugger(boost::mpi::communicator const& comm); diff --git a/src/boost/libs/mpi/test/gather_test.cpp b/src/boost/libs/mpi/test/gather_test.cpp new file mode 100644 index 000000000..9bef7acd2 --- /dev/null +++ b/src/boost/libs/mpi/test/gather_test.cpp @@ -0,0 +1,165 @@ +// Copyright (C) 2005, 2006 Douglas Gregor. + +// 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) + +// A test of the gather() and gatherv() collectives. +#include <boost/mpi/collectives/gather.hpp> +#include <boost/mpi/collectives/gatherv.hpp> +#include <boost/mpi/communicator.hpp> +#include <boost/mpi/environment.hpp> +#include "gps_position.hpp" +#include <boost/serialization/string.hpp> +#include <boost/serialization/list.hpp> +#include <boost/iterator/counting_iterator.hpp> +#include <boost/lexical_cast.hpp> + +#define BOOST_TEST_MODULE mpi_gather +#include <boost/test/included/unit_test.hpp> + +using boost::mpi::communicator; + +template<typename Generator> +void +gather_test(const communicator& comm, Generator generator, + const char* kind, int root = -1) +{ + typedef typename Generator::result_type value_type; + value_type value = generator(comm.rank()); + + if (root == -1) { + for (root = 0; root < comm.size(); ++root) + gather_test(comm, generator, kind, root); + } else { + using boost::mpi::gather; + + std::vector<value_type> values; + if (comm.rank() == root) { + std::cout << "Gathering " << kind << " from root " + << root << "..." << std::endl; + } + + gather(comm, value, values, root); + + if (comm.rank() == root) { + std::vector<value_type> expected_values; + for (int p = 0; p < comm.size(); ++p) + expected_values.push_back(generator(p)); + BOOST_CHECK(values == expected_values); + } else { + BOOST_CHECK(values.empty()); + } + } + + (comm.barrier)(); +} + + +template<typename Generator> +void +gatherv_test(const communicator& comm, Generator generator, + const char* kind, int root = -1) +{ + typedef typename Generator::result_type value_type; + + if (root == -1) { + for (root = 0; root < comm.size(); ++root) + gatherv_test(comm, generator, kind, root); + } else { + using boost::mpi::gatherv; + + int mysize = comm.rank() + 1; + int nprocs = comm.size(); + + // process p will send p+1 identical generator(p) elements + std::vector<value_type> myvalues(mysize, generator(comm.rank())); + + if (comm.rank() == root) { + std::vector<value_type> values((nprocs*(nprocs+1))/2); + std::vector<int> sizes(comm.size()); + for (int p = 0; p < comm.size(); ++p) + sizes[p] = p + 1; + + std::cout << "Gatheringv " << kind << " from root " + << root << "..." << std::endl; + + gatherv(comm, myvalues, &values[0], sizes, root); + + std::vector<value_type> expected_values; + for (int p = 0; p < comm.size(); ++p) + for (int i = 0; i < p+1; ++i) + expected_values.push_back(generator(p)); + + BOOST_CHECK(values == expected_values); + } else { + gatherv(comm, myvalues, root); + } + } + + (comm.barrier)(); +} + +// +// Generators to test with gather/gatherv +// +struct int_generator +{ + typedef int result_type; + + int operator()(int p) const { return 17 + p; } +}; + +struct gps_generator +{ + typedef gps_position result_type; + + gps_position operator()(int p) const + { + return gps_position(39 + p, 16, 20.2799); + } +}; + +struct string_generator +{ + typedef std::string result_type; + + std::string operator()(int p) const + { + std::string result = boost::lexical_cast<std::string>(p); + result += " rosebud"; + if (p != 1) result += 's'; + return result; + } +}; + +struct string_list_generator +{ + typedef std::list<std::string> result_type; + + std::list<std::string> operator()(int p) const + { + std::list<std::string> result; + for (int i = 0; i <= p; ++i) { + std::string value = boost::lexical_cast<std::string>(i); + result.push_back(value); + } + return result; + } +}; + +BOOST_AUTO_TEST_CASE(gather_check) +{ + boost::mpi::environment env; + communicator comm; + + gather_test(comm, int_generator(), "integers"); + gather_test(comm, gps_generator(), "GPS positions"); + gather_test(comm, string_generator(), "string"); + gather_test(comm, string_list_generator(), "list of strings"); + + gatherv_test(comm, int_generator(), "integers"); + gatherv_test(comm, gps_generator(), "GPS positions"); + gatherv_test(comm, string_generator(), "string"); + gatherv_test(comm, string_list_generator(), "list of strings"); +} diff --git a/src/boost/libs/mpi/test/gps_position.hpp b/src/boost/libs/mpi/test/gps_position.hpp new file mode 100644 index 000000000..e6910c444 --- /dev/null +++ b/src/boost/libs/mpi/test/gps_position.hpp @@ -0,0 +1,69 @@ +#ifndef GPS_POSITION_HPP +#define GPS_POSITION_HPP + +// Copyright Matthias Troyer +// 2005. Distributed under 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) + +#include <boost/mpi/datatype_fwd.hpp> +#include <boost/mpl/and.hpp> +#include <boost/serialization/export.hpp> +#include <boost/shared_ptr.hpp> +#include <iostream> + +class gps_position +{ +private: + friend class boost::serialization::access; + // When the class Archive corresponds to an output archive, the + // & operator is defined similar to <<. Likewise, when the class Archive + // is a type of input archive the & operator is defined similar to >>. + template<class Archive> + void serialize(Archive & ar, const unsigned int version) + { + ar & degrees & minutes & seconds; + } + int degrees; + int minutes; + float seconds; +public: + gps_position(){}; + gps_position(int d, int m, float s) : + degrees(d), minutes(m), seconds(s) + {} + + friend std::ostream& operator<<(std::ostream& out, const gps_position& g); + + friend bool operator==(const gps_position& x, const gps_position& y) + { + return (x.degrees == y.degrees + && x.minutes == y.minutes + && x.seconds == y.seconds); + } + + inline friend bool operator!=(const gps_position& x, const gps_position& y) + { + return !(x == y); + } +}; + +inline +std::ostream& operator<<(std::ostream& out, const gps_position& g) { + out << "gps{" << g.degrees << 'd' << g.minutes << 'm' << g.seconds << "s}"; + return out; +} + +namespace boost { namespace mpi { + + template <> + struct is_mpi_datatype<gps_position> + : public mpl::and_ + < + is_mpi_datatype<int>, + is_mpi_datatype<float> + > + {}; + +} } +#endif diff --git a/src/boost/libs/mpi/test/graph_topology_test.cpp b/src/boost/libs/mpi/test/graph_topology_test.cpp new file mode 100644 index 000000000..4d781265c --- /dev/null +++ b/src/boost/libs/mpi/test/graph_topology_test.cpp @@ -0,0 +1,141 @@ +// Copyright (C) 2007 Trustees of Indiana University + +// Authors: Douglas Gregor +// Andrew Lumsdaine + +// 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) + +// A test of the communicator that passes data around a ring and +// verifies that the same data makes it all the way. Should test all +// of the various kinds of data that can be sent (primitive types, POD +// types, serializable objects, etc.) +#include <boost/mpi/graph_communicator.hpp> +#include <boost/mpi/communicator.hpp> +#include <boost/mpi/environment.hpp> +#include <boost/graph/adjacency_list.hpp> +#include <boost/lexical_cast.hpp> +#include <boost/graph/erdos_renyi_generator.hpp> +#include <boost/random/linear_congruential.hpp> +#include <boost/graph/iteration_macros.hpp> +#include <boost/graph/isomorphism.hpp> +#include <algorithm> // for random_shuffle +#include <boost/serialization/vector.hpp> +#include <boost/mpi/collectives/broadcast.hpp> +#include <boost/config.hpp> + +#define BOOST_TEST_MODULE mpi_graph_topology +#include <boost/test/included/unit_test.hpp> + +#if defined(BOOST_NO_CXX98_RANDOM_SHUFFLE) + +#include <random> + +std::default_random_engine gen; + +template<typename RandomIt> void random_shuffle( RandomIt first, RandomIt last ) +{ + std::shuffle( first, last, gen ); +} + +#else + +using std::random_shuffle; + +#endif // #if defined(BOOST_NO_CXX98_RANDOM_SHUFFLE) + + +using boost::mpi::communicator; +using boost::mpi::graph_communicator; +using namespace boost; + +BOOST_AUTO_TEST_CASE(graph_topology) +{ + boost::function_requires< IncidenceGraphConcept<graph_communicator> >(); + boost::function_requires< AdjacencyGraphConcept<graph_communicator> >(); + boost::function_requires< VertexListGraphConcept<graph_communicator> >(); + boost::function_requires< EdgeListGraphConcept<graph_communicator> >(); + + double prob = 0.1; + + boost::mpi::environment env; + communicator world; + + // Random number generator + minstd_rand gen; + + // Build a random graph with as many vertices as there are processes + typedef adjacency_list<listS, vecS, bidirectionalS> Graph; + sorted_erdos_renyi_iterator<minstd_rand, Graph> + first(gen, world.size(), prob), last; + Graph graph(first, last, world.size()); + + // Display the original graph + if (world.rank() == 0) { + std::cout << "Original, random graph:\n"; + BGL_FORALL_VERTICES(v, graph, Graph) { + BGL_FORALL_OUTEDGES(v, e, graph, Graph) { + std::cout << source(e, graph) << " -> " << target(e, graph) + << std::endl; + } + } + } + + // Create an arbitrary mapping from vertices to integers + typedef property_map<Graph, vertex_index_t>::type GraphVertexIndexMap; + std::vector<int> graph_alt_index_vec(num_vertices(graph)); + iterator_property_map<int*, GraphVertexIndexMap> + graph_alt_index(&graph_alt_index_vec[0], get(vertex_index, graph)); + + // Rank 0 will populate the alternative index vector + if (world.rank() == 0) { + int index = 0; + BGL_FORALL_VERTICES(v, graph, Graph) + put(graph_alt_index, v, index++); + + ::random_shuffle(graph_alt_index_vec.begin(), graph_alt_index_vec.end()); + } + broadcast(world, graph_alt_index_vec, 0); + + // Display the original graph with the remapping + if (world.rank() == 0) { + std::cout << "Original, random graph with remapped vertex numbers:\n"; + BGL_FORALL_VERTICES(v, graph, Graph) { + BGL_FORALL_OUTEDGES(v, e, graph, Graph) { + std::cout << get(graph_alt_index, source(e, graph)) << " -> " + << get(graph_alt_index, target(e, graph)) << std::endl; + } + } + } + + // Create a communicator with a topology equivalent to the graph + graph_communicator graph_comm(world, graph, graph_alt_index, false); + + // The communicator's topology should have the same number of + // vertices and edges and the original graph + BOOST_CHECK((int)num_vertices(graph) == num_vertices(graph_comm)); + BOOST_CHECK((int)num_edges(graph) == num_edges(graph_comm)); + + // Display the communicator graph + if (graph_comm.rank() == 0) { + std::cout << "Communicator graph:\n"; + BGL_FORALL_VERTICES(v, graph_comm, graph_communicator) { + BGL_FORALL_OUTEDGES(v, e, graph_comm, graph_communicator) { + std::cout << source(e, graph_comm) << " -> " << target(e, graph_comm) + << std::endl; + } + } + + std::cout << "Communicator graph via edges():\n"; + BGL_FORALL_EDGES(e, graph_comm, graph_communicator) + std::cout << source(e, graph_comm) << " -> " << target(e, graph_comm) + << std::endl; + } + (graph_comm.barrier)(); + + // Verify the isomorphism + if (graph_comm.rank() == 0) + std::cout << "Verifying isomorphism..." << std::endl; + BOOST_CHECK(verify_isomorphism(graph, graph_comm, graph_alt_index)); +} diff --git a/src/boost/libs/mpi/test/groups_test.cpp b/src/boost/libs/mpi/test/groups_test.cpp new file mode 100644 index 000000000..ce81d182d --- /dev/null +++ b/src/boost/libs/mpi/test/groups_test.cpp @@ -0,0 +1,59 @@ +// Copyright (C) 2013 Andreas Hehn <hehn@phys.ethz.ch>, ETH Zurich + +// 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) + +// A test of communicators created from groups. + +#include <boost/mpi/environment.hpp> +#include <boost/mpi/communicator.hpp> +#include <boost/mpi/group.hpp> +#include <vector> +#include <algorithm> + +#define BOOST_TEST_MODULE mpi_group_test +#include <boost/test/included/unit_test.hpp> + +namespace mpi = boost::mpi; + +template <typename T> +struct iota +{ + iota() : state(0){}; + T operator()() + { + return state++; + } + T state; +}; + +void group_test(const mpi::communicator& comm) +{ + std::vector<int> grp_a_ranks(comm.size() / 2); + std::generate(grp_a_ranks.begin(),grp_a_ranks.end(),iota<int>()); + + mpi::group grp_a = comm.group().include(grp_a_ranks.begin(),grp_a_ranks.end()); + mpi::group grp_b = comm.group().exclude(grp_a_ranks.begin(),grp_a_ranks.end()); + + mpi::communicator part_a(comm,grp_a); + mpi::communicator part_b(comm,grp_b); + + if(part_a) + { + std::cout << "comm rank: " << comm.rank() << " -> part_a rank:" << part_a.rank() << std::endl; + BOOST_CHECK(part_a.rank() == comm.rank()); + } + if(part_b) + { + std::cout << "comm rank: " << comm.rank() << " -> part_b rank:" << part_b.rank() << std::endl; + BOOST_CHECK(part_b.rank() == comm.rank() - comm.size()/2); + } +} + +BOOST_AUTO_TEST_CASE(group) +{ + mpi::environment env; + mpi::communicator comm; + group_test(comm); +} diff --git a/src/boost/libs/mpi/test/is_mpi_op_test.cpp b/src/boost/libs/mpi/test/is_mpi_op_test.cpp new file mode 100644 index 000000000..d023c3f76 --- /dev/null +++ b/src/boost/libs/mpi/test/is_mpi_op_test.cpp @@ -0,0 +1,33 @@ +// Copyright (C) 2005-2006 Douglas Gregor <doug.gregor@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) + +// A test of the is_mpi_op functionality. +#include <boost/mpi/operations.hpp> +#include <boost/mpi/environment.hpp> +#include <boost/type_traits/is_base_and_derived.hpp> + +#define BOOST_TEST_MODULE mpi_is_mpi_op_test +#include <boost/test/included/unit_test.hpp> + +using namespace boost::mpi; +using namespace std; +using boost::is_base_and_derived; + +BOOST_AUTO_TEST_CASE(mpi_basic_op) +{ + boost::mpi::environment env; + + // Check each predefined MPI_Op type that we support directly. + BOOST_TEST((is_mpi_op<minimum<float>, float>::op() == MPI_MIN)); + BOOST_TEST((is_mpi_op<plus<double>, double>::op() == MPI_SUM)); + BOOST_TEST((is_mpi_op<multiplies<long>, long>::op() == MPI_PROD)); + BOOST_TEST((is_mpi_op<logical_and<int>, int>::op() == MPI_LAND)); + BOOST_TEST((is_mpi_op<bitwise_and<int>, int>::op() == MPI_BAND)); + BOOST_TEST((is_mpi_op<logical_or<int>, int>::op() == MPI_LOR)); + BOOST_TEST((is_mpi_op<bitwise_or<int>, int>::op() == MPI_BOR)); + BOOST_TEST((is_mpi_op<logical_xor<int>, int>::op() == MPI_LXOR)); + BOOST_TEST((is_mpi_op<bitwise_xor<int>, int>::op() == MPI_BXOR)); +} diff --git a/src/boost/libs/mpi/test/mt_init_test.cpp b/src/boost/libs/mpi/test/mt_init_test.cpp new file mode 100644 index 000000000..cfd0f57b4 --- /dev/null +++ b/src/boost/libs/mpi/test/mt_init_test.cpp @@ -0,0 +1,37 @@ +// Copyright (C) 2013 Alain Miniussi <alain.miniussi@oca.eu> + +// 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) + +// test threading::level operations + +#include <boost/mpi.hpp> +#include <iostream> +#include <sstream> + +#define BOOST_TEST_MODULE mpi_mt_init +#include <boost/test/included/unit_test.hpp> + +namespace mpi = boost::mpi; + +void +test_mt_init(std::string s) +{ + mpi::threading::level required = mpi::threading::level(-1); + std::istringstream in(s); + in >> required; + BOOST_CHECK(!in.bad()); + BOOST_CHECK(mpi::environment::thread_level() >= mpi::threading::single); + BOOST_CHECK(mpi::environment::thread_level() <= mpi::threading::multiple); +} + +BOOST_AUTO_TEST_CASE(mt_init) +{ + mpi::environment env; + mpi::communicator comm; + test_mt_init("single"); + test_mt_init("funneled"); + test_mt_init("serialized"); + test_mt_init("multiple"); +} diff --git a/src/boost/libs/mpi/test/mt_level_test.cpp b/src/boost/libs/mpi/test/mt_level_test.cpp new file mode 100644 index 000000000..a72e9a8a5 --- /dev/null +++ b/src/boost/libs/mpi/test/mt_level_test.cpp @@ -0,0 +1,108 @@ +// Copyright (C) 2013 Alain Miniussi <alain.miniussi@oca.eu> + +// 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) + +// test threading::level operations + +#include <boost/mpi/environment.hpp> +#include <iostream> +#include <sstream> + +#define BOOST_TEST_MODULE mpi_level_test +#include <boost/test/included/unit_test.hpp> + +namespace mpi = boost::mpi; + +void +test_threading_level_io(mpi::threading::level orig) { + std::ostringstream out; + namespace mt = boost::mpi::threading; + mt::level printed = mt::level(-1); + + out << orig; + BOOST_CHECK(out.good()); + std::string orig_str(out.str()); + std::cout << "orig string:" << orig_str << '\n'; + std::istringstream in(orig_str); + in >> printed; + BOOST_CHECK(!in.bad()); + std::cout << "orig: " << orig << ", printed: " << printed << std::endl; + BOOST_CHECK(orig == printed); +} + +void +test_threading_levels_io() { + namespace mt = boost::mpi::threading; + test_threading_level_io(mt::single); + test_threading_level_io(mt::funneled); + test_threading_level_io(mt::serialized); + test_threading_level_io(mt::multiple); +} + +void +test_threading_level_cmp() { + namespace mt = boost::mpi::threading; + BOOST_CHECK(mt::single == mt::single); + BOOST_CHECK(mt::funneled == mt::funneled); + BOOST_CHECK(mt::serialized == mt::serialized); + BOOST_CHECK(mt::multiple == mt::multiple); + + BOOST_CHECK(mt::single != mt::funneled); + BOOST_CHECK(mt::single != mt::serialized); + BOOST_CHECK(mt::single != mt::multiple); + + BOOST_CHECK(mt::funneled != mt::single); + BOOST_CHECK(mt::funneled != mt::serialized); + BOOST_CHECK(mt::funneled != mt::multiple); + + BOOST_CHECK(mt::serialized != mt::single); + BOOST_CHECK(mt::serialized != mt::funneled); + BOOST_CHECK(mt::serialized != mt::multiple); + + BOOST_CHECK(mt::multiple != mt::single); + BOOST_CHECK(mt::multiple != mt::funneled); + BOOST_CHECK(mt::multiple != mt::serialized); + + BOOST_CHECK(mt::single < mt::funneled); + BOOST_CHECK(mt::funneled > mt::single); + BOOST_CHECK(mt::single < mt::serialized); + BOOST_CHECK(mt::serialized > mt::single); + BOOST_CHECK(mt::single < mt::multiple); + BOOST_CHECK(mt::multiple > mt::single); + + BOOST_CHECK(mt::funneled < mt::serialized); + BOOST_CHECK(mt::serialized > mt::funneled); + BOOST_CHECK(mt::funneled < mt::multiple); + BOOST_CHECK(mt::multiple > mt::funneled); + + BOOST_CHECK(mt::serialized < mt::multiple); + BOOST_CHECK(mt::multiple > mt::serialized); + + BOOST_CHECK(mt::single <= mt::single); + BOOST_CHECK(mt::single <= mt::funneled); + BOOST_CHECK(mt::funneled >= mt::single); + BOOST_CHECK(mt::single <= mt::serialized); + BOOST_CHECK(mt::serialized >= mt::single); + BOOST_CHECK(mt::single <= mt::multiple); + BOOST_CHECK(mt::multiple >= mt::single); + + BOOST_CHECK(mt::funneled <= mt::funneled); + BOOST_CHECK(mt::funneled <= mt::serialized); + BOOST_CHECK(mt::serialized >= mt::funneled); + BOOST_CHECK(mt::funneled <= mt::multiple); + BOOST_CHECK(mt::multiple >= mt::funneled); + + BOOST_CHECK(mt::serialized <= mt::serialized); + BOOST_CHECK(mt::serialized <= mt::multiple); + BOOST_CHECK(mt::multiple >= mt::serialized); + + BOOST_CHECK(mt::multiple <= mt::multiple); +} + +BOOST_AUTO_TEST_CASE(mt_level) +{ + test_threading_levels_io(); + test_threading_level_cmp(); +} diff --git a/src/boost/libs/mpi/test/non_blocking_any_source.cpp b/src/boost/libs/mpi/test/non_blocking_any_source.cpp new file mode 100644 index 000000000..dde8f92c6 --- /dev/null +++ b/src/boost/libs/mpi/test/non_blocking_any_source.cpp @@ -0,0 +1,63 @@ +// Copyright (C) 2018 Steffen Hirschmann + +// 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) + +// Test any_source on serialized data +#include <vector> +#include <iostream> +#include <iterator> +#include <boost/mpi.hpp> +#include <boost/serialization/vector.hpp> + +#define BOOST_TEST_MODULE mpi_non_blockin_any_source +#include <boost/test/included/unit_test.hpp> + +namespace mpi = boost::mpi; + +std::string ok(bool b) { + return b ? "ok" : "ko"; +} + +BOOST_AUTO_TEST_CASE(non_blocking_any) +{ + mpi::environment env; + mpi::communicator world; + int rank = world.rank(); +#if BOOST_MPI_VERSION < 3 + if (rank == 0) { + std::cout << "\nExpected failure with MPI standard < 3 (" + << BOOST_MPI_VERSION << "." << BOOST_MPI_SUBVERSION + << " detected)\n\n"; + } + return; +#endif + if (rank == 0) { + std::vector<boost::mpi::request> req; + std::vector<std::vector<int> > data(world.size() - 1); + for (int i = 1; i < world.size(); ++i) { + req.push_back(world.irecv(mpi::any_source, 0, data[i - 1])); + } + boost::mpi::wait_all(req.begin(), req.end()); + std::vector<bool> check(world.size()-1, false); + for (int i = 0; i < world.size() - 1; ++i) { + std::cout << "Process 0 received:" << std::endl; + std::copy(data[i].begin(), data[i].end(), std::ostream_iterator<int>(std::cout, " ")); + std::cout << std::endl; + int idx = data[i].size(); + BOOST_CHECK(std::equal_range(data[i].begin(), data[i].end(), idx) + == std::make_pair(data[i].begin(), data[i].end())); + check[idx-1] = true; + } + for(int i = 0; i < world.size() - 1; ++i) { + std::cout << "Received from " << i+1 << " is " << ok(check[i]) << '\n'; + } + BOOST_CHECK(std::equal_range(check.begin(), check.end(), true) + == std::make_pair(check.begin(), check.end())); + } else { + std::vector<int> vec(rank, rank); + mpi::request req = world.isend(0, 0, vec); + req.wait(); + } +} diff --git a/src/boost/libs/mpi/test/nonblocking_test.cpp b/src/boost/libs/mpi/test/nonblocking_test.cpp new file mode 100644 index 000000000..8e3eb099f --- /dev/null +++ b/src/boost/libs/mpi/test/nonblocking_test.cpp @@ -0,0 +1,247 @@ +// Copyright (C) 2006 Douglas Gregor. + +// 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) + +// A test of the nonblocking point-to-point operations. +#include <boost/mpi/nonblocking.hpp> +#include <boost/mpi/communicator.hpp> +#include <boost/mpi/environment.hpp> +#include "gps_position.hpp" +#include <boost/lexical_cast.hpp> +#include <boost/serialization/string.hpp> +#include <boost/serialization/list.hpp> +#include <iterator> +#include <algorithm> +//#include "debugger.cpp" + +#define BOOST_TEST_MODULE mpi_non_blockin_test +#include <boost/test/included/unit_test.hpp> + +using boost::mpi::communicator; +using boost::mpi::request; +using boost::mpi::status; + +enum method_kind { + mk_wait_any, mk_test_any, mk_wait_all, mk_wait_all_keep, + mk_test_all, mk_test_all_keep, mk_wait_some, mk_wait_some_keep, + mk_test_some, mk_test_some_keep, + mk_test_size +}; + +static const char* method_kind_names[mk_test_size] = { + "wait_any", + "test_any", + "wait_all", + "wait_all (keep results)", + "test_all", + "test_all (keep results)", + "wait_some", + "wait_some (keep results)", + "test_some", + "test_some (keep results)" +}; + + +template<typename T> +void +nonblocking_tests( const communicator& comm, const T* values, int num_values, + const char* kind, bool composite) +{ + nonblocking_test(comm, values, num_values, kind, mk_wait_any); + nonblocking_test(comm, values, num_values, kind, mk_test_any); + //wait_for_debugger(comm); + nonblocking_test(comm, values, num_values, kind, mk_wait_all); + nonblocking_test(comm, values, num_values, kind, mk_wait_all_keep); + if (!composite) { + nonblocking_test(comm, values, num_values, kind, mk_test_all); + nonblocking_test(comm, values, num_values, kind, mk_test_all_keep); + } + nonblocking_test(comm, values, num_values, kind, mk_wait_some); + nonblocking_test(comm, values, num_values, kind, mk_wait_some_keep); + nonblocking_test(comm, values, num_values, kind, mk_test_some); + nonblocking_test(comm, values, num_values, kind, mk_test_some_keep); +} + +template<typename T> +void +nonblocking_test(const communicator& comm, const T* values, int num_values, + const char* kind, method_kind method) +{ + using boost::mpi::wait_any; + using boost::mpi::test_any; + using boost::mpi::wait_all; + using boost::mpi::test_all; + using boost::mpi::wait_some; + using boost::mpi::test_some; + + int next = (comm.rank() + 1) % comm.size(); + int prev = (comm.rank() + comm.size() - 1) % comm.size(); + + if (comm.rank() == 0) { + std::cout << "Testing " << method_kind_names[method] + << " with " << kind << "..."; + std::cout.flush(); + } + + typedef std::pair<status, std::vector<request>::iterator> + status_iterator_pair; + + T incoming_value; + std::vector<T> incoming_values(num_values); + std::vector<request> reqs; + // Send/receive the first value + reqs.push_back(comm.isend(next, 0, values[0])); + reqs.push_back(comm.irecv(prev, 0, incoming_value)); + + if (method != mk_wait_any && method != mk_test_any) { +#ifndef LAM_MPI + // We've run into problems here (with 0-length messages) with + // LAM/MPI on Mac OS X and x86-86 Linux. Will investigate + // further at a later time, but the problem only seems to occur + // when using shared memory, not TCP. + + // Send/receive an empty message + reqs.push_back(comm.isend(next, 1)); + reqs.push_back(comm.irecv(prev, 1)); +#endif + + // Send/receive an array + reqs.push_back(comm.isend(next, 2, values, num_values)); + reqs.push_back(comm.irecv(prev, 2, &incoming_values.front(), num_values)); + } + + switch (method) { + case mk_wait_any: + if (wait_any(reqs.begin(), reqs.end()).second == reqs.begin()) + reqs[1].wait(); + else + reqs[0].wait(); + break; + + case mk_test_any: + { + boost::optional<status_iterator_pair> result; + do { + result = test_any(reqs.begin(), reqs.end()); + } while (!result); + if (result->second == reqs.begin()) + reqs[1].wait(); + else + reqs[0].wait(); + break; + } + + case mk_wait_all: + wait_all(reqs.begin(), reqs.end()); + break; + + case mk_wait_all_keep: + { + std::vector<status> stats; + wait_all(reqs.begin(), reqs.end(), std::back_inserter(stats)); + } + break; + + case mk_test_all: + while (!test_all(reqs.begin(), reqs.end())) { /* Busy wait */ } + break; + + case mk_test_all_keep: + { + std::vector<status> stats; + while (!test_all(reqs.begin(), reqs.end(), std::back_inserter(stats))) + /* Busy wait */; + } + break; + + case mk_wait_some: + { + std::vector<request>::iterator pos = reqs.end(); + do { + pos = wait_some(reqs.begin(), pos); + } while (pos != reqs.begin()); + } + break; + + case mk_wait_some_keep: + { + std::vector<status> stats; + std::vector<request>::iterator pos = reqs.end(); + do { + pos = wait_some(reqs.begin(), pos, std::back_inserter(stats)).second; + } while (pos != reqs.begin()); + } + break; + + case mk_test_some: + { + std::vector<request>::iterator pos = reqs.end(); + do { + pos = test_some(reqs.begin(), pos); + } while (pos != reqs.begin()); + } + break; + + case mk_test_some_keep: + { + std::vector<status> stats; + std::vector<request>::iterator pos = reqs.end(); + do { + pos = test_some(reqs.begin(), pos, std::back_inserter(stats)).second; + } while (pos != reqs.begin()); + } + break; + + default: + BOOST_CHECK(false); + } + + if (comm.rank() == 0) { + bool okay = true; + + if (!((incoming_value == values[0]))) + okay = false; + + if (method != mk_wait_any && method != mk_test_any + && !std::equal(incoming_values.begin(), incoming_values.end(), + values)) + okay = false; + + if (okay) + std::cout << "OK." << std::endl; + else + std::cerr << "ERROR!" << std::endl; + } + + BOOST_CHECK(incoming_value == values[0]); + + if (method != mk_wait_any && method != mk_test_any) + BOOST_CHECK(std::equal(incoming_values.begin(), incoming_values.end(), + values)); +} + +BOOST_AUTO_TEST_CASE(nonblocking) +{ + boost::mpi::environment env; + communicator comm; + + int int_array[3] = {17, 42, 256}; + nonblocking_tests(comm, int_array, 3, "integers", false); + + gps_position gps_array[2] = { + gps_position(17, 42, .06), + gps_position(42, 17, .06) + }; + nonblocking_tests(comm, gps_array, 2, "gps positions", false); + + std::string string_array[2] = { "Hello", "World" }; + nonblocking_tests(comm, string_array, 2, "strings", true); + + std::list<std::string> lst_of_strings; + for (int i = 0; i < comm.size(); ++i) + lst_of_strings.push_back(boost::lexical_cast<std::string>(i)); + + nonblocking_tests(comm, &lst_of_strings, 1, "list of strings", true); +} diff --git a/src/boost/libs/mpi/test/pointer_test.cpp b/src/boost/libs/mpi/test/pointer_test.cpp new file mode 100644 index 000000000..65428e752 --- /dev/null +++ b/src/boost/libs/mpi/test/pointer_test.cpp @@ -0,0 +1,42 @@ +// Copyright (C) 2005, 2006 Douglas Gregor. + +// 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) + + +// a test of pointer serialization +#include <boost/mpi.hpp> +#include <boost/serialization/shared_ptr.hpp> + +#define BOOST_TEST_MODULE mpi_pointer +#include <boost/test/included/unit_test.hpp> + +class A +{ + public: + int i; + template<class Archive> + void serialize(Archive & ar, const unsigned int version) + { + ar & i; + } +}; + +BOOST_AUTO_TEST_CASE(pointer) +{ + boost::mpi::environment env; + boost::mpi::communicator world; + + if (world.rank() == 0) { + boost::shared_ptr<A> p(new A); + p->i = 42; + world.send(1, 0, p); + } else if (world.rank() == 1) { + boost::shared_ptr<A> p; + world.recv(0, 0, p); + std::cout << p->i << std::endl; + BOOST_CHECK(p->i==42); + } +} + diff --git a/src/boost/libs/mpi/test/python/all_gather_test.py b/src/boost/libs/mpi/test/python/all_gather_test.py new file mode 100644 index 000000000..824dc892f --- /dev/null +++ b/src/boost/libs/mpi/test/python/all_gather_test.py @@ -0,0 +1,25 @@ +# Copyright (C) 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) + +# Test all_gather() collective. + +import boost.parallel.mpi as mpi +from generators import * + +def all_gather_test(comm, generator, kind): + if comm.rank == 0: print ("Gathering %s..." % (kind,)), + my_value = generator(comm.rank) + result = mpi.all_gather(comm, my_value) + for p in range(0, comm.size): + assert result[p] == generator(p) + if comm.rank == 0: print "OK." + + return + +all_gather_test(mpi.world, int_generator, "integers") +all_gather_test(mpi.world, gps_generator, "GPS positions") +all_gather_test(mpi.world, string_generator, "strings") +all_gather_test(mpi.world, string_list_generator, "list of strings") diff --git a/src/boost/libs/mpi/test/python/all_reduce_test.py b/src/boost/libs/mpi/test/python/all_reduce_test.py new file mode 100644 index 000000000..c3285e65b --- /dev/null +++ b/src/boost/libs/mpi/test/python/all_reduce_test.py @@ -0,0 +1,29 @@ +# Copyright (C) 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) + +# Test all_reduce() collective. + +import boost.parallel.mpi as mpi +from generators import * + +def all_reduce_test(comm, generator, kind, op, op_kind): + if comm.rank == 0: + print ("Reducing to %s of %s..." % (op_kind, kind)), + my_value = generator(comm.rank) + result = mpi.all_reduce(comm, my_value, op) + expected_result = generator(0); + for p in range(1, comm.size): + expected_result = op(expected_result, generator(p)) + + assert result == expected_result + if comm.rank == 0: + print "OK." + return + +all_reduce_test(mpi.world, int_generator, "integers", lambda x,y:x + y, "sum") +all_reduce_test(mpi.world, int_generator, "integers", lambda x,y:x * y, "product") +all_reduce_test(mpi.world, string_generator, "strings", lambda x,y:x + y, "concatenation") +all_reduce_test(mpi.world, string_list_generator, "list of strings", lambda x,y:x + y, "concatenation") diff --git a/src/boost/libs/mpi/test/python/all_to_all_test.py b/src/boost/libs/mpi/test/python/all_to_all_test.py new file mode 100644 index 000000000..b149bf0d3 --- /dev/null +++ b/src/boost/libs/mpi/test/python/all_to_all_test.py @@ -0,0 +1,30 @@ +# Copyright (C) 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) + +# Test all_to_all() collective. + +import boost.parallel.mpi as mpi +from generators import * + +def all_to_all_test(comm, generator, kind): + if comm.rank == 0: + print ("All-to-all transmission of %s..." % (kind,)), + + values = list() + for p in range(0, comm.size): + values.append(generator(p)) + result = mpi.all_to_all(comm, values) + + for p in range(0, comm.size): + assert result[p] == generator(comm.rank) + + if comm.rank == 0: print "OK." + return + +all_to_all_test(mpi.world, int_generator, "integers") +all_to_all_test(mpi.world, gps_generator, "GPS positions") +all_to_all_test(mpi.world, string_generator, "strings") +all_to_all_test(mpi.world, string_list_generator, "list of strings") diff --git a/src/boost/libs/mpi/test/python/broadcast_test.py b/src/boost/libs/mpi/test/python/broadcast_test.py new file mode 100644 index 000000000..dbd53d1be --- /dev/null +++ b/src/boost/libs/mpi/test/python/broadcast_test.py @@ -0,0 +1,29 @@ +# Copyright (C) 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) + +# Test broadcast() collective. + +import boost.parallel.mpi as mpi + +def broadcast_test(comm, value, kind, root): + if comm.rank == root: + print ("Broadcasting %s from root %d..." % (kind, root)), + + got_value = mpi.broadcast(comm, value, root) + assert got_value == value + if comm.rank == root: + print "OK." + return + +broadcast_test(mpi.world, 17, 'integer', 0) +broadcast_test(mpi.world, 17, 'integer', 1) +broadcast_test(mpi.world, 'Hello, World!', 'string', 0) +broadcast_test(mpi.world, 'Hello, World!', 'string', 1) +broadcast_test(mpi.world, ['Hello', 'MPI', 'Python', 'World'], + 'list of strings', 0) +broadcast_test(mpi.world, ['Hello', 'MPI', 'Python', 'World'], + 'list of strings', 1) + diff --git a/src/boost/libs/mpi/test/python/gather_test.py b/src/boost/libs/mpi/test/python/gather_test.py new file mode 100644 index 000000000..d56b3a416 --- /dev/null +++ b/src/boost/libs/mpi/test/python/gather_test.py @@ -0,0 +1,32 @@ +# Copyright (C) 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) + +# Test gather() collective. + +import boost.parallel.mpi as mpi +from generators import * + +def gather_test(comm, generator, kind, root): + if comm.rank == root: + print ("Gathering %s to root %d..." % (kind, root)), + my_value = generator(comm.rank) + result = mpi.gather(comm, my_value, root) + if comm.rank == root: + for p in range(0, comm.size): + assert result[p] == generator(p) + print "OK." + else: + assert result == None + return + +gather_test(mpi.world, int_generator, "integers", 0) +gather_test(mpi.world, int_generator, "integers", 1) +gather_test(mpi.world, gps_generator, "GPS positions", 0) +gather_test(mpi.world, gps_generator, "GPS positions", 1) +gather_test(mpi.world, string_generator, "strings", 0) +gather_test(mpi.world, string_generator, "strings", 1) +gather_test(mpi.world, string_list_generator, "list of strings", 0) +gather_test(mpi.world, string_list_generator, "list of strings", 1) diff --git a/src/boost/libs/mpi/test/python/generators.py b/src/boost/libs/mpi/test/python/generators.py new file mode 100644 index 000000000..8cdd3e056 --- /dev/null +++ b/src/boost/libs/mpi/test/python/generators.py @@ -0,0 +1,23 @@ +# Copyright (C) 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) + +# Value generators used in the Boost.MPI Python regression tests +def int_generator(p): + return 17 + p + +def gps_generator(p): + return (39 + p, 16, 20.2799) + +def string_generator(p): + result = "%d rosebud" % p; + if p != 1: result = result + 's' + return result + +def string_list_generator(p): + result = list() + for i in range(0,p): + result.append(str(i)) + return result diff --git a/src/boost/libs/mpi/test/python/nonblocking_test.py b/src/boost/libs/mpi/test/python/nonblocking_test.py new file mode 100644 index 000000000..73b451c53 --- /dev/null +++ b/src/boost/libs/mpi/test/python/nonblocking_test.py @@ -0,0 +1,131 @@ +# (C) Copyright 2007 +# Andreas Kloeckner <inform -at- tiker.net> +# +# 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: Andreas Kloeckner + + + + +import boost.mpi as mpi +import random +import sys + +MAX_GENERATIONS = 20 +TAG_DEBUG = 0 +TAG_DATA = 1 +TAG_TERMINATE = 2 +TAG_PROGRESS_REPORT = 3 + + + + +class TagGroupListener: + """Class to help listen for only a given set of tags. + + This is contrived: Typicallly you could just listen for + mpi.any_tag and filter.""" + def __init__(self, comm, tags): + self.tags = tags + self.comm = comm + self.active_requests = {} + + def wait(self): + for tag in self.tags: + if tag not in self.active_requests: + self.active_requests[tag] = self.comm.irecv(tag=tag) + requests = mpi.RequestList(self.active_requests.values()) + data, status, index = mpi.wait_any(requests) + del self.active_requests[status.tag] + return status, data + + def cancel(self): + for r in self.active_requests.itervalues(): + r.cancel() + #r.wait() + self.active_requests = {} + + + +def rank0(): + sent_histories = (mpi.size-1)*15 + print "sending %d packets on their way" % sent_histories + send_reqs = mpi.RequestList() + for i in range(sent_histories): + dest = random.randrange(1, mpi.size) + send_reqs.append(mpi.world.isend(dest, TAG_DATA, [])) + + mpi.wait_all(send_reqs) + + completed_histories = [] + progress_reports = {} + dead_kids = [] + + tgl = TagGroupListener(mpi.world, + [TAG_DATA, TAG_DEBUG, TAG_PROGRESS_REPORT, TAG_TERMINATE]) + + def is_complete(): + for i in progress_reports.values(): + if i != sent_histories: + return False + return len(dead_kids) == mpi.size-1 + + while True: + status, data = tgl.wait() + + if status.tag == TAG_DATA: + #print "received completed history %s from %d" % (data, status.source) + completed_histories.append(data) + if len(completed_histories) == sent_histories: + print "all histories received, exiting" + for rank in range(1, mpi.size): + mpi.world.send(rank, TAG_TERMINATE, None) + elif status.tag == TAG_PROGRESS_REPORT: + progress_reports[len(data)] = progress_reports.get(len(data), 0) + 1 + elif status.tag == TAG_DEBUG: + print "[DBG %d] %s" % (status.source, data) + elif status.tag == TAG_TERMINATE: + dead_kids.append(status.source) + else: + print "unexpected tag %d from %d" % (status.tag, status.source) + + if is_complete(): + break + + print "OK" + +def comm_rank(): + while True: + data, status = mpi.world.recv(return_status=True) + if status.tag == TAG_DATA: + mpi.world.send(0, TAG_PROGRESS_REPORT, data) + data.append(mpi.rank) + if len(data) >= MAX_GENERATIONS: + dest = 0 + else: + dest = random.randrange(1, mpi.size) + mpi.world.send(dest, TAG_DATA, data) + elif status.tag == TAG_TERMINATE: + from time import sleep + mpi.world.send(0, TAG_TERMINATE, 0) + break + else: + print "[DIRECTDBG %d] unexpected tag %d from %d" % (mpi.rank, status.tag, status.source) + + +def main(): + # this program sends around messages consisting of lists of visited nodes + # randomly. After MAX_GENERATIONS, they are returned to rank 0. + + if mpi.rank == 0: + rank0() + else: + comm_rank() + + + +if __name__ == "__main__": + main() diff --git a/src/boost/libs/mpi/test/python/reduce_test.py b/src/boost/libs/mpi/test/python/reduce_test.py new file mode 100644 index 000000000..65f09f5ba --- /dev/null +++ b/src/boost/libs/mpi/test/python/reduce_test.py @@ -0,0 +1,31 @@ +# Copyright (C) 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) + +# Test reduce() collective. + +import boost.parallel.mpi as mpi +from generators import * + +def reduce_test(comm, generator, kind, op, op_kind, root): + if comm.rank == root: + print ("Reducing to %s of %s at root %d..." % (op_kind, kind, root)), + my_value = generator(comm.rank) + result = mpi.reduce(comm, my_value, op, root) + if comm.rank == root: + expected_result = generator(0); + for p in range(1, comm.size): + expected_result = op(expected_result, generator(p)) + assert result == expected_result + print "OK." + else: + assert result == None + return + +reduce_test(mpi.world, int_generator, "integers", lambda x,y:x + y, "sum", 0) +reduce_test(mpi.world, int_generator, "integers", lambda x,y:x * y, "product", 1) +reduce_test(mpi.world, int_generator, "integers", min, "minimum", 0) +reduce_test(mpi.world, string_generator, "strings", lambda x,y:x + y, "concatenation", 0) +reduce_test(mpi.world, string_list_generator, "list of strings", lambda x,y:x + y, "concatenation", 0) diff --git a/src/boost/libs/mpi/test/python/ring_test.py b/src/boost/libs/mpi/test/python/ring_test.py new file mode 100644 index 000000000..3c8b5b92f --- /dev/null +++ b/src/boost/libs/mpi/test/python/ring_test.py @@ -0,0 +1,42 @@ +# Copyright (C) 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) + +# Test basic communication. + +import boost.parallel.mpi as mpi + +def ring_test(comm, value, kind, root): + next_peer = (comm.rank + 1) % comm.size; + prior_peer = (comm.rank + comm.size - 1) % comm.size; + + if comm.rank == root: + print ("Passing %s around a ring from root %d..." % (kind, root)), + comm.send(next_peer, 0, value) + (other_value, stat) = comm.recv(return_status = True) + assert value == other_value + assert stat.source == prior_peer + assert stat.tag == 0 + else: + msg = comm.probe() + other_value = comm.recv(msg.source, msg.tag) + assert value == other_value + comm.send(next_peer, 0, other_value) + + comm.barrier() + if comm.rank == root: + print "OK" + pass + +if mpi.world.size < 2: + print "ERROR: ring_test.py must be executed with more than one process" + mpi.world.abort(-1); + +ring_test(mpi.world, 17, 'integers', 0) +ring_test(mpi.world, 17, 'integers', 1) +ring_test(mpi.world, 'Hello, World!', 'string', 0) +ring_test(mpi.world, 'Hello, World!', 'string', 1) +ring_test(mpi.world, ['Hello', 'MPI', 'Python', 'World'], 'list of strings', 0) +ring_test(mpi.world, ['Hello', 'MPI', 'Python', 'World'], 'list of strings', 1) diff --git a/src/boost/libs/mpi/test/python/scan_test.py b/src/boost/libs/mpi/test/python/scan_test.py new file mode 100644 index 000000000..193a6a448 --- /dev/null +++ b/src/boost/libs/mpi/test/python/scan_test.py @@ -0,0 +1,29 @@ +# Copyright (C) 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) + +# Test scan() collective. + +import boost.parallel.mpi as mpi +from generators import * + +def scan_test(comm, generator, kind, op, op_kind): + if comm.rank == 0: + print ("Prefix reduction to %s of %s..." % (op_kind, kind)), + my_value = generator(comm.rank) + result = mpi.scan(comm, my_value, op) + expected_result = generator(0); + for p in range(1, comm.rank+1): + expected_result = op(expected_result, generator(p)) + + assert result == expected_result + if comm.rank == 0: + print "OK." + return + +scan_test(mpi.world, int_generator, "integers", lambda x,y:x + y, "sum") +scan_test(mpi.world, int_generator, "integers", lambda x,y:x * y, "product") +scan_test(mpi.world, string_generator, "strings", lambda x,y:x + y, "concatenation") +scan_test(mpi.world, string_list_generator, "list of strings", lambda x,y:x + y, "concatenation") diff --git a/src/boost/libs/mpi/test/python/scatter_test.py b/src/boost/libs/mpi/test/python/scatter_test.py new file mode 100644 index 000000000..e0bad9673 --- /dev/null +++ b/src/boost/libs/mpi/test/python/scatter_test.py @@ -0,0 +1,36 @@ +# Copyright (C) 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) + +# Test scatter() collective. + +import boost.parallel.mpi as mpi +from generators import * + +def scatter_test(comm, generator, kind, root): + if comm.rank == root: + print ("Scattering %s from root %d..." % (kind, root)), + + if comm.rank == root: + values = list() + for p in range(0, comm.size): + values.append(generator(p)) + result = mpi.scatter(comm, values, root = root) + else: + result = mpi.scatter(comm, root = root); + + assert result == generator(comm.rank) + + if comm.rank == root: print "OK." + return + +scatter_test(mpi.world, int_generator, "integers", 0) +scatter_test(mpi.world, int_generator, "integers", 1) +scatter_test(mpi.world, gps_generator, "GPS positions", 0) +scatter_test(mpi.world, gps_generator, "GPS positions", 1) +scatter_test(mpi.world, string_generator, "strings", 0) +scatter_test(mpi.world, string_generator, "strings", 1) +scatter_test(mpi.world, string_list_generator, "list of strings", 0) +scatter_test(mpi.world, string_list_generator, "list of strings", 1) diff --git a/src/boost/libs/mpi/test/python/skeleton_content_test.cpp b/src/boost/libs/mpi/test/python/skeleton_content_test.cpp new file mode 100644 index 000000000..7ccae00ef --- /dev/null +++ b/src/boost/libs/mpi/test/python/skeleton_content_test.cpp @@ -0,0 +1,37 @@ +// (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: Douglas Gregor + +#include <boost/parallel/mpi/python.hpp> +#include <boost/python.hpp> +#include <boost/serialization/list.hpp> +using namespace boost::python; + +template<typename T> +boost::python::list list_to_python(const std::list<T>& value) { + boost::python::list result; + for (typename std::list<T>::const_iterator i = value.begin(); + i != value.end(); ++i) + result.append(*i); + return result; +} + +BOOST_PYTHON_MODULE(skeleton_content) +{ + using boost::python::arg; + + class_<std::list<int> >("list_int") + .def("push_back", &std::list<int>::push_back, arg("value")) + .def("pop_back", &std::list<int>::pop_back) + .def("reverse", &std::list<int>::reverse) + .def(boost::python::self == boost::python::self) + .def(boost::python::self != boost::python::self) + .add_property("size", &std::list<int>::size) + .def("to_python", &list_to_python<int>); + + boost::parallel::mpi::python::register_skeleton_and_content<std::list<int> >(); +} diff --git a/src/boost/libs/mpi/test/python/skeleton_content_test.py b/src/boost/libs/mpi/test/python/skeleton_content_test.py new file mode 100644 index 000000000..1dfde3cf7 --- /dev/null +++ b/src/boost/libs/mpi/test/python/skeleton_content_test.py @@ -0,0 +1,75 @@ +# Copyright (C) 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) + +# Test skeleton/content + +import boost.parallel.mpi as mpi +import skeleton_content + +def test_skeleton_and_content(comm, root, manual_broadcast = True): + assert manual_broadcast + + # Setup data + list_size = comm.size + 7 + original_list = skeleton_content.list_int() + for i in range(0,list_size): + original_list.push_back(i) + + if comm.rank == root: + # Broadcast skeleton + print ("Broadcasting integer list skeleton from root %d..." % (root)), + if manual_broadcast: + for p in range(0,comm.size): + if p != comm.rank: + comm.send(p, 0, value = mpi.skeleton(original_list)) + print "OK." + + # Broadcast content + print ("Broadcasting integer list content from root %d..." % (root)), + if manual_broadcast: + for p in range(0,comm.size): + if p != comm.rank: + comm.send(p, 0, value = mpi.get_content(original_list)) + + print "OK." + + # Broadcast reversed content + original_list.reverse() + print ("Broadcasting reversed integer list content from root %d..." % (root)), + if manual_broadcast: + for p in range(0,comm.size): + if p != comm.rank: + comm.send(p, 0, value = mpi.get_content(original_list)) + + print "OK." + else: + # Allocate some useless data, to try to get the addresses of + # the underlying lists used later to be different across + # processors. + junk_list = skeleton_content.list_int() + for i in range(0,comm.rank * 3 + 1): + junk_list.push_back(i) + + # Receive the skeleton of the list + if manual_broadcast: + transferred_list_skeleton = comm.recv(root, 0) + assert transferred_list_skeleton.object.size == list_size + + # Receive the content and check it + transferred_list = transferred_list_skeleton.object + if manual_broadcast: + comm.recv(root, 0, mpi.get_content(transferred_list)) + assert transferred_list == original_list + + # Receive the content (again) and check it + original_list.reverse() + if manual_broadcast: + comm.recv(root, 0, mpi.get_content(transferred_list)) + assert transferred_list == original_list + + +test_skeleton_and_content(mpi.world, 0) +test_skeleton_and_content(mpi.world, 1) diff --git a/src/boost/libs/mpi/test/reduce_test.cpp b/src/boost/libs/mpi/test/reduce_test.cpp new file mode 100644 index 000000000..44532cd5b --- /dev/null +++ b/src/boost/libs/mpi/test/reduce_test.cpp @@ -0,0 +1,237 @@ +// Copyright (C) 2005, 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) + +// A test of the reduce() collective. +#include <boost/mpi/collectives/reduce.hpp> +#include <boost/mpi/communicator.hpp> +#include <boost/mpi/environment.hpp> +#include <algorithm> +#include <boost/serialization/string.hpp> +#include <boost/iterator/counting_iterator.hpp> +#include <boost/lexical_cast.hpp> +#include <numeric> + +#define BOOST_TEST_MODULE mpi_reduce_test +#include <boost/test/included/unit_test.hpp> + +using boost::mpi::communicator; + +// A simple point class that we can build, add, compare, and +// serialize. +struct point +{ + point() : x(0), y(0), z(0) { } + point(int x, int y, int z) : x(x), y(y), z(z) { } + + int x; + int y; + int z; + + private: + template<typename Archiver> + void serialize(Archiver& ar, unsigned int /*version*/) + { + ar & x & y & z; + } + + friend class boost::serialization::access; +}; + +std::ostream& operator<<(std::ostream& out, const point& p) +{ + return out << p.x << ' ' << p.y << ' ' << p.z; +} + +bool operator==(const point& p1, const point& p2) +{ + return p1.x == p2.x && p1.y == p2.y && p1.z == p2.z; +} + +bool operator!=(const point& p1, const point& p2) +{ + return !(p1 == p2); +} + +point operator+(const point& p1, const point& p2) +{ + return point(p1.x + p2.x, p1.y + p2.y, p1.z + p2.z); +} + +namespace boost { namespace mpi { + + template <> + struct is_mpi_datatype<point> : public mpl::true_ { }; + +} } // end namespace boost::mpi + +template<typename Generator, typename Op> +void +reduce_test(const communicator& comm, Generator generator, + const char* type_kind, Op op, const char* op_kind, + typename Generator::result_type init, + int root = -1) +{ + typedef typename Generator::result_type value_type; + value_type value = generator(comm.rank()); + + if (root == -1) { + for (root = 0; root < comm.size(); ++root) + reduce_test(comm, generator, type_kind, op, op_kind, init, root); + } else { + using boost::mpi::reduce; + + if (comm.rank() == root) { + std::cout << "Reducing to " << op_kind << " of " << type_kind + << " at root " << root << "..."; + std::cout.flush(); + + value_type result_value; + reduce(comm, value, result_value, op, root); + + // Compute expected result + std::vector<value_type> generated_values; + for (int p = 0; p < comm.size(); ++p) + generated_values.push_back(generator(p)); + value_type expected_result = std::accumulate(generated_values.begin(), + generated_values.end(), + init, op); + BOOST_CHECK(result_value == expected_result); + if (result_value == expected_result) + std::cout << "OK." << std::endl; + } else { + reduce(comm, value, op, root); + } + } + + (comm.barrier)(); +} + +// Generates integers to test with reduce() +struct int_generator +{ + typedef int result_type; + + int_generator(int base = 1) : base(base) { } + + int operator()(int p) const { return base + p; } + + private: + int base; +}; + +// Generate points to test with reduce() +struct point_generator +{ + typedef point result_type; + + point_generator(point origin) : origin(origin) { } + + point operator()(int p) const + { + return point(origin.x + 1, origin.y + 1, origin.z + 1); + } + + private: + point origin; +}; + +struct string_generator +{ + typedef std::string result_type; + + std::string operator()(int p) const + { + std::string result = boost::lexical_cast<std::string>(p); + result += " rosebud"; + if (p != 1) result += 's'; + return result; + } +}; + +struct secret_int_bit_and +{ + int operator()(int x, int y) const { return x & y; } +}; + +struct wrapped_int +{ + wrapped_int() : value(0) { } + explicit wrapped_int(int value) : value(value) { } + + template<typename Archive> + void serialize(Archive& ar, unsigned int /* version */) + { + ar & value; + } + + int value; +}; + +wrapped_int operator+(const wrapped_int& x, const wrapped_int& y) +{ + return wrapped_int(x.value + y.value); +} + +bool operator==(const wrapped_int& x, const wrapped_int& y) +{ + return x.value == y.value; +} + +// Generates wrapped_its to test with reduce() +struct wrapped_int_generator +{ + typedef wrapped_int result_type; + + wrapped_int_generator(int base = 1) : base(base) { } + + wrapped_int operator()(int p) const { return wrapped_int(base + p); } + + private: + int base; +}; + +namespace boost { namespace mpi { + +// Make std::plus<wrapped_int> commutative. +template<> +struct is_commutative<std::plus<wrapped_int>, wrapped_int> + : mpl::true_ { }; + +} } // end namespace boost::mpi + +BOOST_AUTO_TEST_CASE(reduce_check) +{ + using namespace boost::mpi; + environment env; + + communicator comm; + + // Built-in MPI datatypes with built-in MPI operations + reduce_test(comm, int_generator(), "integers", std::plus<int>(), "sum", 0); + reduce_test(comm, int_generator(), "integers", std::multiplies<int>(), + "product", 1); + reduce_test(comm, int_generator(), "integers", maximum<int>(), + "maximum", 0); + reduce_test(comm, int_generator(), "integers", minimum<int>(), + "minimum", 2); + + // User-defined MPI datatypes with operations that have the + // same name as built-in operations. + reduce_test(comm, point_generator(point(0,0,0)), "points", + std::plus<point>(), "sum", point()); + + // Built-in MPI datatypes with user-defined operations + reduce_test(comm, int_generator(17), "integers", secret_int_bit_and(), + "bitwise and", -1); + + // Arbitrary types with user-defined, commutative operations. + reduce_test(comm, wrapped_int_generator(17), "wrapped integers", + std::plus<wrapped_int>(), "sum", wrapped_int(0)); + + // Arbitrary types with (non-commutative) user-defined operations + reduce_test(comm, string_generator(), "strings", + std::plus<std::string>(), "concatenation", std::string()); +} diff --git a/src/boost/libs/mpi/test/ring_test.cpp b/src/boost/libs/mpi/test/ring_test.cpp new file mode 100644 index 000000000..573d3d387 --- /dev/null +++ b/src/boost/libs/mpi/test/ring_test.cpp @@ -0,0 +1,124 @@ +// Copyright (C) 2005, 2006 Douglas Gregor. + +// 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) + +// A test of the communicator that passes data around a ring and +// verifies that the same data makes it all the way. Should test all +// of the various kinds of data that can be sent (primitive types, POD +// types, serializable objects, etc.) +#include <boost/mpi/communicator.hpp> +#include <boost/mpi/environment.hpp> +#include <algorithm> +#include "gps_position.hpp" +#include <boost/serialization/string.hpp> +#include <boost/serialization/list.hpp> +//#include "debugger.cpp" + +#define BOOST_TEST_MODULE mpi_reduce_ring +#include <boost/test/included/unit_test.hpp> + +using boost::mpi::communicator; +using boost::mpi::status; + +template<typename T> +void +ring_test(const communicator& comm, const T& pass_value, const char* kind, + int root = 0) +{ + T transferred_value; + + int rank = comm.rank(); + int size = comm.size(); + + if (rank == root) { + std::cout << "Passing " << kind << " around a ring from root " << root + << "..."; + comm.send((rank + 1) % size, 0, pass_value); + comm.recv((rank + size - 1) % size, 0, transferred_value); + BOOST_CHECK(transferred_value == pass_value); + if (transferred_value == pass_value) std::cout << " OK." << std::endl; + } else { + comm.recv((rank + size - 1) % size, 0, transferred_value); + BOOST_CHECK(transferred_value == pass_value); + comm.send((rank + 1) % size, 0, transferred_value); + } + + (comm.barrier)(); +} + + +template<typename T> +void +ring_array_test(const communicator& comm, const T* pass_values, + int n, const char* kind, int root = 0) +{ + T* transferred_values = new T[n]; + int rank = comm.rank(); + int size = comm.size(); + + if (rank == root) { + + std::cout << "Passing " << kind << " array around a ring from root " + << root << "..."; + comm.send((rank + 1) % size, 0, pass_values, n); + comm.recv((rank + size - 1) % size, 0, transferred_values, n); + bool okay = std::equal(pass_values, pass_values + n, + transferred_values); + BOOST_CHECK(okay); + if (okay) std::cout << " OK." << std::endl; + } else { + status stat = comm.probe(boost::mpi::any_source, 0); + boost::optional<int> num_values = stat.template count<T>(); + if (boost::mpi::is_mpi_datatype<T>()) + BOOST_CHECK(num_values && *num_values == n); + else + BOOST_CHECK(!num_values || *num_values == n); + comm.recv(stat.source(), 0, transferred_values, n); + BOOST_CHECK(std::equal(pass_values, pass_values + n, + transferred_values)); + comm.send((rank + 1) % size, 0, transferred_values, n); + } + (comm.barrier)(); + delete [] transferred_values; +} + +enum color_t {red, green, blue}; +BOOST_IS_MPI_DATATYPE(color_t) + +BOOST_AUTO_TEST_CASE(ring) +{ + boost::mpi::environment env; + communicator comm; + + BOOST_TEST_REQUIRE(comm.size() > 1); + + // Check transfer of individual objects + ring_test(comm, 17, "integers", 0); + ring_test(comm, 17, "integers", 1); + ring_test(comm, red, "enums", 1); + ring_test(comm, red, "enums", 1); + ring_test(comm, gps_position(39,16,20.2799), "GPS positions", 0); + ring_test(comm, gps_position(26,25,30.0), "GPS positions", 1); + ring_test(comm, std::string("Rosie"), "string", 0); + + std::list<std::string> strings; + strings.push_back("Hello"); + strings.push_back("MPI"); + strings.push_back("World"); + ring_test(comm, strings, "list of strings", 1); + + // Check transfer of arrays + int int_array[2] = { 17, 42 }; + ring_array_test(comm, int_array, 2, "integer", 1); + gps_position gps_position_array[2] = { + gps_position(39,16,20.2799), + gps_position(26,25,30.0) + }; + ring_array_test(comm, gps_position_array, 2, "GPS position", 1); + + std::string string_array[3] = { "Hello", "MPI", "World" }; + ring_array_test(comm, string_array, 3, "string", 0); + ring_array_test(comm, string_array, 3, "string", 1); +} diff --git a/src/boost/libs/mpi/test/scan_test.cpp b/src/boost/libs/mpi/test/scan_test.cpp new file mode 100644 index 000000000..579ce8ded --- /dev/null +++ b/src/boost/libs/mpi/test/scan_test.cpp @@ -0,0 +1,228 @@ +// Copyright (C) 2005, 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) + +// A test of the scan() collective. +#include <boost/mpi/collectives/scan.hpp> +#include <boost/mpi/communicator.hpp> +#include <boost/mpi/environment.hpp> +#include <algorithm> +#include <boost/serialization/string.hpp> +#include <boost/iterator/counting_iterator.hpp> +#include <boost/lexical_cast.hpp> +#include <numeric> + +#define BOOST_TEST_MODULE mpi_scan_test +#include <boost/test/included/unit_test.hpp> + + +using boost::mpi::communicator; + +// A simple point class that we can build, add, compare, and +// serialize. +struct point +{ + point() : x(0), y(0), z(0) { } + point(int x, int y, int z) : x(x), y(y), z(z) { } + + int x; + int y; + int z; + + private: + template<typename Archiver> + void serialize(Archiver& ar, unsigned int /*version*/) + { + ar & x & y & z; + } + + friend class boost::serialization::access; +}; + +std::ostream& operator<<(std::ostream& out, const point& p) +{ + return out << p.x << ' ' << p.y << ' ' << p.z; +} + +bool operator==(const point& p1, const point& p2) +{ + return p1.x == p2.x && p1.y == p2.y && p1.z == p2.z; +} + +bool operator!=(const point& p1, const point& p2) +{ + return !(p1 == p2); +} + +point operator+(const point& p1, const point& p2) +{ + return point(p1.x + p2.x, p1.y + p2.y, p1.z + p2.z); +} + +namespace boost { namespace mpi { + + template <> + struct is_mpi_datatype<point> : public mpl::true_ { }; + +} } // end namespace boost::mpi + +template<typename Generator, typename Op> +void +scan_test(const communicator& comm, Generator generator, + const char* type_kind, Op op, const char* op_kind) +{ + typedef typename Generator::result_type value_type; + value_type value = generator(comm.rank()); + using boost::mpi::scan; + + if (comm.rank() == 0) { + std::cout << "Prefix reducing to " << op_kind << " of " << type_kind + << "..."; + std::cout.flush(); + } + + value_type result_value; + scan(comm, value, result_value, op); + value_type scan_result = scan(comm, value, op); + BOOST_CHECK(scan_result == result_value); + + // Compute expected result + std::vector<value_type> generated_values; + for (int p = 0; p < comm.size(); ++p) + generated_values.push_back(generator(p)); + std::vector<value_type> expected_results(comm.size()); + std::partial_sum(generated_values.begin(), generated_values.end(), + expected_results.begin(), op); + BOOST_CHECK(result_value == expected_results[comm.rank()]); + if (comm.rank() == 0) std::cout << "Done." << std::endl; + + (comm.barrier)(); +} + +// Generates integers to test with scan() +struct int_generator +{ + typedef int result_type; + + int_generator(int base = 1) : base(base) { } + + int operator()(int p) const { return base + p; } + + private: + int base; +}; + +// Generate points to test with scan() +struct point_generator +{ + typedef point result_type; + + point_generator(point origin) : origin(origin) { } + + point operator()(int p) const + { + return point(origin.x + 1, origin.y + 1, origin.z + 1); + } + + private: + point origin; +}; + +struct string_generator +{ + typedef std::string result_type; + + std::string operator()(int p) const + { + std::string result = boost::lexical_cast<std::string>(p); + result += " rosebud"; + if (p != 1) result += 's'; + return result; + } +}; + +struct secret_int_bit_and +{ + int operator()(int x, int y) const { return x & y; } +}; + +struct wrapped_int +{ + wrapped_int() : value(0) { } + explicit wrapped_int(int value) : value(value) { } + + template<typename Archive> + void serialize(Archive& ar, unsigned int /* version */) + { + ar & value; + } + + int value; +}; + +wrapped_int operator+(const wrapped_int& x, const wrapped_int& y) +{ + return wrapped_int(x.value + y.value); +} + +bool operator==(const wrapped_int& x, const wrapped_int& y) +{ + return x.value == y.value; +} + +// Generates wrapped_its to test with scan() +struct wrapped_int_generator +{ + typedef wrapped_int result_type; + + wrapped_int_generator(int base = 1) : base(base) { } + + wrapped_int operator()(int p) const { return wrapped_int(base + p); } + + private: + int base; +}; + +namespace boost { namespace mpi { + +// Make std::plus<wrapped_int> commutative. +template<> +struct is_commutative<std::plus<wrapped_int>, wrapped_int> + : mpl::true_ { }; + +} } // end namespace boost::mpi + +BOOST_AUTO_TEST_CASE(scan_check) +{ + using namespace boost::mpi; + environment env; + communicator comm; + + // Built-in MPI datatypes with built-in MPI operations + scan_test(comm, int_generator(), "integers", std::plus<int>(), "sum"); + scan_test(comm, int_generator(), "integers", std::multiplies<int>(), + "product"); + scan_test(comm, int_generator(), "integers", maximum<int>(), + "maximum"); + scan_test(comm, int_generator(), "integers", minimum<int>(), + "minimum"); + + // User-defined MPI datatypes with operations that have the + // same name as built-in operations. + scan_test(comm, point_generator(point(0,0,0)), "points", + std::plus<point>(), "sum"); + + // Built-in MPI datatypes with user-defined operations + scan_test(comm, int_generator(17), "integers", secret_int_bit_and(), + "bitwise and"); + + // Arbitrary types with user-defined, commutative operations. + scan_test(comm, wrapped_int_generator(17), "wrapped integers", + std::plus<wrapped_int>(), "sum"); + + // Arbitrary types with (non-commutative) user-defined operations + scan_test(comm, string_generator(), "strings", + std::plus<std::string>(), "concatenation"); +} diff --git a/src/boost/libs/mpi/test/scatter_test.cpp b/src/boost/libs/mpi/test/scatter_test.cpp new file mode 100644 index 000000000..f116bb342 --- /dev/null +++ b/src/boost/libs/mpi/test/scatter_test.cpp @@ -0,0 +1,233 @@ +// Copyright (C) 2005, 2006 Douglas Gregor. + +// 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) + +// A test of the scatter() and scatterv() collectives. +#include <iterator> +#include <boost/mpi/collectives/scatter.hpp> +#include <boost/mpi/collectives/scatterv.hpp> +#include <boost/mpi/communicator.hpp> +#include <boost/mpi/environment.hpp> +#include "gps_position.hpp" +#include <boost/serialization/string.hpp> +#include <boost/serialization/list.hpp> +#include <boost/iterator/counting_iterator.hpp> +#include <boost/lexical_cast.hpp> + +#define BOOST_TEST_MODULE mpi_scatter +#include <boost/test/included/unit_test.hpp> + +using namespace boost::mpi; + +template<typename Generator> +void +scatter_test(const communicator& comm, Generator generator, + const char* kind, int root = -1) +{ + typedef typename Generator::result_type value_type; + + if (root == -1) { + for (root = 0; root < comm.size(); ++root) + scatter_test(comm, generator, kind, root); + } else { + using boost::mpi::scatter; + + value_type value; + + if (comm.rank() == root) { + std::vector<value_type> values; + + for (int p = 0; p < comm.size(); ++p) + values.push_back(generator(p)); + + std::cout << "Scattering " << kind << " from root " + << root << "..." << std::endl; + + scatter(comm, values, value, root); + } else { + scatter(comm, value, root); + } + + BOOST_CHECK(value == generator(comm.rank())); + } + + comm.barrier(); +} + + +// +// Generators to test with scatter/scatterv +// +struct int_generator +{ + typedef int result_type; + + int operator()(int p) const { return 17 + p; } +}; + +struct gps_generator +{ + typedef gps_position result_type; + + gps_position operator()(int p) const + { + return gps_position(39 + p, 16, 20.2799); + } +}; + +struct string_generator +{ + typedef std::string result_type; + + std::string operator()(int p) const + { + std::string result = boost::lexical_cast<std::string>(p); + result += " rosebud"; + if (p != 1) result += 's'; + return result; + } +}; + +struct string_list_generator +{ + typedef std::list<std::string> result_type; + + std::list<std::string> operator()(int p) const + { + std::list<std::string> result; + for (int i = 0; i <= p; ++i) { + std::string value = boost::lexical_cast<std::string>(i); + result.push_back(value); + } + return result; + } +}; + +std::ostream& +operator<<(std::ostream& out, std::list<std::string> const& l) { + out << '['; + std::copy(l.begin(), l.end(), std::ostream_iterator<std::string>(out, " ")); + out << ']'; + return out; +} + +template<typename Generator> +void +scatterv_test(const communicator& comm, Generator generator, + const char* kind, int root = -1) +{ + typedef typename Generator::result_type value_type; + + if (root == -1) { + for (root = 0; root < comm.size(); ++root) + scatterv_test(comm, generator, kind, root); + } else { + using boost::mpi::scatterv; + + int mysize = comm.rank() + 1; + std::vector<value_type> myvalues(mysize); + + if (comm.rank() == root) { + std::vector<value_type> values; + std::vector<int> sizes(comm.size()); + + // process p will receive p+1 identical generator(p) elements + for (int p = 0; p < comm.size(); ++p) { + for (int i = 0; i < p+1; ++i) + values.push_back(generator(p)); + sizes[p] = p + 1; + } + + std::cout << "Scatteringv " << kind << " from root " + << root << "..." << std::endl; + assert(mysize == sizes[comm.rank()]); + scatterv(comm, values, sizes, &(myvalues[0]), root); + } else { + scatterv(comm, &(myvalues[0]), mysize, root); + } + + for (int i = 0; i < mysize; ++i) + BOOST_CHECK(myvalues[i] == generator(comm.rank())); + } + + comm.barrier(); +} + +template<typename Generator> +void +scatterd_test(const communicator& comm, Generator generator, + const char* kind, int root = -1) +{ + typedef typename Generator::result_type value_type; + + if (root == -1) { + for (root = 0; root < comm.size(); ++root) + scatterv_test(comm, generator, kind, root); + } else { + using boost::mpi::scatterv; + + int mysize = comm.rank() + 1; + std::vector<value_type> myvalues(mysize); + + if (comm.rank() == root) { + std::vector<value_type> values; + std::vector<int> sizes(comm.size()); + std::vector<int> displs(comm.size()); + value_type noise = generator(comm.size()+1); + // process p will receive a payload of p+1 identical generator(p) elements + // root will insert pseudo random pading between each payload. + int shift = 0; // the current position of next payload in source array + for (int p = 0; p < comm.size(); ++p) { + int size = p+1; + int pad = p % 3; + // padding + for (int i = 0; i < pad; ++i) { + values.push_back(noise); + } + // payload + for (int i = 0; i < size; ++i) + values.push_back(generator(p)); + shift += pad; + displs[p] = shift; + sizes[p] = size; + shift += size; + } + + std::cout << "Scatteringv " << kind << " from root " + << root << "..." << std::endl; + assert(mysize == sizes[comm.rank()]); + scatterv(comm, values, sizes, displs, &(myvalues[0]), mysize, root); + } else { + scatterv(comm, &(myvalues[0]), mysize, root); + } + + for (int i = 0; i < mysize; ++i) + BOOST_CHECK(myvalues[i] == generator(comm.rank())); + } + + comm.barrier(); +} + + +BOOST_AUTO_TEST_CASE(simple_scatter) +{ + environment env; + communicator comm; + + scatter_test(comm, int_generator(), "integers"); + scatter_test(comm, gps_generator(), "GPS positions"); + scatter_test(comm, string_generator(), "string"); + scatter_test(comm, string_list_generator(), "list of strings"); + + scatterv_test(comm, int_generator(), "integers"); + scatterv_test(comm, gps_generator(), "GPS positions"); + scatterv_test(comm, string_generator(), "string"); + scatterv_test(comm, string_list_generator(), "list of strings"); + + scatterd_test(comm, int_generator(), "integers"); + scatterd_test(comm, gps_generator(), "GPS positions"); + scatterd_test(comm, string_generator(), "string"); + scatterd_test(comm, string_list_generator(), "list of strings"); +} diff --git a/src/boost/libs/mpi/test/sendrecv_test.cpp b/src/boost/libs/mpi/test/sendrecv_test.cpp new file mode 100644 index 000000000..a7fe3a3ee --- /dev/null +++ b/src/boost/libs/mpi/test/sendrecv_test.cpp @@ -0,0 +1,62 @@ +// Copyright Alain Miniussi 2014. +// Distributed under 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) + +// A test of the sendrecv() operation. +#include <boost/mpi/communicator.hpp> +#include <boost/mpi/environment.hpp> +#include <vector> +#include <algorithm> +#include <boost/serialization/string.hpp> +#include <boost/iterator/counting_iterator.hpp> +#include <boost/lexical_cast.hpp> +#include <numeric> + +#define BOOST_TEST_MODULE mpi_sendrecv +#include <boost/test/included/unit_test.hpp> + +namespace mpi = boost::mpi; + +struct blob { + blob(int i) : value(i) {} + int value; + template<class Archive> + void serialize(Archive& s, const unsigned int version) { + s & value; + } +}; + +std::ostream& operator<<(std::ostream& out, blob const& b) { + out << "blob(" << b.value << ")"; + return out; +} + +bool operator==(blob const& b1, blob const& b2) { + return b1.value == b2.value; +} + +template<typename T> +void test_sendrecv(mpi::communicator& com) { + int const wrank = com.rank(); + int const wsize = com.size(); + int const wnext((wrank + 1) % wsize); + int const wprev((wrank + wsize - 1) % wsize); + T recv(-1); + com.sendrecv(wnext, 1, T(wrank), wprev, 1, recv); + for(int r = 0; r < wsize; ++r) { + com.barrier(); + if (r == wrank) { + std::cout << "rank " << wrank << " received " << recv << " from " << wprev << '\n'; + } + } + BOOST_CHECK(recv == T(wprev)); +} + +BOOST_AUTO_TEST_CASE(sendrecv) +{ + mpi::environment env; + mpi::communicator world; + test_sendrecv<int>(world); + test_sendrecv<blob>(world); +} diff --git a/src/boost/libs/mpi/test/sendrecv_vector.cpp b/src/boost/libs/mpi/test/sendrecv_vector.cpp new file mode 100644 index 000000000..dc1392858 --- /dev/null +++ b/src/boost/libs/mpi/test/sendrecv_vector.cpp @@ -0,0 +1,95 @@ +// Author: K. Noel Belcourt <kbelco -at- sandia.gov> + +// Distributed under 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) + +#if defined(__cplusplus) && (201103L <= __cplusplus) + +#include <array> +#include <cassert> +#include <vector> + +#include "boost/mpi/environment.hpp" +#include "boost/mpi/communicator.hpp" + +using std::array; +using std::vector; + +namespace mpi = boost::mpi; + +struct blob : array<int, 9>, array<double, 3>, array<char, 8> { +}; + +namespace boost { + namespace mpi { + + template <> + struct is_mpi_datatype<blob> : mpl::true_ { + }; + + template <> + MPI_Datatype get_mpi_datatype<blob>(const blob& b) { + array<unsigned long, 3> block_lengths{ + { 9, 3, 8 } + }; + + array<MPI_Aint, 3> displacements{ + { 0, 40, 64 } + }; + + array<MPI_Datatype, 3> datatypes{ + { MPI_INT, MPI_DOUBLE, MPI_CHAR } + }; + + MPI_Datatype blob_type; + MPI_Type_create_struct( + block_lengths.size() + , reinterpret_cast<int*>(block_lengths.data()) + , displacements.data() + , datatypes.data() + , &blob_type); + + MPI_Type_commit(&blob_type); + return blob_type; + } + + } // namespace mpi +} // namespace boost + +#endif // defined(__cplusplus) + + +int main(int argc, char* argv[]) { +#if defined(__cplusplus) && (201103L <= __cplusplus) + + mpi::environment env(argc, argv); + mpi::communicator world; + + vector<blob> data; + + if (world.rank() == 0) { + int size = 10000000; + data.resize(size); + // initialize data at vector ends + blob& b1= data[0]; + array<int, 9>& i = b1; + i[0] = -1; + blob& b2= data[size-1]; + array<int, 9>& d = b2; + d[2] = -17; + world.send(1, 0, data); + } else { + world.recv(0, 0, data); + // check data at vector ends + blob& b1 = data[0]; + array<int, 9>& i = b1; + assert(i[0] == -1); + // blob& b2 = data[data.size()-1]; + // array<int, 9>& d = b2; + // assert(d[2] == -17); + } +#endif // defined(__cplusplus) + + return 0; +} diff --git a/src/boost/libs/mpi/test/skeleton_content_test.cpp b/src/boost/libs/mpi/test/skeleton_content_test.cpp new file mode 100644 index 000000000..6a42fd5e0 --- /dev/null +++ b/src/boost/libs/mpi/test/skeleton_content_test.cpp @@ -0,0 +1,200 @@ +// Copyright 2005 Douglas Gregor. + +// 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) + +// A test of the communicator that transmits skeletons and +// content for data types. +#include <boost/mpi/communicator.hpp> +#include <boost/mpi/environment.hpp> +#include <boost/serialization/list.hpp> +#include <boost/mpi/skeleton_and_content.hpp> +#include <boost/mpi/nonblocking.hpp> +#include <algorithm> +#include <boost/iterator/counting_iterator.hpp> +#include <boost/mpi/collectives/broadcast.hpp> + +#define BOOST_TEST_MODULE mpi_skeleton_content +#include <boost/test/included/unit_test.hpp> + +using boost::mpi::communicator; + +using boost::mpi::packed_skeleton_iarchive; +using boost::mpi::packed_skeleton_oarchive; + +void +test_skeleton_and_content(const communicator& comm, int root, + bool manual_broadcast) +{ + using boost::mpi::skeleton; + using boost::mpi::content; + using boost::mpi::get_content; + using boost::make_counting_iterator; + using boost::mpi::broadcast; + + int list_size = comm.size() + 7; + if (comm.rank() == root) { + // Fill in the seed data + std::list<int> original_list; + for (int i = 0; i < list_size; ++i) + original_list.push_back(i); + + std::cout << "Broadcasting integer list skeleton from root " << root + << "..."; + if (manual_broadcast) { + // Broadcast the skeleton (manually) + for (int p = 0; p < comm.size(); ++p) + if (p != root) comm.send(p, 0, skeleton(original_list)); + } else { + broadcast(comm, skeleton(original_list), root); + } + std::cout << "OK." << std::endl; + + // Broadcast the content (manually) + std::cout << "Broadcasting integer list content from root " << root + << "..."; + { + content c = get_content(original_list); + for (int p = 0; p < comm.size(); ++p) + if (p != root) comm.send(p, 1, c); + } + std::cout << "OK." << std::endl; + + // Reverse the list, broadcast the content again + std::reverse(original_list.begin(), original_list.end()); + std::cout << "Broadcasting reversed integer list content from root " + << root << "..."; + { + content c = get_content(original_list); + for (int p = 0; p < comm.size(); ++p) + if (p != root) comm.send(p, 2, c); + } + std::cout << "OK." << std::endl; + } else { + // Allocate some useless data, to try to get the addresses of the + // list<int>'s used later to be different across processes. + std::list<int> junk_list(comm.rank() * 3 + 1, 17); + + // Receive the skeleton to build up the transferred list + std::list<int> transferred_list; + if (manual_broadcast) { + comm.recv(root, 0, skeleton(transferred_list)); + } else { + broadcast(comm, skeleton(transferred_list), root); + } + BOOST_CHECK((int)transferred_list.size() == list_size); + + // Receive the content and check it + comm.recv(root, 1, get_content(transferred_list)); + BOOST_CHECK(std::equal(make_counting_iterator(0), + make_counting_iterator(list_size), + transferred_list.begin())); + + // Receive the reversed content and check it + comm.recv(root, 2, get_content(transferred_list)); + BOOST_CHECK(std::equal(make_counting_iterator(0), + make_counting_iterator(list_size), + transferred_list.rbegin())); + } + + (comm.barrier)(); +} + +void +test_skeleton_and_content_nonblocking(const communicator& comm, int root) +{ + using boost::mpi::skeleton; + using boost::mpi::content; + using boost::mpi::get_content; + using boost::make_counting_iterator; + using boost::mpi::broadcast; + using boost::mpi::request; + using boost::mpi::wait_all; + + int list_size = comm.size() + 7; + if (comm.rank() == root) { + // Fill in the seed data + std::list<int> original_list; + for (int i = 0; i < list_size; ++i) + original_list.push_back(i); + + std::cout << "Non-blocking broadcast of integer list skeleton from root " << root + << "..."; + + // Broadcast the skeleton (manually) + { + std::vector<request> reqs; + for (int p = 0; p < comm.size(); ++p) + if (p != root) + reqs.push_back(comm.isend(p, 0, skeleton(original_list))); + wait_all(reqs.begin(), reqs.end()); + } + std::cout << "OK." << std::endl; + + // Broadcast the content (manually) + std::cout << "Non-blocking broadcast of integer list content from root " << root + << "..."; + { + content c = get_content(original_list); + std::vector<request> reqs; + for (int p = 0; p < comm.size(); ++p) + if (p != root) reqs.push_back(comm.isend(p, 1, c)); + wait_all(reqs.begin(), reqs.end()); + } + std::cout << "OK." << std::endl; + + // Reverse the list, broadcast the content again + std::reverse(original_list.begin(), original_list.end()); + std::cout << "Non-blocking broadcast of reversed integer list content from root " + << root << "..."; + { + std::vector<request> reqs; + content c = get_content(original_list); + for (int p = 0; p < comm.size(); ++p) + if (p != root) reqs.push_back(comm.isend(p, 2, c)); + wait_all(reqs.begin(), reqs.end()); + } + std::cout << "OK." << std::endl; + } else { + // Allocate some useless data, to try to get the addresses of the + // list<int>'s used later to be different across processes. + std::list<int> junk_list(comm.rank() * 3 + 1, 17); + + // Receive the skeleton to build up the transferred list + std::list<int> transferred_list; + request req = comm.irecv(root, 0, skeleton(transferred_list)); + req.wait(); + BOOST_CHECK((int)transferred_list.size() == list_size); + + // Receive the content and check it + req = comm.irecv(root, 1, get_content(transferred_list)); + req.wait(); + BOOST_CHECK(std::equal(make_counting_iterator(0), + make_counting_iterator(list_size), + transferred_list.begin())); + + // Receive the reversed content and check it + req = comm.irecv(root, 2, get_content(transferred_list)); + req.wait(); + BOOST_CHECK(std::equal(make_counting_iterator(0), + make_counting_iterator(list_size), + transferred_list.rbegin())); + } + + (comm.barrier)(); +} + +BOOST_AUTO_TEST_CASE(sendrecv) +{ + boost::mpi::environment env; + communicator comm; + BOOST_TEST_REQUIRE(comm.size() > 1); + + test_skeleton_and_content(comm, 0, true); + test_skeleton_and_content(comm, 0, false); + test_skeleton_and_content(comm, 1, true); + test_skeleton_and_content(comm, 1, false); + test_skeleton_and_content_nonblocking(comm, 0); + test_skeleton_and_content_nonblocking(comm, 1); +} diff --git a/src/boost/libs/mpi/test/version_test.cpp b/src/boost/libs/mpi/test/version_test.cpp new file mode 100644 index 000000000..0895b74f4 --- /dev/null +++ b/src/boost/libs/mpi/test/version_test.cpp @@ -0,0 +1,60 @@ +// Copyright (C) 2013 Alain Miniussi <alain.miniussi@oca.eu> + +// 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) + +// test mpi version + +#include <boost/mpi/environment.hpp> +#include <boost/mpi/communicator.hpp> +#include <iostream> + +#define BOOST_TEST_MODULE mpi_version +#include <boost/test/included/unit_test.hpp> + +namespace mpi = boost::mpi; + +void +test_version(mpi::communicator const& comm) { +#if defined(MPI_VERSION) + int mpi_version = MPI_VERSION; + int mpi_subversion = MPI_SUBVERSION; +#else + int mpi_version = 0; + int mpi_subversion = 0; +#endif + + std::pair<int,int> version = mpi::environment::version(); + if (comm.rank() == 0) { + std::cout << "MPI Version: " << version.first << ',' << version.second << '\n'; + } + BOOST_CHECK(version.first == mpi_version); + BOOST_CHECK(version.second == mpi_subversion); +} + +std::string +yesno(bool b) { + return b ? std::string("yes") : std::string("no"); +} + +void +report_features(mpi::communicator const& comm) { + if (comm.rank() == 0) { + std::cout << "Assuming working MPI_Improbe:" << +#if defined(BOOST_MPI_USE_IMPROBE) + "yes" << '\n'; +#else + "no" << '\n'; +#endif + } +} + +BOOST_AUTO_TEST_CASE(version) +{ + mpi::environment env; + mpi::communicator world; + + test_version(world); + report_features(world); +} diff --git a/src/boost/libs/mpi/test/wait_all_vector_test.cpp b/src/boost/libs/mpi/test/wait_all_vector_test.cpp new file mode 100644 index 000000000..0e4c800bb --- /dev/null +++ b/src/boost/libs/mpi/test/wait_all_vector_test.cpp @@ -0,0 +1,46 @@ +// Copyright (C) 2017 Alain Miniussi & Vincent Chabannes + +// 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) + +#include <string> +#include <iostream> +#include <sstream> +#include <vector> + +#include <boost/mpi.hpp> +#include <boost/mpi/nonblocking.hpp> +#include <boost/serialization/string.hpp> + +#define BOOST_TEST_MODULE mpi_wait_any +#include <boost/test/included/unit_test.hpp> + +namespace mpi = boost::mpi; + +BOOST_AUTO_TEST_CASE(wait_any) +{ + mpi::environment env; + mpi::communicator comm; + + int rank = comm.rank(); + int const sz = 10; + std::vector<int> data; + std::vector< mpi::request> reqs; + if ( rank == 0 ) { + for ( int i=0; i<sz; ++i ) { + data.push_back( i ); + } + reqs.push_back( comm.isend(1, 0, data) ); + } else if ( rank == 1 ) { + reqs.push_back( comm.irecv(0, 0, data) ); + } + mpi::wait_all( reqs.begin(), reqs.end() ); + + if ( rank == 1 ) { + BOOST_CHECK(data.size() == sz); + for ( int i=0; i<sz; ++i ) { + BOOST_CHECK(data[i] == i); + } + } +} diff --git a/src/boost/libs/mpi/test/wait_any_test.cpp b/src/boost/libs/mpi/test/wait_any_test.cpp new file mode 100644 index 000000000..e1f4c556d --- /dev/null +++ b/src/boost/libs/mpi/test/wait_any_test.cpp @@ -0,0 +1,64 @@ +// Copyright (C) 2017 Alain Miniussi & Steffen Hirschmann + +// 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) + +#include <string> +#include <iostream> +#include <sstream> +#include <vector> +#include <set> + +#include <boost/mpi.hpp> +#include <boost/mpi/nonblocking.hpp> +#include <boost/serialization/string.hpp> + +#define BOOST_TEST_MODULE mpi_wait_any +#include <boost/test/included/unit_test.hpp> + +namespace mpi = boost::mpi; + +BOOST_AUTO_TEST_CASE(wait_any) +{ + mpi::environment env; + mpi::communicator world; + + std::vector<std::string> ss(world.size()); + typedef std::vector<mpi::request> requests; + requests rreqs; + + std::set<int> pending_senders; + for (int i = 0; i < world.size(); ++i) { + rreqs.push_back(world.irecv(i, i, ss[i])); + pending_senders.insert(i); + } + + std::ostringstream fmt; + std::string msg = "Hello, World! this is "; + fmt << msg << world.rank(); + + requests sreqs; + for (int i = 0; i < world.size(); ++i) { + sreqs.push_back(world.isend(i, world.rank(), fmt.str())); + } + + for (int i = 0; i < world.size(); ++i) { + std::pair<mpi::status, requests::iterator> completed = mpi::wait_any(rreqs.begin(), rreqs.end()); + std::ostringstream out; + out << "Proc " << world.rank() << " got message from " << completed.first.source() << '\n'; + std::cout << out.str(); + } + + for (int i = 0; i < world.size(); ++i) { + std::ostringstream fmt; + fmt << msg << i; + std::vector<std::string>::iterator found = std::find(ss.begin(), ss.end(), fmt.str()); + BOOST_CHECK(found != ss.end()); + fmt.str(""); + fmt << "Proc " << world.rank() << " Got msg from " << i << '\n'; + std::cout << fmt.str(); + } + + mpi::wait_all(sreqs.begin(), sreqs.end()); +} |