VTK
vtkMultiProcessController.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: vtkMultiProcessController.h
5 
6  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7  All rights reserved.
8  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
9 
10  This software is distributed WITHOUT ANY WARRANTY; without even
11  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12  PURPOSE. See the above copyright notice for more information.
13 
14 =========================================================================*/
49 #ifndef vtkMultiProcessController_h
50 #define vtkMultiProcessController_h
51 
52 #include "vtkParallelCoreModule.h" // For export macro
53 #include "vtkObject.h"
54 
55 #include "vtkCommunicator.h" // Needed for direct access to communicator
56 
57 class vtkCollection;
58 class vtkDataObject;
59 class vtkDataSet;
60 class vtkImageData;
63 class vtkOutputWindow;
64 class vtkProcessGroup;
65 class vtkProcess;
66 
67 // The type of function that gets called when new processes are initiated.
69  void *userData);
70 
71 // The type of function that gets called when an RMI is triggered.
72 typedef void (*vtkRMIFunctionType)(void *localArg,
73  void *remoteArg, int remoteArgLength,
74  int remoteProcessId);
75 
76 class VTKPARALLELCORE_EXPORT vtkMultiProcessController : public vtkObject
77 {
78 public:
80  void PrintSelf(ostream& os, vtkIndent indent) VTK_OVERRIDE;
81 
87  virtual void Initialize(int* vtkNotUsed(argc), char*** vtkNotUsed(argv))=0;
88 
94  virtual void Initialize(int* vtkNotUsed(argc), char*** vtkNotUsed(argv),
95  int initializedExternally)=0;
96 
102  virtual void Finalize()=0;
103 
109  virtual void Finalize(int finalizedExternally)=0;
110 
112 
117  void SetNumberOfProcesses(int num);
118  int GetNumberOfProcesses();
120 
127  void SetSingleMethod(vtkProcessFunctionType, void *data);
128 
134  void SetSingleProcessObject(vtkProcess *p);
135 
141  virtual void SingleMethodExecute() = 0;
142 
149  void SetMultipleMethod(int index, vtkProcessFunctionType, void *data);
150 
156  virtual void MultipleMethodExecute() = 0;
157 
161  int GetLocalProcessId();
162 
169  static vtkMultiProcessController *GetGlobalController();
170 
176  virtual void CreateOutputWindow() = 0;
177 
189  virtual vtkMultiProcessController *CreateSubController(
190  vtkProcessGroup *group);
191 
202  virtual vtkMultiProcessController *PartitionController(int localColor,
203  int localKey);
204 
205  //------------------ RMIs --------------------
206 
219  virtual unsigned long AddRMI(vtkRMIFunctionType, void *localArg, int tag);
220 
224  virtual int RemoveFirstRMI(int tag);
225 
230  virtual int RemoveRMI(unsigned long id);
231 
235  virtual void RemoveRMI(vtkRMIFunctionType f, void *arg, int tag)
236  {(void)f; (void)arg; (void)tag; vtkErrorMacro("RemoveRMI Not Implemented Yet");};
237 
243  virtual unsigned long AddRMICallback(vtkRMIFunctionType, void* localArg, int tag);
244 
250  virtual void RemoveAllRMICallbacks(int tag);
251 
255  virtual bool RemoveRMICallback(unsigned long id);
256 
260  void TriggerRMI(int remoteProcessId, void *arg, int argLength, int tag);
261 
266  void TriggerBreakRMIs();
267 
271  void TriggerRMI(int remoteProcessId, const char *arg, int tag)
272  { this->TriggerRMI(remoteProcessId, (void*)arg,
273  static_cast<int>(strlen(arg))+1, tag); }
274 
278  void TriggerRMI(int remoteProcessId, int tag)
279  { this->TriggerRMI(remoteProcessId, NULL, 0, tag); }
280 
282 
290  void TriggerRMIOnAllChildren(void *arg, int argLength, int tag);
291  void TriggerRMIOnAllChildren(const char *arg, int tag)
292  {
293  this->TriggerRMIOnAllChildren(
294  (void*)arg, static_cast<int>(strlen(arg))+1, tag);
295  }
297  {
298  this->TriggerRMIOnAllChildren(NULL, 0, tag);
299  }
300  void BroadcastTriggerRMIOnAllChildren(void* arg, int argLength, int tag);
302 
304 
315  int ProcessRMIs(int reportErrors, int dont_loop = 0);
316  int ProcessRMIs();
317  int BroadcastProcessRMIs(int reportErrors, int dont_loop=0);
319 
321 
326  vtkSetMacro(BreakFlag, int);
327  vtkGetMacro(BreakFlag, int);
329 
331 
336  vtkSetMacro(BroadcastTriggerRMI,bool);
337  vtkGetMacro(BroadcastTriggerRMI,bool);
338  vtkBooleanMacro(BroadcastTriggerRMI,bool);
340 
342 
346  vtkGetObjectMacro(Communicator, vtkCommunicator);
348 
352  static int GetBreakRMITag() { return BREAK_RMI_TAG; }
353  static int GetRMITag() { return RMI_TAG; }
354  static int GetRMIArgTag() { return RMI_ARG_TAG; }
355 
356  enum Errors
357  {
360  RMI_ARG_ERROR
361  };
362 
363  enum Consts
364  {
365  ANY_SOURCE = -1,
366  INVALID_SOURCE = -2
367  };
368 
369  enum Tags
370  {
371  RMI_TAG = 1,
372  RMI_ARG_TAG = 2,
373  BREAK_RMI_TAG = 3,
374  XML_WRITER_DATA_INFO = 4
375  };
376 
380  void Barrier();
381 
382  static void SetGlobalController(vtkMultiProcessController *controller);
383 
384  //------------------ Communication --------------------
385 
387 
394  int Send(const int* data, vtkIdType length, int remoteProcessId, int tag);
395  int Send(const short* data, vtkIdType length, int remoteProcessId, int tag);
396  int Send(const unsigned short* data, vtkIdType length, int remoteProcessId, int tag);
397  int Send(const unsigned int* data, vtkIdType length, int remoteProcessId, int tag);
398  int Send(const unsigned long* data, vtkIdType length, int remoteProcessId,
399  int tag);
400  int Send(const long* data, vtkIdType length, int remoteProcessId,
401  int tag);
402  int Send(const signed char* data, vtkIdType length, int remoteProcessId, int tag);
403  int Send(const char* data, vtkIdType length, int remoteProcessId, int tag);
404  int Send(const unsigned char* data, vtkIdType length, int remoteProcessId, int tag);
405  int Send(const float* data, vtkIdType length, int remoteProcessId, int tag);
406  int Send(const double* data, vtkIdType length, int remoteProcessId, int tag);
407  int Send(const long long* data, vtkIdType length, int remoteProcessId, int tag);
408  int Send(const unsigned long long* data, vtkIdType length, int remoteProcessId, int tag);
409  int Send(vtkDataObject *data, int remoteId, int tag);
410  int Send(vtkDataArray *data, int remoteId, int tag);
412 
420  int Send(const vtkMultiProcessStream& stream, int remoteId, int tag);
421 
423 
432  int Receive(int* data, vtkIdType maxlength, int remoteProcessId, int tag);
433  int Receive(unsigned int* data, vtkIdType maxlength, int remoteProcessId, int tag);
434  int Receive(short* data, vtkIdType maxlength, int remoteProcessId, int tag);
435  int Receive(unsigned short* data, vtkIdType maxlength, int remoteProcessId, int tag);
436  int Receive(long* data, vtkIdType maxlength, int remoteProcessId, int tag);
437  int Receive(unsigned long* data, vtkIdType maxlength, int remoteProcessId,
438  int tag);
439  int Receive(char* data, vtkIdType maxlength, int remoteProcessId, int tag);
440  int Receive(unsigned char* data, vtkIdType maxlength, int remoteProcessId, int tag);
441  int Receive(signed char* data, vtkIdType maxlength, int remoteProcessId, int tag);
442  int Receive(float* data, vtkIdType maxlength, int remoteProcessId, int tag);
443  int Receive(double* data, vtkIdType maxlength, int remoteProcessId, int tag);
444  int Receive(long long* data, vtkIdType maxLength, int remoteProcessId, int tag);
445  int Receive(unsigned long long* data, vtkIdType maxLength, int remoteProcessId, int tag);
446  int Receive(vtkDataObject* data, int remoteId, int tag);
447  int Receive(vtkDataArray* data, int remoteId, int tag);
449 
453  int Receive(vtkMultiProcessStream& stream, int remoteId, int tag);
454 
455  vtkDataObject *ReceiveDataObject(int remoteId, int tag);
456 
465  vtkIdType GetCount();
466 
467 
468  //---------------------- Collective Operations ----------------------
469 
471 
476  int Broadcast(int *data, vtkIdType length, int srcProcessId) {
477  return this->Communicator->Broadcast(data, length, srcProcessId);
478  }
479  int Broadcast(unsigned int *data, vtkIdType length, int srcProcessId) {
480  return this->Communicator->Broadcast(data, length, srcProcessId);
481  }
482  int Broadcast(short *data, vtkIdType length, int srcProcessId) {
483  return this->Communicator->Broadcast(data, length, srcProcessId);
484  }
485  int Broadcast(unsigned short *data, vtkIdType length, int srcProcessId) {
486  return this->Communicator->Broadcast(data, length, srcProcessId);
487  }
488  int Broadcast(long *data, vtkIdType length, int srcProcessId) {
489  return this->Communicator->Broadcast(data, length, srcProcessId);
490  }
491  int Broadcast(unsigned long *data, vtkIdType length, int srcProcessId) {
492  return this->Communicator->Broadcast(data, length, srcProcessId);
493  }
494  int Broadcast(unsigned char *data, vtkIdType length, int srcProcessId) {
495  return this->Communicator->Broadcast(data, length, srcProcessId);
496  }
497  int Broadcast(char *data, vtkIdType length, int srcProcessId) {
498  return this->Communicator->Broadcast(data, length, srcProcessId);
499  }
500  int Broadcast(signed char *data, vtkIdType length, int srcProcessId) {
501  return this->Communicator->Broadcast(data, length, srcProcessId);
502  }
503  int Broadcast(float *data, vtkIdType length, int srcProcessId) {
504  return this->Communicator->Broadcast(data, length, srcProcessId);
505  }
506  int Broadcast(double *data, vtkIdType length, int srcProcessId) {
507  return this->Communicator->Broadcast(data, length, srcProcessId);
508  }
509  int Broadcast(long long *data, vtkIdType length, int srcProcessId) {
510  return this->Communicator->Broadcast(data, length, srcProcessId);
511  }
512  int Broadcast(unsigned long long *data, vtkIdType length, int srcProcessId) {
513  return this->Communicator->Broadcast(data, length, srcProcessId);
514  }
515  int Broadcast(vtkDataObject *data, int srcProcessId) {
516  return this->Communicator->Broadcast(data, srcProcessId);
517  }
518  int Broadcast(vtkDataArray *data, int srcProcessId) {
519  return this->Communicator->Broadcast(data, srcProcessId);
520  }
522 
523  int Broadcast(vtkMultiProcessStream& stream, int srcProcessId) {
524  return this->Communicator->Broadcast(stream, srcProcessId);
525  }
526 
528 
537  int Gather(const int *sendBuffer, int *recvBuffer,
538  vtkIdType length, int destProcessId) {
539  return this->Communicator->Gather(sendBuffer, recvBuffer, length,
540  destProcessId);
541  }
542  int Gather(const unsigned int *sendBuffer, unsigned int *recvBuffer,
543  vtkIdType length, int destProcessId) {
544  return this->Communicator->Gather(sendBuffer, recvBuffer, length,
545  destProcessId);
546  }
547  int Gather(const short *sendBuffer, short *recvBuffer,
548  vtkIdType length, int destProcessId) {
549  return this->Communicator->Gather(sendBuffer, recvBuffer, length,
550  destProcessId);
551  }
552  int Gather(const unsigned short *sendBuffer, unsigned short *recvBuffer,
553  vtkIdType length, int destProcessId) {
554  return this->Communicator->Gather(sendBuffer, recvBuffer, length,
555  destProcessId);
556  }
557  int Gather(const long *sendBuffer, long *recvBuffer,
558  vtkIdType length, int destProcessId) {
559  return this->Communicator->Gather(sendBuffer, recvBuffer, length,
560  destProcessId);
561  }
562  int Gather(const unsigned long *sendBuffer, unsigned long *recvBuffer,
563  vtkIdType length, int destProcessId) {
564  return this->Communicator->Gather(sendBuffer, recvBuffer, length,
565  destProcessId);
566  }
567  int Gather(const unsigned char *sendBuffer, unsigned char *recvBuffer,
568  vtkIdType length, int destProcessId) {
569  return this->Communicator->Gather(sendBuffer, recvBuffer, length,
570  destProcessId);
571  }
572  int Gather(const char *sendBuffer, char *recvBuffer,
573  vtkIdType length, int destProcessId) {
574  return this->Communicator->Gather(sendBuffer, recvBuffer, length,
575  destProcessId);
576  }
577  int Gather(const signed char *sendBuffer, signed char *recvBuffer,
578  vtkIdType length, int destProcessId) {
579  return this->Communicator->Gather(sendBuffer, recvBuffer, length,
580  destProcessId);
581  }
582  int Gather(const float *sendBuffer, float *recvBuffer,
583  vtkIdType length, int destProcessId) {
584  return this->Communicator->Gather(sendBuffer, recvBuffer, length,
585  destProcessId);
586  }
587  int Gather(const double *sendBuffer, double *recvBuffer,
588  vtkIdType length, int destProcessId) {
589  return this->Communicator->Gather(sendBuffer, recvBuffer, length,
590  destProcessId);
591  }
592  int Gather(const long long *sendBuffer, long long *recvBuffer,
593  vtkIdType length, int destProcessId) {
594  return this->Communicator->Gather(sendBuffer, recvBuffer, length,
595  destProcessId);
596  }
597  int Gather(const unsigned long long *sendBuffer, unsigned long long *recvBuffer,
598  vtkIdType length, int destProcessId) {
599  return this->Communicator->Gather(sendBuffer, recvBuffer, length,
600  destProcessId);
601  }
602  int Gather(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
603  int destProcessId) {
604  return this->Communicator->Gather(sendBuffer, recvBuffer, destProcessId);
605  }
607 
620  int Gather(vtkDataObject* sendBuffer,
622  int destProcessId)
623  {
624  return this->Communicator->Gather(sendBuffer, recvBuffer, destProcessId);
625  }
626 
628 
639  int GatherV(const int* sendBuffer, int* recvBuffer,
640  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
641  int destProcessId) {
642  return this->Communicator->GatherV(sendBuffer, recvBuffer,
643  sendLength, recvLengths,
644  offsets, destProcessId);
645  }
646  int GatherV(const unsigned int* sendBuffer, unsigned int* recvBuffer,
647  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
648  int destProcessId) {
649  return this->Communicator->GatherV(sendBuffer, recvBuffer,
650  sendLength, recvLengths,
651  offsets, destProcessId);
652  }
653  int GatherV(const short* sendBuffer, short* recvBuffer,
654  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
655  int destProcessId) {
656  return this->Communicator->GatherV(sendBuffer, recvBuffer,
657  sendLength, recvLengths,
658  offsets, destProcessId);
659  }
660  int GatherV(const unsigned short* sendBuffer, unsigned short* recvBuffer,
661  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
662  int destProcessId) {
663  return this->Communicator->GatherV(sendBuffer, recvBuffer,
664  sendLength, recvLengths,
665  offsets, destProcessId);
666  }
667  int GatherV(const long* sendBuffer, long* recvBuffer,
668  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
669  int destProcessId) {
670  return this->Communicator->GatherV(sendBuffer, recvBuffer,
671  sendLength, recvLengths,
672  offsets, destProcessId);
673  }
674  int GatherV(const unsigned long* sendBuffer, unsigned long* recvBuffer,
675  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
676  int destProcessId) {
677  return this->Communicator->GatherV(sendBuffer, recvBuffer,
678  sendLength, recvLengths,
679  offsets, destProcessId);
680  }
681  int GatherV(const unsigned char* sendBuffer, unsigned char* recvBuffer,
682  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
683  int destProcessId) {
684  return this->Communicator->GatherV(sendBuffer, recvBuffer,
685  sendLength, recvLengths,
686  offsets, destProcessId);
687  }
688  int GatherV(const char* sendBuffer, char* recvBuffer,
689  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
690  int destProcessId) {
691  return this->Communicator->GatherV(sendBuffer, recvBuffer,
692  sendLength, recvLengths,
693  offsets, destProcessId);
694  }
695  int GatherV(const signed char* sendBuffer, signed char* recvBuffer,
696  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
697  int destProcessId) {
698  return this->Communicator->GatherV(sendBuffer, recvBuffer,
699  sendLength, recvLengths,
700  offsets, destProcessId);
701  }
702  int GatherV(const float* sendBuffer, float* recvBuffer,
703  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
704  int destProcessId) {
705  return this->Communicator->GatherV(sendBuffer, recvBuffer,
706  sendLength, recvLengths,
707  offsets, destProcessId);
708  }
709  int GatherV(const double* sendBuffer, double* recvBuffer,
710  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
711  int destProcessId) {
712  return this->Communicator->GatherV(sendBuffer, recvBuffer,
713  sendLength, recvLengths,
714  offsets, destProcessId);
715  }
716  int GatherV(const long long* sendBuffer, long long* recvBuffer,
717  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
718  int destProcessId) {
719  return this->Communicator->GatherV(sendBuffer, recvBuffer,
720  sendLength, recvLengths,
721  offsets, destProcessId);
722  }
723  int GatherV(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
724  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
725  int destProcessId) {
726  return this->Communicator->GatherV(sendBuffer, recvBuffer,
727  sendLength, recvLengths,
728  offsets, destProcessId);
729  }
731 
732  int GatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
733  vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId) {
734  return this->Communicator->GatherV(sendBuffer, recvBuffer,
735  recvLengths, offsets,
736  destProcessId);
737  }
738  int GatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
739  vtkIdTypeArray* recvLengths,
740  vtkIdTypeArray* offsets,
741  int destProcessId)
742  {
743  return this->Communicator->GatherV(sendBuffer, recvBuffer,
744  recvLengths, offsets, destProcessId);
745  }
746 
747 
749 
755  int GatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
756  int destProcessId) {
757  return this->Communicator->GatherV(sendBuffer, recvBuffer, destProcessId);
758  }
760  int destProcessId)
761  {
762  return this->Communicator->GatherV(sendData, recvData, destProcessId);
763  }
765 
767 
774  int Scatter(const int *sendBuffer, int *recvBuffer,
775  vtkIdType length, int srcProcessId) {
776  return this->Communicator->Scatter(sendBuffer, recvBuffer, length,
777  srcProcessId);
778  }
779  int Scatter(const unsigned int *sendBuffer, unsigned int *recvBuffer,
780  vtkIdType length, int srcProcessId) {
781  return this->Communicator->Scatter(sendBuffer, recvBuffer, length,
782  srcProcessId);
783  }
784  int Scatter(const short *sendBuffer, short *recvBuffer,
785  vtkIdType length, int srcProcessId) {
786  return this->Communicator->Scatter(sendBuffer, recvBuffer, length,
787  srcProcessId);
788  }
789  int Scatter(const unsigned short *sendBuffer, unsigned short *recvBuffer,
790  vtkIdType length, int srcProcessId) {
791  return this->Communicator->Scatter(sendBuffer, recvBuffer, length,
792  srcProcessId);
793  }
794  int Scatter(const long *sendBuffer, long *recvBuffer,
795  vtkIdType length, int srcProcessId) {
796  return this->Communicator->Scatter(sendBuffer, recvBuffer, length,
797  srcProcessId);
798  }
799  int Scatter(const unsigned long *sendBuffer, unsigned long *recvBuffer,
800  vtkIdType length, int srcProcessId) {
801  return this->Communicator->Scatter(sendBuffer, recvBuffer, length,
802  srcProcessId);
803  }
804  int Scatter(const unsigned char *sendBuffer, unsigned char *recvBuffer,
805  vtkIdType length, int srcProcessId) {
806  return this->Communicator->Scatter(sendBuffer, recvBuffer, length,
807  srcProcessId);
808  }
809  int Scatter(const char *sendBuffer, char *recvBuffer,
810  vtkIdType length, int srcProcessId) {
811  return this->Communicator->Scatter(sendBuffer, recvBuffer, length,
812  srcProcessId);
813  }
814  int Scatter(const signed char *sendBuffer, signed char *recvBuffer,
815  vtkIdType length, int srcProcessId) {
816  return this->Communicator->Scatter(sendBuffer, recvBuffer, length,
817  srcProcessId);
818  }
819  int Scatter(const float *sendBuffer, float *recvBuffer,
820  vtkIdType length, int srcProcessId) {
821  return this->Communicator->Scatter(sendBuffer, recvBuffer, length,
822  srcProcessId);
823  }
824  int Scatter(const double *sendBuffer, double *recvBuffer,
825  vtkIdType length, int srcProcessId) {
826  return this->Communicator->Scatter(sendBuffer, recvBuffer, length,
827  srcProcessId);
828  }
829  int Scatter(const long long *sendBuffer, long long *recvBuffer,
830  vtkIdType length, int srcProcessId) {
831  return this->Communicator->Scatter(sendBuffer, recvBuffer, length,
832  srcProcessId);
833  }
834  int Scatter(const unsigned long long *sendBuffer, unsigned long long *recvBuffer,
835  vtkIdType length, int srcProcessId) {
836  return this->Communicator->Scatter(sendBuffer, recvBuffer, length,
837  srcProcessId);
838  }
839  int Scatter(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
840  int srcProcessId) {
841  return this->Communicator->Scatter(sendBuffer, recvBuffer, srcProcessId);
842  }
844 
846 
853  int ScatterV(const int *sendBuffer, int *recvBuffer,
854  vtkIdType *sendLengths, vtkIdType *offsets,
855  vtkIdType recvLength, int srcProcessId) {
856  return this->Communicator->ScatterV(sendBuffer, recvBuffer,
857  sendLengths, offsets, recvLength,
858  srcProcessId);
859  }
860  int ScatterV(const unsigned int *sendBuffer, unsigned int *recvBuffer,
861  vtkIdType *sendLengths, vtkIdType *offsets,
862  vtkIdType recvLength, int srcProcessId) {
863  return this->Communicator->ScatterV(sendBuffer, recvBuffer,
864  sendLengths, offsets, recvLength,
865  srcProcessId);
866  }
867  int ScatterV(const short *sendBuffer, short *recvBuffer,
868  vtkIdType *sendLengths, vtkIdType *offsets,
869  vtkIdType recvLength, int srcProcessId) {
870  return this->Communicator->ScatterV(sendBuffer, recvBuffer,
871  sendLengths, offsets, recvLength,
872  srcProcessId);
873  }
874  int ScatterV(const unsigned short *sendBuffer, unsigned short *recvBuffer,
875  vtkIdType *sendLengths, vtkIdType *offsets,
876  vtkIdType recvLength, int srcProcessId) {
877  return this->Communicator->ScatterV(sendBuffer, recvBuffer,
878  sendLengths, offsets, recvLength,
879  srcProcessId);
880  }
881  int ScatterV(const long *sendBuffer, long *recvBuffer,
882  vtkIdType *sendLengths, vtkIdType *offsets,
883  vtkIdType recvLength, int srcProcessId) {
884  return this->Communicator->ScatterV(sendBuffer, recvBuffer,
885  sendLengths, offsets, recvLength,
886  srcProcessId);
887  }
888  int ScatterV(const unsigned long *sendBuffer, unsigned long *recvBuffer,
889  vtkIdType *sendLengths, vtkIdType *offsets,
890  vtkIdType recvLength, int srcProcessId) {
891  return this->Communicator->ScatterV(sendBuffer, recvBuffer,
892  sendLengths, offsets, recvLength,
893  srcProcessId);
894  }
895  int ScatterV(const unsigned char *sendBuffer, unsigned char *recvBuffer,
896  vtkIdType *sendLengths, vtkIdType *offsets,
897  vtkIdType recvLength, int srcProcessId) {
898  return this->Communicator->ScatterV(sendBuffer, recvBuffer,
899  sendLengths, offsets, recvLength,
900  srcProcessId);
901  }
902  int ScatterV(const char *sendBuffer, char *recvBuffer,
903  vtkIdType *sendLengths, vtkIdType *offsets,
904  vtkIdType recvLength, int srcProcessId) {
905  return this->Communicator->ScatterV(sendBuffer, recvBuffer,
906  sendLengths, offsets, recvLength,
907  srcProcessId);
908  }
909  int ScatterV(const signed char *sendBuffer, signed char *recvBuffer,
910  vtkIdType *sendLengths, vtkIdType *offsets,
911  vtkIdType recvLength, int srcProcessId) {
912  return this->Communicator->ScatterV(sendBuffer, recvBuffer,
913  sendLengths, offsets, recvLength,
914  srcProcessId);
915  }
916  int ScatterV(const float *sendBuffer, float *recvBuffer,
917  vtkIdType *sendLengths, vtkIdType *offsets,
918  vtkIdType recvLength, int srcProcessId) {
919  return this->Communicator->ScatterV(sendBuffer, recvBuffer,
920  sendLengths, offsets, recvLength,
921  srcProcessId);
922  }
923  int ScatterV(const double *sendBuffer, double *recvBuffer,
924  vtkIdType *sendLengths, vtkIdType *offsets,
925  vtkIdType recvLength, int srcProcessId) {
926  return this->Communicator->ScatterV(sendBuffer, recvBuffer,
927  sendLengths, offsets, recvLength,
928  srcProcessId);
929  }
930  int ScatterV(const long long *sendBuffer, long long *recvBuffer,
931  vtkIdType *sendLengths, vtkIdType *offsets,
932  vtkIdType recvLength, int srcProcessId) {
933  return this->Communicator->ScatterV(sendBuffer, recvBuffer,
934  sendLengths, offsets, recvLength,
935  srcProcessId);
936  }
937  int ScatterV(const unsigned long long *sendBuffer, unsigned long long *recvBuffer,
938  vtkIdType *sendLengths, vtkIdType *offsets,
939  vtkIdType recvLength, int srcProcessId) {
940  return this->Communicator->ScatterV(sendBuffer, recvBuffer,
941  sendLengths, offsets, recvLength,
942  srcProcessId);
943  }
945 
947 
950  int AllGather(const int *sendBuffer, int *recvBuffer, vtkIdType length) {
951  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
952  }
953  int AllGather(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length) {
954  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
955  }
956  int AllGather(const short *sendBuffer, short *recvBuffer, vtkIdType length) {
957  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
958  }
959  int AllGather(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length) {
960  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
961  }
962  int AllGather(const long *sendBuffer, long *recvBuffer, vtkIdType length) {
963  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
964  }
965  int AllGather(const unsigned long *sendBuffer,
966  unsigned long *recvBuffer, vtkIdType length) {
967  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
968  }
969  int AllGather(const unsigned char *sendBuffer,
970  unsigned char *recvBuffer, vtkIdType length) {
971  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
972  }
973  int AllGather(const char *sendBuffer, char *recvBuffer, vtkIdType length) {
974  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
975  }
976  int AllGather(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length) {
977  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
978  }
979  int AllGather(const float *sendBuffer, float *recvBuffer, vtkIdType length) {
980  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
981  }
982  int AllGather(const double *sendBuffer,
983  double *recvBuffer, vtkIdType length) {
984  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
985  }
986  int AllGather(const long long *sendBuffer, long long *recvBuffer, vtkIdType length) {
987  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
988  }
989  int AllGather(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length) {
990  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
991  }
992  int AllGather(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer) {
993  return this->Communicator->AllGather(sendBuffer, recvBuffer);
994  }
996 
998 
1001  int AllGatherV(const int* sendBuffer, int* recvBuffer,
1002  vtkIdType sendLength, vtkIdType* recvLengths,
1003  vtkIdType* offsets) {
1004  return this->Communicator->AllGatherV(sendBuffer, recvBuffer,
1005  sendLength, recvLengths,
1006  offsets);
1007  }
1008  int AllGatherV(const unsigned int* sendBuffer, unsigned int* recvBuffer,
1009  vtkIdType sendLength, vtkIdType* recvLengths,
1010  vtkIdType* offsets) {
1011  return this->Communicator->AllGatherV(sendBuffer, recvBuffer,
1012  sendLength, recvLengths,
1013  offsets);
1014  }
1015  int AllGatherV(const short* sendBuffer, short* recvBuffer,
1016  vtkIdType sendLength, vtkIdType* recvLengths,
1017  vtkIdType* offsets) {
1018  return this->Communicator->AllGatherV(sendBuffer, recvBuffer,
1019  sendLength, recvLengths,
1020  offsets);
1021  }
1022  int AllGatherV(const unsigned short* sendBuffer, unsigned short* recvBuffer,
1023  vtkIdType sendLength, vtkIdType* recvLengths,
1024  vtkIdType* offsets) {
1025  return this->Communicator->AllGatherV(sendBuffer, recvBuffer,
1026  sendLength, recvLengths,
1027  offsets);
1028  }
1029  int AllGatherV(const long* sendBuffer, long* recvBuffer,
1030  vtkIdType sendLength, vtkIdType* recvLengths,
1031  vtkIdType* offsets) {
1032  return this->Communicator->AllGatherV(sendBuffer, recvBuffer,
1033  sendLength, recvLengths,
1034  offsets);
1035  }
1036  int AllGatherV(const unsigned long* sendBuffer, unsigned long* recvBuffer,
1037  vtkIdType sendLength, vtkIdType* recvLengths,
1038  vtkIdType* offsets) {
1039  return this->Communicator->AllGatherV(sendBuffer, recvBuffer,
1040  sendLength, recvLengths,
1041  offsets);
1042  }
1043  int AllGatherV(const unsigned char* sendBuffer, unsigned char* recvBuffer,
1044  vtkIdType sendLength, vtkIdType* recvLengths,
1045  vtkIdType* offsets) {
1046  return this->Communicator->AllGatherV(sendBuffer, recvBuffer,
1047  sendLength, recvLengths,
1048  offsets);
1049  }
1050  int AllGatherV(const char* sendBuffer, char* recvBuffer,
1051  vtkIdType sendLength, vtkIdType* recvLengths,
1052  vtkIdType* offsets) {
1053  return this->Communicator->AllGatherV(sendBuffer, recvBuffer,
1054  sendLength, recvLengths,
1055  offsets);
1056  }
1057  int AllGatherV(const signed char* sendBuffer, signed char* recvBuffer,
1058  vtkIdType sendLength, vtkIdType* recvLengths,
1059  vtkIdType* offsets) {
1060  return this->Communicator->AllGatherV(sendBuffer, recvBuffer,
1061  sendLength, recvLengths,
1062  offsets);
1063  }
1064  int AllGatherV(const float* sendBuffer, float* recvBuffer,
1065  vtkIdType sendLength, vtkIdType* recvLengths,
1066  vtkIdType* offsets) {
1067  return this->Communicator->AllGatherV(sendBuffer, recvBuffer,
1068  sendLength, recvLengths,
1069  offsets);
1070  }
1071  int AllGatherV(const double* sendBuffer, double* recvBuffer,
1072  vtkIdType sendLength, vtkIdType* recvLengths,
1073  vtkIdType* offsets) {
1074  return this->Communicator->AllGatherV(sendBuffer, recvBuffer,
1075  sendLength, recvLengths,
1076  offsets);
1077  }
1078  int AllGatherV(const long long* sendBuffer, long long* recvBuffer,
1079  vtkIdType sendLength, vtkIdType* recvLengths,
1080  vtkIdType* offsets) {
1081  return this->Communicator->AllGatherV(sendBuffer, recvBuffer,
1082  sendLength, recvLengths,
1083  offsets);
1084  }
1085  int AllGatherV(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
1086  vtkIdType sendLength, vtkIdType* recvLengths,
1087  vtkIdType* offsets) {
1088  return this->Communicator->AllGatherV(sendBuffer, recvBuffer,
1089  sendLength, recvLengths,
1090  offsets);
1091  }
1092  int AllGatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
1093  vtkIdType *recvLengths, vtkIdType *offsets) {
1094  return this->Communicator->AllGatherV(sendBuffer, recvBuffer,
1095  recvLengths, offsets);
1096  }
1098 
1105  int AllGatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer) {
1106  return this->Communicator->AllGatherV(sendBuffer, recvBuffer);
1107  }
1108 
1110 
1115  int Reduce(const int *sendBuffer, int *recvBuffer,
1116  vtkIdType length, int operation, int destProcessId) {
1117  return this->Communicator->Reduce(sendBuffer, recvBuffer, length,
1118  operation, destProcessId);
1119  }
1120  int Reduce(const unsigned int *sendBuffer, unsigned int *recvBuffer,
1121  vtkIdType length, int operation, int destProcessId) {
1122  return this->Communicator->Reduce(sendBuffer, recvBuffer, length,
1123  operation, destProcessId);
1124  }
1125  int Reduce(const short *sendBuffer, short *recvBuffer,
1126  vtkIdType length, int operation, int destProcessId) {
1127  return this->Communicator->Reduce(sendBuffer, recvBuffer, length,
1128  operation, destProcessId);
1129  }
1130  int Reduce(const unsigned short *sendBuffer, unsigned short *recvBuffer,
1131  vtkIdType length, int operation, int destProcessId) {
1132  return this->Communicator->Reduce(sendBuffer, recvBuffer, length,
1133  operation, destProcessId);
1134  }
1135  int Reduce(const long *sendBuffer, long *recvBuffer,
1136  vtkIdType length, int operation, int destProcessId) {
1137  return this->Communicator->Reduce(sendBuffer, recvBuffer, length,
1138  operation, destProcessId);
1139  }
1140  int Reduce(const unsigned long *sendBuffer, unsigned long *recvBuffer,
1141  vtkIdType length, int operation, int destProcessId) {
1142  return this->Communicator->Reduce(sendBuffer, recvBuffer, length,
1143  operation, destProcessId);
1144  }
1145  int Reduce(const unsigned char *sendBuffer, unsigned char *recvBuffer,
1146  vtkIdType length, int operation, int destProcessId) {
1147  return this->Communicator->Reduce(sendBuffer, recvBuffer, length,
1148  operation, destProcessId);
1149  }
1150  int Reduce(const char *sendBuffer, char *recvBuffer,
1151  vtkIdType length, int operation, int destProcessId) {
1152  return this->Communicator->Reduce(sendBuffer, recvBuffer, length,
1153  operation, destProcessId);
1154  }
1155  int Reduce(const signed char *sendBuffer, signed char *recvBuffer,
1156  vtkIdType length, int operation, int destProcessId) {
1157  return this->Communicator->Reduce(sendBuffer, recvBuffer, length,
1158  operation, destProcessId);
1159  }
1160  int Reduce(const float *sendBuffer, float *recvBuffer,
1161  vtkIdType length, int operation, int destProcessId) {
1162  return this->Communicator->Reduce(sendBuffer, recvBuffer, length,
1163  operation, destProcessId);
1164  }
1165  int Reduce(const double *sendBuffer, double *recvBuffer,
1166  vtkIdType length, int operation, int destProcessId) {
1167  return this->Communicator->Reduce(sendBuffer, recvBuffer, length,
1168  operation, destProcessId);
1169  }
1170  int Reduce(const long long *sendBuffer, long long *recvBuffer,
1171  vtkIdType length, int operation, int destProcessId) {
1172  return this->Communicator->Reduce(sendBuffer, recvBuffer, length,
1173  operation, destProcessId);
1174  }
1175  int Reduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer,
1176  vtkIdType length, int operation, int destProcessId) {
1177  return this->Communicator->Reduce(sendBuffer, recvBuffer, length,
1178  operation, destProcessId);
1179  }
1180  int Reduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
1181  int operation, int destProcessId) {
1182  return this->Communicator->Reduce(sendBuffer, recvBuffer,
1183  operation, destProcessId);
1184  }
1186 
1188 
1192  int Reduce(const int *sendBuffer, int *recvBuffer,
1194  int destProcessId) {
1195  return this->Communicator->Reduce(sendBuffer, recvBuffer, length,
1196  operation, destProcessId);
1197  }
1198  int Reduce(const unsigned int *sendBuffer, unsigned int *recvBuffer,
1200  int destProcessId) {
1201  return this->Communicator->Reduce(sendBuffer, recvBuffer, length,
1202  operation, destProcessId);
1203  }
1204  int Reduce(const short *sendBuffer, short *recvBuffer,
1206  int destProcessId) {
1207  return this->Communicator->Reduce(sendBuffer, recvBuffer, length,
1208  operation, destProcessId);
1209  }
1210  int Reduce(const unsigned short *sendBuffer, unsigned short *recvBuffer,
1212  int destProcessId) {
1213  return this->Communicator->Reduce(sendBuffer, recvBuffer, length,
1214  operation, destProcessId);
1215  }
1216  int Reduce(const long *sendBuffer, long *recvBuffer,
1218  int destProcessId) {
1219  return this->Communicator->Reduce(sendBuffer, recvBuffer, length,
1220  operation, destProcessId);
1221  }
1222  int Reduce(const unsigned long *sendBuffer, unsigned long *recvBuffer,
1224  int destProcessId) {
1225  return this->Communicator->Reduce(sendBuffer, recvBuffer, length,
1226  operation, destProcessId);
1227  }
1228  int Reduce(const unsigned char *sendBuffer, unsigned char *recvBuffer,
1230  int destProcessId) {
1231  return this->Communicator->Reduce(sendBuffer, recvBuffer, length,
1232  operation, destProcessId);
1233  }
1234  int Reduce(const char *sendBuffer, char *recvBuffer,
1236  int destProcessId) {
1237  return this->Communicator->Reduce(sendBuffer, recvBuffer, length,
1238  operation, destProcessId);
1239  }
1240  int Reduce(const signed char *sendBuffer, signed char *recvBuffer,
1242  int destProcessId) {
1243  return this->Communicator->Reduce(sendBuffer, recvBuffer, length,
1244  operation, destProcessId);
1245  }
1246  int Reduce(const float *sendBuffer, float *recvBuffer,
1248  int destProcessId) {
1249  return this->Communicator->Reduce(sendBuffer, recvBuffer, length,
1250  operation, destProcessId);
1251  }
1252  int Reduce(const double *sendBuffer, double *recvBuffer,
1254  int destProcessId) {
1255  return this->Communicator->Reduce(sendBuffer, recvBuffer, length,
1256  operation, destProcessId);
1257  }
1258  int Reduce(const long long *sendBuffer, long long *recvBuffer,
1260  int destProcessId) {
1261  return this->Communicator->Reduce(sendBuffer, recvBuffer, length,
1262  operation, destProcessId);
1263  }
1264  int Reduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer,
1266  int destProcessId) {
1267  return this->Communicator->Reduce(sendBuffer, recvBuffer, length,
1268  operation, destProcessId);
1269  }
1270  int Reduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
1271  vtkCommunicator::Operation *operation, int destProcessId) {
1272  return this->Communicator->Reduce(sendBuffer, recvBuffer,
1273  operation, destProcessId);
1274  }
1276 
1278 
1281  int AllReduce(const int *sendBuffer, int *recvBuffer,
1282  vtkIdType length, int operation) {
1283  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length,
1284  operation);
1285  }
1286  int AllReduce(const unsigned int *sendBuffer, unsigned int *recvBuffer,
1287  vtkIdType length, int operation) {
1288  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length,
1289  operation);
1290  }
1291  int AllReduce(const short *sendBuffer, short *recvBuffer,
1292  vtkIdType length, int operation) {
1293  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length,
1294  operation);
1295  }
1296  int AllReduce(const unsigned short *sendBuffer, unsigned short *recvBuffer,
1297  vtkIdType length, int operation) {
1298  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length,
1299  operation);
1300  }
1301  int AllReduce(const long *sendBuffer, long *recvBuffer,
1302  vtkIdType length, int operation) {
1303  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length,
1304  operation);
1305  }
1306  int AllReduce(const unsigned long *sendBuffer, unsigned long *recvBuffer,
1307  vtkIdType length, int operation) {
1308  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length,
1309  operation);
1310  }
1311  int AllReduce(const unsigned char *sendBuffer, unsigned char *recvBuffer,
1312  vtkIdType length, int operation) {
1313  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length,
1314  operation);
1315  }
1316  int AllReduce(const char *sendBuffer, char *recvBuffer,
1317  vtkIdType length, int operation) {
1318  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length,
1319  operation);
1320  }
1321  int AllReduce(const signed char *sendBuffer, signed char *recvBuffer,
1322  vtkIdType length, int operation) {
1323  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length,
1324  operation);
1325  }
1326  int AllReduce(const float *sendBuffer, float *recvBuffer,
1327  vtkIdType length, int operation) {
1328  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length,
1329  operation);
1330  }
1331  int AllReduce(const double *sendBuffer, double *recvBuffer,
1332  vtkIdType length, int operation) {
1333  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length,
1334  operation);
1335  }
1336  int AllReduce(const long long *sendBuffer, long long *recvBuffer,
1337  vtkIdType length, int operation) {
1338  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length,
1339  operation);
1340  }
1341  int AllReduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer,
1342  vtkIdType length, int operation) {
1343  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length,
1344  operation);
1345  }
1346  int AllReduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
1347  int operation) {
1348  return this->Communicator->AllReduce(sendBuffer, recvBuffer, operation);
1349  }
1351 
1352  int AllReduce(const int *sendBuffer, int *recvBuffer,
1354  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length,
1355  operation);
1356  }
1357  int AllReduce(const unsigned int *sendBuffer, unsigned int *recvBuffer,
1359  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length,
1360  operation);
1361  }
1362  int AllReduce(const short *sendBuffer, short *recvBuffer,
1364  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length,
1365  operation);
1366  }
1367  int AllReduce(const unsigned short *sendBuffer, unsigned short *recvBuffer,
1369  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length,
1370  operation);
1371  }
1372  int AllReduce(const long *sendBuffer, long *recvBuffer,
1374  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length,
1375  operation);
1376  }
1377  int AllReduce(const unsigned long *sendBuffer, unsigned long *recvBuffer,
1379  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length,
1380  operation);
1381  }
1382  int AllReduce(const unsigned char *sendBuffer, unsigned char *recvBuffer,
1384  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length,
1385  operation);
1386  }
1387  int AllReduce(const char *sendBuffer, char *recvBuffer,
1389  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length,
1390  operation);
1391  }
1392  int AllReduce(const signed char *sendBuffer, signed char *recvBuffer,
1394  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length,
1395  operation);
1396  }
1397  int AllReduce(const float *sendBuffer, float *recvBuffer,
1399  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length,
1400  operation);
1401  }
1402  int AllReduce(const double *sendBuffer, double *recvBuffer,
1404  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length,
1405  operation);
1406  }
1407  int AllReduce(const long long *sendBuffer, long long *recvBuffer,
1409  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length,
1410  operation);
1411  }
1412  int AllReduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer,
1414  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length,
1415  operation);
1416  }
1417  int AllReduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
1418  vtkCommunicator::Operation *operation) {
1419  return this->Communicator->AllReduce(sendBuffer, recvBuffer, operation);
1420  }
1421 
1422 // Internally implemented RMI to break the process loop.
1423 
1424 protected:
1426  ~vtkMultiProcessController() VTK_OVERRIDE;
1427 
1433  virtual void TriggerRMIInternal(int remoteProcessId,
1434  void* arg, int argLength, int rmiTag, bool propagate);
1435 
1437  void *SingleData;
1438 
1439  void GetMultipleMethod(int index, vtkProcessFunctionType &func, void *&data);
1440 
1441  // This is a flag that can be used by the ports to break
1442  // their update loop. (same as ProcessRMIs)
1443  int BreakFlag;
1444 
1445  void ProcessRMI(int remoteProcessId, void *arg, int argLength, int rmiTag);
1446 
1447  // This method implements "GetGlobalController".
1448  // It needs to be virtual and static.
1449  virtual vtkMultiProcessController *GetLocalController();
1450 
1451 
1452  // This flag can force deep copies during send.
1453  int ForceDeepCopy;
1454 
1455  // This flag can be used to indicate that an MPI Broadcast will be used
1456  // when calling TriggerRMIOnAllChildren(), instead of the binary tree
1457  // propagation of the data to the satellite ranks from rank 0.
1458  bool BroadcastTriggerRMI;
1459 
1460  vtkOutputWindow* OutputWindow;
1461 
1462  // Note that since the communicators can be created differently
1463  // depending on the type of controller, the subclasses are
1464  // responsible of deleting them.
1465  vtkCommunicator* Communicator;
1466 
1467  // Communicator which is a copy of the current user
1468  // level communicator except the context; i.e. even if the tags
1469  // are the same, the RMI messages will not interfere with user
1470  // level messages.
1471  // Note that since the communicators can be created differently
1472  // depending on the type of controller, the subclasses are
1473  // responsible of deleting them.
1474  vtkCommunicator* RMICommunicator;
1475 
1476 private:
1477  vtkMultiProcessController(const vtkMultiProcessController&) VTK_DELETE_FUNCTION;
1478  void operator=(const vtkMultiProcessController&) VTK_DELETE_FUNCTION;
1479 
1480  unsigned long RMICount;
1481 
1482  class vtkInternal;
1483  vtkInternal *Internal;
1484 
1485 };
1486 
1487 
1489  int remoteProcessId, int tag)
1490 {
1491  if (this->Communicator)
1492  {
1493  return this->Communicator->Send(data, remoteProcessId, tag);
1494  }
1495  else
1496  {
1497  return 0;
1498  }
1499 }
1500 
1502  int remoteProcessId, int tag)
1503 {
1504  if (this->Communicator)
1505  {
1506  return this->Communicator->Send(data, remoteProcessId, tag);
1507  }
1508  else
1509  {
1510  return 0;
1511  }
1512 }
1513 
1515  int remoteProcessId, int tag)
1516 {
1517  if (this->Communicator)
1518  {
1519  return this->Communicator->Send(data, length, remoteProcessId, tag);
1520  }
1521  else
1522  {
1523  return 0;
1524  }
1525 }
1526 
1528  int remoteProcessId, int tag)
1529 {
1530  if (this->Communicator)
1531  {
1532  return this->Communicator->Send(data, length, remoteProcessId, tag);
1533  }
1534  else
1535  {
1536  return 0;
1537  }
1538 }
1539 
1540 inline int vtkMultiProcessController::Send(const unsigned short* data, vtkIdType length,
1541  int remoteProcessId, int tag)
1542 {
1543  if (this->Communicator)
1544  {
1545  return this->Communicator->Send(data, length, remoteProcessId, tag);
1546  }
1547  else
1548  {
1549  return 0;
1550  }
1551 }
1552 
1553 inline int vtkMultiProcessController::Send(const unsigned int* data, vtkIdType length,
1554  int remoteProcessId, int tag)
1555 {
1556  if (this->Communicator)
1557  {
1558  return this->Communicator->Send(data, length, remoteProcessId, tag);
1559  }
1560  else
1561  {
1562  return 0;
1563  }
1564 }
1565 
1566 inline int vtkMultiProcessController::Send(const unsigned long* data,
1567  vtkIdType length,
1568  int remoteProcessId,
1569  int tag)
1570 {
1571  if (this->Communicator)
1572  {
1573  return this->Communicator->Send(data, length, remoteProcessId, tag);
1574  }
1575  else
1576  {
1577  return 0;
1578  }
1579 }
1580 
1581 inline int vtkMultiProcessController::Send(const long* data,
1582  vtkIdType length,
1583  int remoteProcessId,
1584  int tag)
1585 {
1586  if (this->Communicator)
1587  {
1588  return this->Communicator->Send(data, length, remoteProcessId, tag);
1589  }
1590  else
1591  {
1592  return 0;
1593  }
1594 }
1595 
1596 inline int vtkMultiProcessController::Send(const signed char* data, vtkIdType length,
1597  int remoteProcessId, int tag)
1598 {
1599  if (this->Communicator)
1600  {
1601  return this->Communicator->Send(data, length, remoteProcessId, tag);
1602  }
1603  else
1604  {
1605  return 0;
1606  }
1607 }
1608 
1610  int remoteProcessId, int tag)
1611 {
1612  if (this->Communicator)
1613  {
1614  return this->Communicator->Send(data, length, remoteProcessId, tag);
1615  }
1616  else
1617  {
1618  return 0;
1619  }
1620 }
1621 
1622 inline int vtkMultiProcessController::Send(const unsigned char* data,
1623  vtkIdType length,
1624  int remoteProcessId, int tag)
1625 {
1626  if (this->Communicator)
1627  {
1628  return this->Communicator->Send(data, length, remoteProcessId, tag);
1629  }
1630  else
1631  {
1632  return 0;
1633  }
1634 }
1635 
1637  int remoteProcessId, int tag)
1638 {
1639  if (this->Communicator)
1640  {
1641  return this->Communicator->Send(data, length, remoteProcessId, tag);
1642  }
1643  else
1644  {
1645  return 0;
1646  }
1647 }
1648 
1650  int remoteProcessId, int tag)
1651 {
1652  if (this->Communicator)
1653  {
1654  return this->Communicator->Send(data, length, remoteProcessId, tag);
1655  }
1656  else
1657  {
1658  return 0;
1659  }
1660 }
1661 
1662 inline int vtkMultiProcessController::Send(const long long* data,
1663  vtkIdType length,
1664  int remoteProcessId, int tag)
1665 {
1666  if (this->Communicator)
1667  {
1668  return this->Communicator->Send(data, length, remoteProcessId, tag);
1669  }
1670  else
1671  {
1672  return 0;
1673  }
1674 }
1675 
1676 inline int vtkMultiProcessController::Send(const unsigned long long* data,
1677  vtkIdType length,
1678  int remoteProcessId, int tag)
1679 {
1680  if (this->Communicator)
1681  {
1682  return this->Communicator->Send(data, length, remoteProcessId, tag);
1683  }
1684  else
1685  {
1686  return 0;
1687  }
1688 }
1689 
1691  int remoteId, int tag)
1692 {
1693  if (this->Communicator)
1694  {
1695  return this->Communicator->Send(stream, remoteId, tag);
1696  }
1697  return 0;
1698 }
1699 
1701  int remoteProcessId, int tag)
1702 {
1703  if (this->Communicator)
1704  {
1705  return this->Communicator->Receive(data, remoteProcessId, tag);
1706  }
1707  else
1708  {
1709  return 0;
1710  }
1711 }
1712 
1714  int remoteProcessId, int tag)
1715 {
1716  if (this->Communicator)
1717  {
1718  return this->Communicator->ReceiveDataObject(remoteProcessId, tag);
1719  }
1720  else
1721  {
1722  return 0;
1723  }
1724 }
1725 
1727  int remoteProcessId, int tag)
1728 {
1729  if (this->Communicator)
1730  {
1731  return this->Communicator->Receive(data, remoteProcessId, tag);
1732  }
1733  else
1734  {
1735  return 0;
1736  }
1737 }
1738 
1740  int remoteProcessId, int tag)
1741 {
1742  if (this->Communicator)
1743  {
1744  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1745  }
1746  else
1747  {
1748  return 0;
1749  }
1750 }
1751 
1753  int remoteProcessId, int tag)
1754 {
1755  if (this->Communicator)
1756  {
1757  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1758  }
1759  else
1760  {
1761  return 0;
1762  }
1763 }
1764 
1766  int remoteProcessId, int tag)
1767 {
1768  if (this->Communicator)
1769  {
1770  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1771  }
1772  else
1773  {
1774  return 0;
1775  }
1776 }
1777 
1779  int remoteProcessId, int tag)
1780 {
1781  if (this->Communicator)
1782  {
1783  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1784  }
1785  else
1786  {
1787  return 0;
1788  }
1789 }
1790 
1792  int remoteProcessId, int tag)
1793 {
1794  if (this->Communicator)
1795  {
1796  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1797  }
1798  else
1799  {
1800  return 0;
1801  }
1802 }
1803 
1804 
1805 inline int vtkMultiProcessController::Receive(unsigned long* data,
1806  vtkIdType length,
1807  int remoteProcessId,
1808  int tag)
1809 {
1810  if (this->Communicator)
1811  {
1812  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1813  }
1814  else
1815  {
1816  return 0;
1817  }
1818 }
1819 
1821  int remoteProcessId, int tag)
1822 {
1823  if (this->Communicator)
1824  {
1825  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1826  }
1827  else
1828  {
1829  return 0;
1830  }
1831 }
1832 
1833 inline int vtkMultiProcessController::Receive(unsigned char* data,
1834  vtkIdType length,
1835  int remoteProcessId, int tag)
1836 {
1837  if (this->Communicator)
1838  {
1839  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1840  }
1841  else
1842  {
1843  return 0;
1844  }
1845 }
1846 
1848  int remoteProcessId, int tag)
1849 {
1850  if (this->Communicator)
1851  {
1852  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1853  }
1854  else
1855  {
1856  return 0;
1857  }
1858 }
1859 
1860 
1862  int remoteProcessId, int tag)
1863 {
1864  if (this->Communicator)
1865  {
1866  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1867  }
1868  else
1869  {
1870  return 0;
1871  }
1872 }
1873 
1875  int remoteProcessId, int tag)
1876 {
1877  if (this->Communicator)
1878  {
1879  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1880  }
1881  else
1882  {
1883  return 0;
1884  }
1885 }
1886 
1888  int remoteProcessId, int tag)
1889 {
1890  if (this->Communicator)
1891  {
1892  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1893  }
1894  else
1895  {
1896  return 0;
1897  }
1898 }
1899 
1901  int remoteProcessId, int tag)
1902 {
1903  if (this->Communicator)
1904  {
1905  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1906  }
1907  else
1908  {
1909  return 0;
1910  }
1911 }
1912 
1914  int remoteId, int tag)
1915 {
1916  if (this->Communicator)
1917  {
1918  return this->Communicator->Receive(stream, remoteId, tag);
1919  }
1920  return 0;
1921 }
1922 
1924 {
1925  if (this->Communicator)
1926  {
1927  this->Communicator->Barrier();
1928  }
1929 }
1930 
1932 {
1933  if (this->Communicator)
1934  {
1935  return this->Communicator->GetCount();
1936  }
1937  return 0;
1938 }
1939 
1940 #endif
int AllGather(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
int AllGather(const float *sendBuffer, float *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
int Scatter(const int *sendBuffer, int *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
void TriggerRMI(int remoteProcessId, int tag)
Convenience method when there is no argument.
void(* vtkProcessFunctionType)(vtkMultiProcessController *controller, void *userData)
int Broadcast(short *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes...
int Reduce(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
int Reduce(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
int Send(vtkDataObject *data, int remoteHandle, int tag)
This method sends a data object to a destination.
int Scatter(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
int AllGatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, vtkIdType *recvLengths, vtkIdType *offsets)
Same as GatherV except that the result is placed in all processes.
A custom operation to use in a reduce command.
int ScatterV(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
int Reduce(const long *sendBuffer, long *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
int AllReduce(const int *sendBuffer, int *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
int Reduce(const long *sendBuffer, long *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Reduce an array to the given destination process.
int Reduce(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
abstract base class for most VTK objects
Definition: vtkObject.h:53
int Gather(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
int AllGather(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
int AllGatherV(const double *sendBuffer, double *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Same as GatherV except that the result is placed in all processes.
int AllReduce(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
int Scatter(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
int ScatterV(const long long *sendBuffer, long long *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
int Reduce(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Reduce an array to the given destination process.
int AllReduce(const char *sendBuffer, char *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
int AllGatherV(const long long *sendBuffer, long long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Same as GatherV except that the result is placed in all processes.
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
int Scatter(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
int Reduce(const int *sendBuffer, int *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
int AllGather(const long *sendBuffer, long *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
int GatherV(const int *sendBuffer, int *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
stream used to pass data across processes using vtkMultiProcessController.
int Reduce(const char *sendBuffer, char *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Reduce an array to the given destination process.
void TriggerRMIOnAllChildren(const char *arg, int tag)
This is a convenicence method to trigger an RMI call on all the "children" of the current node...
int ScatterV(const double *sendBuffer, double *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
int Scatter(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
abstract class to specify dataset behavior
Definition: vtkDataSet.h:56
int AllGatherV(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Same as GatherV except that the result is placed in all processes.
void TriggerRMIOnAllChildren(int tag)
This is a convenicence method to trigger an RMI call on all the "children" of the current node...
int AllReduce(const float *sendBuffer, float *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
int GatherV(vtkDataObject *sendData, vtkSmartPointer< vtkDataObject > *recvData, int destProcessId)
This special form of GatherV will automatically determine recvLengths and offsets to tightly pack the...
int AllGatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer)
This special form of AllGatherV will automatically determine recvLengths and offsets to tightly pack ...
int Gather(const long *sendBuffer, long *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
int AllReduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, vtkCommunicator::Operation *operation)
a process that can be launched by a vtkMultiProcessController
Definition: vtkProcess.h:46
int GatherV(const double *sendBuffer, double *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
int AllReduce(const int *sendBuffer, int *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
int Reduce(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Reduce an array to the given destination process.
int Reduce(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Reduce an array to the given destination process.
int ScatterV(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
int Gather(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
int Gather(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
int AllGatherV(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Same as GatherV except that the result is placed in all processes.
int Reduce(const short *sendBuffer, short *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
int Broadcast(int *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes...
int AllReduce(const char *sendBuffer, char *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
int AllGather(const short *sendBuffer, short *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
int AllReduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, int operation)
Same as Reduce except that the result is placed in all of the processes.
dynamic, self-adjusting array of vtkIdType
int AllReduce(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
int AllGather(const double *sendBuffer, double *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
int AllGather(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
int vtkIdType
Definition: vtkType.h:345
int ScatterV(const char *sendBuffer, char *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
int GatherV(const long long *sendBuffer, long long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
int Gather(const short *sendBuffer, short *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
int Broadcast(unsigned long long *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes...
int AllReduce(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
int Reduce(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Reduce an array to the given destination process.
int AllReduce(const long *sendBuffer, long *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
static int GetBreakRMITag()
Accessor to some default tags.
int Broadcast(vtkMultiProcessStream &stream, int srcProcessId)
int Reduce(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Reduce an array to the given destination process.
int Scatter(const short *sendBuffer, short *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
int ScatterV(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
int AllGather(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
int AllGather(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
int Reduce(const double *sendBuffer, double *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Reduce an array to the given destination process.
int AllGatherV(const int *sendBuffer, int *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Same as GatherV except that the result is placed in all processes.
int Gather(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
int AllReduce(const long *sendBuffer, long *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
int Broadcast(char *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes...
int AllReduce(const short *sendBuffer, short *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
int Scatter(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
int ScatterV(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
int Gather(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, int destProcessId)
Gather collects arrays in the process with id destProcessId.
int AllReduce(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
void(* vtkRMIFunctionType)(void *localArg, void *remoteArg, int remoteArgLength, int remoteProcessId)
int Gather(const float *sendBuffer, float *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
int Reduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, int operation, int destProcessId)
Reduce an array to the given destination process.
void TriggerRMI(int remoteProcessId, const char *arg, int tag)
Convenience method when the arg is a string.
int GatherV(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
int Reduce(const int *sendBuffer, int *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Reduce an array to the given destination process.
int AllReduce(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
int Broadcast(float *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes...
a simple class to control print indentation
Definition: vtkIndent.h:33
int GatherV(const short *sendBuffer, short *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
int AllReduce(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
int AllReduce(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
int Gather(vtkDataObject *sendBuffer, std::vector< vtkSmartPointer< vtkDataObject > > &recvBuffer, int destProcessId)
Gathers vtkDataObject (sendBuffer) from all ranks to the destProcessId.
topologically and geometrically regular array of data
Definition: vtkImageData.h:39
virtual void RemoveRMI(vtkRMIFunctionType f, void *arg, int tag)
Take an RMI away.
int Reduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Reduce an array to the given destination process.
int AllReduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:48
A subgroup of processes from a communicator.
int AllReduce(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
int AllGatherV(const long *sendBuffer, long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Same as GatherV except that the result is placed in all processes.
int Broadcast(vtkDataObject *data, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes...
int Reduce(const short *sendBuffer, short *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Reduce an array to the given destination process.
int AllGatherV(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Same as GatherV except that the result is placed in all processes.
vtkDataObject * ReceiveDataObject(int remoteId, int tag)
int GatherV(const char *sendBuffer, char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
int AllReduce(const double *sendBuffer, double *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
int AllGather(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer)
Same as gather except that the result ends up on all processes.
int AllGather(const int *sendBuffer, int *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
int GatherV(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
int ScatterV(const short *sendBuffer, short *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
void Barrier()
This method can be used to synchronize processes.
int Broadcast(unsigned int *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes...
int Scatter(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
int GatherV(const long *sendBuffer, long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
base class for writing debug output to a console
int AllGatherV(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Same as GatherV except that the result is placed in all processes.
int AllReduce(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
vtkSetMacro(IgnoreDriverBugs, bool)
When set known driver bugs are ignored during driver feature detection.
int AllReduce(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
int Broadcast(unsigned char *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes...
int Reduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, vtkCommunicator::Operation *operation, int destProcessId)
Reduce an array to the given destination process.
int GatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, vtkIdTypeArray *recvLengths, vtkIdTypeArray *offsets, int destProcessId)
int GatherV(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
int AllReduce(const double *sendBuffer, double *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
int AllGatherV(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Same as GatherV except that the result is placed in all processes.
int AllReduce(const short *sendBuffer, short *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
int AllReduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
int Reduce(const double *sendBuffer, double *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
int GatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
int GatherV(const float *sendBuffer, float *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
int ScatterV(const float *sendBuffer, float *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
int ScatterV(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
int Send(const int *data, vtkIdType length, int remoteProcessId, int tag)
This method sends data to another process.
create and manipulate ordered lists of objects
Definition: vtkCollection.h:48
int AllReduce(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
int Scatter(const float *sendBuffer, float *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
int Gather(const double *sendBuffer, double *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
int AllGatherV(const float *sendBuffer, float *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Same as GatherV except that the result is placed in all processes.
int Reduce(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Reduce an array to the given destination process.
int Broadcast(vtkDataArray *data, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes...
int Receive(int *data, vtkIdType maxlength, int remoteProcessId, int tag)
This method receives data from a corresponding send.
int AllGather(const long long *sendBuffer, long long *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
int Reduce(const float *sendBuffer, float *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
int Broadcast(double *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes...
int Reduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
int Reduce(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
int Broadcast(long long *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes...
int AllGather(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
int Broadcast(signed char *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes...
int Reduce(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
int Reduce(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
int Gather(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
int Broadcast(unsigned long *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes...
int Reduce(const float *sendBuffer, float *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Reduce an array to the given destination process.
int Broadcast(unsigned short *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes...
int Scatter(const char *sendBuffer, char *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
int AllGatherV(const char *sendBuffer, char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Same as GatherV except that the result is placed in all processes.
int Scatter(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
int GatherV(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
vtkBooleanMacro(IgnoreDriverBugs, bool)
When set known driver bugs are ignored during driver feature detection.
int AllGatherV(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Same as GatherV except that the result is placed in all processes.
vtkIdType GetCount()
Returns the number of words received by the most recent Receive().
int Reduce(const char *sendBuffer, char *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
int Scatter(const double *sendBuffer, double *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
int ScatterV(const long *sendBuffer, long *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
Used to send/receive messages in a multiprocess environment.
general representation of visualization data
Definition: vtkDataObject.h:58
int Gather(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
int ScatterV(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
int AllGatherV(const short *sendBuffer, short *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Same as GatherV except that the result is placed in all processes.
int AllReduce(const float *sendBuffer, float *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
int Broadcast(long *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes...
int Gather(const int *sendBuffer, int *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
int Scatter(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
int GatherV(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
int GatherV(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
int AllReduce(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
int GatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, int destProcessId)
This special form of GatherV will automatically determine recvLengths and offsets to tightly pack the...
int Gather(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
int Scatter(const long *sendBuffer, long *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
int ScatterV(const int *sendBuffer, int *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
int Gather(const char *sendBuffer, char *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
int AllGather(const char *sendBuffer, char *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
Multiprocessing communication superclass.