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) 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, nullptr, 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(nullptr, 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() 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)
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.
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.
1459 
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.
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.
1475 
1476 private:
1478  void operator=(const vtkMultiProcessController&) = delete;
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 nullptr;
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
vtkMultiProcessController::GatherV
int GatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, vtkIdTypeArray *recvLengths, vtkIdTypeArray *offsets, int destProcessId)
Definition: vtkMultiProcessController.h:738
vtkMultiProcessController::Scatter
int Scatter(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:789
vtkMultiProcessController::TriggerRMIOnAllChildren
void TriggerRMIOnAllChildren(const char *arg, int tag)
Definition: vtkMultiProcessController.h:291
vtkMultiProcessController::AllReduce
int AllReduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
Definition: vtkMultiProcessController.h:1412
vtkMultiProcessController::AllReduce
int AllReduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length, int operation)
Definition: vtkMultiProcessController.h:1341
vtkCommunicator::Receive
int Receive(vtkDataObject *data, int remoteHandle, int tag)
This method receives a data object from a corresponding send.
vtkX3D::vector
Definition: vtkX3D.h:237
vtkMultiProcessController::Broadcast
int Broadcast(long *data, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:488
vtkMultiProcessController::AllGatherV
int AllGatherV(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Definition: vtkMultiProcessController.h:1057
vtkMultiProcessController::RMICommunicator
vtkCommunicator * RMICommunicator
Definition: vtkMultiProcessController.h:1474
vtkMultiProcessController::AllGather
int AllGather(const long *sendBuffer, long *recvBuffer, vtkIdType length)
Definition: vtkMultiProcessController.h:962
vtkMultiProcessController::Reduce
int Reduce(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Definition: vtkMultiProcessController.h:1240
vtkMultiProcessController::Scatter
int Scatter(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:814
vtkMultiProcessController::Reduce
int Reduce(const char *sendBuffer, char *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Definition: vtkMultiProcessController.h:1234
vtkMultiProcessController::Consts
Consts
Definition: vtkMultiProcessController.h:363
vtkMultiProcessController::Reduce
int Reduce(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Definition: vtkMultiProcessController.h:1258
vtkMultiProcessController::ReceiveDataObject
vtkDataObject * ReceiveDataObject(int remoteId, int tag)
Definition: vtkMultiProcessController.h:1713
vtkProcessFunctionType
void(* vtkProcessFunctionType)(vtkMultiProcessController *controller, void *userData)
Definition: vtkMultiProcessController.h:68
vtkMultiProcessController::Broadcast
int Broadcast(long long *data, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:509
vtkMultiProcessController::AllReduce
int AllReduce(const double *sendBuffer, double *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
Definition: vtkMultiProcessController.h:1402
vtkMultiProcessController::Receive
int Receive(int *data, vtkIdType maxlength, int remoteProcessId, int tag)
This method receives data from a corresponding send.
Definition: vtkMultiProcessController.h:1739
vtkMultiProcessController::AllGatherV
int AllGatherV(const long *sendBuffer, long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Definition: vtkMultiProcessController.h:1029
vtkMultiProcessController::Broadcast
int Broadcast(unsigned long *data, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:491
vtkMultiProcessController::GatherV
int GatherV(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
Definition: vtkMultiProcessController.h:695
vtkMultiProcessController::AllGatherV
int AllGatherV(const char *sendBuffer, char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Definition: vtkMultiProcessController.h:1050
vtkCommunicator
Used to send/receive messages in a multiprocess environment.
Definition: vtkCommunicator.h:50
vtkIdType
int vtkIdType
Definition: vtkType.h:347
vtkMultiProcessController::Communicator
vtkCommunicator * Communicator
Definition: vtkMultiProcessController.h:1465
vtkMultiProcessController::Gather
int Gather(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, int destProcessId)
Definition: vtkMultiProcessController.h:602
vtkMultiProcessController::AllReduce
int AllReduce(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
Definition: vtkMultiProcessController.h:1392
vtkMultiProcessController::Scatter
int Scatter(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:834
vtkMultiProcessController::Reduce
int Reduce(const int *sendBuffer, int *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Reduce an array to the given destination process.
Definition: vtkMultiProcessController.h:1192
vtkMultiProcessController::SingleMethod
vtkProcessFunctionType SingleMethod
Definition: vtkMultiProcessController.h:1436
vtkX3D::data
Definition: vtkX3D.h:315
vtkMultiProcessController::Scatter
int Scatter(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:829
vtkMultiProcessController::Broadcast
int Broadcast(unsigned char *data, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:494
vtkMultiProcessController::AllReduce
int AllReduce(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
Definition: vtkMultiProcessController.h:1377
vtkMultiProcessController::GatherV
int GatherV(const long *sendBuffer, long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
Definition: vtkMultiProcessController.h:667
vtkMultiProcessController::AllGather
int AllGather(const double *sendBuffer, double *recvBuffer, vtkIdType length)
Definition: vtkMultiProcessController.h:982
vtkMultiProcessController::ScatterV
int ScatterV(const long *sendBuffer, long *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
Definition: vtkMultiProcessController.h:881
vtkCommunicator::Operation
A custom operation to use in a reduce command.
Definition: vtkCommunicator.h:104
vtkMultiProcessStream
stream used to pass data across processes using vtkMultiProcessController.
Definition: vtkMultiProcessStream.h:37
vtkMultiProcessController::Reduce
int Reduce(const long *sendBuffer, long *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Definition: vtkMultiProcessController.h:1216
vtkMultiProcessController::Broadcast
int Broadcast(unsigned long long *data, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:512
vtkMultiProcessController::Reduce
int Reduce(const short *sendBuffer, short *recvBuffer, vtkIdType length, int operation, int destProcessId)
Definition: vtkMultiProcessController.h:1125
vtkMultiProcessController::GatherV
int GatherV(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
Definition: vtkMultiProcessController.h:674
vtkMultiProcessController::Gather
int Gather(vtkDataObject *sendBuffer, std::vector< vtkSmartPointer< vtkDataObject > > &recvBuffer, int destProcessId)
Gathers vtkDataObject (sendBuffer) from all ranks to the destProcessId.
Definition: vtkMultiProcessController.h:620
vtkMultiProcessController::Reduce
int Reduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Definition: vtkMultiProcessController.h:1264
vtkMultiProcessController::Reduce
int Reduce(const double *sendBuffer, double *recvBuffer, vtkIdType length, int operation, int destProcessId)
Definition: vtkMultiProcessController.h:1165
vtkMultiProcessController::AllGather
int AllGather(const short *sendBuffer, short *recvBuffer, vtkIdType length)
Definition: vtkMultiProcessController.h:956
vtkMultiProcessController::AllReduce
int AllReduce(const short *sendBuffer, short *recvBuffer, vtkIdType length, int operation)
Definition: vtkMultiProcessController.h:1291
vtkMultiProcessController::AllReduce
int AllReduce(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
Definition: vtkMultiProcessController.h:1407
vtkCommunicator::Barrier
virtual void Barrier()
Will block the processes until all other processes reach the Barrier function.
vtkMultiProcessController::Gather
int Gather(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, int destProcessId)
Definition: vtkMultiProcessController.h:577
vtkSmartPointer< vtkDataObject >
vtkObject
abstract base class for most VTK objects
Definition: vtkObject.h:53
vtkMultiProcessController::GetRMITag
static int GetRMITag()
Definition: vtkMultiProcessController.h:353
vtkMultiProcessController::Broadcast
int Broadcast(vtkDataArray *data, int srcProcessId)
Definition: vtkMultiProcessController.h:518
vtkMultiProcessController::GatherV
int GatherV(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
Definition: vtkMultiProcessController.h:681
vtkMultiProcessController::AllReduce
int AllReduce(const long *sendBuffer, long *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
Definition: vtkMultiProcessController.h:1372
vtkMultiProcessController::AllGatherV
int AllGatherV(const float *sendBuffer, float *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Definition: vtkMultiProcessController.h:1064
vtkX3D::length
Definition: vtkX3D.h:393
vtkMultiProcessController::Gather
int Gather(const char *sendBuffer, char *recvBuffer, vtkIdType length, int destProcessId)
Definition: vtkMultiProcessController.h:572
vtkMultiProcessController::BroadcastTriggerRMI
bool BroadcastTriggerRMI
Definition: vtkMultiProcessController.h:1458
vtkMultiProcessController::Gather
int Gather(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, int destProcessId)
Definition: vtkMultiProcessController.h:592
vtkMultiProcessController::GatherV
int GatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, int destProcessId)
This special form of GatherV will automatically determine recvLengths and offsets to tightly pack the...
Definition: vtkMultiProcessController.h:755
vtkMultiProcessController::AllReduce
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.
Definition: vtkMultiProcessController.h:1281
vtkDataArray
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:48
vtkMultiProcessController::TriggerRMIOnAllChildren
void TriggerRMIOnAllChildren(int tag)
Definition: vtkMultiProcessController.h:296
vtkMultiProcessController::Broadcast
int Broadcast(signed char *data, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:500
vtkMultiProcessController::RMI_NO_ERROR
Definition: vtkMultiProcessController.h:358
vtkMultiProcessController::Reduce
int Reduce(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, int operation, int destProcessId)
Definition: vtkMultiProcessController.h:1120
vtkMultiProcessController::AllGatherV
int AllGatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer)
This special form of AllGatherV will automatically determine recvLengths and offsets to tightly pack ...
Definition: vtkMultiProcessController.h:1105
vtkMultiProcessController::AllGather
int AllGather(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length)
Definition: vtkMultiProcessController.h:989
vtkMultiProcessController::Broadcast
int Broadcast(double *data, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:506
vtkMultiProcessController::AllGather
int AllGather(const int *sendBuffer, int *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
Definition: vtkMultiProcessController.h:950
vtkMultiProcessController::AllGather
int AllGather(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length)
Definition: vtkMultiProcessController.h:953
vtkMultiProcessController::Broadcast
int Broadcast(int *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes.
Definition: vtkMultiProcessController.h:476
vtkMultiProcessController::Broadcast
int Broadcast(unsigned int *data, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:479
vtkMultiProcessController::Gather
int Gather(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, int destProcessId)
Definition: vtkMultiProcessController.h:567
vtkMultiProcessController::AllReduce
int AllReduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, vtkCommunicator::Operation *operation)
Definition: vtkMultiProcessController.h:1417
vtkMultiProcessController::Tags
Tags
Definition: vtkMultiProcessController.h:369
vtkMultiProcessController::AllGatherV
int AllGatherV(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Definition: vtkMultiProcessController.h:1022
vtkMultiProcessController::AllGatherV
int AllGatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, vtkIdType *recvLengths, vtkIdType *offsets)
Definition: vtkMultiProcessController.h:1092
vtkMultiProcessController::Reduce
int Reduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, int operation, int destProcessId)
Definition: vtkMultiProcessController.h:1180
vtkCommunicator::ReceiveDataObject
vtkDataObject * ReceiveDataObject(int remoteHandle, int tag)
The caller does not have to know the data type before this call is made.
vtkMultiProcessController::ScatterV
int ScatterV(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
Definition: vtkMultiProcessController.h:874
vtkMultiProcessController::Broadcast
int Broadcast(float *data, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:503
vtkMultiProcessController::Scatter
int Scatter(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:799
vtkMultiProcessController::AllReduce
int AllReduce(const double *sendBuffer, double *recvBuffer, vtkIdType length, int operation)
Definition: vtkMultiProcessController.h:1331
vtkMultiProcessController::AllReduce
int AllReduce(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, int operation)
Definition: vtkMultiProcessController.h:1286
vtkMultiProcessController::Reduce
int Reduce(const long *sendBuffer, long *recvBuffer, vtkIdType length, int operation, int destProcessId)
Definition: vtkMultiProcessController.h:1135
vtkMultiProcessController::AllReduce
int AllReduce(const int *sendBuffer, int *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
Definition: vtkMultiProcessController.h:1352
vtkMultiProcessController::Reduce
int Reduce(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Definition: vtkMultiProcessController.h:1222
vtkMultiProcessController::Reduce
int Reduce(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Definition: vtkMultiProcessController.h:1198
vtkMultiProcessController::AllGather
int AllGather(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length)
Definition: vtkMultiProcessController.h:959
vtkMultiProcessController::ScatterV
int ScatterV(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
Definition: vtkMultiProcessController.h:895
vtkMultiProcessController::GatherV
int GatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
Definition: vtkMultiProcessController.h:732
vtkCollection
create and manipulate ordered lists of objects
Definition: vtkCollection.h:48
vtkMultiProcessController::GatherV
int GatherV(const short *sendBuffer, short *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
Definition: vtkMultiProcessController.h:653
vtkMultiProcessController::ScatterV
int ScatterV(const float *sendBuffer, float *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
Definition: vtkMultiProcessController.h:916
vtkMultiProcessController::Broadcast
int Broadcast(vtkDataObject *data, int srcProcessId)
Definition: vtkMultiProcessController.h:515
vtkMultiProcessController::AllReduce
int AllReduce(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
Definition: vtkMultiProcessController.h:1367
vtkMultiProcessController::Scatter
int Scatter(const long *sendBuffer, long *recvBuffer, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:794
vtkMultiProcessController::AllGather
int AllGather(const char *sendBuffer, char *recvBuffer, vtkIdType length)
Definition: vtkMultiProcessController.h:973
vtkMultiProcessController::Reduce
int Reduce(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, int operation, int destProcessId)
Definition: vtkMultiProcessController.h:1140
vtkMultiProcessController::Reduce
int Reduce(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, int operation, int destProcessId)
Definition: vtkMultiProcessController.h:1170
vtkMultiProcessController
Multiprocessing communication superclass.
Definition: vtkMultiProcessController.h:76
vtkMultiProcessController::GatherV
int GatherV(vtkDataObject *sendData, vtkSmartPointer< vtkDataObject > *recvData, int destProcessId)
Definition: vtkMultiProcessController.h:759
vtkMultiProcessController::Gather
int Gather(const long *sendBuffer, long *recvBuffer, vtkIdType length, int destProcessId)
Definition: vtkMultiProcessController.h:557
vtkMultiProcessController::AllReduce
int AllReduce(const long *sendBuffer, long *recvBuffer, vtkIdType length, int operation)
Definition: vtkMultiProcessController.h:1301
vtkMultiProcessController::Broadcast
int Broadcast(unsigned short *data, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:485
vtkOutputWindow
base class for writing debug output to a console
Definition: vtkOutputWindow.h:43
vtkMultiProcessController::Reduce
int Reduce(const short *sendBuffer, short *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Definition: vtkMultiProcessController.h:1204
vtkRMIFunctionType
void(* vtkRMIFunctionType)(void *localArg, void *remoteArg, int remoteArgLength, int remoteProcessId)
Definition: vtkMultiProcessController.h:72
vtkMultiProcessController::Scatter
int Scatter(const int *sendBuffer, int *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
Definition: vtkMultiProcessController.h:774
vtkMultiProcessController::AllGather
int AllGather(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer)
Definition: vtkMultiProcessController.h:992
vtkImageData
topologically and geometrically regular array of data
Definition: vtkImageData.h:39
vtkMultiProcessController::Scatter
int Scatter(const char *sendBuffer, char *recvBuffer, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:809
vtkIndent
a simple class to control print indentation
Definition: vtkIndent.h:33
vtkMultiProcessController::GatherV
int GatherV(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
Definition: vtkMultiProcessController.h:646
vtkMultiProcessController::GetRMIArgTag
static int GetRMIArgTag()
Definition: vtkMultiProcessController.h:354
vtkMultiProcessController::Scatter
int Scatter(const double *sendBuffer, double *recvBuffer, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:824
vtkMultiProcessController::ScatterV
int ScatterV(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
Definition: vtkMultiProcessController.h:937
vtkMultiProcessController::Barrier
void Barrier()
This method can be used to synchronize processes.
Definition: vtkMultiProcessController.h:1923
vtkMultiProcessController::AllGatherV
int AllGatherV(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Definition: vtkMultiProcessController.h:1036
vtkMultiProcessController::AllReduce
int AllReduce(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, int operation)
Definition: vtkMultiProcessController.h:1321
vtkMultiProcessController::AllReduce
int AllReduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, int operation)
Definition: vtkMultiProcessController.h:1346
vtkMultiProcessController::AllGatherV
int AllGatherV(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Definition: vtkMultiProcessController.h:1008
vtkObject::PrintSelf
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
vtkMultiProcessController::Gather
int Gather(const int *sendBuffer, int *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
Definition: vtkMultiProcessController.h:537
vtkMultiProcessController::AllReduce
int AllReduce(const float *sendBuffer, float *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
Definition: vtkMultiProcessController.h:1397
vtkMultiProcessController::AllGatherV
int AllGatherV(const short *sendBuffer, short *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Definition: vtkMultiProcessController.h:1015
vtkMultiProcessController::Scatter
int Scatter(const short *sendBuffer, short *recvBuffer, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:784
vtkMultiProcessController::ScatterV
int ScatterV(const char *sendBuffer, char *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
Definition: vtkMultiProcessController.h:902
vtkMultiProcessController::GatherV
int GatherV(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
Definition: vtkMultiProcessController.h:660
vtkMultiProcessController::Reduce
int Reduce(const double *sendBuffer, double *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Definition: vtkMultiProcessController.h:1252
vtkMultiProcessController::Broadcast
int Broadcast(vtkMultiProcessStream &stream, int srcProcessId)
Definition: vtkMultiProcessController.h:523
vtkMultiProcessController::GatherV
int GatherV(const int *sendBuffer, int *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
Definition: vtkMultiProcessController.h:639
vtkMultiProcessController::AllGatherV
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.
Definition: vtkMultiProcessController.h:1001
vtkMultiProcessController::AllGather
int AllGather(const long long *sendBuffer, long long *recvBuffer, vtkIdType length)
Definition: vtkMultiProcessController.h:986
vtkMultiProcessController::ScatterV
int ScatterV(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
Definition: vtkMultiProcessController.h:888
vtkMultiProcessController::ScatterV
int ScatterV(const int *sendBuffer, int *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
Definition: vtkMultiProcessController.h:853
vtkObject.h
vtkMultiProcessController::AllGatherV
int AllGatherV(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Definition: vtkMultiProcessController.h:1085
vtkMultiProcessController::Send
int Send(const int *data, vtkIdType length, int remoteProcessId, int tag)
This method sends data to another process.
Definition: vtkMultiProcessController.h:1514
vtkMultiProcessController::AllReduce
int AllReduce(const short *sendBuffer, short *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
Definition: vtkMultiProcessController.h:1362
vtkDataSet
abstract class to specify dataset behavior
Definition: vtkDataSet.h:56
vtkMultiProcessController::AllReduce
int AllReduce(const float *sendBuffer, float *recvBuffer, vtkIdType length, int operation)
Definition: vtkMultiProcessController.h:1326
vtkMultiProcessController::ForceDeepCopy
int ForceDeepCopy
Definition: vtkMultiProcessController.h:1453
vtkProcess
a process that can be launched by a vtkMultiProcessController
Definition: vtkProcess.h:46
vtkMultiProcessController::BreakFlag
int BreakFlag
Definition: vtkMultiProcessController.h:1443
vtkMultiProcessController::AllGather
int AllGather(const float *sendBuffer, float *recvBuffer, vtkIdType length)
Definition: vtkMultiProcessController.h:979
vtkMultiProcessController::Reduce
int Reduce(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, int operation, int destProcessId)
Definition: vtkMultiProcessController.h:1145
vtkMultiProcessController::Broadcast
int Broadcast(short *data, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:482
vtkProcessGroup
A subgroup of processes from a communicator.
Definition: vtkProcessGroup.h:54
vtkMultiProcessController::Reduce
int Reduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length, int operation, int destProcessId)
Definition: vtkMultiProcessController.h:1175
vtkMultiProcessController::Gather
int Gather(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, int destProcessId)
Definition: vtkMultiProcessController.h:552
vtkMultiProcessController::Errors
Errors
Definition: vtkMultiProcessController.h:356
vtkIdTypeArray
dynamic, self-adjusting array of vtkIdType
Definition: vtkIdTypeArray.h:35
vtkCommunicator::Send
int Send(vtkDataObject *data, int remoteHandle, int tag)
This method sends a data object to a destination.
vtkCommunicator.h
vtkMultiProcessController::Reduce
int Reduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, vtkCommunicator::Operation *operation, int destProcessId)
Definition: vtkMultiProcessController.h:1270
vtkMultiProcessController::ScatterV
int ScatterV(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
Definition: vtkMultiProcessController.h:860
vtkMultiProcessController::Gather
int Gather(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length, int destProcessId)
Definition: vtkMultiProcessController.h:597
vtkMultiProcessController::AllReduce
int AllReduce(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, int operation)
Definition: vtkMultiProcessController.h:1306
vtkMultiProcessController::AllReduce
int AllReduce(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, int operation)
Definition: vtkMultiProcessController.h:1336
vtkMultiProcessController::AllReduce
int AllReduce(const char *sendBuffer, char *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
Definition: vtkMultiProcessController.h:1387
vtkMultiProcessController::Gather
int Gather(const float *sendBuffer, float *recvBuffer, vtkIdType length, int destProcessId)
Definition: vtkMultiProcessController.h:582
vtkMultiProcessController::ScatterV
int ScatterV(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
Definition: vtkMultiProcessController.h:909
vtkMultiProcessController::Scatter
int Scatter(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:804
vtkMultiProcessController::AllReduce
int AllReduce(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, int operation)
Definition: vtkMultiProcessController.h:1311
vtkMultiProcessController::AllGather
int AllGather(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length)
Definition: vtkMultiProcessController.h:976
vtkCommunicator::GetCount
virtual vtkIdType GetCount()
Returns the number of words received by the most recent Receive().
vtkMultiProcessController::AllGatherV
int AllGatherV(const long long *sendBuffer, long long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Definition: vtkMultiProcessController.h:1078
vtkMultiProcessController::OutputWindow
vtkOutputWindow * OutputWindow
Definition: vtkMultiProcessController.h:1460
vtkMultiProcessController::AllGather
int AllGather(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length)
Definition: vtkMultiProcessController.h:969
vtkMultiProcessController::ScatterV
int ScatterV(const double *sendBuffer, double *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
Definition: vtkMultiProcessController.h:923
vtkMultiProcessController::Gather
int Gather(const short *sendBuffer, short *recvBuffer, vtkIdType length, int destProcessId)
Definition: vtkMultiProcessController.h:547
vtkMultiProcessController::GetBreakRMITag
static int GetBreakRMITag()
Accessor to some default tags.
Definition: vtkMultiProcessController.h:352
vtkMultiProcessController::AllReduce
int AllReduce(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, int operation)
Definition: vtkMultiProcessController.h:1296
vtkMultiProcessController::GatherV
int GatherV(const float *sendBuffer, float *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
Definition: vtkMultiProcessController.h:702
vtkMultiProcessController::RemoveRMI
virtual void RemoveRMI(vtkRMIFunctionType f, void *arg, int tag)
Take an RMI away.
Definition: vtkMultiProcessController.h:235
vtkMultiProcessController::SingleData
void * SingleData
Definition: vtkMultiProcessController.h:1437
vtkMultiProcessController::Scatter
int Scatter(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, int srcProcessId)
Definition: vtkMultiProcessController.h:839
vtkMultiProcessController::Scatter
int Scatter(const float *sendBuffer, float *recvBuffer, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:819
vtkMultiProcessController::Gather
int Gather(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, int destProcessId)
Definition: vtkMultiProcessController.h:542
vtkMultiProcessController::Gather
int Gather(const double *sendBuffer, double *recvBuffer, vtkIdType length, int destProcessId)
Definition: vtkMultiProcessController.h:587
vtkMultiProcessController::RMI_TAG_ERROR
Definition: vtkMultiProcessController.h:359
vtkMultiProcessController::Reduce
int Reduce(const float *sendBuffer, float *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Definition: vtkMultiProcessController.h:1246
vtkMultiProcessController::TriggerRMI
void TriggerRMI(int remoteProcessId, int tag)
Convenience method when there is no argument.
Definition: vtkMultiProcessController.h:278
vtkMultiProcessController::AllReduce
int AllReduce(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
Definition: vtkMultiProcessController.h:1382
vtkMultiProcessController::GatherV
int GatherV(const char *sendBuffer, char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
Definition: vtkMultiProcessController.h:688
vtkDataObject
general representation of visualization data
Definition: vtkDataObject.h:58
vtkMultiProcessController::Broadcast
int Broadcast(char *data, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:497
vtkMultiProcessController::Scatter
int Scatter(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:779
vtkX3D::index
Definition: vtkX3D.h:246
vtkMultiProcessController::GatherV
int GatherV(const double *sendBuffer, double *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
Definition: vtkMultiProcessController.h:709
vtkMultiProcessController::Reduce
int Reduce(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, int operation, int destProcessId)
Definition: vtkMultiProcessController.h:1155
vtkMultiProcessController::ScatterV
int ScatterV(const short *sendBuffer, short *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
Definition: vtkMultiProcessController.h:867
vtkMultiProcessController::Reduce
int Reduce(const float *sendBuffer, float *recvBuffer, vtkIdType length, int operation, int destProcessId)
Definition: vtkMultiProcessController.h:1160
vtkMultiProcessController::Reduce
int Reduce(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Definition: vtkMultiProcessController.h:1228
vtkMultiProcessController::AllReduce
int AllReduce(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
Definition: vtkMultiProcessController.h:1357
vtkMultiProcessController::Reduce
int Reduce(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, int operation, int destProcessId)
Definition: vtkMultiProcessController.h:1130
vtkMultiProcessController::TriggerRMI
void TriggerRMI(int remoteProcessId, const char *arg, int tag)
Convenience method when the arg is a string.
Definition: vtkMultiProcessController.h:271
vtkMultiProcessController::AllGatherV
int AllGatherV(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Definition: vtkMultiProcessController.h:1043
vtkMultiProcessController::Gather
int Gather(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, int destProcessId)
Definition: vtkMultiProcessController.h:562
vtkMultiProcessController::AllGatherV
int AllGatherV(const double *sendBuffer, double *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Definition: vtkMultiProcessController.h:1071
vtkMultiProcessController::AllGather
int AllGather(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length)
Definition: vtkMultiProcessController.h:965
vtkMultiProcessController::ScatterV
int ScatterV(const long long *sendBuffer, long long *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
Definition: vtkMultiProcessController.h:930
vtkMultiProcessController::GatherV
int GatherV(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
Definition: vtkMultiProcessController.h:723
vtkMultiProcessController::AllReduce
int AllReduce(const char *sendBuffer, char *recvBuffer, vtkIdType length, int operation)
Definition: vtkMultiProcessController.h:1316
vtkMultiProcessController::GetCount
vtkIdType GetCount()
Returns the number of words received by the most recent Receive().
Definition: vtkMultiProcessController.h:1931
vtkMultiProcessController::GatherV
int GatherV(const long long *sendBuffer, long long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
Definition: vtkMultiProcessController.h:716
vtkMultiProcessController::Reduce
int Reduce(const char *sendBuffer, char *recvBuffer, vtkIdType length, int operation, int destProcessId)
Definition: vtkMultiProcessController.h:1150
vtkMultiProcessController::Reduce
int Reduce(const int *sendBuffer, int *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
Definition: vtkMultiProcessController.h:1115
vtkMultiProcessController::Reduce
int Reduce(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Definition: vtkMultiProcessController.h:1210