Main Page Class Hierarchy Alphabetical List Compound List File List Compound Members File Members Related Pages

# vtkMultiProcessController Class Reference

`#include <vtkMultiProcessController.h>`

Inheritance diagram for vtkMultiProcessController:

[legend]
Collaboration diagram for vtkMultiProcessController:

[legend]
List of all members.

## Detailed Description

Multiprocessing communication superclass.

Date:
  2002/08/12 15:20:30

Revision:
  1.18

vtkMultiProcessController is used to control multiple processes/threads in a shared memory/distributed computing environment. It has methods for executing single/multiple method(s) on multiple processors, triggering registered callbacks (Remote Methods) (AddRMI(), TriggerRMI()) and communication. Please note that the communication is done using the communicator which is accessible to the user. Therefore it is possible to get the communicator with GetCommunicator() and use it to send and receive data. This is the encoured communication method. The internal (RMI) communications are done using a second internal communicator (called RMICommunicator). For the threaded controllers, this is identical to the user communicator. However, for the MPI controller, this is a communicator which shares the same process group as the user communicator but uses a different context. Therefore, the user and the internal communications can not interfere with each other (even if the same message tag is used).

See also:
  vtkMPIController vtkThreadedController vtkInputPort vtkOutputPort vtkCommunicator vtkSharedMemoryCommunicator vtkMPICommunicator

Created by:
  - Martin, Ken

CVS contributions (if > 5%):
  - Martin, Ken (71%)
  - Lee, Jeff (10%)

