vtkMPIController.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef vtkMPIController_h
#define vtkMPIController_h
 
#include "vtkMultiProcessController.h"
#include "vtkParallelMPIModule.h" // For export macro
#include "vtkTypeList.h"          // For vtkTypeList
// Do not remove this header file. This class contains methods
// which take arguments defined in  vtkMPICommunicator.h by
// reference.
#include "vtkMPICommunicator.h" // Needed for direct access to communicator
 
VTK_ABI_NAMESPACE_BEGIN
class vtkIntArray;
 
class VTKPARALLELMPI_EXPORT vtkMPIController : public vtkMultiProcessController
{
 
public:
  static vtkMPIController* New();
  vtkTypeMacro(vtkMPIController, vtkMultiProcessController);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  using ValueTypes =
    vtkTypeList::Create<float, double, char, int, vtkTypeInt64, unsigned char, unsigned long>;

  void Initialize(int* argc, char*** argv) override { this->Initialize(argc, argv, 0); }
 
  void Initialize(
    int* vtkNotUsed(argc), char*** vtkNotUsed(argv), int initializedExternally) override;

  virtual void Initialize();

  void Finalize() override { this->Finalize(0); }
 
  void Finalize(int finalizedExternally) override;

  void SingleMethodExecute() override;

  void MultipleMethodExecute() override;

  void CreateOutputWindow() override;

  static char* ErrorString(int err);

  void SetCommunicator(vtkMPICommunicator* comm);
 
  vtkMPIController* CreateSubController(vtkProcessGroup* group) override;
 
  vtkMPIController* PartitionController(int localColor, int localKey) override;


  int NoBlockSend(
    const int* data, int length, int remoteProcessId, int tag, vtkMPICommunicator::Request& req)
  {
    return ((vtkMPICommunicator*)this->Communicator)
      ->NoBlockSend(data, length, remoteProcessId, tag, req);
  }
  int NoBlockSend(const unsigned long* data, int length, int remoteProcessId, int tag,
    vtkMPICommunicator::Request& req)
  {
    return ((vtkMPICommunicator*)this->Communicator)
      ->NoBlockSend(data, length, remoteProcessId, tag, req);
  }
  int NoBlockSend(
    const char* data, int length, int remoteProcessId, int tag, vtkMPICommunicator::Request& req)
  {
    return ((vtkMPICommunicator*)this->Communicator)
      ->NoBlockSend(data, length, remoteProcessId, tag, req);
  }
  int NoBlockSend(const unsigned char* data, int length, int remoteProcessId, int tag,
    vtkMPICommunicator::Request& req)
  {
    return ((vtkMPICommunicator*)this->Communicator)
      ->NoBlockSend(data, length, remoteProcessId, tag, req);
  }
  int NoBlockSend(
    const float* data, int length, int remoteProcessId, int tag, vtkMPICommunicator::Request& req)
  {
    return ((vtkMPICommunicator*)this->Communicator)
      ->NoBlockSend(data, length, remoteProcessId, tag, req);
  }
  int NoBlockSend(
    const double* data, int length, int remoteProcessId, int tag, vtkMPICommunicator::Request& req)
  {
    return ((vtkMPICommunicator*)this->Communicator)
      ->NoBlockSend(data, length, remoteProcessId, tag, req);
  }
  int NoBlockSend(const vtkTypeInt64* data, int length, int remoteProcessId, int tag,
    vtkMPICommunicator::Request& req)
  {
    return ((vtkMPICommunicator*)this->Communicator)
      ->NoBlockSend(data, length, remoteProcessId, tag, req);
  }
  int NoBlockSend(const int* data, vtkTypeInt64 length, int remoteProcessId, int tag,
    vtkMPICommunicator::Request& req)
  {
    return ((vtkMPICommunicator*)this->Communicator)
      ->NoBlockSend(data, length, remoteProcessId, tag, req);
  }
  int NoBlockSend(const unsigned long* data, vtkTypeInt64 length, int remoteProcessId, int tag,
    vtkMPICommunicator::Request& req)
  {
    return ((vtkMPICommunicator*)this->Communicator)
      ->NoBlockSend(data, length, remoteProcessId, tag, req);
  }
  int NoBlockSend(const char* data, vtkTypeInt64 length, int remoteProcessId, int tag,
    vtkMPICommunicator::Request& req)
  {
    return ((vtkMPICommunicator*)this->Communicator)
      ->NoBlockSend(data, length, remoteProcessId, tag, req);
  }
  int NoBlockSend(const unsigned char* data, vtkTypeInt64 length, int remoteProcessId, int tag,
    vtkMPICommunicator::Request& req)
  {
    return ((vtkMPICommunicator*)this->Communicator)
      ->NoBlockSend(data, length, remoteProcessId, tag, req);
  }
  int NoBlockSend(const float* data, vtkTypeInt64 length, int remoteProcessId, int tag,
    vtkMPICommunicator::Request& req)
  {
    return ((vtkMPICommunicator*)this->Communicator)
      ->NoBlockSend(data, length, remoteProcessId, tag, req);
  }
  int NoBlockSend(const double* data, vtkTypeInt64 length, int remoteProcessId, int tag,
    vtkMPICommunicator::Request& req)
  {
    return ((vtkMPICommunicator*)this->Communicator)
      ->NoBlockSend(data, length, remoteProcessId, tag, req);
  }
  int NoBlockSend(const vtkTypeInt64* data, vtkTypeInt64 length, int remoteProcessId, int tag,
    vtkMPICommunicator::Request& req)
  {
    return ((vtkMPICommunicator*)this->Communicator)
      ->NoBlockSend(data, length, remoteProcessId, tag, req);
  }


