ceph/src/boost/libs/graph_parallel/test/distributed_queue_test.cpp

   1 // Copyright (C) 2004-2006 The Trustees of Indiana University.
   2
   3 // Use, modification and distribution is subject to the Boost Software
   4 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
   5 // http://www.boost.org/LICENSE_1_0.txt)
   6
   7 //  Authors: Douglas Gregor
   8 //           Andrew Lumsdaine
   9 #include <boost/graph/use_mpi.hpp>
  10 #include <boost/config.hpp>
  11 #include <boost/throw_exception.hpp>
  12 #include <boost/serialization/vector.hpp>
  13 #include <boost/graph/distributed/queue.hpp>
  14 #include <boost/test/minimal.hpp>
  15 #include <boost/graph/distributed/mpi_process_group.hpp>
  16 #include <boost/pending/queue.hpp>
  17 #include <boost/property_map/property_map.hpp>
  18 #include <utility>
  19 #include <iostream>
  20
  21 #ifdef BOOST_NO_EXCEPTIONS
  22 void
  23 boost::throw_exception(std::exception const& ex)
  24 {
  25     std::cout << ex.what() << std::endl;
  26     abort();
  27 }
  28 #endif
  29
  30 using boost::graph::distributed::mpi_process_group;
  31
  32 struct global_value
  33 {
  34   global_value(int p = -1, std::size_t l = 0) : processor(p), value(l) {}
  35
  36   int processor;
  37   std::size_t value;
  38
  39   template<typename Archiver>
  40   void serialize(Archiver& ar, const unsigned int /*version*/)
  41   {
  42     ar & processor & value;
  43   }
  44 };
  45
  46 namespace boost { namespace mpi {
  47     template<> struct is_mpi_datatype<global_value> : mpl::true_ { };
  48 } } // end namespace boost::mpi
  49
  50 BOOST_IS_BITWISE_SERIALIZABLE(global_value)
  51 BOOST_CLASS_IMPLEMENTATION(global_value,object_serializable)
  52 BOOST_CLASS_TRACKING(global_value,track_never)
  53
  54 inline bool operator==(const global_value& x, const global_value& y)
  55 { return x.processor == y.processor && x.value == y.value; }
  56
  57 struct global_value_owner_map
  58 {
  59   typedef int value_type;
  60   typedef value_type reference;
  61   typedef global_value key_type;
  62   typedef boost::readable_property_map_tag category;
  63 };
  64
  65 int get(global_value_owner_map, global_value k)
  66 {
  67   return k.processor;
  68 }
  69
  70 void test_distributed_queue()
  71 {
  72   mpi_process_group process_group;
  73
  74   typedef boost::queue<global_value> local_queue_type;
  75
  76   typedef boost::graph::distributed::distributed_queue<mpi_process_group,
  77                                              global_value_owner_map,
  78                                              local_queue_type> dist_queue_type;
  79
  80   dist_queue_type Q(process_group, global_value_owner_map());
  81
  82   mpi_process_group::process_id_type id = process_id(process_group),
  83     n = num_processes(process_group);
  84   global_value v(0, 0);
  85
  86   if (id == 0) {
  87     std::cerr << "Should print level of each processor in a binary tree:\n";
  88   }
  89   synchronize(process_group);
  90
  91   if (id == n-1) Q.push(v);
  92   while (!Q.empty()) {
  93     v = Q.top(); Q.pop();
  94
  95     std::cerr << "#" << id << ": level = " << v.value << std::endl;
  96
  97     int level_begin = 1;
  98     for (std::size_t i = 0; i < v.value; ++i) level_begin *= 2;
  99     int level_end = level_begin * 2;
 100     BOOST_CHECK(level_begin <= (id + 1));
 101     BOOST_CHECK((id + 1) <= level_end);
 102
 103     ++v.value;
 104     v.processor = v.processor * 2 + 1;
 105     if (v.processor < n) Q.push(v);
 106     ++v.processor;
 107     if (v.processor < n) Q.push(v);
 108   }
 109 }
 110
 111 int test_main(int argc, char** argv)
 112 {
 113   boost::mpi::environment env(argc, argv);
 114   test_distributed_queue();
 115   return 0;
 116 }