PLMPI.h

Go to the documentation of this file.

// -*- C++ -*-

// PLearn (A C++ Machine Learning Library)
// Copyright (C) 2001 Pascal Vincent
//

// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// 
//  1. Redistributions of source code must retain the above copyright
//     notice, this list of conditions and the following disclaimer.
// 
//  2. Redistributions in binary form must reproduce the above copyright
//     notice, this list of conditions and the following disclaimer in the
//     documentation and/or other materials provided with the distribution.
// 
//  3. The name of the authors may not be used to endorse or promote
//     products derived from this software without specific prior written
//     permission.
// 
// THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
// NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
// TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// 
// This file is part of the PLearn library. For more information on the PLearn
// library, go to the PLearn Web site at www.plearn.org


 

/* *******************************************************      
   * $Id: PLMPI.h,v 1.7 2004/07/21 16:30:54 chrish42 Exp $
   * AUTHORS: Pascal Vincent 
   * This file is part of the PLearn library.
   ******************************************************* */


#ifndef PLMPI_INC
#define PLMPI_INC

#if USING_MPI
#include <mpi.h>
#endif

#include <plearn/math/Mat.h>
#include <plearn/base/plerror.h>
#include <plearn/io/plstreams.h>
// norman: changed to standard calls
#include <iostream>
#include <fstream>

namespace PLearn {
using namespace std;


//  Let's define PLMPI_REAL to be either MPI_FLOAT or MPI_DOUBLE

#if USING_MPI
#ifdef USEDOUBLE
#define PLMPI_REAL MPI_DOUBLE
#endif
#ifdef USEFLOAT
#define PLMPI_REAL MPI_FLOAT
#endif
#endif


class PLMPI
{
protected:
  static streambuf* new_cin_buf;

public:
  static bool using_mpi; 
  static int size;  
  static int rank;  

  static bool synchronized; 

//  static oassignstream mycout;
//  static oassignstream mycerr;
//  static iassignstream mycin;
  static PStream mycout;
  static PStream mycerr;
  static PStream mycin;

  static int tag; 

  inline static void init(int* argc, char*** argv);
  inline static void finalize();
  
    // exchange blocks of data among the PLMPI::size CPUs:
    // each CPU has the block starting at position PLMPI::rank*blocksize
    // and they must exchange the blocks so that, upon return,
    // data contains all of them on all the CPUs. A buffer
    // of length blocksize is provided by the caller.
    // The last block may potentially be shorter than blocksize.
    // (only for PLMPI::rank==PLMPI::size-1). This only happens
    // when blocksize*PLMPI::size != n.
    static void exchangeBlocks(double* data,int n,int blocksize,double* buffer=0);  

    // CPU i holds sourceBlock which is going to be
    // copied into the i-th block of columns of the destBlocks
    // matrix in all the CPUs. Note that the last block may be
    // smaller when destBlocks.width() is not a multiple of PLMPI::size.
    static void exchangeColumnBlocks(Mat sourceBlock, Mat destBlocks);

    static void exchangeBlocks(float* data,int n,int blocksize,float* buffer=0);

    
#if USING_MPI  

  inline static int wait_any();

  inline static int peek_any();
#endif

};


#if USING_MPI
class pofstream: public ofstream
{
public:
  pofstream() {}
  pofstream(const char *name, ios::openmode mode=ios::out)
  { open(name, mode); }

  void open(const char *name,  ios::openmode mode=ios::out)
  { 
    if(PLMPI::rank==0)
      ofstream::open(name, mode); 
    else
      ios::rdbuf(nullout.rdbuf());
  }

};
#else
typedef ofstream pofstream;
#endif



inline void PLMPI::init(int* argc, char*** argv)
  {
    mycout(&cout);//.rdbuf(cout.rdbuf());
    mycerr(&cerr);//.rdbuf(cerr.rdbuf());
    mycin(&cin);//.rdbuf(cin.rdbuf());

#if USING_MPI
    MPI_Init( argc, argv );
    MPI_Comm_size( MPI_COMM_WORLD, &size) ;
    MPI_Comm_rank( MPI_COMM_WORLD, &rank );
    if(rank!=0)
      {
        cout.rdbuf(nullout.rdbuf());
        cin.rdbuf(nullin.rdbuf());
      }
#endif
  }

inline void PLMPI::finalize()
  {
#if USING_MPI
    MPI_Finalize();
#endif 
  }


#if USING_MPI
inline int PLMPI::wait_any()
  {
    MPI_Status status;
    MPI_Probe(MPI_ANY_SOURCE, PLMPI::tag, MPI_COMM_WORLD, &status);
    return status.MPI_SOURCE;
  }

inline int PLMPI::peek_any()
  {
    int ready;
    MPI_Status status;
    MPI_Iprobe(MPI_ANY_SOURCE, PLMPI::tag, MPI_COMM_WORLD, &ready, &status);
    if(!ready)
      return -1;
    else
      return status.MPI_SOURCE;
  }
#endif

} // end of namespace PLearn


#endif

---