vtkMultiProcessController.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkMultiProcessController.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 vtkMultiProcessController_h
#define vtkMultiProcessController_h
 
#include "vtkObject.h"
#include "vtkParallelCoreModule.h" // For export macro
 
#include "vtkCommunicator.h" // Needed for direct access to communicator
 
VTK_ABI_NAMESPACE_BEGIN
class vtkBoundingBox;
class vtkCollection;
class vtkDataObject;
class vtkDataSet;
class vtkImageData;
class vtkMultiProcessController;
class vtkMultiProcessStream;
class vtkOutputWindow;
class vtkProcessGroup;
class vtkProcess;
class vtkDataArraySelection;
 
// The type of function that gets called when new processes are initiated.
typedef void (*vtkProcessFunctionType)(vtkMultiProcessController* controller, void* userData);
 
// The type of function that gets called when an RMI is triggered.
typedef void (*vtkRMIFunctionType)(
  void* localArg, void* remoteArg, int remoteArgLength, int remoteProcessId);
 
class VTKPARALLELCORE_EXPORT vtkMultiProcessController : public vtkObject
{
public:
  vtkTypeMacro(vtkMultiProcessController, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  virtual void Initialize(int* vtkNotUsed(argc), char*** vtkNotUsed(argv)) = 0;
 
  virtual void Initialize(
    int* vtkNotUsed(argc), char*** vtkNotUsed(argv), int initializedExternally) = 0;
 
  virtual void Finalize() = 0;
 
  virtual void Finalize(int finalizedExternally) = 0;
 
 
  void SetNumberOfProcesses(int num);
  int GetNumberOfProcesses();
 
  void SetSingleMethod(vtkProcessFunctionType, void* data);
 
  void SetSingleProcessObject(vtkProcess* p);
 
  virtual void SingleMethodExecute() = 0;
 
  void SetMultipleMethod(int index, vtkProcessFunctionType, void* data);
 
  virtual void MultipleMethodExecute() = 0;
 
  int GetLocalProcessId();
 
  static vtkMultiProcessController* GetGlobalController();
 
  virtual void CreateOutputWindow() = 0;
 
  virtual vtkMultiProcessController* CreateSubController(vtkProcessGroup* group);
 
  virtual vtkMultiProcessController* PartitionController(int localColor, int localKey);
 
  //------------------ RMIs --------------------
 
  virtual unsigned long AddRMI(vtkRMIFunctionType, void* localArg, int tag);
 
  virtual int RemoveFirstRMI(int tag);
 
  virtual int RemoveRMI(unsigned long id);
 
  virtual void RemoveRMI(vtkRMIFunctionType f, void* arg, int tag)
  {
    (void)f;
    (void)arg;
    (void)tag;
    vtkErrorMacro("RemoveRMI Not Implemented Yet");
  }
 
  virtual unsigned long AddRMICallback(vtkRMIFunctionType, void* localArg, int tag);
 
  virtual void RemoveAllRMICallbacks(int tag);
 
  virtual bool RemoveRMICallback(unsigned long id);
 
  void TriggerRMI(int remoteProcessId, void* arg, int argLength, int tag);
 
  void TriggerBreakRMIs();
 
  void TriggerRMI(int remoteProcessId, const char* arg, int tag)
  {
    this->TriggerRMI(remoteProcessId, (void*)arg, static_cast<int>(strlen(arg)) + 1, tag);
  }
 
  void TriggerRMI(int remoteProcessId, int tag)
  {
    this->TriggerRMI(remoteProcessId, nullptr, 0, tag);
  }
 
 
  void TriggerRMIOnAllChildren(void* arg, int argLength, int tag);
  void TriggerRMIOnAllChildren(const char* arg, int tag)
  {
    this->TriggerRMIOnAllChildren((void*)arg, static_cast<int>(strlen(arg)) + 1, tag);
  }
  void TriggerRMIOnAllChildren(int tag) { this->TriggerRMIOnAllChildren(nullptr, 0, tag); }
  void BroadcastTriggerRMIOnAllChildren(void* arg, int argLength, int tag);
 
 
  int ProcessRMIs(int reportErrors, int dont_loop = 0);
  int ProcessRMIs();
  int BroadcastProcessRMIs(int reportErrors, int dont_loop = 0);
 
 
  vtkSetMacro(BreakFlag, int);
  vtkGetMacro(BreakFlag, int);
 
 
  vtkSetMacro(BroadcastTriggerRMI, bool);
  vtkGetMacro(BroadcastTriggerRMI, bool);
  vtkBooleanMacro(BroadcastTriggerRMI, bool);
 
 
  vtkGetObjectMacro(Communicator, vtkCommunicator);
 
  static int GetBreakRMITag() { return BREAK_RMI_TAG; }
  static int GetRMITag() { return RMI_TAG; }
  static int GetRMIArgTag() { return RMI_ARG_TAG; }
 
  enum Errors
  {
    RMI_NO_ERROR,
    RMI_TAG_ERROR,
    RMI_ARG_ERROR
  };
 
  enum Consts
  {
    ANY_SOURCE = -1,
    INVALID_SOURCE = -2
  };
 
  enum Tags
  {
    RMI_TAG = 1,
    RMI_ARG_TAG = 2,
    BREAK_RMI_TAG = 3,
    XML_WRITER_DATA_INFO = 4
  };
 
  void Barrier();
 
  static void SetGlobalController(vtkMultiProcessController* controller);
 
  //------------------ Communication --------------------
 
 
  int Send(const int* data, vtkIdType length, int remoteProcessId, int tag);
  int Send(const short* data, vtkIdType length, int remoteProcessId, int tag);
  int Send(const unsigned short* data, vtkIdType length, int remoteProcessId, int tag);
  int Send(const unsigned int* data, vtkIdType length, int remoteProcessId, int tag);
  int Send(const unsigned long* data, vtkIdType length, int remoteProcessId, int tag);
  int Send(const long* data, vtkIdType length, int remoteProcessId, int tag);
  int Send(const signed char* data, vtkIdType length, int remoteProcessId, int tag);
  int Send(const char* data, vtkIdType length, int remoteProcessId, int tag);
  int Send(const unsigned char* data, vtkIdType length, int remoteProcessId, int tag);
  int Send(const float* data, vtkIdType length, int remoteProcessId, int tag);
  int Send(const double* data, vtkIdType length, int remoteProcessId, int tag);
  int Send(const long long* data, vtkIdType length, int remoteProcessId, int tag);
  int Send(const unsigned long long* data, vtkIdType length, int remoteProcessId, int tag);
  int Send(vtkDataObject* data, int remoteId, int tag);
  int Send(vtkDataArray* data, int remoteId, int tag);
 
  int Send(const vtkMultiProcessStream& stream, int remoteId, int tag);
 
 
  int Receive(int* data, vtkIdType maxlength, int remoteProcessId, int tag);
  int Receive(unsigned int* data, vtkIdType maxlength, int remoteProcessId, int tag);
  int Receive(short* data, vtkIdType maxlength, int remoteProcessId, int tag);
  int Receive(unsigned short* data, vtkIdType maxlength, int remoteProcessId, int tag);
  int Receive(long* data, vtkIdType maxlength, int remoteProcessId, int tag);
  int Receive(unsigned long* data, vtkIdType maxlength, int remoteProcessId, int tag);
  int Receive(char* data, vtkIdType maxlength, int remoteProcessId, int tag);
  int Receive(unsigned char* data, vtkIdType maxlength, int remoteProcessId, int tag);
  int Receive(signed char* data, vtkIdType maxlength, int remoteProcessId, int tag);
  int Receive(float* data, vtkIdType maxlength, int remoteProcessId, int tag);
  int Receive(double* data, vtkIdType maxlength, int remoteProcessId, int tag);
  int Receive(long long* data, vtkIdType maxLength, int remoteProcessId, int tag);
  int Receive(unsigned long long* data, vtkIdType maxLength, int remoteProcessId, int tag);
  int Receive(vtkDataObject* data, int remoteId, int tag);
  int Receive(vtkDataArray* data, int remoteId, int tag);
 
  int Receive(vtkMultiProcessStream& stream, int remoteId, int tag);
 
  vtkDataObject* ReceiveDataObject(int remoteId, int tag);
 
  vtkIdType GetCount();
 
  //---------------------- Collective Operations ----------------------
 
 
  int Broadcast(int* data, vtkIdType length, int srcProcessId)
  {
    return this->Communicator->Broadcast(data, length, srcProcessId);
  }
  int Broadcast(unsigned int* data, vtkIdType length, int srcProcessId)
  {
    return this->Communicator->Broadcast(data, length, srcProcessId);
  }
  int Broadcast(short* data, vtkIdType length, int srcProcessId)
  {
    return this->Communicator->Broadcast(data, length, srcProcessId);
  }
  int Broadcast(unsigned short* data, vtkIdType length, int srcProcessId)
  {
    return this->Communicator->Broadcast(data, length, srcProcessId);
  }
  int Broadcast(long* data, vtkIdType length, int srcProcessId)
  {
    return this->Communicator->Broadcast(data, length, srcProcessId);
  }
  int Broadcast(unsigned long* data, vtkIdType length, int srcProcessId)
  {
    return this->Communicator->Broadcast(data, length, srcProcessId);
  }
  int Broadcast(unsigned char* data, vtkIdType length, int srcProcessId)
  {
    return this->Communicator->Broadcast(data, length, srcProcessId);
  }
  int Broadcast(char* data, vtkIdType length, int srcProcessId)
  {
    return this->Communicator->Broadcast(data, length, srcProcessId);
  }
  int Broadcast(signed char* data, vtkIdType length, int srcProcessId)
  {
    return this->Communicator->Broadcast(data, length, srcProcessId);
  }
  int Broadcast(float* data, vtkIdType length, int srcProcessId)
  {
    return this->Communicator->Broadcast(data, length, srcProcessId);
  }
  int Broadcast(double* data, vtkIdType length, int srcProcessId)
  {
    return this->Communicator->Broadcast(data, length, srcProcessId);
  }
  int Broadcast(long long* data, vtkIdType length, int srcProcessId)
  {
    return this->Communicator->Broadcast(data, length, srcProcessId);
  }
  int Broadcast(unsigned long long* data, vtkIdType length, int srcProcessId)
  {
    return this->Communicator->Broadcast(data, length, srcProcessId);
  }
  int Broadcast(vtkDataObject* data, int srcProcessId)
  {
    return this->Communicator->Broadcast(data, srcProcessId);
  }
  int Broadcast(vtkDataArray* data, int srcProcessId)
  {
    return this->Communicator->Broadcast(data, srcProcessId);
  }
 
  int Broadcast(vtkMultiProcessStream& stream, int srcProcessId)
  {
    return this->Communicator->Broadcast(stream, srcProcessId);
  }
 
 
  int Gather(const int* sendBuffer, int* recvBuffer, vtkIdType length, int destProcessId)
  {
    return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
  }
  int Gather(
    const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType length, int destProcessId)
  {
    return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
  }
  int Gather(const short* sendBuffer, short* recvBuffer, vtkIdType length, int destProcessId)
  {
    return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
  }
  int Gather(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType length,
    int destProcessId)
  {
    return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
  }
  int Gather(const long* sendBuffer, long* recvBuffer, vtkIdType length, int destProcessId)
  {
    return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
  }
  int Gather(
    const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length, int destProcessId)
  {
    return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
  }
  int Gather(
    const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType length, int destProcessId)
  {
    return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
  }
  int Gather(const char* sendBuffer, char* recvBuffer, vtkIdType length, int destProcessId)
  {
    return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
  }
  int Gather(
    const signed char* sendBuffer, signed char* recvBuffer, vtkIdType length, int destProcessId)
  {
    return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
  }
  int Gather(const float* sendBuffer, float* recvBuffer, vtkIdType length, int destProcessId)
  {
    return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
  }
  int Gather(const double* sendBuffer, double* recvBuffer, vtkIdType length, int destProcessId)
  {
    return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
  }
  int Gather(
    const long long* sendBuffer, long long* recvBuffer, vtkIdType length, int destProcessId)
  {
    return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
  }
  int Gather(const unsigned long long* sendBuffer, unsigned long long* recvBuffer, vtkIdType length,
    int destProcessId)
  {
    return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
  }
  int Gather(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, int destProcessId)
  {
    return this->Communicator->Gather(sendBuffer, recvBuffer, destProcessId);
  }
 
  int Gather(vtkDataObject* sendBuffer, std::vector<vtkSmartPointer<vtkDataObject>>& recvBuffer,
    int destProcessId)
  {
    return this->Communicator->Gather(sendBuffer, recvBuffer, destProcessId);
  }
 
  int Gather(const vtkMultiProcessStream& sendBuffer,
    std::vector<vtkMultiProcessStream>& recvBuffer, int destProcessId)
  {
    return this->Communicator->Gather(sendBuffer, recvBuffer, destProcessId);
  }
 
 
  int GatherV(const int* sendBuffer, int* recvBuffer, vtkIdType sendLength, vtkIdType* recvLengths,
    vtkIdType* offsets, int destProcessId)
  {
    return this->Communicator->GatherV(
      sendBuffer, recvBuffer, sendLength, recvLengths, offsets, destProcessId);
  }
  int GatherV(const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
  {
    return this->Communicator->GatherV(
      sendBuffer, recvBuffer, sendLength, recvLengths, offsets, destProcessId);
  }
  int GatherV(const short* sendBuffer, short* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
  {
    return this->Communicator->GatherV(
      sendBuffer, recvBuffer, sendLength, recvLengths, offsets, destProcessId);
  }
  int GatherV(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
  {
    return this->Communicator->GatherV(
      sendBuffer, recvBuffer, sendLength, recvLengths, offsets, destProcessId);
  }
  int GatherV(const long* sendBuffer, long* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
  {
    return this->Communicator->GatherV(
      sendBuffer, recvBuffer, sendLength, recvLengths, offsets, destProcessId);
  }
  int GatherV(const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
  {
    return this->Communicator->GatherV(
      sendBuffer, recvBuffer, sendLength, recvLengths, offsets, destProcessId);
  }
  int GatherV(const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
  {
    return this->Communicator->GatherV(
      sendBuffer, recvBuffer, sendLength, recvLengths, offsets, destProcessId);
  }
  int GatherV(const char* sendBuffer, char* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
  {
    return this->Communicator->GatherV(
      sendBuffer, recvBuffer, sendLength, recvLengths, offsets, destProcessId);
  }
  int GatherV(const signed char* sendBuffer, signed char* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
  {
    return this->Communicator->GatherV(
      sendBuffer, recvBuffer, sendLength, recvLengths, offsets, destProcessId);
  }
  int GatherV(const float* sendBuffer, float* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
  {
    return this->Communicator->GatherV(
      sendBuffer, recvBuffer, sendLength, recvLengths, offsets, destProcessId);
  }
  int GatherV(const double* sendBuffer, double* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
  {
    return this->Communicator->GatherV(
      sendBuffer, recvBuffer, sendLength, recvLengths, offsets, destProcessId);
  }
  int GatherV(const long long* sendBuffer, long long* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
  {
    return this->Communicator->GatherV(
      sendBuffer, recvBuffer, sendLength, recvLengths, offsets, destProcessId);
  }
  int GatherV(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
    vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
  {
    return this->Communicator->GatherV(
      sendBuffer, recvBuffer, sendLength, recvLengths, offsets, destProcessId);
  }
 
  int GatherV(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, vtkIdType* recvLengths,
    vtkIdType* offsets, int destProcessId)
  {
    return this->Communicator->GatherV(sendBuffer, recvBuffer, recvLengths, offsets, destProcessId);
  }
  int GatherV(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, vtkIdTypeArray* recvLengths,
    vtkIdTypeArray* offsets, int destProcessId)
  {
    return this->Communicator->GatherV(sendBuffer, recvBuffer, recvLengths, offsets, destProcessId);
  }
 
 
  int GatherV(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, int destProcessId)
  {
    return this->Communicator->GatherV(sendBuffer, recvBuffer, destProcessId);
  }
  int GatherV(vtkDataObject* sendData, vtkSmartPointer<vtkDataObject>* recvData, int destProcessId)
  {
    return this->Communicator->GatherV(sendData, recvData, destProcessId);
  }
 
 
  int Scatter(const int* sendBuffer, int* recvBuffer, vtkIdType length, int srcProcessId)
  {
    return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
  }
  int Scatter(
    const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType length, int srcProcessId)
  {
    return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
  }
  int Scatter(const short* sendBuffer, short* recvBuffer, vtkIdType length, int srcProcessId)
  {
    return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
  }
  int Scatter(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType length,
    int srcProcessId)
  {
    return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
  }
  int Scatter(const long* sendBuffer, long* recvBuffer, vtkIdType length, int srcProcessId)
  {
    return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
  }
  int Scatter(
    const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length, int srcProcessId)
  {
    return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
  }
  int Scatter(
    const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType length, int srcProcessId)
  {
    return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
  }
  int Scatter(const char* sendBuffer, char* recvBuffer, vtkIdType length, int srcProcessId)
  {
    return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
  }
  int Scatter(
    const signed char* sendBuffer, signed char* recvBuffer, vtkIdType length, int srcProcessId)
  {
    return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
  }
  int Scatter(const float* sendBuffer, float* recvBuffer, vtkIdType length, int srcProcessId)
  {
    return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
  }
  int Scatter(const double* sendBuffer, double* recvBuffer, vtkIdType length, int srcProcessId)
  {
    return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
  }
  int Scatter(
    const long long* sendBuffer, long long* recvBuffer, vtkIdType length, int srcProcessId)
  {
    return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
  }
  int Scatter(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
    vtkIdType length, int srcProcessId)
  {
    return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
  }
  int Scatter(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, int srcProcessId)
  {
    return this->Communicator->Scatter(sendBuffer, recvBuffer, srcProcessId);
  }
 
 
  int ScatterV(const int* sendBuffer, int* recvBuffer, vtkIdType* sendLengths, vtkIdType* offsets,
    vtkIdType recvLength, int srcProcessId)
  {
    return this->Communicator->ScatterV(
      sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
  }
  int ScatterV(const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType* sendLengths,
    vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
  {
    return this->Communicator->ScatterV(
      sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
  }
  int ScatterV(const short* sendBuffer, short* recvBuffer, vtkIdType* sendLengths,
    vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
  {
    return this->Communicator->ScatterV(
      sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
  }
  int ScatterV(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType* sendLengths,
    vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
  {
    return this->Communicator->ScatterV(
      sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
  }
  int ScatterV(const long* sendBuffer, long* recvBuffer, vtkIdType* sendLengths, vtkIdType* offsets,
    vtkIdType recvLength, int srcProcessId)
  {
    return this->Communicator->ScatterV(
      sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
  }
  int ScatterV(const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType* sendLengths,
    vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
  {
    return this->Communicator->ScatterV(
      sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
  }
  int ScatterV(const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType* sendLengths,
    vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
  {
    return this->Communicator->ScatterV(
      sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
  }
  int ScatterV(const char* sendBuffer, char* recvBuffer, vtkIdType* sendLengths, vtkIdType* offsets,
    vtkIdType recvLength, int srcProcessId)
  {
    return this->Communicator->ScatterV(
      sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
  }
  int ScatterV(const signed char* sendBuffer, signed char* recvBuffer, vtkIdType* sendLengths,
    vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
  {
    return this->Communicator->ScatterV(
      sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
  }
  int ScatterV(const float* sendBuffer, float* recvBuffer, vtkIdType* sendLengths,
    vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
  {
    return this->Communicator->ScatterV(
      sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
  }
  int ScatterV(const double* sendBuffer, double* recvBuffer, vtkIdType* sendLengths,
    vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
  {
    return this->Communicator->ScatterV(
      sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
  }
  int ScatterV(const long long* sendBuffer, long long* recvBuffer, vtkIdType* sendLengths,
    vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
  {
    return this->Communicator->ScatterV(
      sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
  }
  int ScatterV(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
    vtkIdType* sendLengths, vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
  {
    return this->Communicator->ScatterV(
      sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
  }
 
 
  int AllGather(const int* sendBuffer, int* recvBuffer, vtkIdType length)
  {
    return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
  }
  int AllGather(const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType length)
  {
    return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
  }
  int AllGather(const short* sendBuffer, short* recvBuffer, vtkIdType length)
  {
    return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
  }
  int AllGather(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType length)
  {
    return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
  }
  int AllGather(const long* sendBuffer, long* recvBuffer, vtkIdType length)
  {
    return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
  }
  int AllGather(const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length)
  {
    return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
  }
  int AllGather(const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType length)
  {
    return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
  }
  int AllGather(const char* sendBuffer, char* recvBuffer, vtkIdType length)
  {
    return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
  }
  int AllGather(const signed char* sendBuffer, signed char* recvBuffer, vtkIdType length)
  {
    return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
  }
  int AllGather(const float* sendBuffer, float* recvBuffer, vtkIdType length)
  {
    return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
  }
  int AllGather(const double* sendBuffer, double* recvBuffer, vtkIdType length)
  {
    return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
  }
  int AllGather(const long long* sendBuffer, long long* recvBuffer, vtkIdType length)
  {
    return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
  }
  int AllGather(
    const unsigned long long* sendBuffer, unsigned long long* recvBuffer, vtkIdType length)
  {
    return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
  }
  int AllGather(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer)
  {
    return this->Communicator->AllGather(sendBuffer, recvBuffer);
  }
 
  int AllGather(vtkDataObject* sendBuffer, std::vector<vtkSmartPointer<vtkDataObject>>& recvBuffer)
  {
    return this->Communicator->AllGather(sendBuffer, recvBuffer);
  }
 
  int AllGather(
    const vtkMultiProcessStream& sendBuffer, std::vector<vtkMultiProcessStream>& recvBuffer)
  {
    return this->Communicator->AllGather(sendBuffer, recvBuffer);
  }
 
 
  int AllGatherV(const int* sendBuffer, int* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets)
  {
    return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
  }
  int AllGatherV(const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets)
  {
    return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
  }
  int AllGatherV(const short* sendBuffer, short* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets)
  {
    return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
  }
  int AllGatherV(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets)
  {
    return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
  }
  int AllGatherV(const long* sendBuffer, long* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets)
  {
    return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
  }
  int AllGatherV(const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets)
  {
    return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
  }
  int AllGatherV(const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets)
  {
    return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
  }
  int AllGatherV(const char* sendBuffer, char* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets)
  {
    return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
  }
  int AllGatherV(const signed char* sendBuffer, signed char* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets)
  {
    return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
  }
  int AllGatherV(const float* sendBuffer, float* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets)
  {
    return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
  }
  int AllGatherV(const double* sendBuffer, double* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets)
  {
    return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
  }
  int AllGatherV(const long long* sendBuffer, long long* recvBuffer, vtkIdType sendLength,
    vtkIdType* recvLengths, vtkIdType* offsets)
  {
    return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
  }
  int AllGatherV(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
    vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets)
  {
    return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
  }
  int AllGatherV(
    vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, vtkIdType* recvLengths, vtkIdType* offsets)
  {
    return this->Communicator->AllGatherV(sendBuffer, recvBuffer, recvLengths, offsets);
  }
 
  int AllGatherV(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer)
  {
    return this->Communicator->AllGatherV(sendBuffer, recvBuffer);
  }
 
 
  int Reduce(
    const int* sendBuffer, int* recvBuffer, vtkIdType length, int operation, int destProcessId)
  {
    return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
  }
  int Reduce(const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType length,
    int operation, int destProcessId)
  {
    return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
  }
  int Reduce(
    const short* sendBuffer, short* recvBuffer, vtkIdType length, int operation, int destProcessId)
  {
    return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
  }
  int Reduce(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType length,
    int operation, int destProcessId)
  {
    return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
  }
  int Reduce(
    const long* sendBuffer, long* recvBuffer, vtkIdType length, int operation, int destProcessId)
  {
    return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
  }
  int Reduce(const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length,
    int operation, int destProcessId)
  {
    return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
  }
  int Reduce(const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType length,
    int operation, int destProcessId)
  {
    return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
  }
  int Reduce(
    const char* sendBuffer, char* recvBuffer, vtkIdType length, int operation, int destProcessId)
  {
    return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
  }
  int Reduce(const signed char* sendBuffer, signed char* recvBuffer, vtkIdType length,
    int operation, int destProcessId)
  {
    return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
  }
  int Reduce(
    const float* sendBuffer, float* recvBuffer, vtkIdType length, int operation, int destProcessId)
  {
    return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
  }
  int Reduce(const double* sendBuffer, double* recvBuffer, vtkIdType length, int operation,
    int destProcessId)
  {
    return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
  }
  int Reduce(const long long* sendBuffer, long long* recvBuffer, vtkIdType length, int operation,
    int destProcessId)
  {
    return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
  }
  int Reduce(const unsigned long long* sendBuffer, unsigned long long* recvBuffer, vtkIdType length,
    int operation, int destProcessId)
  {
    return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
  }
  int Reduce(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, int operation, int destProcessId)
  {
    return this->Communicator->Reduce(sendBuffer, recvBuffer, operation, destProcessId);
  }
 
 
  int Reduce(const int* sendBuffer, int* recvBuffer, vtkIdType length,
    vtkCommunicator::Operation* operation, int destProcessId)
  {
    return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
  }
  int Reduce(const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType length,
    vtkCommunicator::Operation* operation, int destProcessId)
  {
    return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
  }
  int Reduce(const short* sendBuffer, short* recvBuffer, vtkIdType length,
    vtkCommunicator::Operation* operation, int destProcessId)
  {
    return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
  }
  int Reduce(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType length,
    vtkCommunicator::Operation* operation, int destProcessId)
  {
    return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
  }
  int Reduce(const long* sendBuffer, long* recvBuffer, vtkIdType length,
    vtkCommunicator::Operation* operation, int destProcessId)
  {
    return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
  }
  int Reduce(const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length,
    vtkCommunicator::Operation* operation, int destProcessId)
  {
    return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
  }
  int Reduce(const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType length,
    vtkCommunicator::Operation* operation, int destProcessId)
  {
    return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
  }
  int Reduce(const char* sendBuffer, char* recvBuffer, vtkIdType length,
    vtkCommunicator::Operation* operation, int destProcessId)
  {
    return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
  }
  int Reduce(const signed char* sendBuffer, signed char* recvBuffer, vtkIdType length,
    vtkCommunicator::Operation* operation, int destProcessId)
  {
    return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
  }
  int Reduce(const float* sendBuffer, float* recvBuffer, vtkIdType length,
    vtkCommunicator::Operation* operation, int destProcessId)
  {
    return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
  }
  int Reduce(const double* sendBuffer, double* recvBuffer, vtkIdType length,
    vtkCommunicator::Operation* operation, int destProcessId)
  {
    return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
  }
  int Reduce(const long long* sendBuffer, long long* recvBuffer, vtkIdType length,
    vtkCommunicator::Operation* operation, int destProcessId)
  {
    return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
  }
  int Reduce(const unsigned long long* sendBuffer, unsigned long long* recvBuffer, vtkIdType length,
    vtkCommunicator::Operation* operation, int destProcessId)
  {
    return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
  }
  int Reduce(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer,
    vtkCommunicator::Operation* operation, int destProcessId)
  {
    return this->Communicator->Reduce(sendBuffer, recvBuffer, operation, destProcessId);
  }
 
 
  int AllReduce(const int* sendBuffer, int* recvBuffer, vtkIdType length, int operation)
  {
    return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
  }
  int AllReduce(
    const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType length, int operation)
  {
    return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
  }
  int AllReduce(const short* sendBuffer, short* recvBuffer, vtkIdType length, int operation)
  {
    return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
  }
  int AllReduce(
    const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType length, int operation)
  {
    return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
  }
  int AllReduce(const long* sendBuffer, long* recvBuffer, vtkIdType length, int operation)
  {
    return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
  }
  int AllReduce(
    const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length, int operation)
  {
    return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
  }
  int AllReduce(
    const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType length, int operation)
  {
    return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
  }
  int AllReduce(const char* sendBuffer, char* recvBuffer, vtkIdType length, int operation)
  {
    return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
  }
  int AllReduce(
    const signed char* sendBuffer, signed char* recvBuffer, vtkIdType length, int operation)
  {
    return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
  }
  int AllReduce(const float* sendBuffer, float* recvBuffer, vtkIdType length, int operation)
  {
    return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
  }
  int AllReduce(const double* sendBuffer, double* recvBuffer, vtkIdType length, int operation)
  {
    return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
  }
  int AllReduce(const long long* sendBuffer, long long* recvBuffer, vtkIdType length, int operation)
  {
    return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
  }
  int AllReduce(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
    vtkIdType length, int operation)
  {
    return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
  }
  int AllReduce(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, int operation)
  {
    return this->Communicator->AllReduce(sendBuffer, recvBuffer, operation);
  }
 
  int AllReduce(
    const int* sendBuffer, int* recvBuffer, vtkIdType length, vtkCommunicator::Operation* operation)
  {
    return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
  }
  int AllReduce(const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType length,
    vtkCommunicator::Operation* operation)
  {
    return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
  }
  int AllReduce(const short* sendBuffer, short* recvBuffer, vtkIdType length,
    vtkCommunicator::Operation* operation)
  {
    return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
  }
  int AllReduce(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType length,
    vtkCommunicator::Operation* operation)
  {
    return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
  }
  int AllReduce(const long* sendBuffer, long* recvBuffer, vtkIdType length,
    vtkCommunicator::Operation* operation)
  {
    return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
  }
  int AllReduce(const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length,
    vtkCommunicator::Operation* operation)
  {
    return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
  }
  int AllReduce(const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType length,
    vtkCommunicator::Operation* operation)
  {
    return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
  }
  int AllReduce(const char* sendBuffer, char* recvBuffer, vtkIdType length,
    vtkCommunicator::Operation* operation)
  {
    return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
  }
  int AllReduce(const signed char* sendBuffer, signed char* recvBuffer, vtkIdType length,
    vtkCommunicator::Operation* operation)
  {
    return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
  }
  int AllReduce(const float* sendBuffer, float* recvBuffer, vtkIdType length,
    vtkCommunicator::Operation* operation)
  {
    return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
  }
  int AllReduce(const double* sendBuffer, double* recvBuffer, vtkIdType length,
    vtkCommunicator::Operation* operation)
  {
    return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
  }
  int AllReduce(const long long* sendBuffer, long long* recvBuffer, vtkIdType length,
    vtkCommunicator::Operation* operation)
  {
    return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
  }
  int AllReduce(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
    vtkIdType length, vtkCommunicator::Operation* operation)
  {
    return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
  }
  int AllReduce(
    vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, vtkCommunicator::Operation* operation)
  {
    return this->Communicator->AllReduce(sendBuffer, recvBuffer, operation);
  }
 
 
  int Reduce(const vtkBoundingBox& sendBuffer, vtkBoundingBox& recvBuffer, int destProcessId);
  int AllReduce(const vtkBoundingBox& sendBuffer, vtkBoundingBox& recvBuffer);
 
 
  int Reduce(
    vtkDataArraySelection* sendBuffer, vtkDataArraySelection* recvBuffer, int destProcessId);
  int AllReduce(vtkDataArraySelection* sendBuffer, vtkDataArraySelection* recvBuffer);
 
  // Internally implemented RMI to break the process loop.
 
protected:
  vtkMultiProcessController();
  ~vtkMultiProcessController() override;
 
  virtual void TriggerRMIInternal(
    int remoteProcessId, void* arg, int argLength, int rmiTag, bool propagate);
 
  vtkProcessFunctionType SingleMethod;
  void* SingleData;
 
  void GetMultipleMethod(int index, vtkProcessFunctionType& func, void*& data);
 
  // This is a flag that can be used by the ports to break
  // their update loop. (same as ProcessRMIs)
  int BreakFlag;
 
  void ProcessRMI(int remoteProcessId, void* arg, int argLength, int rmiTag);
 
  // This method implements "GetGlobalController".
  // It needs to be virtual and static.
  virtual vtkMultiProcessController* GetLocalController();
 
  // This flag can force deep copies during send.
  int ForceDeepCopy;
 
  // This flag can be used to indicate that an MPI Broadcast will be used
  // when calling TriggerRMIOnAllChildren(), instead of the binary tree
  // propagation of the data to the satellite ranks from rank 0.
  bool BroadcastTriggerRMI;
 
  vtkOutputWindow* OutputWindow;
 
  // Note that since the communicators can be created differently
  // depending on the type of controller, the subclasses are
  // responsible of deleting them.
  vtkCommunicator* Communicator;
 
  // Communicator which is a copy of the current user
  // level communicator except the context; i.e. even if the tags
  // are the same, the RMI messages will not interfere with user
  // level messages.
  // Note that since the communicators can be created differently
  // depending on the type of controller, the subclasses are
  // responsible of deleting them.
  vtkCommunicator* RMICommunicator;
 
private:
  vtkMultiProcessController(const vtkMultiProcessController&) = delete;
  void operator=(const vtkMultiProcessController&) = delete;
 
  unsigned long RMICount;
 
  class vtkInternal;
  vtkInternal* Internal;
};
 
inline int vtkMultiProcessController::Send(vtkDataObject* data, int remoteProcessId, int tag)
{
  if (this->Communicator)
  {
    return this->Communicator->Send(data, remoteProcessId, tag);
  }
  else
  {
    return 0;
  }
}
 
inline int vtkMultiProcessController::Send(vtkDataArray* data, int remoteProcessId, int tag)
{
  if (this->Communicator)
  {
    return this->Communicator->Send(data, remoteProcessId, tag);
  }
  else
  {
    return 0;
  }
}
 
inline int vtkMultiProcessController::Send(
  const int* data, vtkIdType length, int remoteProcessId, int tag)
{
  if (this->Communicator)
  {
    return this->Communicator->Send(data, length, remoteProcessId, tag);
  }
  else
  {
    return 0;
  }
}
 
inline int vtkMultiProcessController::Send(
  const short* data, vtkIdType length, int remoteProcessId, int tag)
{
  if (this->Communicator)
  {
    return this->Communicator->Send(data, length, remoteProcessId, tag);
  }
  else
  {
    return 0;
  }
}
 
inline int vtkMultiProcessController::Send(
  const unsigned short* data, vtkIdType length, int remoteProcessId, int tag)
{
  if (this->Communicator)
  {
    return this->Communicator->Send(data, length, remoteProcessId, tag);
  }
  else
  {
    return 0;
  }
}
 
inline int vtkMultiProcessController::Send(
  const unsigned int* data, vtkIdType length, int remoteProcessId, int tag)
{
  if (this->Communicator)
  {
    return this->Communicator->Send(data, length, remoteProcessId, tag);
  }
  else
  {
    return 0;
  }
}
 
inline int vtkMultiProcessController::Send(
  const unsigned long* data, vtkIdType length, int remoteProcessId, int tag)
{
  if (this->Communicator)
  {
    return this->Communicator->Send(data, length, remoteProcessId, tag);
  }
  else
  {
    return 0;
  }
}
 
inline int vtkMultiProcessController::Send(
  const long* data, vtkIdType length, int remoteProcessId, int tag)
{
  if (this->Communicator)
  {
    return this->Communicator->Send(data, length, remoteProcessId, tag);
  }
  else
  {
    return 0;
  }
}
 
inline int vtkMultiProcessController::Send(
  const signed char* data, vtkIdType length, int remoteProcessId, int tag)
{
  if (this->Communicator)
  {
    return this->Communicator->Send(data, length, remoteProcessId, tag);
  }
  else
  {
    return 0;
  }
}
 
inline int vtkMultiProcessController::Send(
  const char* data, vtkIdType length, int remoteProcessId, int tag)
{
  if (this->Communicator)
  {
    return this->Communicator->Send(data, length, remoteProcessId, tag);
  }
  else
  {
    return 0;
  }
}
 
inline int vtkMultiProcessController::Send(
  const unsigned char* data, vtkIdType length, int remoteProcessId, int tag)
{
  if (this->Communicator)
  {
    return this->Communicator->Send(data, length, remoteProcessId, tag);
  }
  else
  {
    return 0;
  }
}
 
inline int vtkMultiProcessController::Send(
  const float* data, vtkIdType length, int remoteProcessId, int tag)
{
  if (this->Communicator)
  {
    return this->Communicator->Send(data, length, remoteProcessId, tag);
  }
  else
  {
    return 0;
  }
}
 
inline int vtkMultiProcessController::Send(
  const double* data, vtkIdType length, int remoteProcessId, int tag)
{
  if (this->Communicator)
  {
    return this->Communicator->Send(data, length, remoteProcessId, tag);
  }
  else
  {
    return 0;
  }
}
 
inline int vtkMultiProcessController::Send(
  const long long* data, vtkIdType length, int remoteProcessId, int tag)
{
  if (this->Communicator)
  {
    return this->Communicator->Send(data, length, remoteProcessId, tag);
  }
  else
  {
    return 0;
  }
}
 
inline int vtkMultiProcessController::Send(
  const unsigned long long* data, vtkIdType length, int remoteProcessId, int tag)
{
  if (this->Communicator)
  {
    return this->Communicator->Send(data, length, remoteProcessId, tag);
  }
  else
  {
    return 0;
  }
}
 
inline int vtkMultiProcessController::Send(
  const vtkMultiProcessStream& stream, int remoteId, int tag)
{
  if (this->Communicator)
  {
    return this->Communicator->Send(stream, remoteId, tag);
  }
  return 0;
}
 
inline int vtkMultiProcessController::Receive(vtkDataObject* data, int remoteProcessId, int tag)
{
  if (this->Communicator)
  {
    return this->Communicator->Receive(data, remoteProcessId, tag);
  }
  else
  {
    return 0;
  }
}
 
inline vtkDataObject* vtkMultiProcessController::ReceiveDataObject(int remoteProcessId, int tag)
{
  if (this->Communicator)
  {
    return this->Communicator->ReceiveDataObject(remoteProcessId, tag);
  }
  else
  {
    return nullptr;
  }
}
 
inline int vtkMultiProcessController::Receive(vtkDataArray* data, int remoteProcessId, int tag)
{
  if (this->Communicator)
  {
    return this->Communicator->Receive(data, remoteProcessId, tag);
  }
  else
  {
    return 0;
  }
}
 
inline int vtkMultiProcessController::Receive(
  int* data, vtkIdType length, int remoteProcessId, int tag)
{
  if (this->Communicator)
  {
    return this->Communicator->Receive(data, length, remoteProcessId, tag);
  }
  else
  {
    return 0;
  }
}
 
inline int vtkMultiProcessController::Receive(
  unsigned int* data, vtkIdType length, int remoteProcessId, int tag)
{
  if (this->Communicator)
  {
    return this->Communicator->Receive(data, length, remoteProcessId, tag);
  }
  else
  {
    return 0;
  }
}
 
inline int vtkMultiProcessController::Receive(
  short* data, vtkIdType length, int remoteProcessId, int tag)
{
  if (this->Communicator)
  {
    return this->Communicator->Receive(data, length, remoteProcessId, tag);
  }
  else
  {
    return 0;
  }
}
 
inline int vtkMultiProcessController::Receive(
  unsigned short* data, vtkIdType length, int remoteProcessId, int tag)
{
  if (this->Communicator)
  {
    return this->Communicator->Receive(data, length, remoteProcessId, tag);
  }
  else
  {
    return 0;
  }
}
 
inline int vtkMultiProcessController::Receive(
  long* data, vtkIdType length, int remoteProcessId, int tag)
{
  if (this->Communicator)
  {
    return this->Communicator->Receive(data, length, remoteProcessId, tag);
  }
  else
  {
    return 0;
  }
}
 
inline int vtkMultiProcessController::Receive(
  unsigned long* data, vtkIdType length, int remoteProcessId, int tag)
{
  if (this->Communicator)
  {
    return this->Communicator->Receive(data, length, remoteProcessId, tag);
  }
  else
  {
    return 0;
  }
}
 
inline int vtkMultiProcessController::Receive(
  char* data, vtkIdType length, int remoteProcessId, int tag)
{
  if (this->Communicator)
  {
    return this->Communicator->Receive(data, length, remoteProcessId, tag);
  }
  else
  {
    return 0;
  }
}
 
inline int vtkMultiProcessController::Receive(
  unsigned char* data, vtkIdType length, int remoteProcessId, int tag)
{
  if (this->Communicator)
  {
    return this->Communicator->Receive(data, length, remoteProcessId, tag);
  }
  else
  {
    return 0;
  }
}
 
inline int vtkMultiProcessController::Receive(
  signed char* data, vtkIdType length, int remoteProcessId, int tag)
{
  if (this->Communicator)
  {
    return this->Communicator->Receive(data, length, remoteProcessId, tag);
  }
  else
  {
    return 0;
  }
}
 
inline int vtkMultiProcessController::Receive(
  float* data, vtkIdType length, int remoteProcessId, int tag)
{
  if (this->Communicator)
  {
    return this->Communicator->Receive(data, length, remoteProcessId, tag);
  }
  else
  {
    return 0;
  }
}
 
inline int vtkMultiProcessController::Receive(
  double* data, vtkIdType length, int remoteProcessId, int tag)
{
  if (this->Communicator)
  {
    return this->Communicator->Receive(data, length, remoteProcessId, tag);
  }
  else
  {
    return 0;
  }
}
 
inline int vtkMultiProcessController::Receive(
  long long* data, vtkIdType length, int remoteProcessId, int tag)
{
  if (this->Communicator)
  {
    return this->Communicator->Receive(data, length, remoteProcessId, tag);
  }
  else
  {
    return 0;
  }
}
 
inline int vtkMultiProcessController::Receive(
  unsigned long long* data, vtkIdType length, int remoteProcessId, int tag)
{
  if (this->Communicator)
  {
    return this->Communicator->Receive(data, length, remoteProcessId, tag);
  }
  else
  {
    return 0;
  }
}
 
inline int vtkMultiProcessController::Receive(vtkMultiProcessStream& stream, int remoteId, int tag)
{
  if (this->Communicator)
  {
    return this->Communicator->Receive(stream, remoteId, tag);
  }
  return 0;
}
 
inline void vtkMultiProcessController::Barrier()
{
  if (this->Communicator)
  {
    this->Communicator->Barrier();
  }
}
 
inline vtkIdType vtkMultiProcessController::GetCount()
{
  if (this->Communicator)
  {
    return this->Communicator->GetCount();
  }
  return 0;
}
 
VTK_ABI_NAMESPACE_END
#endif