MPIRoot.h

//-*-C++-*-
/***************************************************************************
 *
 *   Copyright (C) 2002 by Willem van Straten
 *   Licensed under the Academic Free License version 2.1
 *
 ***************************************************************************/
 
#ifndef __MPIRoot_h
#define __MPIRoot_h
 
#include <mpi.h>
 
#define ACTIVATE_MPI 1
#include "dsp/Input.h"
 
 
namespace dsp {
 
  class MPIRoot : public Input {
    
  public:
    
    friend class MPIServer;
 
    MPIRoot (MPI_Comm comm);
 
    virtual ~MPIRoot ();
    
    int get_size () const { return mpi_size; }
 
    int get_rank () const { return mpi_rank; }
 
    int get_root () const { return mpi_root; }
    void set_root (int root);
 
    int get_tag () const { return mpi_tag; }
    void set_tag (int tag) { mpi_tag = tag; }
 
    void set_block_size (uint64_t _size);
 
    void prepare ();
 
    bool eod();
 
 
    void set_Input (Input* input);
 
    void serve (BitSeries* bitseries = 0);
 
 
    void set_resolution (unsigned resolution);
 
  protected:
 
    virtual void set_eod(bool _eod){/* HSK doesn't know what to put here*/}
 
    void send_data (BitSeries* data, int dest);
 
    void load_data (BitSeries* data);
 
    void wait (MPI_Request& request, bool receive);
 
    int next_destination ();
 
    void size_pack_buffer ();
 
    MPI_Comm comm;
 
    int mpi_size;
 
    int mpi_rank;
 
    int mpi_root;
 
    int mpi_tag;
 
    bool auto_request;
 
    MPI_Request data_request;
 
    MPI_Request ready_request;
 
    MPI_Status status;
 
    int ready;
 
    char* pack_buf;
 
    int pack_buf_size;
 
    int pack_size;
 
    int min_header_size;
 
    int data_size;
 
    bool end_of_data;
 
    vector<bool> eod_sent;
 
    Reference::To<Input> input;
 
    void init();
 
    void request_ready ();
 
    void request_data ();
 
    int receive_data ();
 
    void load_data ();
 
    void ensure_root (const char* method) const;
 
    void ensure_receptive (const char* method) const;
 
    void check_error (int mpi_err, const char* call, const char* method);
 
    void check_status (MPI_Status& mpi_status, const char* method);
 
    void check_block_size (const char* method);
 
  };
 
}
 
 
int mpiPack_size (const dsp::MPIRoot&, MPI_Comm comm, int* size);
 
int mpiPack (const dsp::MPIRoot&, void* outbuf, int outcount,
             int* position, MPI_Comm comm);
 
int mpiUnpack (void* inbuf, int insize, int* position, 
               dsp::MPIRoot*, MPI_Comm comm);
 
 
#endif // !defined(__SeekInput_h)