  int NoBlockSend(const void* data, vtkTypeInt64 length, MPI_Datatype mpiType, int remoteProcessId,
    int tag, vtkMPICommunicator::Request& req)
  {
    return ((vtkMPICommunicator*)this->Communicator)
      ->NoBlockSend(data, length, mpiType, remoteProcessId, tag, req);
  }


  int NoBlockReceive(
    int* data, int length, int remoteProcessId, int tag, vtkMPICommunicator::Request& req)
  {
    return ((vtkMPICommunicator*)this->Communicator)
      ->NoBlockReceive(data, length, remoteProcessId, tag, req);
  }
  int NoBlockReceive(
    unsigned long* data, int length, int remoteProcessId, int tag, vtkMPICommunicator::Request& req)
  {
    return ((vtkMPICommunicator*)this->Communicator)
      ->NoBlockReceive(data, length, remoteProcessId, tag, req);
  }
  int NoBlockReceive(
    char* data, int length, int remoteProcessId, int tag, vtkMPICommunicator::Request& req)
  {
    return ((vtkMPICommunicator*)this->Communicator)
      ->NoBlockReceive(data, length, remoteProcessId, tag, req);
  }
  int NoBlockReceive(
    unsigned char* data, int length, int remoteProcessId, int tag, vtkMPICommunicator::Request& req)
  {
    return ((vtkMPICommunicator*)this->Communicator)
      ->NoBlockReceive(data, length, remoteProcessId, tag, req);
  }
  int NoBlockReceive(
    float* data, int length, int remoteProcessId, int tag, vtkMPICommunicator::Request& req)
  {
    return ((vtkMPICommunicator*)this->Communicator)
      ->NoBlockReceive(data, length, remoteProcessId, tag, req);
  }
  int NoBlockReceive(
    double* data, int length, int remoteProcessId, int tag, vtkMPICommunicator::Request& req)
  {
    return ((vtkMPICommunicator*)this->Communicator)
      ->NoBlockReceive(data, length, remoteProcessId, tag, req);
  }
  int NoBlockReceive(
    vtkTypeInt64* data, int length, int remoteProcessId, int tag, vtkMPICommunicator::Request& req)
  {
    return ((vtkMPICommunicator*)this->Communicator)
      ->NoBlockReceive(data, length, remoteProcessId, tag, req);
  }
  int NoBlockReceive(
    int* data, vtkTypeInt64 length, int remoteProcessId, int tag, vtkMPICommunicator::Request& req)
  {
    return ((vtkMPICommunicator*)this->Communicator)
      ->NoBlockReceive(data, length, remoteProcessId, tag, req);
  }
  int NoBlockReceive(unsigned long* data, vtkTypeInt64 length, int remoteProcessId, int tag,
    vtkMPICommunicator::Request& req)
  {
    return ((vtkMPICommunicator*)this->Communicator)
      ->NoBlockReceive(data, length, remoteProcessId, tag, req);
  }
  int NoBlockReceive(
    char* data, vtkTypeInt64 length, int remoteProcessId, int tag, vtkMPICommunicator::Request& req)
  {
    return ((vtkMPICommunicator*)this->Communicator)
      ->NoBlockReceive(data, length, remoteProcessId, tag, req);
  }
  int NoBlockReceive(unsigned char* data, vtkTypeInt64 length, int remoteProcessId, int tag,
    vtkMPICommunicator::Request& req)
  {
    return ((vtkMPICommunicator*)this->Communicator)
      ->NoBlockReceive(data, length, remoteProcessId, tag, req);
  }
  int NoBlockReceive(float* data, vtkTypeInt64 length, int remoteProcessId, int tag,
    vtkMPICommunicator::Request& req)
  {
    return ((vtkMPICommunicator*)this->Communicator)
      ->NoBlockReceive(data, length, remoteProcessId, tag, req);
  }
  int NoBlockReceive(double* data, vtkTypeInt64 length, int remoteProcessId, int tag,
    vtkMPICommunicator::Request& req)
  {
    return ((vtkMPICommunicator*)this->Communicator)
      ->NoBlockReceive(data, length, remoteProcessId, tag, req);
  }
  int NoBlockReceive(vtkTypeInt64* data, vtkTypeInt64 length, int remoteProcessId, int tag,
    vtkMPICommunicator::Request& req)
  {
    return ((vtkMPICommunicator*)this->Communicator)
      ->NoBlockReceive(data, length, remoteProcessId, tag, req);
  }



