/usr/include/vtk-5.8/vtkMPIController.h is in libvtk5-dev 5.8.0-5.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 | /*=========================================================================
Program: Visualization Toolkit
Module: vtkMPIController.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.
=========================================================================*/
// .NAME vtkMPIController - Process communication using MPI
// .SECTION Description
// vtkMPIController is a concrete class which implements the
// abstract multi-process control methods defined in vtkMultiProcessController
// using MPI (Message Passing Interface)
// cf. Using MPI / Portable Parallel Programming with the Message-Passing
// Interface, Gropp et al, MIT Press.
// It also provide functionality specific to MPI and not present in
// vtkMultiProcessController.
// Before any MPI communication can occur Initialize() must be called
// by all processes. It is required to be called once, controllers
// created after this need not call Initialize().
// At the end of the program Finalize() must be called by all
// processes.
//
// The use of user-defined communicators are supported with the
// CreateSubController method. Note that a duplicate of the user defined
// communicator is used for internal communications (RMIs). This communicator
// has the same properties as the user one except that it has a new context
// which prevents the two communicators from interfering with each other.
// .SECTION see also
// vtkOutputPort vtkInputPort vtkMultiProcessController
// vtkMPICommunicator vtkProcessGroup
#ifndef __vtkMPIController_h
#define __vtkMPIController_h
#include "vtkMultiProcessController.h"
// 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
class VTK_PARALLEL_EXPORT vtkMPIController : public vtkMultiProcessController
{
public:
static vtkMPIController *New();
vtkTypeMacro(vtkMPIController,vtkMultiProcessController);
void PrintSelf(ostream& os, vtkIndent indent);
// Description:
// This method is for setting up the processes.
// It needs to be called only once during program execution.
// Calling it more than once will have no effect. Controllers
// created after this call will be initialized automatically
// (i.e. they will have the proper LocalProcessId and NumberOfProcesses).
// The addresses of argc and argv should be passed to this method
// otherwise command line arguments will not be correct (because
// usually MPI implementations add their own arguments during
// startup).
virtual void Initialize(int* argc, char*** argv)
{ this->Initialize(argc, argv, 0); }
virtual void Initialize(int* vtkNotUsed(argc), char*** vtkNotUsed(argv),
int initializedExternally);
// Description:
// Same as Initialize(0, 0, 1). Mainly for calling from wrapped languages.
virtual void Initialize();
// Description:
// This method is for cleaning up and has to be called before
// the end of the program if MPI was initialized with
//Initialize()
virtual void Finalize() { this->Finalize(0); }
virtual void Finalize(int finalizedExternally);
// Description:
// Execute the SingleMethod (as define by SetSingleMethod) using
// this->NumberOfProcesses processes.
virtual void SingleMethodExecute();
// Description:
// Execute the MultipleMethods (as define by calling SetMultipleMethod
// for each of the required this->NumberOfProcesses methods) using
// this->NumberOfProcesses processes.
virtual void MultipleMethodExecute();
// Description:
// This method can be used to tell the controller to create
// a special output window in which all messages are preceded
// by the process id.
virtual void CreateOutputWindow();
// Description:
// Given an MPI error code, return a string which contains
// an error message. This string has to be freed by the user.
static char* ErrorString(int err);
// Description:
// MPIController uses this communicator in all sends and
// receives. By default, MPI_COMM_WORLD is used.
// THIS SHOULD ONLY BE CALLED ON THE PROCESSES INCLUDED
// IN THE COMMUNICATOR. FOR EXAMPLE, IF THE COMMUNICATOR
// CONTAINES PROCESSES 0 AND 1, INVOKING THIS METHOD ON
// ANY OTHER PROCESS WILL CAUSE AN MPI ERROR AND POSSIBLY
// LEAD TO A CRASH.
void SetCommunicator(vtkMPICommunicator* comm);
virtual vtkMPIController *CreateSubController(vtkProcessGroup *group);
virtual vtkMPIController *PartitionController(int localColor, int localKey);
//BTX
// Description:
// This method sends data to another process (non-blocking).
// Tag eliminates ambiguity when multiple sends or receives
// exist in the same process. The last argument,
// vtkMPICommunicator::Request& req can later be used (with
// req.Test() ) to test the success of the message.
// Note: These methods delegate to the communicator
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 float* data, int length, int remoteProcessId,
int tag, vtkMPICommunicator::Request& req)
{ return ((vtkMPICommunicator*)this->Communicator)->NoBlockSend
(data, length, remoteProcessId, tag, req); }
// Description:
// This method receives data from a corresponding send (non-blocking).
// The last argument,
// vtkMPICommunicator::Request& req can later be used (with
// req.Test() ) to test the success of the message.
// Note: These methods delegate to the communicator
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(float* data, int length, int remoteProcessId,
int tag, vtkMPICommunicator::Request& req)
{ return ((vtkMPICommunicator*)this->Communicator)->NoBlockReceive
(data, length, remoteProcessId, tag, req); }
#ifdef VTK_USE_64BIT_IDS
int NoBlockReceive(vtkIdType* data, int length, int remoteProcessId,
int tag, vtkMPICommunicator::Request& req)
{ return ((vtkMPICommunicator*)this->Communicator)->NoBlockReceive
(data, length, remoteProcessId, tag, req); }
#endif
//ETX
static const char* GetProcessorName();
// Description:
// When set to 1, TriggerRMI uses Ssend() instead of Send() calls.
// Off (0) by default.
static void SetUseSsendForRMI(int use_send)
{ vtkMPIController::UseSsendForRMI = (use_send != 0)? 1: 0; }
static int GetUseSsendForRMI() { return vtkMPIController::UseSsendForRMI; }
//BTX
protected:
vtkMPIController();
~vtkMPIController();
// Set the communicator to comm and call InitializeNumberOfProcesses()
void InitializeCommunicator(vtkMPICommunicator* comm);
// Duplicate the current communicator, creating RMICommunicator
void InitializeRMICommunicator();
// Description:
// Implementation for TriggerRMI() provides subclasses an opportunity to
// modify the behaviour eg. MPIController provides ability to use Ssend
// instead of Send.
virtual void TriggerRMIInternal(int remoteProcessId,
void* arg, int argLength, int rmiTag, bool propagate);
// 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[];
// Description:
// When set, TriggerRMI uses Ssend instead of Send.
static int UseSsendForRMI;
private:
vtkMPIController(const vtkMPIController&); // Not implemented.
void operator=(const vtkMPIController&); // Not implemented.
//ETX
};
#endif
|