vtkMPICommunicator.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkMPICommunicator.h
 
  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
 
     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.
 
=========================================================================*/
#ifndef vtkMPICommunicator_h
#define vtkMPICommunicator_h
 
#include "vtkParallelMPIModule.h" // For export macro
#include "vtkCommunicator.h"
 
class vtkMPIController;
class vtkProcessGroup;
 
class vtkMPICommunicatorOpaqueComm;
class vtkMPICommunicatorOpaqueRequest;
class vtkMPICommunicatorReceiveDataInfo;
 
class VTKPARALLELMPI_EXPORT vtkMPICommunicator : public vtkCommunicator
{
public:
//BTX
 
  class VTKPARALLELMPI_EXPORT Request
  {
  public:
    Request();
    Request( const Request& );
    ~Request();
    Request& operator = ( const Request& );
    int Test();
    void Cancel();
    void Wait();
    vtkMPICommunicatorOpaqueRequest* Req;
  };
 
//ETX
 
  vtkTypeMacro( vtkMPICommunicator,vtkCommunicator);
  void PrintSelf(ostream& os, vtkIndent indent);
 
  static vtkMPICommunicator* New();
 
  static vtkMPICommunicator* GetWorldCommunicator();
 
 
  int Initialize(vtkProcessGroup *group);
 
  int SplitInitialize(vtkCommunicator *oldcomm, int color, int key);
 
 
  virtual int SendVoidArray(const void *data, vtkIdType length, int type,
                            int remoteProcessId, int tag);
  virtual int ReceiveVoidArray(void *data, vtkIdType length, int type,
                               int remoteProcessId, int tag);
 
 
  int NoBlockSend(const int* data, int length, int remoteProcessId, int tag,
                  Request& req);
  int NoBlockSend(const unsigned long* data, int length, int remoteProcessId,
                  int tag, Request& req);
  int NoBlockSend(const char* data, int length, int remoteProcessId,
                  int tag, Request& req);
  int NoBlockSend(const unsigned char* data, int length, int remoteProcessId,
                    int tag, Request& req);
  int NoBlockSend(const float* data, int length, int remoteProcessId,
                  int tag, Request& req);
  int NoBlockSend(const double* data, int length, int remoteProcessId,
                  int tag, Request& req);
#ifdef VTK_USE_64BIT_IDS
  int NoBlockSend(const vtkIdType* data, int length, int remoteProcessId,
                  int tag, Request& req);
#endif
 
 
 
