VTK  9.0.1
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 "vtkObject.h"
53 #include "vtkParallelCoreModule.h" // For export macro
54 
55 #include "vtkCommunicator.h" // Needed for direct access to communicator
56 
57 class vtkBoundingBox;
58 class vtkCollection;
59 class vtkDataObject;
60 class vtkDataSet;
61 class vtkImageData;
64 class vtkOutputWindow;
65 class vtkProcessGroup;
66 class vtkProcess;
67 
68 // The type of function that gets called when new processes are initiated.
69 typedef void (*vtkProcessFunctionType)(vtkMultiProcessController* controller, void* userData);
70 
71 // The type of function that gets called when an RMI is triggered.
72 typedef void (*vtkRMIFunctionType)(
73  void* localArg, void* remoteArg, int remoteArgLength, int remoteProcessId);
74 
75 class VTKPARALLELCORE_EXPORT vtkMultiProcessController : public vtkObject
76 {
77 public:
79  void PrintSelf(ostream& os, vtkIndent indent) override;
80 
86  virtual void Initialize(int* vtkNotUsed(argc), char*** vtkNotUsed(argv)) = 0;
87 
93  virtual void Initialize(
94  int* vtkNotUsed(argc), char*** vtkNotUsed(argv), int initializedExternally) = 0;
95 
101  virtual void Finalize() = 0;
102 
108  virtual void Finalize(int finalizedExternally) = 0;
109 
111 
116  void SetNumberOfProcesses(int num);
117  int GetNumberOfProcesses();
119 
126  void SetSingleMethod(vtkProcessFunctionType, void* data);
127 
133  void SetSingleProcessObject(vtkProcess* p);
134 
140  virtual void SingleMethodExecute() = 0;
141 
148  void SetMultipleMethod(int index, vtkProcessFunctionType, void* data);
149 
155  virtual void MultipleMethodExecute() = 0;
156 
160  int GetLocalProcessId();
161 
168  static vtkMultiProcessController* GetGlobalController();
169 
175  virtual void CreateOutputWindow() = 0;
176 
188  virtual vtkMultiProcessController* CreateSubController(vtkProcessGroup* group);
189 
200  virtual vtkMultiProcessController* PartitionController(int localColor, int localKey);
201 
202  //------------------ RMIs --------------------
203 
216  virtual unsigned long AddRMI(vtkRMIFunctionType, void* localArg, int tag);
217 
221  virtual int RemoveFirstRMI(int tag);
222 
227  virtual int RemoveRMI(unsigned long id);
228 
232  virtual void RemoveRMI(vtkRMIFunctionType f, void* arg, int tag)
233  {
234  (void)f;
235  (void)arg;
236  (void)tag;
237  vtkErrorMacro("RemoveRMI Not Implemented Yet");
238  }
239 
245  virtual unsigned long AddRMICallback(vtkRMIFunctionType, void* localArg, int tag);
246 
252  virtual void RemoveAllRMICallbacks(int tag);
253 
257  virtual bool RemoveRMICallback(unsigned long id);
258 
262  void TriggerRMI(int remoteProcessId, void* arg, int argLength, int tag);
263 
268  void TriggerBreakRMIs();
269 
273  void TriggerRMI(int remoteProcessId, const char* arg, int tag)
274  {
275  this->TriggerRMI(remoteProcessId, (void*)arg, static_cast<int>(strlen(arg)) + 1, tag);
276  }
277 
281  void TriggerRMI(int remoteProcessId, int tag)
282  {
283  this->TriggerRMI(remoteProcessId, nullptr, 0, tag);
284  }
285 
287 
295  void TriggerRMIOnAllChildren(void* arg, int argLength, int tag);
296  void TriggerRMIOnAllChildren(const char* arg, int tag)
297  {
298  this->TriggerRMIOnAllChildren((void*)arg, static_cast<int>(strlen(arg)) + 1, tag);
299  }
300  void TriggerRMIOnAllChildren(int tag) { this->TriggerRMIOnAllChildren(nullptr, 0, tag); }
301  void BroadcastTriggerRMIOnAllChildren(void* arg, int argLength, int tag);
303 
305 
316  int ProcessRMIs(int reportErrors, int dont_loop = 0);
317  int ProcessRMIs();
318  int BroadcastProcessRMIs(int reportErrors, int dont_loop = 0);
320 
322 
327  vtkSetMacro(BreakFlag, int);
328  vtkGetMacro(BreakFlag, int);
330 
332 
337  vtkSetMacro(BroadcastTriggerRMI, bool);
338  vtkGetMacro(BroadcastTriggerRMI, bool);
339  vtkBooleanMacro(BroadcastTriggerRMI, bool);
341 
343 
347  vtkGetObjectMacro(Communicator, vtkCommunicator);
349 
353  static int GetBreakRMITag() { return BREAK_RMI_TAG; }
354  static int GetRMITag() { return RMI_TAG; }
355  static int GetRMIArgTag() { return RMI_ARG_TAG; }
356 
357  enum Errors
358  {
361  RMI_ARG_ERROR
362  };
363 
364  enum Consts
365  {
366  ANY_SOURCE = -1,
367  INVALID_SOURCE = -2
368  };
369 
370  enum Tags
371  {
372  RMI_TAG = 1,
373  RMI_ARG_TAG = 2,
374  BREAK_RMI_TAG = 3,
375  XML_WRITER_DATA_INFO = 4
376  };
377 
381  void Barrier();
382 
383  static void SetGlobalController(vtkMultiProcessController* controller);
384 
385  //------------------ Communication --------------------
386 
388 
395  int Send(const int* data, vtkIdType length, int remoteProcessId, int tag);
396  int Send(const short* data, vtkIdType length, int remoteProcessId, int tag);
397  int Send(const unsigned short* data, vtkIdType length, int remoteProcessId, int tag);
398  int Send(const unsigned int* data, vtkIdType length, int remoteProcessId, int tag);
399  int Send(const unsigned long* data, vtkIdType length, int remoteProcessId, int tag);
400  int Send(const long* data, vtkIdType length, int remoteProcessId, int tag);
401  int Send(const signed char* data, vtkIdType length, int remoteProcessId, int tag);
402  int Send(const char* data, vtkIdType length, int remoteProcessId, int tag);
403  int Send(const unsigned char* data, vtkIdType length, int remoteProcessId, int tag);
404  int Send(const float* data, vtkIdType length, int remoteProcessId, int tag);
405  int Send(const double* data, vtkIdType length, int remoteProcessId, int tag);
406  int Send(const long long* data, vtkIdType length, int remoteProcessId, int tag);
407  int Send(const unsigned long long* data, vtkIdType length, int remoteProcessId, int tag);
408  int Send(vtkDataObject* data, int remoteId, int tag);
409  int Send(vtkDataArray* data, int remoteId, int tag);
411 
419  int Send(const vtkMultiProcessStream& stream, int remoteId, int tag);
420 
422 
431  int Receive(int* data, vtkIdType maxlength, int remoteProcessId, int tag);
432  int Receive(unsigned int* data, vtkIdType maxlength, int remoteProcessId, int tag);
433  int Receive(short* data, vtkIdType maxlength, int remoteProcessId, int tag);
434  int Receive(unsigned short* data, vtkIdType maxlength, int remoteProcessId, int tag);
435  int Receive(long* data, vtkIdType maxlength, int remoteProcessId, int tag);
436  int Receive(unsigned long* data, vtkIdType maxlength, int remoteProcessId, int tag);
437  int Receive(char* data, vtkIdType maxlength, int remoteProcessId, int tag);
438  int Receive(unsigned char* data, vtkIdType maxlength, int remoteProcessId, int tag);
439  int Receive(signed char* data, vtkIdType maxlength, int remoteProcessId, int tag);
440  int Receive(float* data, vtkIdType maxlength, int remoteProcessId, int tag);
441  int Receive(double* data, vtkIdType maxlength, int remoteProcessId, int tag);
442  int Receive(long long* data, vtkIdType maxLength, int remoteProcessId, int tag);
443  int Receive(unsigned long long* data, vtkIdType maxLength, int remoteProcessId, int tag);
444  int Receive(vtkDataObject* data, int remoteId, int tag);
445  int Receive(vtkDataArray* data, int remoteId, int tag);
447 
451  int Receive(vtkMultiProcessStream& stream, int remoteId, int tag);
452 
453  vtkDataObject* ReceiveDataObject(int remoteId, int tag);
454 
463  vtkIdType GetCount();
464 
465  //---------------------- Collective Operations ----------------------
466 
468 
473  int Broadcast(int* data, vtkIdType length, int srcProcessId)
474  {
475  return this->Communicator->Broadcast(data, length, srcProcessId);
476  }
477  int Broadcast(unsigned int* data, vtkIdType length, int srcProcessId)
478  {
479  return this->Communicator->Broadcast(data, length, srcProcessId);
480  }
481  int Broadcast(short* data, vtkIdType length, int srcProcessId)
482  {
483  return this->Communicator->Broadcast(data, length, srcProcessId);
484  }
485  int Broadcast(unsigned short* data, vtkIdType length, int srcProcessId)
486  {
487  return this->Communicator->Broadcast(data, length, srcProcessId);
488  }
489  int Broadcast(long* data, vtkIdType length, int srcProcessId)
490  {
491  return this->Communicator->Broadcast(data, length, srcProcessId);
492  }
493  int Broadcast(unsigned long* data, vtkIdType length, int srcProcessId)
494  {
495  return this->Communicator->Broadcast(data, length, srcProcessId);
496  }
497  int Broadcast(unsigned char* data, vtkIdType length, int srcProcessId)
498  {
499  return this->Communicator->Broadcast(data, length, srcProcessId);
500  }
501  int Broadcast(char* data, vtkIdType length, int srcProcessId)
502  {
503  return this->Communicator->Broadcast(data, length, srcProcessId);
504  }
505  int Broadcast(signed char* data, vtkIdType length, int srcProcessId)
506  {
507  return this->Communicator->Broadcast(data, length, srcProcessId);
508  }
509  int Broadcast(float* data, vtkIdType length, int srcProcessId)
510  {
511  return this->Communicator->Broadcast(data, length, srcProcessId);
512  }
513  int Broadcast(double* data, vtkIdType length, int srcProcessId)
514  {
515  return this->Communicator->Broadcast(data, length, srcProcessId);
516  }
517  int Broadcast(long long* data, vtkIdType length, int srcProcessId)
518  {
519  return this->Communicator->Broadcast(data, length, srcProcessId);
520  }
521  int Broadcast(unsigned long long* data, vtkIdType length, int srcProcessId)
522  {
523  return this->Communicator->Broadcast(data, length, srcProcessId);
524  }
525  int Broadcast(vtkDataObject* data, int srcProcessId)
526  {
527  return this->Communicator->Broadcast(data, srcProcessId);
528  }
529  int Broadcast(vtkDataArray* data, int srcProcessId)
530  {
531  return this->Communicator->Broadcast(data, srcProcessId);
532  }
534 
535  int Broadcast(vtkMultiProcessStream& stream, int srcProcessId)
536  {
537  return this->Communicator->Broadcast(stream, srcProcessId);
538  }
539 
541 
550  int Gather(const int* sendBuffer, int* recvBuffer, vtkIdType length, int destProcessId)
551  {
552  return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
553  }
554  int Gather(
555  const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType length, int destProcessId)
556  {
557  return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
558  }
559  int Gather(const short* sendBuffer, short* recvBuffer, vtkIdType length, int destProcessId)
560  {
561  return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
562  }
563  int Gather(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType length,
564  int destProcessId)
565  {
566  return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
567  }
568  int Gather(const long* sendBuffer, long* recvBuffer, vtkIdType length, int destProcessId)
569  {
570  return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
571  }
572  int Gather(
573  const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length, int destProcessId)
574  {
575  return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
576  }
577  int Gather(
578  const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType length, int destProcessId)
579  {
580  return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
581  }
582  int Gather(const char* sendBuffer, char* recvBuffer, vtkIdType length, int destProcessId)
583  {
584  return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
585  }
586  int Gather(
587  const signed char* sendBuffer, signed char* recvBuffer, vtkIdType length, int destProcessId)
588  {
589  return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
590  }
591  int Gather(const float* sendBuffer, float* recvBuffer, vtkIdType length, int destProcessId)
592  {
593  return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
594  }
595  int Gather(const double* sendBuffer, double* recvBuffer, vtkIdType length, int destProcessId)
596  {
597  return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
598  }
599  int Gather(
600  const long long* sendBuffer, long long* recvBuffer, vtkIdType length, int destProcessId)
601  {
602  return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
603  }
604  int Gather(const unsigned long long* sendBuffer, unsigned long long* recvBuffer, vtkIdType length,
605  int destProcessId)
606  {
607  return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
608  }
609  int Gather(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, int destProcessId)
610  {
611  return this->Communicator->Gather(sendBuffer, recvBuffer, destProcessId);
612  }
614 
628  int destProcessId)
629  {
630  return this->Communicator->Gather(sendBuffer, recvBuffer, destProcessId);
631  }
632 
642  int Gather(const vtkMultiProcessStream& sendBuffer,
643  std::vector<vtkMultiProcessStream>& recvBuffer, int destProcessId)
644  {
645  return this->Communicator->Gather(sendBuffer, recvBuffer, destProcessId);
646  }
647 
649 
660  int GatherV(const int* sendBuffer, int* recvBuffer, vtkIdType sendLength, vtkIdType* recvLengths,
661  vtkIdType* offsets, int destProcessId)
662  {
663  return this->Communicator->GatherV(
664  sendBuffer, recvBuffer, sendLength, recvLengths, offsets, destProcessId);
665  }
666  int GatherV(const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType sendLength,
667  vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
668  {
669  return this->Communicator->GatherV(
670  sendBuffer, recvBuffer, sendLength, recvLengths, offsets, destProcessId);
671  }
672  int GatherV(const short* sendBuffer, short* recvBuffer, vtkIdType sendLength,
673  vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
674  {
675  return this->Communicator->GatherV(
676  sendBuffer, recvBuffer, sendLength, recvLengths, offsets, destProcessId);
677  }
678  int GatherV(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType sendLength,
679  vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
680  {
681  return this->Communicator->GatherV(
682  sendBuffer, recvBuffer, sendLength, recvLengths, offsets, destProcessId);
683  }
684  int GatherV(const long* sendBuffer, long* recvBuffer, vtkIdType sendLength,
685  vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
686  {
687  return this->Communicator->GatherV(
688  sendBuffer, recvBuffer, sendLength, recvLengths, offsets, destProcessId);
689  }
690  int GatherV(const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType sendLength,
691  vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
692  {
693  return this->Communicator->GatherV(
694  sendBuffer, recvBuffer, sendLength, recvLengths, offsets, destProcessId);
695  }
696  int GatherV(const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType sendLength,
697  vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
698  {
699  return this->Communicator->GatherV(
700  sendBuffer, recvBuffer, sendLength, recvLengths, offsets, destProcessId);
701  }
702  int GatherV(const char* sendBuffer, char* recvBuffer, vtkIdType sendLength,
703  vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
704  {
705  return this->Communicator->GatherV(
706  sendBuffer, recvBuffer, sendLength, recvLengths, offsets, destProcessId);
707  }
708  int GatherV(const signed char* sendBuffer, signed char* recvBuffer, vtkIdType sendLength,
709  vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
710  {
711  return this->Communicator->GatherV(
712  sendBuffer, recvBuffer, sendLength, recvLengths, offsets, destProcessId);
713  }
714  int GatherV(const float* sendBuffer, float* recvBuffer, vtkIdType sendLength,
715  vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
716  {
717  return this->Communicator->GatherV(
718  sendBuffer, recvBuffer, sendLength, recvLengths, offsets, destProcessId);
719  }
720  int GatherV(const double* sendBuffer, double* recvBuffer, vtkIdType sendLength,
721  vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
722  {
723  return this->Communicator->GatherV(
724  sendBuffer, recvBuffer, sendLength, recvLengths, offsets, destProcessId);
725  }
726  int GatherV(const long long* sendBuffer, long long* recvBuffer, vtkIdType sendLength,
727  vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
728  {
729  return this->Communicator->GatherV(
730  sendBuffer, recvBuffer, sendLength, recvLengths, offsets, destProcessId);
731  }
732  int GatherV(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
733  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
734  {
735  return this->Communicator->GatherV(
736  sendBuffer, recvBuffer, sendLength, recvLengths, offsets, destProcessId);
737  }
739 
740  int GatherV(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, vtkIdType* recvLengths,
741  vtkIdType* offsets, int destProcessId)
742  {
743  return this->Communicator->GatherV(sendBuffer, recvBuffer, recvLengths, offsets, destProcessId);
744  }
745  int GatherV(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, vtkIdTypeArray* recvLengths,
746  vtkIdTypeArray* offsets, int destProcessId)
747  {
748  return this->Communicator->GatherV(sendBuffer, recvBuffer, recvLengths, offsets, destProcessId);
749  }
750 
752 
758  int GatherV(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, int destProcessId)
759  {
760  return this->Communicator->GatherV(sendBuffer, recvBuffer, destProcessId);
761  }
762  int GatherV(vtkDataObject* sendData, vtkSmartPointer<vtkDataObject>* recvData, int destProcessId)
763  {
764  return this->Communicator->GatherV(sendData, recvData, destProcessId);
765  }
767 
769 
776  int Scatter(const int* sendBuffer, int* recvBuffer, vtkIdType length, int srcProcessId)
777  {
778  return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
779  }
780  int Scatter(
781  const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType length, int srcProcessId)
782  {
783  return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
784  }
785  int Scatter(const short* sendBuffer, short* recvBuffer, vtkIdType length, int srcProcessId)
786  {
787  return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
788  }
789  int Scatter(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType length,
790  int srcProcessId)
791  {
792  return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
793  }
794  int Scatter(const long* sendBuffer, long* recvBuffer, vtkIdType length, int srcProcessId)
795  {
796  return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
797  }
798  int Scatter(
799  const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length, int srcProcessId)
800  {
801  return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
802  }
803  int Scatter(
804  const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType length, int srcProcessId)
805  {
806  return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
807  }
808  int Scatter(const char* sendBuffer, char* recvBuffer, vtkIdType length, int srcProcessId)
809  {
810  return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
811  }
812  int Scatter(
813  const signed char* sendBuffer, signed char* recvBuffer, vtkIdType length, int srcProcessId)
814  {
815  return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
816  }
817  int Scatter(const float* sendBuffer, float* recvBuffer, vtkIdType length, int srcProcessId)
818  {
819  return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
820  }
821  int Scatter(const double* sendBuffer, double* recvBuffer, vtkIdType length, int srcProcessId)
822  {
823  return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
824  }
825  int Scatter(
826  const long long* sendBuffer, long long* recvBuffer, vtkIdType length, int srcProcessId)
827  {
828  return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
829  }
830  int Scatter(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
831  vtkIdType length, int srcProcessId)
832  {
833  return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
834  }
835  int Scatter(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, int srcProcessId)
836  {
837  return this->Communicator->Scatter(sendBuffer, recvBuffer, srcProcessId);
838  }
840 
842 
849  int ScatterV(const int* sendBuffer, int* recvBuffer, vtkIdType* sendLengths, vtkIdType* offsets,
850  vtkIdType recvLength, int srcProcessId)
851  {
852  return this->Communicator->ScatterV(
853  sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
854  }
855  int ScatterV(const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType* sendLengths,
856  vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
857  {
858  return this->Communicator->ScatterV(
859  sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
860  }
861  int ScatterV(const short* sendBuffer, short* recvBuffer, vtkIdType* sendLengths,
862  vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
863  {
864  return this->Communicator->ScatterV(
865  sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
866  }
867  int ScatterV(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType* sendLengths,
868  vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
869  {
870  return this->Communicator->ScatterV(
871  sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
872  }
873  int ScatterV(const long* sendBuffer, long* recvBuffer, vtkIdType* sendLengths, vtkIdType* offsets,
874  vtkIdType recvLength, int srcProcessId)
875  {
876  return this->Communicator->ScatterV(
877  sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
878  }
879  int ScatterV(const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType* sendLengths,
880  vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
881  {
882  return this->Communicator->ScatterV(
883  sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
884  }
885  int ScatterV(const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType* sendLengths,
886  vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
887  {
888  return this->Communicator->ScatterV(
889  sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
890  }
891  int ScatterV(const char* sendBuffer, char* recvBuffer, vtkIdType* sendLengths, vtkIdType* offsets,
892  vtkIdType recvLength, int srcProcessId)
893  {
894  return this->Communicator->ScatterV(
895  sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
896  }
897  int ScatterV(const signed char* sendBuffer, signed char* recvBuffer, vtkIdType* sendLengths,
898  vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
899  {
900  return this->Communicator->ScatterV(
901  sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
902  }
903  int ScatterV(const float* sendBuffer, float* recvBuffer, vtkIdType* sendLengths,
904  vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
905  {
906  return this->Communicator->ScatterV(
907  sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
908  }
909  int ScatterV(const double* sendBuffer, double* recvBuffer, vtkIdType* sendLengths,
910  vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
911  {
912  return this->Communicator->ScatterV(
913  sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
914  }
915  int ScatterV(const long long* sendBuffer, long long* recvBuffer, vtkIdType* sendLengths,
916  vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
917  {
918  return this->Communicator->ScatterV(
919  sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
920  }
921  int ScatterV(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
922  vtkIdType* sendLengths, vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
923  {
924  return this->Communicator->ScatterV(
925  sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
926  }
928 
930 
933  int AllGather(const int* sendBuffer, int* recvBuffer, vtkIdType length)
934  {
935  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
936  }
937  int AllGather(const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType length)
938  {
939  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
940  }
941  int AllGather(const short* sendBuffer, short* recvBuffer, vtkIdType length)
942  {
943  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
944  }
945  int AllGather(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType length)
946  {
947  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
948  }
949  int AllGather(const long* sendBuffer, long* recvBuffer, vtkIdType length)
950  {
951  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
952  }
953  int AllGather(const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length)
954  {
955  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
956  }
957  int AllGather(const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType length)
958  {
959  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
960  }
961  int AllGather(const char* sendBuffer, char* recvBuffer, vtkIdType length)
962  {
963  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
964  }
965  int AllGather(const signed char* sendBuffer, signed char* recvBuffer, vtkIdType length)
966  {
967  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
968  }
969  int AllGather(const float* sendBuffer, float* recvBuffer, vtkIdType length)
970  {
971  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
972  }
973  int AllGather(const double* sendBuffer, double* recvBuffer, vtkIdType length)
974  {
975  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
976  }
977  int AllGather(const long long* sendBuffer, long long* recvBuffer, vtkIdType length)
978  {
979  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
980  }
982  const unsigned long long* sendBuffer, unsigned long long* recvBuffer, vtkIdType length)
983  {
984  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
985  }
986  int AllGather(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer)
987  {
988  return this->Communicator->AllGather(sendBuffer, recvBuffer);
989  }
991 
993 
996  int AllGatherV(const int* sendBuffer, int* recvBuffer, vtkIdType sendLength,
997  vtkIdType* recvLengths, vtkIdType* offsets)
998  {
999  return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
1000  }
1001  int AllGatherV(const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType sendLength,
1002  vtkIdType* recvLengths, vtkIdType* offsets)
1003  {
1004  return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
1005  }
1006  int AllGatherV(const short* sendBuffer, short* recvBuffer, vtkIdType sendLength,
1007  vtkIdType* recvLengths, vtkIdType* offsets)
1008  {
1009  return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
1010  }
1011  int AllGatherV(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType sendLength,
1012  vtkIdType* recvLengths, vtkIdType* offsets)
1013  {
1014  return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
1015  }
1016  int AllGatherV(const long* sendBuffer, long* recvBuffer, vtkIdType sendLength,
1017  vtkIdType* recvLengths, vtkIdType* offsets)
1018  {
1019  return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
1020  }
1021  int AllGatherV(const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType sendLength,
1022  vtkIdType* recvLengths, vtkIdType* offsets)
1023  {
1024  return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
1025  }
1026  int AllGatherV(const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType sendLength,
1027  vtkIdType* recvLengths, vtkIdType* offsets)
1028  {
1029  return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
1030  }
1031  int AllGatherV(const char* sendBuffer, char* recvBuffer, vtkIdType sendLength,
1032  vtkIdType* recvLengths, vtkIdType* offsets)
1033  {
1034  return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
1035  }
1036  int AllGatherV(const signed char* sendBuffer, signed char* recvBuffer, vtkIdType sendLength,
1037  vtkIdType* recvLengths, vtkIdType* offsets)
1038  {
1039  return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
1040  }
1041  int AllGatherV(const float* sendBuffer, float* recvBuffer, vtkIdType sendLength,
1042  vtkIdType* recvLengths, vtkIdType* offsets)
1043  {
1044  return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
1045  }
1046  int AllGatherV(const double* sendBuffer, double* recvBuffer, vtkIdType sendLength,
1047  vtkIdType* recvLengths, vtkIdType* offsets)
1048  {
1049  return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
1050  }
1051  int AllGatherV(const long long* sendBuffer, long long* recvBuffer, vtkIdType sendLength,
1052  vtkIdType* recvLengths, vtkIdType* offsets)
1053  {
1054  return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
1055  }
1056  int AllGatherV(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
1057  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets)
1058  {
1059  return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
1060  }
1062  vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, vtkIdType* recvLengths, vtkIdType* offsets)
1063  {
1064  return this->Communicator->AllGatherV(sendBuffer, recvBuffer, recvLengths, offsets);
1065  }
1067 
1074  int AllGatherV(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer)
1075  {
1076  return this->Communicator->AllGatherV(sendBuffer, recvBuffer);
1077  }
1078 
1080 
1085  int Reduce(
1086  const int* sendBuffer, int* recvBuffer, vtkIdType length, int operation, int destProcessId)
1087  {
1088  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1089  }
1090  int Reduce(const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType length,
1091  int operation, int destProcessId)
1092  {
1093  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1094  }
1095  int Reduce(
1096  const short* sendBuffer, short* recvBuffer, vtkIdType length, int operation, int destProcessId)
1097  {
1098  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1099  }
1100  int Reduce(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType length,
1101  int operation, int destProcessId)
1102  {
1103  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1104  }
1105  int Reduce(
1106  const long* sendBuffer, long* recvBuffer, vtkIdType length, int operation, int destProcessId)
1107  {
1108  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1109  }
1110  int Reduce(const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length,
1111  int operation, int destProcessId)
1112  {
1113  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1114  }
1115  int Reduce(const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType length,
1116  int operation, int destProcessId)
1117  {
1118  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1119  }
1120  int Reduce(
1121  const char* sendBuffer, char* recvBuffer, vtkIdType length, int operation, int destProcessId)
1122  {
1123  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1124  }
1125  int Reduce(const signed char* sendBuffer, signed char* recvBuffer, vtkIdType length,
1126  int operation, int destProcessId)
1127  {
1128  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1129  }
1130  int Reduce(
1131  const float* sendBuffer, float* recvBuffer, vtkIdType length, int operation, int destProcessId)
1132  {
1133  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1134  }
1135  int Reduce(const double* sendBuffer, double* recvBuffer, vtkIdType length, int operation,
1136  int destProcessId)
1137  {
1138  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1139  }
1140  int Reduce(const long long* sendBuffer, long long* recvBuffer, vtkIdType length, int operation,
1141  int destProcessId)
1142  {
1143  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1144  }
1145  int Reduce(const unsigned long long* sendBuffer, unsigned long long* recvBuffer, vtkIdType length,
1146  int operation, int destProcessId)
1147  {
1148  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1149  }
1150  int Reduce(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, int operation, int destProcessId)
1151  {
1152  return this->Communicator->Reduce(sendBuffer, recvBuffer, operation, destProcessId);
1153  }
1155 
1157 
1161  int Reduce(const int* sendBuffer, int* recvBuffer, vtkIdType length,
1162  vtkCommunicator::Operation* operation, int destProcessId)
1163  {
1164  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1165  }
1166  int Reduce(const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType length,
1167  vtkCommunicator::Operation* operation, int destProcessId)
1168  {
1169  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1170  }
1171  int Reduce(const short* sendBuffer, short* recvBuffer, vtkIdType length,
1172  vtkCommunicator::Operation* operation, int destProcessId)
1173  {
1174  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1175  }
1176  int Reduce(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType length,
1177  vtkCommunicator::Operation* operation, int destProcessId)
1178  {
1179  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1180  }
1181  int Reduce(const long* sendBuffer, long* recvBuffer, vtkIdType length,
1182  vtkCommunicator::Operation* operation, int destProcessId)
1183  {
1184  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1185  }
1186  int Reduce(const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length,
1187  vtkCommunicator::Operation* operation, int destProcessId)
1188  {
1189  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1190  }
1191  int Reduce(const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType length,
1192  vtkCommunicator::Operation* operation, int destProcessId)
1193  {
1194  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1195  }
1196  int Reduce(const char* sendBuffer, char* recvBuffer, vtkIdType length,
1197  vtkCommunicator::Operation* operation, int destProcessId)
1198  {
1199  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1200  }
1201  int Reduce(const signed char* sendBuffer, signed char* recvBuffer, vtkIdType length,
1202  vtkCommunicator::Operation* operation, int destProcessId)
1203  {
1204  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1205  }
1206  int Reduce(const float* sendBuffer, float* recvBuffer, vtkIdType length,
1207  vtkCommunicator::Operation* operation, int destProcessId)
1208  {
1209  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1210  }
1211  int Reduce(const double* sendBuffer, double* recvBuffer, vtkIdType length,
1212  vtkCommunicator::Operation* operation, int destProcessId)
1213  {
1214  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1215  }
1216  int Reduce(const long long* sendBuffer, long long* recvBuffer, vtkIdType length,
1217  vtkCommunicator::Operation* operation, int destProcessId)
1218  {
1219  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1220  }
1221  int Reduce(const unsigned long long* sendBuffer, unsigned long long* recvBuffer, vtkIdType length,
1222  vtkCommunicator::Operation* operation, int destProcessId)
1223  {
1224  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1225  }
1226  int Reduce(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer,
1227  vtkCommunicator::Operation* operation, int destProcessId)
1228  {
1229  return this->Communicator->Reduce(sendBuffer, recvBuffer, operation, destProcessId);
1230  }
1232 
1234 
1237  int AllReduce(const int* sendBuffer, int* recvBuffer, vtkIdType length, int operation)
1238  {
1239  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1240  }
1242  const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType length, int operation)
1243  {
1244  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1245  }
1246  int AllReduce(const short* sendBuffer, short* recvBuffer, vtkIdType length, int operation)
1247  {
1248  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1249  }
1251  const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType length, int operation)
1252  {
1253  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1254  }
1255  int AllReduce(const long* sendBuffer, long* recvBuffer, vtkIdType length, int operation)
1256  {
1257  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1258  }
1260  const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length, int operation)
1261  {
1262  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1263  }
1265  const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType length, int operation)
1266  {
1267  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1268  }
1269  int AllReduce(const char* sendBuffer, char* recvBuffer, vtkIdType length, int operation)
1270  {
1271  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1272  }
1274  const signed char* sendBuffer, signed char* recvBuffer, vtkIdType length, int operation)
1275  {
1276  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1277  }
1278  int AllReduce(const float* sendBuffer, float* recvBuffer, vtkIdType length, int operation)
1279  {
1280  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1281  }
1282  int AllReduce(const double* sendBuffer, double* recvBuffer, vtkIdType length, int operation)
1283  {
1284  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1285  }
1286  int AllReduce(const long long* sendBuffer, long long* recvBuffer, vtkIdType length, int operation)
1287  {
1288  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1289  }
1290  int AllReduce(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
1291  vtkIdType length, int operation)
1292  {
1293  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1294  }
1295  int AllReduce(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, int operation)
1296  {
1297  return this->Communicator->AllReduce(sendBuffer, recvBuffer, operation);
1298  }
1300 
1302  const int* sendBuffer, int* recvBuffer, vtkIdType length, vtkCommunicator::Operation* operation)
1303  {
1304  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1305  }
1306  int AllReduce(const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType length,
1307  vtkCommunicator::Operation* operation)
1308  {
1309  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1310  }
1311  int AllReduce(const short* sendBuffer, short* recvBuffer, vtkIdType length,
1312  vtkCommunicator::Operation* operation)
1313  {
1314  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1315  }
1316  int AllReduce(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType length,
1317  vtkCommunicator::Operation* operation)
1318  {
1319  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1320  }
1321  int AllReduce(const long* sendBuffer, long* recvBuffer, vtkIdType length,
1322  vtkCommunicator::Operation* operation)
1323  {
1324  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1325  }
1326  int AllReduce(const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length,
1327  vtkCommunicator::Operation* operation)
1328  {
1329  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1330  }
1331  int AllReduce(const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType length,
1332  vtkCommunicator::Operation* operation)
1333  {
1334  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1335  }
1336  int AllReduce(const char* sendBuffer, char* recvBuffer, vtkIdType length,
1337  vtkCommunicator::Operation* operation)
1338  {
1339  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1340  }
1341  int AllReduce(const signed char* sendBuffer, signed char* recvBuffer, vtkIdType length,
1342  vtkCommunicator::Operation* operation)
1343  {
1344  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1345  }
1346  int AllReduce(const float* sendBuffer, float* recvBuffer, vtkIdType length,
1347  vtkCommunicator::Operation* operation)
1348  {
1349  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1350  }
1351  int AllReduce(const double* sendBuffer, double* recvBuffer, vtkIdType length,
1352  vtkCommunicator::Operation* operation)
1353  {
1354  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1355  }
1356  int AllReduce(const long long* sendBuffer, long long* recvBuffer, vtkIdType length,
1357  vtkCommunicator::Operation* operation)
1358  {
1359  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1360  }
1361  int AllReduce(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
1363  {
1364  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1365  }
1367  vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, vtkCommunicator::Operation* operation)
1368  {
1369  return this->Communicator->AllReduce(sendBuffer, recvBuffer, operation);
1370  }
1371 
1373 
1376  int Reduce(const vtkBoundingBox& sendBuffer, vtkBoundingBox& recvBuffer, int destProcessId);
1377  int AllReduce(const vtkBoundingBox& sendBuffer, vtkBoundingBox& recvBuffer);
1379 
1380  // Internally implemented RMI to break the process loop.
1381 
1382 protected:
1384  ~vtkMultiProcessController() override;
1385 
1391  virtual void TriggerRMIInternal(
1392  int remoteProcessId, void* arg, int argLength, int rmiTag, bool propagate);
1393 
1395  void* SingleData;
1396 
1397  void GetMultipleMethod(int index, vtkProcessFunctionType& func, void*& data);
1398 
1399  // This is a flag that can be used by the ports to break
1400  // their update loop. (same as ProcessRMIs)
1402 
1403  void ProcessRMI(int remoteProcessId, void* arg, int argLength, int rmiTag);
1404 
1405  // This method implements "GetGlobalController".
1406  // It needs to be virtual and static.
1407  virtual vtkMultiProcessController* GetLocalController();
1408 
1409  // This flag can force deep copies during send.
1411 
1412  // This flag can be used to indicate that an MPI Broadcast will be used
1413  // when calling TriggerRMIOnAllChildren(), instead of the binary tree
1414  // propagation of the data to the satellite ranks from rank 0.
1416 
1418 
1419  // Note that since the communicators can be created differently
1420  // depending on the type of controller, the subclasses are
1421  // responsible of deleting them.
1423 
1424  // Communicator which is a copy of the current user
1425  // level communicator except the context; i.e. even if the tags
1426  // are the same, the RMI messages will not interfere with user
1427  // level messages.
1428  // Note that since the communicators can be created differently
1429  // depending on the type of controller, the subclasses are
1430  // responsible of deleting them.
1432 
1433 private:
1435  void operator=(const vtkMultiProcessController&) = delete;
1436 
1437  unsigned long RMICount;
1438 
1439  class vtkInternal;
1440  vtkInternal* Internal;
1441 };
1442 
1443 inline int vtkMultiProcessController::Send(vtkDataObject* data, int remoteProcessId, int tag)
1444 {
1445  if (this->Communicator)
1446  {
1447  return this->Communicator->Send(data, remoteProcessId, tag);
1448  }
1449  else
1450  {
1451  return 0;
1452  }
1453 }
1454 
1455 inline int vtkMultiProcessController::Send(vtkDataArray* data, int remoteProcessId, int tag)
1456 {
1457  if (this->Communicator)
1458  {
1459  return this->Communicator->Send(data, remoteProcessId, tag);
1460  }
1461  else
1462  {
1463  return 0;
1464  }
1465 }
1466 
1468  const int* data, vtkIdType length, int remoteProcessId, int tag)
1469 {
1470  if (this->Communicator)
1471  {
1472  return this->Communicator->Send(data, length, remoteProcessId, tag);
1473  }
1474  else
1475  {
1476  return 0;
1477  }
1478 }
1479 
1481  const short* data, vtkIdType length, int remoteProcessId, int tag)
1482 {
1483  if (this->Communicator)
1484  {
1485  return this->Communicator->Send(data, length, remoteProcessId, tag);
1486  }
1487  else
1488  {
1489  return 0;
1490  }
1491 }
1492 
1494  const unsigned short* data, vtkIdType length, int remoteProcessId, int tag)
1495 {
1496  if (this->Communicator)
1497  {
1498  return this->Communicator->Send(data, length, remoteProcessId, tag);
1499  }
1500  else
1501  {
1502  return 0;
1503  }
1504 }
1505 
1507  const unsigned int* data, vtkIdType length, int remoteProcessId, int tag)
1508 {
1509  if (this->Communicator)
1510  {
1511  return this->Communicator->Send(data, length, remoteProcessId, tag);
1512  }
1513  else
1514  {
1515  return 0;
1516  }
1517 }
1518 
1520  const unsigned long* data, vtkIdType length, int remoteProcessId, int tag)
1521 {
1522  if (this->Communicator)
1523  {
1524  return this->Communicator->Send(data, length, remoteProcessId, tag);
1525  }
1526  else
1527  {
1528  return 0;
1529  }
1530 }
1531 
1533  const long* data, vtkIdType length, int remoteProcessId, int tag)
1534 {
1535  if (this->Communicator)
1536  {
1537  return this->Communicator->Send(data, length, remoteProcessId, tag);
1538  }
1539  else
1540  {
1541  return 0;
1542  }
1543 }
1544 
1546  const signed char* data, vtkIdType length, int remoteProcessId, int tag)
1547 {
1548  if (this->Communicator)
1549  {
1550  return this->Communicator->Send(data, length, remoteProcessId, tag);
1551  }
1552  else
1553  {
1554  return 0;
1555  }
1556 }
1557 
1559  const char* data, vtkIdType length, int remoteProcessId, int tag)
1560 {
1561  if (this->Communicator)
1562  {
1563  return this->Communicator->Send(data, length, remoteProcessId, tag);
1564  }
1565  else
1566  {
1567  return 0;
1568  }
1569 }
1570 
1572  const unsigned char* data, vtkIdType length, int remoteProcessId, int tag)
1573 {
1574  if (this->Communicator)
1575  {
1576  return this->Communicator->Send(data, length, remoteProcessId, tag);
1577  }
1578  else
1579  {
1580  return 0;
1581  }
1582 }
1583 
1585  const float* data, vtkIdType length, int remoteProcessId, int tag)
1586 {
1587  if (this->Communicator)
1588  {
1589  return this->Communicator->Send(data, length, remoteProcessId, tag);
1590  }
1591  else
1592  {
1593  return 0;
1594  }
1595 }
1596 
1598  const double* data, vtkIdType length, int remoteProcessId, int tag)
1599 {
1600  if (this->Communicator)
1601  {
1602  return this->Communicator->Send(data, length, remoteProcessId, tag);
1603  }
1604  else
1605  {
1606  return 0;
1607  }
1608 }
1609 
1611  const long long* data, vtkIdType length, int remoteProcessId, int tag)
1612 {
1613  if (this->Communicator)
1614  {
1615  return this->Communicator->Send(data, length, remoteProcessId, tag);
1616  }
1617  else
1618  {
1619  return 0;
1620  }
1621 }
1622 
1624  const unsigned long long* data, vtkIdType length, 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  const vtkMultiProcessStream& stream, int remoteId, int tag)
1638 {
1639  if (this->Communicator)
1640  {
1641  return this->Communicator->Send(stream, remoteId, tag);
1642  }
1643  return 0;
1644 }
1645 
1646 inline int vtkMultiProcessController::Receive(vtkDataObject* data, int remoteProcessId, int tag)
1647 {
1648  if (this->Communicator)
1649  {
1650  return this->Communicator->Receive(data, remoteProcessId, tag);
1651  }
1652  else
1653  {
1654  return 0;
1655  }
1656 }
1657 
1659 {
1660  if (this->Communicator)
1661  {
1662  return this->Communicator->ReceiveDataObject(remoteProcessId, tag);
1663  }
1664  else
1665  {
1666  return nullptr;
1667  }
1668 }
1669 
1670 inline int vtkMultiProcessController::Receive(vtkDataArray* data, int remoteProcessId, int tag)
1671 {
1672  if (this->Communicator)
1673  {
1674  return this->Communicator->Receive(data, remoteProcessId, tag);
1675  }
1676  else
1677  {
1678  return 0;
1679  }
1680 }
1681 
1683  int* data, vtkIdType length, int remoteProcessId, int tag)
1684 {
1685  if (this->Communicator)
1686  {
1687  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1688  }
1689  else
1690  {
1691  return 0;
1692  }
1693 }
1694 
1696  unsigned int* data, vtkIdType length, int remoteProcessId, int tag)
1697 {
1698  if (this->Communicator)
1699  {
1700  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1701  }
1702  else
1703  {
1704  return 0;
1705  }
1706 }
1707 
1709  short* data, vtkIdType length, int remoteProcessId, int tag)
1710 {
1711  if (this->Communicator)
1712  {
1713  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1714  }
1715  else
1716  {
1717  return 0;
1718  }
1719 }
1720 
1722  unsigned short* data, vtkIdType length, int remoteProcessId, int tag)
1723 {
1724  if (this->Communicator)
1725  {
1726  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1727  }
1728  else
1729  {
1730  return 0;
1731  }
1732 }
1733 
1735  long* data, vtkIdType length, int remoteProcessId, int tag)
1736 {
1737  if (this->Communicator)
1738  {
1739  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1740  }
1741  else
1742  {
1743  return 0;
1744  }
1745 }
1746 
1748  unsigned long* data, vtkIdType length, int remoteProcessId, int tag)
1749 {
1750  if (this->Communicator)
1751  {
1752  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1753  }
1754  else
1755  {
1756  return 0;
1757  }
1758 }
1759 
1761  char* data, vtkIdType length, int remoteProcessId, int tag)
1762 {
1763  if (this->Communicator)
1764  {
1765  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1766  }
1767  else
1768  {
1769  return 0;
1770  }
1771 }
1772 
1774  unsigned char* data, vtkIdType length, int remoteProcessId, int tag)
1775 {
1776  if (this->Communicator)
1777  {
1778  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1779  }
1780  else
1781  {
1782  return 0;
1783  }
1784 }
1785 
1787  signed char* data, vtkIdType length, int remoteProcessId, int tag)
1788 {
1789  if (this->Communicator)
1790  {
1791  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1792  }
1793  else
1794  {
1795  return 0;
1796  }
1797 }
1798 
1800  float* data, vtkIdType length, int remoteProcessId, int tag)
1801 {
1802  if (this->Communicator)
1803  {
1804  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1805  }
1806  else
1807  {
1808  return 0;
1809  }
1810 }
1811 
1813  double* data, vtkIdType length, int remoteProcessId, int tag)
1814 {
1815  if (this->Communicator)
1816  {
1817  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1818  }
1819  else
1820  {
1821  return 0;
1822  }
1823 }
1824 
1826  long long* data, vtkIdType length, int remoteProcessId, int tag)
1827 {
1828  if (this->Communicator)
1829  {
1830  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1831  }
1832  else
1833  {
1834  return 0;
1835  }
1836 }
1837 
1839  unsigned long long* data, vtkIdType length, int remoteProcessId, int tag)
1840 {
1841  if (this->Communicator)
1842  {
1843  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1844  }
1845  else
1846  {
1847  return 0;
1848  }
1849 }
1850 
1851 inline int vtkMultiProcessController::Receive(vtkMultiProcessStream& stream, int remoteId, int tag)
1852 {
1853  if (this->Communicator)
1854  {
1855  return this->Communicator->Receive(stream, remoteId, tag);
1856  }
1857  return 0;
1858 }
1859 
1861 {
1862  if (this->Communicator)
1863  {
1864  this->Communicator->Barrier();
1865  }
1866 }
1867 
1869 {
1870  if (this->Communicator)
1871  {
1872  return this->Communicator->GetCount();
1873  }
1874  return 0;
1875 }
1876 
1877 #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:62
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:338
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 Receive(vtkDataObject *data, int remoteHandle, int tag)
This method receives a data object from a corresponding send.
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.
vtkDataObject * ReceiveDataObject(int remoteHandle, int tag)
The caller does not have to know the data type before this call is made.
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:41
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.
virtual vtkIdType GetCount()
Returns the number of words received by the most recent Receive().
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:49
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.
int AllReduce(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
int Gather(const vtkMultiProcessStream &sendBuffer, std::vector< vtkMultiProcessStream > &recvBuffer, int destProcessId)
Gathers vtkMultiProcessStream (sendBuffer) from all ranks to the destProcessId.
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.
virtual void Barrier()
Will block the processes until all other processes reach the Barrier function.
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:52
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.
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:59
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...
Fast, simple class for dealing with 3D bounds.
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.