CVS logs (CVSweb):
  - .`h` (`/Parallel/vtkMultiProcessController.h)`
  - .`cxx` (`/Parallel/vtkMultiProcessController.cxx)`

Examples:
  vtkMultiProcessController (Examples)

Tests:
  vtkMultiProcessController (Tests)

Definition at line 86 of file vtkMultiProcessController.h.

## [NOHEADER]
int | Receive (int *data, int length, int remoteProcessId, int tag)
int | Receive (unsigned long *data, int length, int remoteProcessId, int tag)
int | Receive (char *data, int length, int remoteProcessId, int tag)
int | Receive (unsigned char *data, int length, int remoteProcessId, int tag)
int | Receive (float *data, int length, int remoteProcessId, int tag)
int | Receive (double *data, int length, int remoteProcessId, int tag)
int | Receive (vtkDataObject *data, int remoteId, int tag)
int | Receive (vtkDataArray *data, int remoteId, int tag)
| vtkMultiProcessController ()
| ~vtkMultiProcessController ()
void | ProcessRMI (int remoteProcessId, void *arg, int argLength, int rmiTag)
virtual vtkMultiProcessController * | GetLocalController ()
int | MaximumNumberOfProcesses
int | NumberOfProcesses
int | LocalProcessId
vtkProcessFunctionType | SingleMethod
void * | SingleData
vtkProcessFunctionType | MultipleMethod [MAX_PROCESSES]
void * | MultipleData [MAX_PROCESSES]
vtkCollection * | RMIs
int | BreakFlag
int | ForceDeepCopy
vtkOutputWindow * | OutputWindow
vtkCommunicator * | Communicator
vtkCommunicator * | RMICommunicator
## Public Types
typedef vtkObject | Superclass
enum | Consts { MAX_PROCESSES = 8192, ANY_SOURCE = -1, INVALID_SOURCE = -2, RMI_TAG = 315167, RMI_ARG_TAG = 315168, BREAK_RMI_TAG = 239954 }
## Public Methods
virtual const char * | GetClassName ()
virtual int | IsA (const char *type)
void | PrintSelf (ostream &os, vtkIndent indent)
virtual void | Initialize (int *vtkNotUsed(argc), char ***vtkNotUsed(argv))=0
virtual void | Finalize ()=0
virtual void | Finalize (int finalizedExternally)=0
virtual void | SingleMethodExecute ()=0
virtual void | MultipleMethodExecute ()=0
virtual int | GetLocalProcessId ()
virtual void | CreateOutputWindow ()=0
void | AddRMI (vtkRMIFunctionType, void *localArg, int tag)
void | TriggerRMI (int remoteProcessId, void *arg, int argLength, int tag)
void | TriggerBreakRMIs ()
void | ProcessRMIs ()
virtual void | Barrier ()=0
virtual void | Initialize (int *vtkNotUsed(argc), char ***vtkNotUsed(argv), int initializedExternally)=0
virtual void | SetNumberOfProcesses (int num)
virtual int | GetNumberOfProcesses ()
void | SetSingleMethod (vtkProcessFunctionType, void *data)
void | SetMultipleMethod (int index, vtkProcessFunctionType, void *data)
virtual void | SetForceDeepCopy (int)
virtual int | GetForceDeepCopy ()
virtual void | ForceDeepCopyOn ()
virtual void | ForceDeepCopyOff ()
void | RemoveRMI (vtkRMIFunctionType f, void *arg, int tag)
void | TriggerRMI (int remoteProcessId, char *arg, int tag)
void | TriggerRMI (int remoteProcessId, int tag)
virtual void | SetBreakFlag (int)
virtual int | GetBreakFlag ()
virtual vtkCommunicator * | GetCommunicator ()
int | Send (int *data, int length, int remoteProcessId, int tag)
int | Send (unsigned long *data, int length, int remoteProcessId, int tag)
int | Send (char *data, int length, int remoteProcessId, int tag)
int | Send (unsigned char *data, int length, int remoteProcessId, int tag)
int | Send (float *data, int length, int remoteProcessId, int tag)
int | Send (double *data, int length, int remoteProcessId, int tag)
int | Send (vtkDataObject *data, int remoteId, int tag)
int | Send (vtkDataArray *data, int remoteId, int tag)
## Static Public Methods
vtkMultiProcessController * | New ()
int | IsTypeOf (const char *type)
vtkMultiProcessController * | SafeDownCast (vtkObject *o)
vtkMultiProcessController * | GetGlobalController ()
void | SetGlobalController (vtkMultiProcessController *controller)

## Member Typedef Documentation

typedef vtkObject vtkMultiProcessController::Superclass

| Reimplemented from vtkObject. Reimplemented in vtkDummyController, vtkMPIController, vtkSocketController, and vtkThreadedController. Definition at line 90 of file vtkMultiProcessController.h.

## Member Enumeration Documentation

enum vtkMultiProcessController::Consts

  | Enumeration values:
  MAX_PROCESSES |
  ANY_SOURCE |
  INVALID_SOURCE |
  RMI_TAG |
  RMI_ARG_TAG |
  BREAK_RMI_TAG |
Reimplemented in vtkSocketController. Definition at line 231 of file vtkMultiProcessController.h.

## Constructor & Destructor Documentation

vtkMultiProcessController::vtkMultiProcessController | ( |  | ) | `[protected]`

| This method receives data from a corresponding send. It blocks until the receive is finished. It calls methods in "data" to communicate the sending data.

vtkMultiProcessController::~vtkMultiProcessController | ( |  | ) | `[protected]`

| This method receives data from a corresponding send. It blocks until the receive is finished. It calls methods in "data" to communicate the sending data.

## Member Function Documentation

vtkMultiProcessController* vtkMultiProcessController::New | ( |  | ) | `[static]`

| Create an object with Debug turned off, modified time initialized to zero, and reference counting on. Reimplemented from vtkObject. Reimplemented in vtkDummyController, vtkMPIController, vtkSocketController, and vtkThreadedController.

virtual const char* vtkMultiProcessController::GetClassName | ( |  | ) | `[virtual]`

| Reimplemented from vtkObject. Reimplemented in vtkDummyController, vtkMPIController, vtkSocketController, and vtkThreadedController.

int vtkMultiProcessController::IsTypeOf | ( | const char * | type | ) | `[static]`

| Return 1 if this class type is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeRevisionMacro found in vtkSetGet.h. Reimplemented from vtkObject. Reimplemented in vtkDummyController, vtkMPIController, vtkSocketController, and vtkThreadedController.

virtual int vtkMultiProcessController::IsA | ( | const char * | type | ) | `[virtual]`

| Return 1 if this class is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeRevisionMacro found in vtkSetGet.h. Reimplemented from vtkObject. Reimplemented in vtkDummyController, vtkMPIController, vtkSocketController, and vtkThreadedController.

vtkMultiProcessController* vtkMultiProcessController::SafeDownCast | ( | vtkObject * | o | ) | `[static]`

| Reimplemented from vtkObject. Reimplemented in vtkDummyController, vtkMPIController, vtkSocketController, and vtkThreadedController.

void vtkMultiProcessController::PrintSelf | ( | ostream & | os,
|  | vtkIndent | indent
| ) | `[virtual]`

| Methods invoked by print to print information about the object including superclasses. Typically not called by the user (use Print() instead) but used in the hierarchical print process to combine the output of several classes. Reimplemented from vtkObject. Reimplemented in vtkDummyController, vtkMPIController, vtkSocketController, and vtkThreadedController.

virtual void vtkMultiProcessController::Initialize | ( | int * | vtkNotUsed(argc),
|  | char *** | vtkNotUsed(argv)
| ) | `[pure virtual]`

| This method is for setting up the processes. If a subclass needs to initialize process communication (i.e. MPI) it would over ride this method. Referenced by vtkThreadedController::Initialize(), vtkSocketController::Initialize(), and vtkMPIController::Initialize().

virtual void vtkMultiProcessController::Initialize | ( | int * | vtkNotUsed(argc),
|  | char *** | vtkNotUsed(argv),
|  | int | initializedExternally
| ) | `[pure virtual]`

| This method is for setting up the processes. If a subclass needs to initialize process communication (i.e. MPI) it would over ride this method. Provided for initialization outside vtk. Implemented in vtkMPIController.

virtual void vtkMultiProcessController::Finalize | ( |  | ) | `[pure virtual]`

| This method is for cleaning up. If a subclass needs to clean up process communication (i.e. MPI) it would over ride this method. Implemented in vtkDummyController, vtkMPIController, vtkSocketController, and vtkThreadedController. Referenced by vtkThreadedController::Finalize(), and vtkMPIController::Finalize().

virtual void vtkMultiProcessController::Finalize | ( | int | finalizedExternally | ) | `[pure virtual]`

| This method is for cleaning up. If a subclass needs to clean up process communication (i.e. MPI) it would over ride this method. Provided for finalization outside vtk. Implemented in vtkDummyController, vtkMPIController, vtkSocketController, and vtkThreadedController.

virtual void vtkMultiProcessController::SetNumberOfProcesses | ( | int | num | ) | `[virtual]`

| Set the number of processes you will be using. This defaults to the maximum number available. If you set this to a value higher than the default, you will get an error. Reimplemented in vtkSocketController.

virtual int vtkMultiProcessController::GetNumberOfProcesses | ( |  | ) | `[virtual]`

| Set the number of processes you will be using. This defaults to the maximum number available. If you set this to a value higher than the default, you will get an error.

void vtkMultiProcessController::SetSingleMethod | ( | vtkProcessFunctionType | ,
|  | void * | data
| ) |

| Set the SingleMethod to f() and the UserData of the for the method to be executed by all of the processes when SingleMethodExecute is called. All the processes will start by calling this function.

virtual void vtkMultiProcessController::SingleMethodExecute | ( |  | ) | `[pure virtual]`

| Execute the SingleMethod (as define by SetSingleMethod) using this->NumberOfProcesses processes. This will only return when all the processes finish executing their methods. Implemented in vtkDummyController, vtkMPIController, vtkSocketController, and vtkThreadedController.

void vtkMultiProcessController::SetMultipleMethod | ( | int | index,
|  | vtkProcessFunctionType | ,
|  | void * | data
| ) |

| Set the MultipleMethod to f() and the UserData of the for the method to be executed by the process index when MultipleMethodExecute is called. This is for having each process start with a different function and data argument.

virtual void vtkMultiProcessController::MultipleMethodExecute | ( |  | ) | `[pure virtual]`

| Execute the MultipleMethods (as define by calling SetMultipleMethod for each of the required this->NumberOfProcesses methods) using this->NumberOfProcesses processes. Implemented in vtkDummyController, vtkMPIController, vtkSocketController, and vtkThreadedController.

virtual int vtkMultiProcessController::GetLocalProcessId | ( |  | ) | `[inline, virtual]`

| Tells you which process [0, NumProcess) you are in. Reimplemented in vtkDummyController, and vtkThreadedController. Definition at line 153 of file vtkMultiProcessController.h.

vtkMultiProcessController* vtkMultiProcessController::GetGlobalController | ( |  | ) | `[static]`

| This convenience method returns the controller associated with the local process. It returns NULL until the processes are spawned. It is better if you hang on to the controller passed as an argument to the SingleMethod or MultipleMethod functions.

virtual void vtkMultiProcessController::CreateOutputWindow | ( |  | ) | `[pure virtual]`

| 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. Implemented in vtkDummyController, vtkMPIController, vtkSocketController, and vtkThreadedController.

virtual void vtkMultiProcessController::SetForceDeepCopy | ( | int |  | ) | `[virtual]`

| By default, sending objects use shallow copy whenever possible. This flag forces the controller to use deep copies instead. This is necessary when asynchronous processing occurs (i.e. pipeline parallelism). This is only important when using vtkThreadedController.

virtual int vtkMultiProcessController::GetForceDeepCopy | ( |  | ) | `[virtual]`

| By default, sending objects use shallow copy whenever possible. This flag forces the controller to use deep copies instead. This is necessary when asynchronous processing occurs (i.e. pipeline parallelism). This is only important when using vtkThreadedController.

virtual void vtkMultiProcessController::ForceDeepCopyOn | ( |  | ) | `[virtual]`

| By default, sending objects use shallow copy whenever possible. This flag forces the controller to use deep copies instead. This is necessary when asynchronous processing occurs (i.e. pipeline parallelism). This is only important when using vtkThreadedController.

virtual void vtkMultiProcessController::ForceDeepCopyOff | ( |  | ) | `[virtual]`

| By default, sending objects use shallow copy whenever possible. This flag forces the controller to use deep copies instead. This is necessary when asynchronous processing occurs (i.e. pipeline parallelism). This is only important when using vtkThreadedController.

void vtkMultiProcessController::AddRMI | ( | vtkRMIFunctionType | ,
|  | void * | localArg,
|  | int | tag
| ) |

| Register remote method invocation in the receiving process which makes the call. It must have a unique tag as an RMI id. The vtkRMIFunctionType has several arguments: localArg (same as passed in), remoteArg, remoteArgLength (memory passed by process triggering the RMI), remoteProcessId.

void vtkMultiProcessController::RemoveRMI | ( | vtkRMIFunctionType | f,
|  | void * | arg,
|  | int | tag
| ) | `[inline]`

| Take an RMI away. Definition at line 188 of file vtkMultiProcessController.h. References vtkRMIFunctionType.

void vtkMultiProcessController::TriggerRMI | ( | int | remoteProcessId,
|  | void * | arg,
|  | int | argLength,
|  | int | tag
| ) |

| A method to trigger a method invocation in another process.

void vtkMultiProcessController::TriggerBreakRMIs | ( |  | ) |

| A conveniance method. Called on process 0 to break "ProcessRMIs" loop on all other processes.

void vtkMultiProcessController::TriggerRMI | ( | int | remoteProcessId,
|  | char * | arg,
|  | int | tag
| ) | `[inline]`

| Convenience method when the arg is a string. Definition at line 202 of file vtkMultiProcessController.h.

void vtkMultiProcessController::TriggerRMI | ( | int | remoteProcessId,
|  | int | tag
| ) | `[inline]`

| Convenience method when there is no argument. Definition at line 209 of file vtkMultiProcessController.h.

void vtkMultiProcessController::ProcessRMIs | ( |  | ) |

| Calling this method gives control to the controller to start processing RMIs.

virtual void vtkMultiProcessController::SetBreakFlag | ( | int |  | ) | `[virtual]`

| Setting this flag to 1 will cause the ProcessRMIs loop to return. This also causes vtkUpStreamPorts to return from their WaitForUpdate loops.

virtual int vtkMultiProcessController::GetBreakFlag | ( |  | ) | `[virtual]`

| Setting this flag to 1 will cause the ProcessRMIs loop to return. This also causes vtkUpStreamPorts to return from their WaitForUpdate loops.

virtual vtkCommunicator* vtkMultiProcessController::GetCommunicator | ( |  | ) | `[virtual]`

virtual void vtkMultiProcessController::Barrier | ( |  | ) | `[pure virtual]`

| This method can be used to synchronize processes/threads. Implemented in vtkDummyController, vtkMPIController, vtkSocketController, and vtkThreadedController.

void vtkMultiProcessController::SetGlobalController | ( | vtkMultiProcessController * | controller | ) | `[static]`

int vtkMultiProcessController::Send | ( | int * | data,
|  | int | length,
|  | int | remoteProcessId,
|  | int | tag
| ) | `[inline]`

| This method sends data to another process. Tag eliminates ambiguity when multiple sends or receives exist in the same process. Definition at line 365 of file vtkMultiProcessController.h. References Communicator, and vtkCommunicator::Send().

int vtkMultiProcessController::Send | ( | unsigned long * | data,
|  | int | length,
|  | int | remoteProcessId,
|  | int | tag
| ) | `[inline]`

| This method sends data to another process. Tag eliminates ambiguity when multiple sends or receives exist in the same process. Definition at line 378 of file vtkMultiProcessController.h. References Communicator, and vtkCommunicator::Send().

int vtkMultiProcessController::Send | ( | char * | data,
|  | int | length,
|  | int | remoteProcessId,
|  | int | tag
| ) | `[inline]`

| This method sends data to another process. Tag eliminates ambiguity when multiple sends or receives exist in the same process. Definition at line 392 of file vtkMultiProcessController.h. References Communicator, and vtkCommunicator::Send().

int vtkMultiProcessController::Send | ( | unsigned char * | data,
|  | int | length,
|  | int | remoteProcessId,
|  | int | tag
| ) | `[inline]`

| This method sends data to another process. Tag eliminates ambiguity when multiple sends or receives exist in the same process. Definition at line 405 of file vtkMultiProcessController.h. References Communicator, and vtkCommunicator::Send().

int vtkMultiProcessController::Send | ( | float * | data,
|  | int | length,
|  | int | remoteProcessId,
|  | int | tag
| ) | `[inline]`

| This method sends data to another process. Tag eliminates ambiguity when multiple sends or receives exist in the same process. Definition at line 418 of file vtkMultiProcessController.h. References Communicator, and vtkCommunicator::Send().

int vtkMultiProcessController::Send | ( | double * | data,
|  | int | length,
|  | int | remoteProcessId,
|  | int | tag
| ) | `[inline]`

| This method sends data to another process. Tag eliminates ambiguity when multiple sends or receives exist in the same process. Definition at line 431 of file vtkMultiProcessController.h. References Communicator, and vtkCommunicator::Send().

int vtkMultiProcessController::Send | ( | vtkDataObject * | data,
|  | int | remoteId,
|  | int | tag
| ) | `[inline]`

| This method sends data to another process. Tag eliminates ambiguity when multiple sends or receives exist in the same process. Definition at line 339 of file vtkMultiProcessController.h. References Communicator, and vtkCommunicator::Send().

int vtkMultiProcessController::Send | ( | vtkDataArray * | data,
|  | int | remoteId,
|  | int | tag
| ) | `[inline]`

| This method sends data to another process. Tag eliminates ambiguity when multiple sends or receives exist in the same process. Definition at line 352 of file vtkMultiProcessController.h. References Communicator, and vtkCommunicator::Send().

int vtkMultiProcessController::Receive | ( | int * | data,
|  | int | length,
|  | int | remoteProcessId,
|  | int | tag
| ) | `[inline]`

| This method receives data from a corresponding send. It blocks until the receive is finished. It calls methods in "data" to communicate the sending data. Definition at line 485 of file vtkMultiProcessController.h. References Communicator, and vtkCommunicator::Receive().

int vtkMultiProcessController::Receive | ( | unsigned long * | data,
|  | int | length,
|  | int | remoteProcessId,
|  | int | tag
| ) | `[inline]`

| This method receives data from a corresponding send. It blocks until the receive is finished. It calls methods in "data" to communicate the sending data. Definition at line 498 of file vtkMultiProcessController.h. References Communicator, and vtkCommunicator::Receive().

int vtkMultiProcessController::Receive | ( | char * | data,
|  | int | length,
|  | int | remoteProcessId,
|  | int | tag
| ) | `[inline]`

| This method receives data from a corresponding send. It blocks until the receive is finished. It calls methods in "data" to communicate the sending data. Definition at line 512 of file vtkMultiProcessController.h. References Communicator, and vtkCommunicator::Receive().

int vtkMultiProcessController::Receive | ( | unsigned char * | data,
|  | int | length,
|  | int | remoteProcessId,
|  | int | tag
| ) | `[inline]`

| This method receives data from a corresponding send. It blocks until the receive is finished. It calls methods in "data" to communicate the sending data. Definition at line 525 of file vtkMultiProcessController.h. References Communicator, and vtkCommunicator::Receive().

int vtkMultiProcessController::Receive | ( | float * | data,
|  | int | length,
|  | int | remoteProcessId,
|  | int | tag
| ) | `[inline]`

| This method receives data from a corresponding send. It blocks until the receive is finished. It calls methods in "data" to communicate the sending data. Definition at line 538 of file vtkMultiProcessController.h. References Communicator, and vtkCommunicator::Receive().

int vtkMultiProcessController::Receive | ( | double * | data,
|  | int | length,
|  | int | remoteProcessId,
|  | int | tag
| ) | `[inline]`

| This method receives data from a corresponding send. It blocks until the receive is finished. It calls methods in "data" to communicate the sending data. Definition at line 551 of file vtkMultiProcessController.h. References Communicator, and vtkCommunicator::Receive().

int vtkMultiProcessController::Receive | ( | vtkDataObject * | data,
|  | int | remoteId,
|  | int | tag
| ) | `[inline]`

| This method receives data from a corresponding send. It blocks until the receive is finished. It calls methods in "data" to communicate the sending data. Definition at line 459 of file vtkMultiProcessController.h. References Communicator, and vtkCommunicator::Receive().

int vtkMultiProcessController::Receive | ( | vtkDataArray * | data,
|  | int | remoteId,
|  | int | tag
| ) | `[inline]`

| This method receives data from a corresponding send. It blocks until the receive is finished. It calls methods in "data" to communicate the sending data. Definition at line 472 of file vtkMultiProcessController.h. References Communicator, and vtkCommunicator::Receive().

void vtkMultiProcessController::ProcessRMI | ( | int | remoteProcessId,
|  | void * | arg,
|  | int | argLength,
|  | int | rmiTag
| ) | `[protected]`

| This method receives data from a corresponding send. It blocks until the receive is finished. It calls methods in "data" to communicate the sending data.

virtual vtkMultiProcessController* vtkMultiProcessController::GetLocalController | ( |  | ) | `[protected, virtual]`

| This method receives data from a corresponding send. It blocks until the receive is finished. It calls methods in "data" to communicate the sending data. Reimplemented in vtkThreadedController.

## Member Data Documentation

int vtkMultiProcessController::MaximumNumberOfProcesses`[protected]`

| This method receives data from a corresponding send. It blocks until the receive is finished. It calls methods in "data" to communicate the sending data. Definition at line 290 of file vtkMultiProcessController.h.

int vtkMultiProcessController::NumberOfProcesses`[protected]`

| This method receives data from a corresponding send. It blocks until the receive is finished. It calls methods in "data" to communicate the sending data. Definition at line 291 of file vtkMultiProcessController.h.

int vtkMultiProcessController::LocalProcessId`[protected]`

| This method receives data from a corresponding send. It blocks until the receive is finished. It calls methods in "data" to communicate the sending data. Definition at line 293 of file vtkMultiProcessController.h.

vtkProcessFunctionType vtkMultiProcessController::SingleMethod`[protected]`

| This method receives data from a corresponding send. It blocks until the receive is finished. It calls methods in "data" to communicate the sending data. Definition at line 295 of file vtkMultiProcessController.h.

void* vtkMultiProcessController::SingleData`[protected]`

| This method receives data from a corresponding send. It blocks until the receive is finished. It calls methods in "data" to communicate the sending data. Definition at line 296 of file vtkMultiProcessController.h.

vtkProcessFunctionType vtkMultiProcessController::MultipleMethod[MAX_PROCESSES]`[protected]`

| This method receives data from a corresponding send. It blocks until the receive is finished. It calls methods in "data" to communicate the sending data. Definition at line 297 of file vtkMultiProcessController.h.

void* vtkMultiProcessController::MultipleData[MAX_PROCESSES]`[protected]`

| This method receives data from a corresponding send. It blocks until the receive is finished. It calls methods in "data" to communicate the sending data. Definition at line 298 of file vtkMultiProcessController.h.

vtkCollection* vtkMultiProcessController::RMIs`[protected]`

| This method receives data from a corresponding send. It blocks until the receive is finished. It calls methods in "data" to communicate the sending data. Definition at line 300 of file vtkMultiProcessController.h.

int vtkMultiProcessController::BreakFlag`[protected]`

| This method receives data from a corresponding send. It blocks until the receive is finished. It calls methods in "data" to communicate the sending data. Definition at line 304 of file vtkMultiProcessController.h.

int vtkMultiProcessController::ForceDeepCopy`[protected]`

| This method receives data from a corresponding send. It blocks until the receive is finished. It calls methods in "data" to communicate the sending data. Definition at line 314 of file vtkMultiProcessController.h.

vtkOutputWindow* vtkMultiProcessController::OutputWindow`[protected]`

| This method receives data from a corresponding send. It blocks until the receive is finished. It calls methods in "data" to communicate the sending data. Definition at line 316 of file vtkMultiProcessController.h.

vtkCommunicator* vtkMultiProcessController::Communicator`[protected]`

| This method receives data from a corresponding send. It blocks until the receive is finished. It calls methods in "data" to communicate the sending data. Definition at line 321 of file vtkMultiProcessController.h. Referenced by Receive(), and Send().

vtkCommunicator* vtkMultiProcessController::RMICommunicator`[protected]`

| This method receives data from a corresponding send. It blocks until the receive is finished. It calls methods in "data" to communicate the sending data. Definition at line 331 of file vtkMultiProcessController.h.

The documentation for this class was generated from the following file:

- Parallel/vtkMultiProcessController.h