title: Boost.MPI: What's received isn't what was sent!
body: <p>I am relatively new to using Boost MPI. I have got the libraries installed, the code compiles, but I am getting a very odd error - some integer data received by the slave nodes is not what was sent by the master. What is going on?</p>
  
  <p>I am using boost version 1.42.0, compiling the code using mpic++ (which wraps g++ on one cluster and icpc on the other). A reduced example follows, including the output.</p>
  
  <p>Code:</p>
  
  <pre><code>#include &lt;iostream&gt;
  #include &lt;boost/mpi.hpp&gt;
  
  using namespace std;
  namespace mpi = boost::mpi;
  
  class Solution
  {
  public:
    Solution() :
    solution_num(num_solutions++)
    {
      // Master node's constructor
    }
  
    Solution(int solutionNum) :
    solution_num(solutionNum)
    {
      // Slave nodes' constructor.
    }
  
    int solutionNum() const
    {
      return solution_num;
    }
  
  private:
    static int num_solutions;
    int solution_num;
  };
  
  int Solution::num_solutions = 0;
  
  int main(int argc, char* argv[])
  {
    // Initialization of MPI
    mpi::environment env(argc, argv);
    mpi::communicator world;
  
    if (world.rank() == 0)
    {
      // Create solutions
      int numSolutions = world.size() - 1;  // One solution per slave
      vector&lt;Solution*&gt; solutions(numSolutions);
      for (int sol = 0; sol &lt; numSolutions; ++sol)
      {
        solutions[sol] = new Solution;
      }
  
      // Send solutions
      for (int sol = 0; sol &lt; numSolutions; ++sol)
      {
        world.isend(sol + 1, 0, false);  // Tells the slave to expect work
        cout &lt;&lt; "Sending solution no. " &lt;&lt; solutions[sol]-&gt;solutionNum() &lt;&lt; " to node " &lt;&lt; sol + 1 &lt;&lt; endl;
        world.isend(sol + 1, 1, solutions[sol]-&gt;solutionNum());
      }
  
      // Retrieve values (solution numbers squared)
      vector&lt;double&gt; values(numSolutions, 0);
      for (int i = 0; i &lt; numSolutions; ++i)
      {
        // Get values for each solution
        double value = 0;
        mpi::status status = world.recv(mpi::any_source, 2, value);
        int source = status.source();
  
        int sol = source - 1;
        values[sol] = value;
      }
      for (int i = 1; i &lt;= numSolutions; ++i)
      {
        world.isend(i, 0, true);  // Tells the slave to finish
      }
  
      // Output the solutions numbers and their squares
      for (int i = 0; i &lt; numSolutions; ++i)
      {
        cout &lt;&lt; solutions[i]-&gt;solutionNum() &lt;&lt; ", " &lt;&lt; values[i] &lt;&lt; endl;
        delete solutions[i];
      }
    }
    else
    {
      // Slave nodes merely square the solution number
      bool finished;
      mpi::status status = world.recv(0, 0, finished);
      while (!finished)
      {
        int solNum;
        world.recv(0, 1, solNum);
        cout &lt;&lt; "Node " &lt;&lt; world.rank() &lt;&lt; " receiving solution no. " &lt;&lt; solNum &lt;&lt; endl;
  
        Solution solution(solNum);
        double value = static_cast&lt;double&gt;(solNum * solNum);
        world.send(0, 2, value);
  
        status = world.recv(0, 0, finished);
      }
  
      cout &lt;&lt; "Node " &lt;&lt; world.rank() &lt;&lt; " finished." &lt;&lt; endl;
    }
  
    return EXIT_SUCCESS;
  }
  </code></pre>
  
  <p>Running this on 21 nodes (1 master, 20 slaves) produces:</p>
  
  <pre><code>Sending solution no. 0 to node 1
  Sending solution no. 1 to node 2
  Sending solution no. 2 to node 3
  Sending solution no. 3 to node 4
  Sending solution no. 4 to node 5
  Sending solution no. 5 to node 6
  Sending solution no. 6 to node 7
  Sending solution no. 7 to node 8
  Sending solution no. 8 to node 9
  Sending solution no. 9 to node 10
  Sending solution no. 10 to node 11
  Sending solution no. 11 to node 12
  Sending solution no. 12 to node 13
  Sending solution no. 13 to node 14
  Sending solution no. 14 to node 15
  Sending solution no. 15 to node 16
  Sending solution no. 16 to node 17
  Sending solution no. 17 to node 18
  Sending solution no. 18 to node 19
  Sending solution no. 19 to node 20
  Node 1 receiving solution no. 0
  Node 2 receiving solution no. 1
  Node 12 receiving solution no. 19
  Node 3 receiving solution no. 19
  Node 15 receiving solution no. 19
  Node 13 receiving solution no. 19
  Node 4 receiving solution no. 19
  Node 9 receiving solution no. 19
  Node 10 receiving solution no. 19
  Node 14 receiving solution no. 19
  Node 6 receiving solution no. 19
  Node 5 receiving solution no. 19
  Node 11 receiving solution no. 19
  Node 8 receiving solution no. 19
  Node 16 receiving solution no. 19
  Node 19 receiving solution no. 19
  Node 20 receiving solution no. 19
  Node 1 finished.
  Node 2 finished.
  Node 7 receiving solution no. 19
  0, 0
  1, 1
  2, 361
  3, 361
  4, 361
  5, 361
  6, 361
  7, 361
  8, 361
  9, 361
  10, 361
  11, 361
  12, 361
  13, 361
  14, 361
  15, 361
  16, 361
  17, 361
  18, 361
  19, 361
  Node 6 finished.
  Node 3 finished.
  Node 17 receiving solution no. 19
  Node 17 finished.
  Node 10 finished.
  Node 12 finished.
  Node 8 finished.
  Node 4 finished.
  Node 15 finished.
  Node 18 receiving solution no. 19
  Node 18 finished.
  Node 11 finished.
  Node 13 finished.
  Node 20 finished.
  Node 16 finished.
  Node 9 finished.
  Node 19 finished.
  Node 7 finished.
  Node 5 finished.
  Node 14 finished.
  </code></pre>
  
  <p>So while the master sends 0 to node 1, 1 to node 2, 2 to node 3 etc, most of the slave nodes (for some reason) receive the number 19. So rather than producing the squares of the numbers from 0 to 19, we get 0 squared, 1 squared and 19 squared 18 times!</p>
  
  <p>Thanks in advance to anyone who can explain this.</p>
  
  <p>Alan</p>