  int Iprobe(int source, int tag, int* flag, int* actualSource)
  {
    return ((vtkMPICommunicator*)this->Communicator)->Iprobe(source, tag, flag, actualSource);
  }
  int Iprobe(int source, int tag, int* flag, int* actualSource, int* type, int* size)
  {
    return ((vtkMPICommunicator*)this->Communicator)
      ->Iprobe(source, tag, flag, actualSource, type, size);
  }
  int Iprobe(int source, int tag, int* flag, int* actualSource, unsigned long* type, int* size)
  {
    return ((vtkMPICommunicator*)this->Communicator)
      ->Iprobe(source, tag, flag, actualSource, type, size);
  }
  int Iprobe(int source, int tag, int* flag, int* actualSource, const char* type, int* size)
  {
    return ((vtkMPICommunicator*)this->Communicator)
      ->Iprobe(source, tag, flag, actualSource, type, size);
  }
  int Iprobe(int source, int tag, int* flag, int* actualSource, float* type, int* size)
  {
    return ((vtkMPICommunicator*)this->Communicator)
      ->Iprobe(source, tag, flag, actualSource, type, size);
  }
  int Iprobe(int source, int tag, int* flag, int* actualSource, double* type, int* size)
  {
    return ((vtkMPICommunicator*)this->Communicator)
      ->Iprobe(source, tag, flag, actualSource, type, size);
  }


  bool CanProbe() override { return ((vtkMPICommunicator*)this->Communicator)->CanProbe(); }


  int Probe(int source, int tag, int* actualSource) override
  {
    return ((vtkMPICommunicator*)this->Communicator)->Probe(source, tag, actualSource);
  }
  int Probe(int source, int tag, int* actualSource, int* type, int* size)
  {
    return ((vtkMPICommunicator*)this->Communicator)->Probe(source, tag, actualSource, type, size);
  }
  int Probe(int source, int tag, int* actualSource, unsigned long* type, int* size)
  {
    return ((vtkMPICommunicator*)this->Communicator)->Probe(source, tag, actualSource, type, size);
  }
  int Probe(int source, int tag, int* actualSource, const char* type, int* size)
  {
    return ((vtkMPICommunicator*)this->Communicator)->Probe(source, tag, actualSource, type, size);
  }
  int Probe(int source, int tag, int* actualSource, float* type, int* size)
  {
    return ((vtkMPICommunicator*)this->Communicator)->Probe(source, tag, actualSource, type, size);
  }
  int Probe(int source, int tag, int* actualSource, double* type, int* size)
  {
    return ((vtkMPICommunicator*)this->Communicator)->Probe(source, tag, actualSource, type, size);
  }


  int WaitAll(int count, vtkMPICommunicator::Request requests[])
  {
    return ((vtkMPICommunicator*)this->Communicator)->WaitAll(count, requests);
  }

  int WaitAny(int count, vtkMPICommunicator::Request requests[], int& idx)
    VTK_SIZEHINT(requests, count)
  {
    return ((vtkMPICommunicator*)this->Communicator)->WaitAny(count, requests, idx);
  }

  int WaitSome(int count, vtkMPICommunicator::Request requests[], vtkIntArray* completed)
    VTK_SIZEHINT(requests, count);

  bool TestAll(int count, vtkMPICommunicator::Request requests[]);

  bool TestAny(int count, vtkMPICommunicator::Request requests[], int& idx)
    VTK_SIZEHINT(requests, count);

  bool TestSome(int count, vtkMPICommunicator::Request requests[], vtkIntArray* completed)
    VTK_SIZEHINT(requests, count);
 
  static const char* GetProcessorName();

  static void SetUseSsendForRMI(int use_send)
  {
    vtkMPIController::UseSsendForRMI = (use_send != 0) ? 1 : 0;
  }
  static int GetUseSsendForRMI() { return vtkMPIController::UseSsendForRMI; }
 
protected:
  vtkMPIController();
  ~vtkMPIController() override;
 
  // Set the communicator to comm and call InitializeNumberOfProcesses()
  void InitializeCommunicator(vtkMPICommunicator* comm);
 
  // Duplicate the current communicator, creating RMICommunicator
  void InitializeRMICommunicator();

  void TriggerRMIInternal(
    int remoteProcessId, void* arg, int argLength, int rmiTag, bool propagate) override;
 
  // MPI communicator created when Initialize() called.
  // This is a copy of MPI_COMM_WORLD but uses a new
  // context, i.e. even if the tags are the same, the
  // RMI messages will not interfere with user level
  // messages.
  static vtkMPICommunicator* WorldRMICommunicator;
 
  friend class vtkMPIOutputWindow;
 
  // Initialize only once.
  static int Initialized;
 
  static char ProcessorName[];

  static int UseSsendForRMI;
 
private:
  vtkMPIController(const vtkMPIController&) = delete;
  void operator=(const vtkMPIController&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif