VTK
|
00001 /*========================================================================= 00002 00003 Program: Visualization Toolkit 00004 Module: vtkMultiProcessController.h 00005 00006 Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen 00007 All rights reserved. 00008 See Copyright.txt or http://www.kitware.com/Copyright.htm for details. 00009 00010 This software is distributed WITHOUT ANY WARRANTY; without even 00011 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 00012 PURPOSE. See the above copyright notice for more information. 00013 00014 =========================================================================*/ 00040 #ifndef __vtkMultiProcessController_h 00041 #define __vtkMultiProcessController_h 00042 00043 #include "vtkObject.h" 00044 00045 #include "vtkCommunicator.h" // Needed for direct access to communicator 00046 00047 class vtkCollection; 00048 class vtkDataObject; 00049 class vtkDataSet; 00050 class vtkImageData; 00051 class vtkMultiProcessController; 00052 class vtkMultiProcessStream; 00053 class vtkOutputWindow; 00054 class vtkProcessGroup; 00055 class vtkProcess; 00056 00057 //BTX 00058 // The type of function that gets called when new processes are initiated. 00059 typedef void (*vtkProcessFunctionType)(vtkMultiProcessController *controller, 00060 void *userData); 00061 00062 // The type of function that gets called when an RMI is triggered. 00063 typedef void (*vtkRMIFunctionType)(void *localArg, 00064 void *remoteArg, int remoteArgLength, 00065 int remoteProcessId); 00066 //ETX 00067 00068 00069 class VTK_PARALLEL_EXPORT vtkMultiProcessController : public vtkObject 00070 { 00071 public: 00072 vtkTypeMacro(vtkMultiProcessController,vtkObject); 00073 void PrintSelf(ostream& os, vtkIndent indent); 00074 00078 virtual void Initialize(int* vtkNotUsed(argc), char*** vtkNotUsed(argv))=0; 00079 00081 00084 virtual void Initialize(int* vtkNotUsed(argc), char*** vtkNotUsed(argv), 00085 int initializedExternally)=0; 00087 00090 virtual void Finalize()=0; 00091 00095 virtual void Finalize(int finalizedExternally)=0; 00096 00098 00101 void SetNumberOfProcesses(int num); 00102 int GetNumberOfProcesses(); 00104 00105 //BTX 00109 void SetSingleMethod(vtkProcessFunctionType, void *data); 00110 00112 00115 void SetSingleProcessObject(vtkProcess *p); 00116 //ETX 00118 00122 virtual void SingleMethodExecute() = 0; 00123 00124 //BTX 00126 00130 void SetMultipleMethod(int index, vtkProcessFunctionType, void *data); 00131 //ETX 00133 00137 virtual void MultipleMethodExecute() = 0; 00138 00140 int GetLocalProcessId(); 00141 00146 static vtkMultiProcessController *GetGlobalController(); 00147 00150 virtual void CreateOutputWindow() = 0; 00151 00153 00163 virtual vtkMultiProcessController *CreateSubController( 00164 vtkProcessGroup *group); 00166 00168 00177 virtual vtkMultiProcessController *PartitionController(int localColor, 00178 int localKey); 00180 00181 //------------------ RMIs -------------------- 00182 //BTX 00193 unsigned long AddRMI(vtkRMIFunctionType, void *localArg, int tag); 00194 00196 int RemoveFirstRMI(int tag); 00197 00200 int RemoveRMI(unsigned long id); 00201 00203 00204 void RemoveRMI(vtkRMIFunctionType f, void *arg, int tag) 00205 {f = f; arg = arg; tag = tag; vtkErrorMacro("RemoveRMI Not Implemented Yet");}; 00206 //ETX 00208 00210 void TriggerRMI(int remoteProcessId, void *arg, int argLength, int tag); 00211 00214 void TriggerBreakRMIs(); 00215 00217 00218 void TriggerRMI(int remoteProcessId, const char *arg, int tag) 00219 { this->TriggerRMI(remoteProcessId, (void*)arg, 00220 static_cast<int>(strlen(arg))+1, tag); } 00222 00224 00225 void TriggerRMI(int remoteProcessId, int tag) 00226 { this->TriggerRMI(remoteProcessId, NULL, 0, tag); } 00228 00230 00236 void TriggerRMIOnAllChildren(void *arg, int argLength, int tag); 00237 void TriggerRMIOnAllChildren(const char *arg, int tag) 00238 { 00239 this->TriggerRMIOnAllChildren( 00240 (void*)arg, static_cast<int>(strlen(arg))+1, tag); 00241 } 00242 void TriggerRMIOnAllChildren(int tag) 00243 { 00244 this->TriggerRMIOnAllChildren(NULL, 0, tag); 00245 } 00247 00249 00256 int ProcessRMIs(int reportErrors, int dont_loop = 0); 00257 int ProcessRMIs(); 00259 00261 00264 vtkSetMacro(BreakFlag, int); 00265 vtkGetMacro(BreakFlag, int); 00267 00269 00271 vtkGetObjectMacro(Communicator, vtkCommunicator); 00273 00275 00276 static int GetBreakRMITag() { return BREAK_RMI_TAG; } 00277 static int GetRMITag() { return RMI_TAG; } 00278 static int GetRMIArgTag() { return RMI_ARG_TAG; } 00280 00281 //BTX 00282 00283 enum Errors 00284 { 00285 RMI_NO_ERROR, 00286 RMI_TAG_ERROR, 00287 RMI_ARG_ERROR 00288 }; 00289 00290 enum Consts 00291 { 00292 ANY_SOURCE = -1, 00293 INVALID_SOURCE = -2 00294 }; 00295 00296 enum Tags 00297 { 00298 RMI_TAG = 1, 00299 RMI_ARG_TAG = 2, 00300 BREAK_RMI_TAG = 3, 00301 XML_WRITER_DATA_INFO = 4 00302 }; 00303 00304 //ETX 00305 00307 void Barrier(); 00308 00309 static void SetGlobalController(vtkMultiProcessController *controller); 00310 00311 //------------------ Communication -------------------- 00312 00314 00319 int Send(const int* data, vtkIdType length, int remoteProcessId, int tag); 00320 int Send(const unsigned int* data, vtkIdType length, int remoteProcessId, int tag); 00321 int Send(const unsigned long* data, vtkIdType length, int remoteProcessId, 00322 int tag); 00323 int Send(const char* data, vtkIdType length, int remoteProcessId, int tag); 00324 int Send(const unsigned char* data, vtkIdType length, int remoteProcessId, int tag); 00325 int Send(const float* data, vtkIdType length, int remoteProcessId, int tag); 00326 int Send(const double* data, vtkIdType length, int remoteProcessId, int tag); 00327 #ifdef VTK_USE_64BIT_IDS 00328 int Send(const vtkIdType* data, vtkIdType length, int remoteProcessId, int tag); 00330 #endif 00331 int Send(vtkDataObject *data, int remoteId, int tag); 00332 int Send(vtkDataArray *data, int remoteId, int tag); 00333 00334 //BTX 00340 int Send(const vtkMultiProcessStream& stream, int remoteId, int tag); 00341 //ETX 00342 00344 00352 int Receive(int* data, vtkIdType maxlength, int remoteProcessId, int tag); 00353 int Receive(unsigned int* data, vtkIdType maxlength, int remoteProcessId, int tag); 00354 int Receive(unsigned long* data, vtkIdType maxlength, int remoteProcessId, 00355 int tag); 00356 int Receive(char* data, vtkIdType maxlength, int remoteProcessId, int tag); 00357 int Receive(unsigned char* data, vtkIdType maxlength, int remoteProcessId, int tag); 00358 int Receive(float* data, vtkIdType maxlength, int remoteProcessId, int tag); 00359 int Receive(double* data, vtkIdType maxlength, int remoteProcessId, int tag); 00360 #ifdef VTK_USE_64BIT_IDS 00361 int Receive(vtkIdType* data, vtkIdType maxlength, int remoteProcessId, int tag); 00363 #endif 00364 int Receive(vtkDataObject* data, int remoteId, int tag); 00365 int Receive(vtkDataArray* data, int remoteId, int tag); 00366 //BTX 00368 int Receive(vtkMultiProcessStream& stream, int remoteId, int tag); 00369 //ETX 00370 vtkDataObject *ReceiveDataObject(int remoteId, int tag); 00371 00379 vtkIdType GetCount(); 00380 00381 00382 //---------------------- Collective Operations ---------------------- 00383 00385 00388 int Broadcast(int *data, vtkIdType length, int srcProcessId) { 00389 return this->Communicator->Broadcast(data, length, srcProcessId); 00390 } 00391 int Broadcast(unsigned long *data, vtkIdType length, int srcProcessId) { 00392 return this->Communicator->Broadcast(data, length, srcProcessId); 00393 } 00394 int Broadcast(unsigned char *data, vtkIdType length, int srcProcessId) { 00395 return this->Communicator->Broadcast(data, length, srcProcessId); 00396 } 00397 int Broadcast(char *data, vtkIdType length, int srcProcessId) { 00398 return this->Communicator->Broadcast(data, length, srcProcessId); 00399 } 00400 int Broadcast(float *data, vtkIdType length, int srcProcessId) { 00401 return this->Communicator->Broadcast(data, length, srcProcessId); 00402 } 00403 int Broadcast(double *data, vtkIdType length, int srcProcessId) { 00404 return this->Communicator->Broadcast(data, length, srcProcessId); 00405 } 00406 #ifdef VTK_USE_64BIT_IDS 00407 int Broadcast(vtkIdType *data, vtkIdType length, int srcProcessId) { 00408 return this->Communicator->Broadcast(data, length, srcProcessId); 00409 } 00411 #endif 00412 int Broadcast(vtkDataObject *data, int srcProcessId) { 00413 return this->Communicator->Broadcast(data, srcProcessId); 00414 } 00415 int Broadcast(vtkDataArray *data, int srcProcessId) { 00416 return this->Communicator->Broadcast(data, srcProcessId); 00417 } 00418 //BTX 00419 int Broadcast(vtkMultiProcessStream& stream, int srcProcessId) { 00420 return this->Communicator->Broadcast(stream, srcProcessId); 00421 } 00422 //ETX 00423 00425 00433 int Gather(const int *sendBuffer, int *recvBuffer, 00434 vtkIdType length, int destProcessId) { 00435 return this->Communicator->Gather(sendBuffer, recvBuffer, length, 00436 destProcessId); 00437 } 00438 int Gather(const unsigned long *sendBuffer, unsigned long *recvBuffer, 00439 vtkIdType length, int destProcessId) { 00440 return this->Communicator->Gather(sendBuffer, recvBuffer, length, 00441 destProcessId); 00442 } 00443 int Gather(const unsigned char *sendBuffer, unsigned char *recvBuffer, 00444 vtkIdType length, int destProcessId) { 00445 return this->Communicator->Gather(sendBuffer, recvBuffer, length, 00446 destProcessId); 00447 } 00448 int Gather(const char *sendBuffer, char *recvBuffer, 00449 vtkIdType length, int destProcessId) { 00450 return this->Communicator->Gather(sendBuffer, recvBuffer, length, 00451 destProcessId); 00452 } 00453 int Gather(const float *sendBuffer, float *recvBuffer, 00454 vtkIdType length, int destProcessId) { 00455 return this->Communicator->Gather(sendBuffer, recvBuffer, length, 00456 destProcessId); 00457 } 00458 int Gather(const double *sendBuffer, double *recvBuffer, 00459 vtkIdType length, int destProcessId) { 00460 return this->Communicator->Gather(sendBuffer, recvBuffer, length, 00461 destProcessId); 00462 } 00463 #ifdef VTK_USE_64BIT_IDS 00464 int Gather(const vtkIdType *sendBuffer, vtkIdType *recvBuffer, 00465 vtkIdType length, int destProcessId) { 00466 return this->Communicator->Gather(sendBuffer, recvBuffer, length, 00467 destProcessId); 00468 } 00470 #endif 00471 int Gather(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, 00472 int destProcessId) { 00473 return this->Communicator->Gather(sendBuffer, recvBuffer, destProcessId); 00474 } 00475 00477 00487 int GatherV(const int* sendBuffer, int* recvBuffer, 00488 vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets, 00489 int destProcessId) { 00490 return this->Communicator->GatherV(sendBuffer, recvBuffer, 00491 sendLength, recvLengths, 00492 offsets, destProcessId); 00493 } 00494 int GatherV(const unsigned long* sendBuffer, unsigned long* recvBuffer, 00495 vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets, 00496 int destProcessId) { 00497 return this->Communicator->GatherV(sendBuffer, recvBuffer, 00498 sendLength, recvLengths, 00499 offsets, destProcessId); 00500 } 00501 int GatherV(const unsigned char* sendBuffer, unsigned char* recvBuffer, 00502 vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets, 00503 int destProcessId) { 00504 return this->Communicator->GatherV(sendBuffer, recvBuffer, 00505 sendLength, recvLengths, 00506 offsets, destProcessId); 00507 } 00508 int GatherV(const char* sendBuffer, char* recvBuffer, 00509 vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets, 00510 int destProcessId) { 00511 return this->Communicator->GatherV(sendBuffer, recvBuffer, 00512 sendLength, recvLengths, 00513 offsets, destProcessId); 00514 } 00515 int GatherV(const float* sendBuffer, float* recvBuffer, 00516 vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets, 00517 int destProcessId) { 00518 return this->Communicator->GatherV(sendBuffer, recvBuffer, 00519 sendLength, recvLengths, 00520 offsets, destProcessId); 00521 } 00522 int GatherV(const double* sendBuffer, double* recvBuffer, 00523 vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets, 00524 int destProcessId) { 00525 return this->Communicator->GatherV(sendBuffer, recvBuffer, 00526 sendLength, recvLengths, 00527 offsets, destProcessId); 00528 } 00529 #ifdef VTK_USE_64BIT_IDS 00530 int GatherV(const vtkIdType* sendBuffer, vtkIdType* recvBuffer, 00531 vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets, 00532 int destProcessId) { 00533 return this->Communicator->GatherV(sendBuffer, recvBuffer, 00534 sendLength, recvLengths, 00535 offsets, destProcessId); 00536 } 00538 #endif 00539 00541 00546 int Scatter(const int *sendBuffer, int *recvBuffer, 00547 vtkIdType length, int srcProcessId) { 00548 return this->Communicator->Scatter(sendBuffer, recvBuffer, length, 00549 srcProcessId); 00550 } 00551 int Scatter(const unsigned long *sendBuffer, unsigned long *recvBuffer, 00552 vtkIdType length, int srcProcessId) { 00553 return this->Communicator->Scatter(sendBuffer, recvBuffer, length, 00554 srcProcessId); 00555 } 00556 int Scatter(const unsigned char *sendBuffer, unsigned char *recvBuffer, 00557 vtkIdType length, int srcProcessId) { 00558 return this->Communicator->Scatter(sendBuffer, recvBuffer, length, 00559 srcProcessId); 00560 } 00561 int Scatter(const char *sendBuffer, char *recvBuffer, 00562 vtkIdType length, int srcProcessId) { 00563 return this->Communicator->Scatter(sendBuffer, recvBuffer, length, 00564 srcProcessId); 00565 } 00566 int Scatter(const float *sendBuffer, float *recvBuffer, 00567 vtkIdType length, int srcProcessId) { 00568 return this->Communicator->Scatter(sendBuffer, recvBuffer, length, 00569 srcProcessId); 00570 } 00571 int Scatter(const double *sendBuffer, double *recvBuffer, 00572 vtkIdType length, int srcProcessId) { 00573 return this->Communicator->Scatter(sendBuffer, recvBuffer, length, 00574 srcProcessId); 00575 } 00576 #ifdef VTK_USE_64BIT_IDS 00577 int Scatter(const vtkIdType *sendBuffer, vtkIdType *recvBuffer, 00578 vtkIdType length, int srcProcessId) { 00579 return this->Communicator->Scatter(sendBuffer, recvBuffer, length, 00580 srcProcessId); 00581 } 00583 #endif 00584 int Scatter(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, 00585 int srcProcessId) { 00586 return this->Communicator->Scatter(sendBuffer, recvBuffer, srcProcessId); 00587 } 00588 00590 00596 int ScatterV(const int *sendBuffer, int *recvBuffer, 00597 vtkIdType *sendLengths, vtkIdType *offsets, 00598 vtkIdType recvLength, int srcProcessId) { 00599 return this->Communicator->ScatterV(sendBuffer, recvBuffer, 00600 sendLengths, offsets, recvLength, 00601 srcProcessId); 00602 } 00603 int ScatterV(const unsigned long *sendBuffer, unsigned long *recvBuffer, 00604 vtkIdType *sendLengths, vtkIdType *offsets, 00605 vtkIdType recvLength, int srcProcessId) { 00606 return this->Communicator->ScatterV(sendBuffer, recvBuffer, 00607 sendLengths, offsets, recvLength, 00608 srcProcessId); 00609 } 00610 int ScatterV(const unsigned char *sendBuffer, unsigned char *recvBuffer, 00611 vtkIdType *sendLengths, vtkIdType *offsets, 00612 vtkIdType recvLength, int srcProcessId) { 00613 return this->Communicator->ScatterV(sendBuffer, recvBuffer, 00614 sendLengths, offsets, recvLength, 00615 srcProcessId); 00616 } 00617 int ScatterV(const char *sendBuffer, char *recvBuffer, 00618 vtkIdType *sendLengths, vtkIdType *offsets, 00619 vtkIdType recvLength, int srcProcessId) { 00620 return this->Communicator->ScatterV(sendBuffer, recvBuffer, 00621 sendLengths, offsets, recvLength, 00622 srcProcessId); 00623 } 00624 int ScatterV(const float *sendBuffer, float *recvBuffer, 00625 vtkIdType *sendLengths, vtkIdType *offsets, 00626 vtkIdType recvLength, int srcProcessId) { 00627 return this->Communicator->ScatterV(sendBuffer, recvBuffer, 00628 sendLengths, offsets, recvLength, 00629 srcProcessId); 00630 } 00631 int ScatterV(const double *sendBuffer, double *recvBuffer, 00632 vtkIdType *sendLengths, vtkIdType *offsets, 00633 vtkIdType recvLength, int srcProcessId) { 00634 return this->Communicator->ScatterV(sendBuffer, recvBuffer, 00635 sendLengths, offsets, recvLength, 00636 srcProcessId); 00637 } 00638 #ifdef VTK_USE_64BIT_IDS 00639 int ScatterV(const vtkIdType *sendBuffer, vtkIdType *recvBuffer, 00640 vtkIdType *sendLengths, vtkIdType *offsets, 00641 vtkIdType recvLength, int srcProcessId) { 00642 return this->Communicator->ScatterV(sendBuffer, recvBuffer, 00643 sendLengths, offsets, recvLength, 00644 srcProcessId); 00645 } 00647 #endif 00648 00650 00651 int AllGather(const int *sendBuffer, int *recvBuffer, vtkIdType length) { 00652 return this->Communicator->AllGather(sendBuffer, recvBuffer, length); 00653 } 00654 int AllGather(const unsigned long *sendBuffer, 00655 unsigned long *recvBuffer, vtkIdType length) { 00656 return this->Communicator->AllGather(sendBuffer, recvBuffer, length); 00657 } 00658 int AllGather(const unsigned char *sendBuffer, 00659 unsigned char *recvBuffer, vtkIdType length) { 00660 return this->Communicator->AllGather(sendBuffer, recvBuffer, length); 00661 } 00662 int AllGather(const char *sendBuffer, char *recvBuffer, vtkIdType length) { 00663 return this->Communicator->AllGather(sendBuffer, recvBuffer, length); 00664 } 00665 int AllGather(const float *sendBuffer, float *recvBuffer, vtkIdType length) { 00666 return this->Communicator->AllGather(sendBuffer, recvBuffer, length); 00667 } 00668 int AllGather(const double *sendBuffer, 00669 double *recvBuffer, vtkIdType length) { 00670 return this->Communicator->AllGather(sendBuffer, recvBuffer, length); 00671 } 00672 #ifdef VTK_USE_64BIT_IDS 00673 int AllGather(const vtkIdType *sendBuffer, vtkIdType *recvBuffer, 00674 vtkIdType length) { 00675 return this->Communicator->AllGather(sendBuffer, recvBuffer, length); 00676 } 00678 #endif 00679 int AllGather(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer) { 00680 return this->Communicator->AllGather(sendBuffer, recvBuffer); 00681 } 00682 00684 00685 int AllGatherV(const int* sendBuffer, int* recvBuffer, 00686 vtkIdType sendLength, vtkIdType* recvLengths, 00687 vtkIdType* offsets) { 00688 return this->Communicator->AllGatherV(sendBuffer, recvBuffer, 00689 sendLength, recvLengths, 00690 offsets); 00691 } 00692 int AllGatherV(const unsigned long* sendBuffer, unsigned long* recvBuffer, 00693 vtkIdType sendLength, vtkIdType* recvLengths, 00694 vtkIdType* offsets) { 00695 return this->Communicator->AllGatherV(sendBuffer, recvBuffer, 00696 sendLength, recvLengths, 00697 offsets); 00698 } 00699 int AllGatherV(const unsigned char* sendBuffer, unsigned char* recvBuffer, 00700 vtkIdType sendLength, vtkIdType* recvLengths, 00701 vtkIdType* offsets) { 00702 return this->Communicator->AllGatherV(sendBuffer, recvBuffer, 00703 sendLength, recvLengths, 00704 offsets); 00705 } 00706 int AllGatherV(const char* sendBuffer, char* recvBuffer, 00707 vtkIdType sendLength, vtkIdType* recvLengths, 00708 vtkIdType* offsets) { 00709 return this->Communicator->AllGatherV(sendBuffer, recvBuffer, 00710 sendLength, recvLengths, 00711 offsets); 00712 } 00713 int AllGatherV(const float* sendBuffer, float* recvBuffer, 00714 vtkIdType sendLength, vtkIdType* recvLengths, 00715 vtkIdType* offsets) { 00716 return this->Communicator->AllGatherV(sendBuffer, recvBuffer, 00717 sendLength, recvLengths, 00718 offsets); 00719 } 00720 int AllGatherV(const double* sendBuffer, double* recvBuffer, 00721 vtkIdType sendLength, vtkIdType* recvLengths, 00722 vtkIdType* offsets) { 00723 return this->Communicator->AllGatherV(sendBuffer, recvBuffer, 00724 sendLength, recvLengths, 00725 offsets); 00726 } 00727 #ifdef VTK_USE_64BIT_IDS 00728 int AllGatherV(const vtkIdType* sendBuffer, vtkIdType* recvBuffer, 00729 vtkIdType sendLength, vtkIdType* recvLengths, 00730 vtkIdType* offsets) { 00731 return this->Communicator->AllGatherV(sendBuffer, recvBuffer, 00732 sendLength, recvLengths, 00733 offsets); 00734 } 00736 #endif 00737 00739 00742 int Reduce(const int *sendBuffer, int *recvBuffer, 00743 vtkIdType length, int operation, int destProcessId) { 00744 return this->Communicator->Reduce(sendBuffer, recvBuffer, length, 00745 operation, destProcessId); 00746 } 00747 int Reduce(const unsigned long *sendBuffer, unsigned long *recvBuffer, 00748 vtkIdType length, int operation, int destProcessId) { 00749 return this->Communicator->Reduce(sendBuffer, recvBuffer, length, 00750 operation, destProcessId); 00751 } 00752 int Reduce(const unsigned char *sendBuffer, unsigned char *recvBuffer, 00753 vtkIdType length, int operation, int destProcessId) { 00754 return this->Communicator->Reduce(sendBuffer, recvBuffer, length, 00755 operation, destProcessId); 00756 } 00757 int Reduce(const char *sendBuffer, char *recvBuffer, 00758 vtkIdType length, int operation, int destProcessId) { 00759 return this->Communicator->Reduce(sendBuffer, recvBuffer, length, 00760 operation, destProcessId); 00761 } 00762 int Reduce(const float *sendBuffer, float *recvBuffer, 00763 vtkIdType length, int operation, int destProcessId) { 00764 return this->Communicator->Reduce(sendBuffer, recvBuffer, length, 00765 operation, destProcessId); 00766 } 00767 int Reduce(const double *sendBuffer, double *recvBuffer, 00768 vtkIdType length, int operation, int destProcessId) { 00769 return this->Communicator->Reduce(sendBuffer, recvBuffer, length, 00770 operation, destProcessId); 00771 } 00772 #ifdef VTK_USE_64BIT_IDS 00773 int Reduce(const vtkIdType *sendBuffer, vtkIdType *recvBuffer, 00774 vtkIdType length, int operation, int destProcessId) { 00775 return this->Communicator->Reduce(sendBuffer, recvBuffer, length, 00776 operation, destProcessId); 00777 } 00779 #endif 00780 int Reduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, 00781 int operation, int destProcessId) { 00782 return this->Communicator->Reduce(sendBuffer, recvBuffer, 00783 operation, destProcessId); 00784 } 00785 00786 //BTX 00788 00791 int Reduce(const int *sendBuffer, int *recvBuffer, 00792 vtkIdType length, vtkCommunicator::Operation *operation, 00793 int destProcessId) { 00794 return this->Communicator->Reduce(sendBuffer, recvBuffer, length, 00795 operation, destProcessId); 00796 } 00797 int Reduce(const unsigned long *sendBuffer, unsigned long *recvBuffer, 00798 vtkIdType length, vtkCommunicator::Operation *operation, 00799 int destProcessId) { 00800 return this->Communicator->Reduce(sendBuffer, recvBuffer, length, 00801 operation, destProcessId); 00802 } 00803 int Reduce(const unsigned char *sendBuffer, unsigned char *recvBuffer, 00804 vtkIdType length, vtkCommunicator::Operation *operation, 00805 int destProcessId) { 00806 return this->Communicator->Reduce(sendBuffer, recvBuffer, length, 00807 operation, destProcessId); 00808 } 00809 int Reduce(const char *sendBuffer, char *recvBuffer, 00810 vtkIdType length, vtkCommunicator::Operation *operation, 00811 int destProcessId) { 00812 return this->Communicator->Reduce(sendBuffer, recvBuffer, length, 00813 operation, destProcessId); 00814 } 00815 int Reduce(const float *sendBuffer, float *recvBuffer, 00816 vtkIdType length, vtkCommunicator::Operation *operation, 00817 int destProcessId) { 00818 return this->Communicator->Reduce(sendBuffer, recvBuffer, length, 00819 operation, destProcessId); 00820 } 00821 int Reduce(const double *sendBuffer, double *recvBuffer, 00822 vtkIdType length, vtkCommunicator::Operation *operation, 00823 int destProcessId) { 00824 return this->Communicator->Reduce(sendBuffer, recvBuffer, length, 00825 operation, destProcessId); 00826 } 00827 #ifdef VTK_USE_64BIT_IDS 00828 int Reduce(const vtkIdType *sendBuffer, vtkIdType *recvBuffer, 00829 vtkIdType length, vtkCommunicator::Operation *operation, 00830 int destProcessId) { 00831 return this->Communicator->Reduce(sendBuffer, recvBuffer, length, 00832 operation, destProcessId); 00833 } 00835 #endif 00836 int Reduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, 00837 vtkCommunicator::Operation *operation, int destProcessId) { 00838 return this->Communicator->Reduce(sendBuffer, recvBuffer, 00839 operation, destProcessId); 00840 } 00841 //ETX 00842 00844 00846 int AllReduce(const int *sendBuffer, int *recvBuffer, 00847 vtkIdType length, int operation) { 00848 return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, 00849 operation); 00850 } 00851 int AllReduce(const unsigned long *sendBuffer, unsigned long *recvBuffer, 00852 vtkIdType length, int operation) { 00853 return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, 00854 operation); 00855 } 00856 int AllReduce(const unsigned char *sendBuffer, unsigned char *recvBuffer, 00857 vtkIdType length, int operation) { 00858 return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, 00859 operation); 00860 } 00861 int AllReduce(const char *sendBuffer, char *recvBuffer, 00862 vtkIdType length, int operation) { 00863 return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, 00864 operation); 00865 } 00866 int AllReduce(const float *sendBuffer, float *recvBuffer, 00867 vtkIdType length, int operation) { 00868 return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, 00869 operation); 00870 } 00871 int AllReduce(const double *sendBuffer, double *recvBuffer, 00872 vtkIdType length, int operation) { 00873 return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, 00874 operation); 00875 } 00876 #ifdef VTK_USE_64BIT_IDS 00877 int AllReduce(const vtkIdType *sendBuffer, vtkIdType *recvBuffer, 00878 vtkIdType length, int operation) { 00879 return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, 00880 operation); 00881 } 00883 #endif 00884 int AllReduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, 00885 int operation) { 00886 return this->Communicator->AllReduce(sendBuffer, recvBuffer, operation); 00887 } 00888 //BTX 00889 int AllReduce(const int *sendBuffer, int *recvBuffer, 00890 vtkIdType length, vtkCommunicator::Operation *operation) { 00891 return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, 00892 operation); 00893 } 00894 int AllReduce(const unsigned long *sendBuffer, unsigned long *recvBuffer, 00895 vtkIdType length, vtkCommunicator::Operation *operation) { 00896 return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, 00897 operation); 00898 } 00899 int AllReduce(const unsigned char *sendBuffer, unsigned char *recvBuffer, 00900 vtkIdType length, vtkCommunicator::Operation *operation) { 00901 return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, 00902 operation); 00903 } 00904 int AllReduce(const char *sendBuffer, char *recvBuffer, 00905 vtkIdType length, vtkCommunicator::Operation *operation) { 00906 return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, 00907 operation); 00908 } 00909 int AllReduce(const float *sendBuffer, float *recvBuffer, 00910 vtkIdType length, vtkCommunicator::Operation *operation) { 00911 return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, 00912 operation); 00913 } 00914 int AllReduce(const double *sendBuffer, double *recvBuffer, 00915 vtkIdType length, vtkCommunicator::Operation *operation) { 00916 return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, 00917 operation); 00918 } 00919 #ifdef VTK_USE_64BIT_IDS 00920 int AllReduce(const vtkIdType *sendBuffer, vtkIdType *recvBuffer, 00921 vtkIdType length, vtkCommunicator::Operation *operation) { 00922 return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, 00923 operation); 00924 } 00925 #endif 00926 int AllReduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, 00927 vtkCommunicator::Operation *operation) { 00928 return this->Communicator->AllReduce(sendBuffer, recvBuffer, operation); 00929 } 00930 //ETX 00931 00932 // Internally implemented RMI to break the process loop. 00933 00934 protected: 00935 vtkMultiProcessController(); 00936 ~vtkMultiProcessController(); 00937 00939 00942 virtual void TriggerRMIInternal(int remoteProcessId, 00943 void* arg, int argLength, int rmiTag, bool propagate); 00945 00946 vtkProcessFunctionType SingleMethod; 00947 void *SingleData; 00948 00949 void GetMultipleMethod(int index, vtkProcessFunctionType &func, void *&data); 00950 00951 vtkCollection *RMIs; 00952 00953 // This is a flag that can be used by the ports to break 00954 // their update loop. (same as ProcessRMIs) 00955 int BreakFlag; 00956 00957 void ProcessRMI(int remoteProcessId, void *arg, int argLength, int rmiTag); 00958 00959 // This method implements "GetGlobalController". 00960 // It needs to be virtual and static. 00961 virtual vtkMultiProcessController *GetLocalController(); 00962 00963 00964 // This flag can force deep copies during send. 00965 int ForceDeepCopy; 00966 00967 vtkOutputWindow* OutputWindow; 00968 00969 // Note that since the communicators can be created differently 00970 // depending on the type of controller, the subclasses are 00971 // responsible of deleting them. 00972 vtkCommunicator* Communicator; 00973 00974 // Communicator which is a copy of the current user 00975 // level communicator except the context; i.e. even if the tags 00976 // are the same, the RMI messages will not interfere with user 00977 // level messages. 00978 // Note that since the communicators can be created differently 00979 // depending on the type of controller, the subclasses are 00980 // responsible of deleting them. 00981 vtkCommunicator* RMICommunicator; 00982 00983 private: 00984 vtkMultiProcessController(const vtkMultiProcessController&); // Not implemented. 00985 void operator=(const vtkMultiProcessController&); // Not implemented. 00986 00987 unsigned long RMICount; 00988 00989 //BTX 00990 class vtkInternal; 00991 vtkInternal *Internal; 00992 //ETX 00993 }; 00994 00995 00996 inline int vtkMultiProcessController::Send(vtkDataObject *data, 00997 int remoteProcessId, int tag) 00998 { 00999 if (this->Communicator) 01000 { 01001 return this->Communicator->Send(data, remoteProcessId, tag); 01002 } 01003 else 01004 { 01005 return 0; 01006 } 01007 } 01008 01009 inline int vtkMultiProcessController::Send(vtkDataArray *data, 01010 int remoteProcessId, int tag) 01011 { 01012 if (this->Communicator) 01013 { 01014 return this->Communicator->Send(data, remoteProcessId, tag); 01015 } 01016 else 01017 { 01018 return 0; 01019 } 01020 } 01021 01022 inline int vtkMultiProcessController::Send(const int* data, vtkIdType length, 01023 int remoteProcessId, int tag) 01024 { 01025 if (this->Communicator) 01026 { 01027 return this->Communicator->Send(data, length, remoteProcessId, tag); 01028 } 01029 else 01030 { 01031 return 0; 01032 } 01033 } 01034 01035 inline int vtkMultiProcessController::Send(const unsigned int* data, vtkIdType length, 01036 int remoteProcessId, int tag) 01037 { 01038 if (this->Communicator) 01039 { 01040 return this->Communicator->Send(data, length, remoteProcessId, tag); 01041 } 01042 else 01043 { 01044 return 0; 01045 } 01046 } 01047 01048 inline int vtkMultiProcessController::Send(const unsigned long* data, 01049 vtkIdType length, 01050 int remoteProcessId, 01051 int tag) 01052 { 01053 if (this->Communicator) 01054 { 01055 return this->Communicator->Send(data, length, remoteProcessId, tag); 01056 } 01057 else 01058 { 01059 return 0; 01060 } 01061 } 01062 01063 inline int vtkMultiProcessController::Send(const char* data, vtkIdType length, 01064 int remoteProcessId, int tag) 01065 { 01066 if (this->Communicator) 01067 { 01068 return this->Communicator->Send(data, length, remoteProcessId, tag); 01069 } 01070 else 01071 { 01072 return 0; 01073 } 01074 } 01075 01076 inline int vtkMultiProcessController::Send(const unsigned char* data, 01077 vtkIdType length, 01078 int remoteProcessId, int tag) 01079 { 01080 if (this->Communicator) 01081 { 01082 return this->Communicator->Send(data, length, remoteProcessId, tag); 01083 } 01084 else 01085 { 01086 return 0; 01087 } 01088 } 01089 01090 inline int vtkMultiProcessController::Send(const float* data, vtkIdType length, 01091 int remoteProcessId, int tag) 01092 { 01093 if (this->Communicator) 01094 { 01095 return this->Communicator->Send(data, length, remoteProcessId, tag); 01096 } 01097 else 01098 { 01099 return 0; 01100 } 01101 } 01102 01103 inline int vtkMultiProcessController::Send(const double* data, vtkIdType length, 01104 int remoteProcessId, int tag) 01105 { 01106 if (this->Communicator) 01107 { 01108 return this->Communicator->Send(data, length, remoteProcessId, tag); 01109 } 01110 else 01111 { 01112 return 0; 01113 } 01114 } 01115 01116 #ifdef VTK_USE_64BIT_IDS 01117 inline int vtkMultiProcessController::Send(const vtkIdType* data, 01118 vtkIdType length, 01119 int remoteProcessId, int tag) 01120 { 01121 if (this->Communicator) 01122 { 01123 return this->Communicator->Send(data, length, remoteProcessId, tag); 01124 } 01125 else 01126 { 01127 return 0; 01128 } 01129 } 01130 #endif 01131 01132 inline int vtkMultiProcessController::Send(const vtkMultiProcessStream& stream, 01133 int remoteId, int tag) 01134 { 01135 if (this->Communicator) 01136 { 01137 return this->Communicator->Send(stream, remoteId, tag); 01138 } 01139 return 0; 01140 } 01141 01142 inline int vtkMultiProcessController::Receive(vtkDataObject* data, 01143 int remoteProcessId, int tag) 01144 { 01145 if (this->Communicator) 01146 { 01147 return this->Communicator->Receive(data, remoteProcessId, tag); 01148 } 01149 else 01150 { 01151 return 0; 01152 } 01153 } 01154 01155 inline vtkDataObject* vtkMultiProcessController::ReceiveDataObject( 01156 int remoteProcessId, int tag) 01157 { 01158 if (this->Communicator) 01159 { 01160 return this->Communicator->ReceiveDataObject(remoteProcessId, tag); 01161 } 01162 else 01163 { 01164 return 0; 01165 } 01166 } 01167 01168 inline int vtkMultiProcessController::Receive(vtkDataArray* data, 01169 int remoteProcessId, int tag) 01170 { 01171 if (this->Communicator) 01172 { 01173 return this->Communicator->Receive(data, remoteProcessId, tag); 01174 } 01175 else 01176 { 01177 return 0; 01178 } 01179 } 01180 01181 inline int vtkMultiProcessController::Receive(int* data, vtkIdType length, 01182 int remoteProcessId, int tag) 01183 { 01184 if (this->Communicator) 01185 { 01186 return this->Communicator->Receive(data, length, remoteProcessId, tag); 01187 } 01188 else 01189 { 01190 return 0; 01191 } 01192 } 01193 01194 inline int vtkMultiProcessController::Receive(unsigned int* data, vtkIdType length, 01195 int remoteProcessId, int tag) 01196 { 01197 if (this->Communicator) 01198 { 01199 return this->Communicator->Receive(data, length, remoteProcessId, tag); 01200 } 01201 else 01202 { 01203 return 0; 01204 } 01205 } 01206 01207 inline int vtkMultiProcessController::Receive(unsigned long* data, 01208 vtkIdType length, 01209 int remoteProcessId, 01210 int tag) 01211 { 01212 if (this->Communicator) 01213 { 01214 return this->Communicator->Receive(data, length, remoteProcessId, tag); 01215 } 01216 else 01217 { 01218 return 0; 01219 } 01220 } 01221 01222 inline int vtkMultiProcessController::Receive(char* data, vtkIdType length, 01223 int remoteProcessId, int tag) 01224 { 01225 if (this->Communicator) 01226 { 01227 return this->Communicator->Receive(data, length, remoteProcessId, tag); 01228 } 01229 else 01230 { 01231 return 0; 01232 } 01233 } 01234 01235 inline int vtkMultiProcessController::Receive(unsigned char* data, 01236 vtkIdType length, 01237 int remoteProcessId, int tag) 01238 { 01239 if (this->Communicator) 01240 { 01241 return this->Communicator->Receive(data, length, remoteProcessId, tag); 01242 } 01243 else 01244 { 01245 return 0; 01246 } 01247 } 01248 01249 inline int vtkMultiProcessController::Receive(float* data, vtkIdType length, 01250 int remoteProcessId, int tag) 01251 { 01252 if (this->Communicator) 01253 { 01254 return this->Communicator->Receive(data, length, remoteProcessId, tag); 01255 } 01256 else 01257 { 01258 return 0; 01259 } 01260 } 01261 01262 inline int vtkMultiProcessController::Receive(double* data, vtkIdType length, 01263 int remoteProcessId, int tag) 01264 { 01265 if (this->Communicator) 01266 { 01267 return this->Communicator->Receive(data, length, remoteProcessId, tag); 01268 } 01269 else 01270 { 01271 return 0; 01272 } 01273 } 01274 01275 #ifdef VTK_USE_64BIT_IDS 01276 inline int vtkMultiProcessController::Receive(vtkIdType* data, 01277 vtkIdType length, 01278 int remoteProcessId, int tag) 01279 { 01280 if (this->Communicator) 01281 { 01282 return this->Communicator->Receive(data, length, remoteProcessId, tag); 01283 } 01284 else 01285 { 01286 return 0; 01287 } 01288 } 01289 #endif 01290 01291 01292 inline int vtkMultiProcessController::Receive(vtkMultiProcessStream& stream, 01293 int remoteId, int tag) 01294 { 01295 if (this->Communicator) 01296 { 01297 return this->Communicator->Receive(stream, remoteId, tag); 01298 } 01299 return 0; 01300 } 01301 01302 inline void vtkMultiProcessController::Barrier() 01303 { 01304 if (this->Communicator) 01305 { 01306 this->Communicator->Barrier(); 01307 } 01308 } 01309 01310 inline vtkIdType vtkMultiProcessController::GetCount() 01311 { 01312 if (this->Communicator) 01313 { 01314 return this->Communicator->GetCount(); 01315 } 01316 return 0; 01317 } 01318 01319 #endif