Parallel/vtkMPICommunicator.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Visualization Toolkit
  Module:    $RCSfile: vtkMPICommunicator.h,v $
  Language:  C++

  Copyright (c) 1993-2002 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 "vtkCommunicator.h"

class vtkMPIController;
class vtkMPIGroup;

class vtkMPICommunicatorOpaqueRequest;
class vtkMPICommunicatorOpaqueComm;

class VTK_PARALLEL_EXPORT vtkMPICommunicator : public vtkCommunicator
{
public:
  vtkTypeRevisionMacro( vtkMPICommunicator,vtkCommunicator);
  
  static vtkMPICommunicator* New();

  static vtkMPICommunicator* GetWorldCommunicator();
  
  virtual void PrintSelf(ostream& os, vtkIndent indent);

  int Initialize(vtkMPICommunicator* mpiComm, vtkMPIGroup* group);


  virtual int Send(int* data, int length, int remoteProcessId, int tag);
  virtual int Send(unsigned long* data, int length, int remoteProcessId,
                   int tag);
  virtual int Send(char* data, int length, int remoteProcessId, int tag);
  virtual int Send(unsigned char* data, int length, int remoteProcessId, 
                   int tag);
  virtual int Send(float* data, int length, int remoteProcessId, 
                   int tag);
  virtual int Send(double* data, int length, int remoteProcessId, 
                   int tag);
#ifdef VTK_USE_64BIT_IDS
  virtual int Send(vtkIdType* data, int length, int remoteProcessId, 
                   int tag);
#endif
  virtual int Send(vtkDataObject* data, int remoteProcessId, int tag)
    { return this->vtkCommunicator::Send(data, remoteProcessId, tag); }
  virtual int Send(vtkDataArray* data, int remoteProcessId, int tag)
    { return this->vtkCommunicator::Send(data, remoteProcessId, tag); }

//BTX

  class VTK_PARALLEL_EXPORT Request
  {
  public:
    Request();
    ~Request();
    int Test();
    void Cancel();
    void Wait();
    vtkMPICommunicatorOpaqueRequest* Req;
  };

//ETX


  int NoBlockSend(int* data, int length, int remoteProcessId, int tag,
                  Request& req);
  int NoBlockSend(unsigned long* data, int length, int remoteProcessId,
                  int tag, Request& req);
  int NoBlockSend(char* data, int length, int remoteProcessId, 
                  int tag, Request& req);
  int NoBlockSend(float* data, int length, int remoteProcessId, 
                  int tag, Request& req);


  virtual int Receive(int* data, int length, int remoteProcessId, 
                      int tag);
  virtual int Receive(unsigned long* data, int length, 
                      int remoteProcessId, int tag);
  virtual int Receive(char* data, int length, int remoteProcessId, 
                      int tag);
  virtual int Receive(unsigned char* data, int length, int remoteProcessId, 
                      int tag);
  virtual int Receive(float* data, int length, int remoteProcessId, 
                      int tag);
  virtual int Receive(double* data, int length, int remoteProcessId, 
                      int tag);
#ifdef VTK_USE_64BIT_IDS
  virtual int Receive(vtkIdType* data, int length, int remoteProcessId, 
                      int tag);
#endif
  virtual int Receive(vtkDataObject* data, int remoteProcessId, int tag)
    { return this->vtkCommunicator::Receive(data, remoteProcessId, tag); }
  virtual int Receive(vtkDataArray* data, int remoteProcessId, int tag)
    { return this->vtkCommunicator::Receive(data, remoteProcessId, tag); }


  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(float* data, int length, int remoteProcessId, 
                     int tag, Request& req);



  int Broadcast(int* data          , int length, int root);
  int Broadcast(unsigned long* data, int length, int root);
  int Broadcast(char* data         , int length, int root);
  int Broadcast(float* data        , int length, int root);
  int Broadcast(double* data        , int length, int root);

  

  int Gather(int* data          , int* to          , int length, int root);
  int Gather(unsigned long* data, unsigned long* to, int length, int root);
  int Gather(char* data         , char* to         , int length, int root);
  int Gather(float* data        , float* to        , int length, int root);
  int Gather(double* data       , double* to       , int length, int root);


  int GatherV(int* data, int* to, 
              int sendlength, int* recvlengths, int* offsets, int root);
  int GatherV(unsigned long* data, unsigned long* to, 
              int sendlength, int* recvlengths, int* offsets, int root);
  int GatherV(char* data, char* to, 
              int sendlength, int* recvlengths, int* offsets, int root);
  int GatherV(float* data, float* to, 
              int sendlength, int* recvlengths, int* offsets, int root);
  int GatherV(double* data, double* to, 
              int sendlength, int* recvlengths, int* offsets, int root);


  int ReduceMax(int* data, int* to, int size, int root);
  int ReduceMax(long* data, long* to, int size, int root);
  int ReduceMax(float* data, float* to, int size, int root);
  int ReduceMax(double* data, double* to, int size, int root);

  int ReduceMin(int* data, int* to, int size, int root);
  int ReduceMin(long* data, long* to, int size, int root);
  int ReduceMin(float* data, float* to, int size, int root);
  int ReduceMin(double* data, double* to, int size, int root);

  int ReduceSum(int* data, int* to, int size, int root);
  int ReduceSum(long* data, long* to, int size, int root);
  int ReduceSum(float* data, float* to, int size, int root);
  int ReduceSum(double* data, double* to, int size, int root);

  int ReduceAnd(bool* data, bool* to, int size, int root);
  int ReduceOr(bool* data, bool* to, int size, int root);


//BTX

  friend class vtkMPIController;

  vtkMPICommunicatorOpaqueComm* GetMPIComm()
    {
      return this->Comm;
    }

//ETX

  static char* Allocate(size_t size);
  static void Free(char* ptr);


protected:
  vtkMPICommunicator();
  ~vtkMPICommunicator();

  virtual void SetGroup(vtkMPIGroup*);


  vtkSetMacro(KeepHandle, int);
  vtkBooleanMacro(KeepHandle, int);


  static vtkMPICommunicator* WorldCommunicator;

  void InitializeCopy(vtkMPICommunicator* source);

  void CopyFrom(vtkMPICommunicator* source);

  void Duplicate(vtkMPICommunicator* source);

  vtkMPICommunicatorOpaqueComm* Comm;
  vtkMPIGroup* Group;

  int Initialized;
  int KeepHandle;

  static int CheckForMPIError(int err);

private:
  vtkMPICommunicator(const vtkMPICommunicator&);  // Not implemented.
  void operator=(const vtkMPICommunicator&);  // Not implemented.
};


#endif //  __vtkMPICommunicator_h

Generated on Thu Jan 22 15:46:56 2004 for VTK by Doxygen 1.3.4