  int NoBlockReceive(int* data, int length, int remoteProcessId,
                     int tag, Request& req);
  int NoBlockReceive(unsigned long* data, int length,
                     int remoteProcessId, int tag, Request& req);
  int NoBlockReceive(char* data, int length, int remoteProcessId,
                     int tag, Request& req);
  int NoBlockReceive(unsigned char* data, int length, int remoteProcessId,
                     int tag, Request& req);
  int NoBlockReceive(float* data, int length, int remoteProcessId,
                     int tag, Request& req);
  int NoBlockReceive(double* data, int length, int remoteProcessId,
                     int tag, Request& req);
#ifdef VTK_USE_64BIT_IDS
  int NoBlockReceive(vtkIdType* data, int length, int remoteProcessId,
                     int tag, Request& req);
#endif
 
 
 
 
  virtual void Barrier();
  virtual int BroadcastVoidArray(void *data, vtkIdType length, int type,
                                 int srcProcessId);
  virtual int GatherVoidArray(const void *sendBuffer, void *recvBuffer,
                              vtkIdType length, int type, int destProcessId);
  virtual int GatherVVoidArray(const void *sendBuffer, void *recvBuffer,
                               vtkIdType sendLength, vtkIdType *recvLengths,
                               vtkIdType *offsets, int type, int destProcessId);
  virtual int ScatterVoidArray(const void *sendBuffer, void *recvBuffer,
                               vtkIdType length, int type, int srcProcessId);
  virtual int ScatterVVoidArray(const void *sendBuffer, void *recvBuffer,
                                vtkIdType *sendLengths, vtkIdType *offsets,
                                vtkIdType recvLength, int type,
                                int srcProcessId);
  virtual int AllGatherVoidArray(const void *sendBuffer, void *recvBuffer,
                                 vtkIdType length, int type);
  virtual int AllGatherVVoidArray(const void *sendBuffer, void *recvBuffer,
                                  vtkIdType sendLength, vtkIdType *recvLengths,
                                  vtkIdType *offsets, int type);
  virtual int ReduceVoidArray(const void *sendBuffer, void *recvBuffer,
                              vtkIdType length, int type,
                              int operation, int destProcessId);
  virtual int ReduceVoidArray(const void *sendBuffer, void *recvBuffer,
                              vtkIdType length, int type,
                              Operation *operation, int destProcessId);
  virtual int AllReduceVoidArray(const void *sendBuffer, void *recvBuffer,
                                 vtkIdType length, int type,
                                 int operation);
  virtual int AllReduceVoidArray(const void *sendBuffer, void *recvBuffer,
                                 vtkIdType length, int type,
                                 Operation *operation);
 
 
  int Iprobe(int source, int tag, int* flag, int* actualSource);
  int Iprobe(int source, int tag, int* flag, int* actualSource,
             int* type, int* size);
  int Iprobe(int source, int tag, int* flag, int* actualSource,
             unsigned long* type, int* size);
  int Iprobe(int source, int tag, int* flag, int* actualSource,
             const char* type, int* size);
  int Iprobe(int source, int tag, int* flag, int* actualSource,
             float* type, int* size);
  int Iprobe(int source, int tag, int* flag, int* actualSource,
             double* type, int* size);
 
  int WaitAll(const int count, Request requests[]);
 
  int WaitAny(const int count, Request requests[], int& idx);
 
 
  int WaitSome(
      const int count, Request requests[], int &NCompleted, int *completed );
 
  int TestAll( const int count, Request requests[], int& flag );
 
  int TestAny(const int count, Request requests[], int &idx, int &flag );
 
 
  int TestSome(const int count,Request requests[],
               int& NCompleted,int *completed);
//BTX
 
  friend class vtkMPIController;
 
  vtkMPICommunicatorOpaqueComm *GetMPIComm()
    {
    return this->MPIComm;
    }
 
  int InitializeExternal(vtkMPICommunicatorOpaqueComm *comm);
 
//ETX
 
  static char* Allocate(size_t size);
  static void Free(char* ptr);
 
 
 
  vtkSetClampMacro(UseSsend, int, 0, 1);
  vtkGetMacro(UseSsend, int);
  vtkBooleanMacro(UseSsend, int);
 
 
  void CopyFrom(vtkMPICommunicator* source);
protected:
  vtkMPICommunicator();
  ~vtkMPICommunicator();
 
  // Obtain size and rank setting NumberOfProcesses and LocalProcessId Should
  // not be called if the current communicator does not include this process
  int InitializeNumberOfProcesses();
 
 
  vtkSetMacro(KeepHandle, int);
  vtkBooleanMacro(KeepHandle, int);
 
 
  static vtkMPICommunicator* WorldCommunicator;
 
  void InitializeCopy(vtkMPICommunicator* source);
 
  void Duplicate(vtkMPICommunicator* source);
 
 
  virtual int ReceiveDataInternal(
    char* data, int length, int sizeoftype,
    int remoteProcessId, int tag,
    vtkMPICommunicatorReceiveDataInfo* info,
    int useCopy, int& senderId);
 
  vtkMPICommunicatorOpaqueComm* MPIComm;
 
  int Initialized;
  int KeepHandle;
 
  int LastSenderId;
  int UseSsend;
  static int CheckForMPIError(int err);
 
private:
  vtkMPICommunicator(const vtkMPICommunicator&);  // Not implemented.
  void operator=(const vtkMPICommunicator&);  // Not implemented.
};
 
#endif