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 "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
vtkMultiProcessController::GatherV
int GatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, vtkIdTypeArray *recvLengths, vtkIdTypeArray *offsets, int destProcessId)
Definition: vtkMultiProcessController.h:745
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:296
vtkMultiProcessController::AllReduce
int AllReduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
Definition: vtkMultiProcessController.h:1361
vtkMultiProcessController::AllReduce
int AllReduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length, int operation)
Definition: vtkMultiProcessController.h:1290
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:243
vtkMultiProcessController::Broadcast
int Broadcast(long *data, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:489
vtkMultiProcessController::AllGatherV
int AllGatherV(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Definition: vtkMultiProcessController.h:1036
vtkMultiProcessController::RMICommunicator
vtkCommunicator * RMICommunicator
Definition: vtkMultiProcessController.h:1431
vtkMultiProcessController::AllGather
int AllGather(const long *sendBuffer, long *recvBuffer, vtkIdType length)
Definition: vtkMultiProcessController.h:949
vtkMultiProcessController::Reduce
int Reduce(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Definition: vtkMultiProcessController.h:1201
vtkMultiProcessController::Scatter
int Scatter(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:812
vtkMultiProcessController::Reduce
int Reduce(const char *sendBuffer, char *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Definition: vtkMultiProcessController.h:1196
vtkMultiProcessController::Consts
Consts
Definition: vtkMultiProcessController.h:364
vtkMultiProcessController::Reduce
int Reduce(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Definition: vtkMultiProcessController.h:1216
vtkMultiProcessController::ReceiveDataObject
vtkDataObject * ReceiveDataObject(int remoteId, int tag)
Definition: vtkMultiProcessController.h:1658
vtkProcessFunctionType
void(* vtkProcessFunctionType)(vtkMultiProcessController *controller, void *userData)
Definition: vtkMultiProcessController.h:69
vtkMultiProcessController::Broadcast
int Broadcast(long long *data, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:517
vtkMultiProcessController::AllReduce
int AllReduce(const double *sendBuffer, double *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
Definition: vtkMultiProcessController.h:1351
vtkMultiProcessController::Receive
int Receive(int *data, vtkIdType maxlength, int remoteProcessId, int tag)
This method receives data from a corresponding send.
Definition: vtkMultiProcessController.h:1682
vtkMultiProcessController::AllGatherV
int AllGatherV(const long *sendBuffer, long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Definition: vtkMultiProcessController.h:1016
vtkMultiProcessController::Broadcast
int Broadcast(unsigned long *data, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:493
vtkMultiProcessController::GatherV
int GatherV(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
Definition: vtkMultiProcessController.h:708
vtkMultiProcessController::AllGatherV
int AllGatherV(const char *sendBuffer, char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Definition: vtkMultiProcessController.h:1031
vtkCommunicator
Used to send/receive messages in a multiprocess environment.
Definition: vtkCommunicator.h:50
vtkIdType
int vtkIdType
Definition: vtkType.h:343
vtkMultiProcessController::Communicator
vtkCommunicator * Communicator
Definition: vtkMultiProcessController.h:1422
vtkMultiProcessController::Gather
int Gather(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, int destProcessId)
Definition: vtkMultiProcessController.h:609
vtkMultiProcessController::AllReduce
int AllReduce(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
Definition: vtkMultiProcessController.h:1341
vtkMultiProcessController::Scatter
int Scatter(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:830
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:1161
vtkMultiProcessController::SingleMethod
vtkProcessFunctionType SingleMethod
Definition: vtkMultiProcessController.h:1394
vtkX3D::data
Definition: vtkX3D.h:321
vtkMultiProcessController::Scatter
int Scatter(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:825
vtkMultiProcessController::Broadcast
int Broadcast(unsigned char *data, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:497
vtkMultiProcessController::AllReduce
int AllReduce(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
Definition: vtkMultiProcessController.h:1326
vtkMultiProcessController::GatherV
int GatherV(const long *sendBuffer, long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
Definition: vtkMultiProcessController.h:684
vtkMultiProcessController::AllGather
int AllGather(const double *sendBuffer, double *recvBuffer, vtkIdType length)
Definition: vtkMultiProcessController.h:973
vtkMultiProcessController::ScatterV
int ScatterV(const long *sendBuffer, long *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
Definition: vtkMultiProcessController.h:873
vtkCommunicator::Operation
A custom operation to use in a reduce command.
Definition: vtkCommunicator.h:103
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:1181
vtkMultiProcessController::Broadcast
int Broadcast(unsigned long long *data, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:521
vtkMultiProcessController::Reduce
int Reduce(const short *sendBuffer, short *recvBuffer, vtkIdType length, int operation, int destProcessId)
Definition: vtkMultiProcessController.h:1095
vtkMultiProcessController::GatherV
int GatherV(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
Definition: vtkMultiProcessController.h:690
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:627
vtkMultiProcessController::Reduce
int Reduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Definition: vtkMultiProcessController.h:1221
vtkMultiProcessController::Reduce
int Reduce(const double *sendBuffer, double *recvBuffer, vtkIdType length, int operation, int destProcessId)
Definition: vtkMultiProcessController.h:1135
vtkMultiProcessController::AllGather
int AllGather(const short *sendBuffer, short *recvBuffer, vtkIdType length)
Definition: vtkMultiProcessController.h:941
vtkMultiProcessController::AllReduce
int AllReduce(const short *sendBuffer, short *recvBuffer, vtkIdType length, int operation)
Definition: vtkMultiProcessController.h:1246
vtkMultiProcessController::AllReduce
int AllReduce(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
Definition: vtkMultiProcessController.h:1356
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:586
vtkSmartPointer< vtkDataObject >
vtkObject
abstract base class for most VTK objects
Definition: vtkObject.h:53
vtkMultiProcessController::GetRMITag
static int GetRMITag()
Definition: vtkMultiProcessController.h:354
vtkMultiProcessController::Broadcast
int Broadcast(vtkDataArray *data, int srcProcessId)
Definition: vtkMultiProcessController.h:529
vtkMultiProcessController::GatherV
int GatherV(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
Definition: vtkMultiProcessController.h:696
vtkMultiProcessController::AllReduce
int AllReduce(const long *sendBuffer, long *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
Definition: vtkMultiProcessController.h:1321
vtkMultiProcessController::AllGatherV
int AllGatherV(const float *sendBuffer, float *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Definition: vtkMultiProcessController.h:1041
vtkX3D::length
Definition: vtkX3D.h:399
vtkMultiProcessController::Gather
int Gather(const char *sendBuffer, char *recvBuffer, vtkIdType length, int destProcessId)
Definition: vtkMultiProcessController.h:582
vtkMultiProcessController::BroadcastTriggerRMI
bool BroadcastTriggerRMI
Definition: vtkMultiProcessController.h:1415
vtkMultiProcessController::Gather
int Gather(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, int destProcessId)
Definition: vtkMultiProcessController.h:599
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:758
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:1237
vtkDataArray
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:49
vtkMultiProcessController::TriggerRMIOnAllChildren
void TriggerRMIOnAllChildren(int tag)
Definition: vtkMultiProcessController.h:300
vtkMultiProcessController::Broadcast
int Broadcast(signed char *data, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:505
vtkMultiProcessController::RMI_NO_ERROR
Definition: vtkMultiProcessController.h:359
vtkMultiProcessController::Reduce
int Reduce(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, int operation, int destProcessId)
Definition: vtkMultiProcessController.h:1090
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:1074
vtkMultiProcessController::AllGather
int AllGather(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length)
Definition: vtkMultiProcessController.h:981
vtkMultiProcessController::Broadcast
int Broadcast(double *data, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:513
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:933
vtkMultiProcessController::AllGather
int AllGather(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length)
Definition: vtkMultiProcessController.h:937
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:473
vtkMultiProcessController::Broadcast
int Broadcast(unsigned int *data, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:477
vtkMultiProcessController::Gather
int Gather(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, int destProcessId)
Definition: vtkMultiProcessController.h:577
vtkMultiProcessController::AllReduce
int AllReduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, vtkCommunicator::Operation *operation)
Definition: vtkMultiProcessController.h:1366
vtkMultiProcessController::Tags
Tags
Definition: vtkMultiProcessController.h:370
vtkMultiProcessController::AllGatherV
int AllGatherV(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Definition: vtkMultiProcessController.h:1011
vtkMultiProcessController::AllGatherV
int AllGatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, vtkIdType *recvLengths, vtkIdType *offsets)
Definition: vtkMultiProcessController.h:1061
vtkMultiProcessController::Reduce
int Reduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, int operation, int destProcessId)
Definition: vtkMultiProcessController.h:1150
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:867
vtkMultiProcessController::Broadcast
int Broadcast(float *data, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:509
vtkMultiProcessController::Scatter
int Scatter(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:798
vtkMultiProcessController::AllReduce
int AllReduce(const double *sendBuffer, double *recvBuffer, vtkIdType length, int operation)
Definition: vtkMultiProcessController.h:1282
vtkMultiProcessController::AllReduce
int AllReduce(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, int operation)
Definition: vtkMultiProcessController.h:1241
vtkMultiProcessController::Reduce
int Reduce(const long *sendBuffer, long *recvBuffer, vtkIdType length, int operation, int destProcessId)
Definition: vtkMultiProcessController.h:1105
vtkMultiProcessController::AllReduce
int AllReduce(const int *sendBuffer, int *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
Definition: vtkMultiProcessController.h:1301
vtkMultiProcessController::Reduce
int Reduce(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Definition: vtkMultiProcessController.h:1186
vtkMultiProcessController::Reduce
int Reduce(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Definition: vtkMultiProcessController.h:1166
vtkBoundingBox
Fast, simple class for dealing with 3D bounds.
Definition: vtkBoundingBox.h:34
vtkMultiProcessController::AllGather
int AllGather(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length)
Definition: vtkMultiProcessController.h:945
vtkMultiProcessController::ScatterV
int ScatterV(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
Definition: vtkMultiProcessController.h:885
vtkMultiProcessController::GatherV
int GatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
Definition: vtkMultiProcessController.h:740
vtkCollection
create and manipulate ordered lists of objects
Definition: vtkCollection.h:52
vtkMultiProcessController::GatherV
int GatherV(const short *sendBuffer, short *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
Definition: vtkMultiProcessController.h:672
vtkMultiProcessController::ScatterV
int ScatterV(const float *sendBuffer, float *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
Definition: vtkMultiProcessController.h:903
vtkMultiProcessController::Broadcast
int Broadcast(vtkDataObject *data, int srcProcessId)
Definition: vtkMultiProcessController.h:525
vtkMultiProcessController::AllReduce
int AllReduce(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
Definition: vtkMultiProcessController.h:1316
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:961
vtkMultiProcessController::Reduce
int Reduce(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, int operation, int destProcessId)
Definition: vtkMultiProcessController.h:1110
vtkMultiProcessController::Reduce
int Reduce(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, int operation, int destProcessId)
Definition: vtkMultiProcessController.h:1140
vtkMultiProcessController
Multiprocessing communication superclass.
Definition: vtkMultiProcessController.h:75
vtkMultiProcessController::GatherV
int GatherV(vtkDataObject *sendData, vtkSmartPointer< vtkDataObject > *recvData, int destProcessId)
Definition: vtkMultiProcessController.h:762
vtkMultiProcessController::Gather
int Gather(const long *sendBuffer, long *recvBuffer, vtkIdType length, int destProcessId)
Definition: vtkMultiProcessController.h:568
vtkMultiProcessController::AllReduce
int AllReduce(const long *sendBuffer, long *recvBuffer, vtkIdType length, int operation)
Definition: vtkMultiProcessController.h:1255
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:44
vtkMultiProcessController::Reduce
int Reduce(const short *sendBuffer, short *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Definition: vtkMultiProcessController.h:1171
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:776
vtkMultiProcessController::AllGather
int AllGather(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer)
Definition: vtkMultiProcessController.h:986
vtkImageData
topologically and geometrically regular array of data
Definition: vtkImageData.h:41
vtkMultiProcessController::Scatter
int Scatter(const char *sendBuffer, char *recvBuffer, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:808
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:666
vtkMultiProcessController::GetRMIArgTag
static int GetRMIArgTag()
Definition: vtkMultiProcessController.h:355
vtkMultiProcessController::Scatter
int Scatter(const double *sendBuffer, double *recvBuffer, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:821
vtkMultiProcessController::ScatterV
int ScatterV(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
Definition: vtkMultiProcessController.h:921
vtkMultiProcessController::Barrier
void Barrier()
This method can be used to synchronize processes.
Definition: vtkMultiProcessController.h:1860
vtkMultiProcessController::AllGatherV
int AllGatherV(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Definition: vtkMultiProcessController.h:1021
vtkMultiProcessController::AllReduce
int AllReduce(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, int operation)
Definition: vtkMultiProcessController.h:1273
vtkMultiProcessController::AllReduce
int AllReduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, int operation)
Definition: vtkMultiProcessController.h:1295
vtkMultiProcessController::AllGatherV
int AllGatherV(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Definition: vtkMultiProcessController.h:1001
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:550
vtkMultiProcessController::AllReduce
int AllReduce(const float *sendBuffer, float *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
Definition: vtkMultiProcessController.h:1346
vtkMultiProcessController::AllGatherV
int AllGatherV(const short *sendBuffer, short *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Definition: vtkMultiProcessController.h:1006
vtkMultiProcessController::Scatter
int Scatter(const short *sendBuffer, short *recvBuffer, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:785
vtkMultiProcessController::ScatterV
int ScatterV(const char *sendBuffer, char *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
Definition: vtkMultiProcessController.h:891
vtkMultiProcessController::GatherV
int GatherV(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
Definition: vtkMultiProcessController.h:678
vtkMultiProcessController::Reduce
int Reduce(const double *sendBuffer, double *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Definition: vtkMultiProcessController.h:1211
vtkMultiProcessController::Broadcast
int Broadcast(vtkMultiProcessStream &stream, int srcProcessId)
Definition: vtkMultiProcessController.h:535
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:660
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:996
vtkMultiProcessController::AllGather
int AllGather(const long long *sendBuffer, long long *recvBuffer, vtkIdType length)
Definition: vtkMultiProcessController.h:977
vtkMultiProcessController::ScatterV
int ScatterV(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
Definition: vtkMultiProcessController.h:879
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:849
vtkObject.h
vtkMultiProcessController::AllGatherV
int AllGatherV(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Definition: vtkMultiProcessController.h:1056
vtkMultiProcessController::Send
int Send(const int *data, vtkIdType length, int remoteProcessId, int tag)
This method sends data to another process.
Definition: vtkMultiProcessController.h:1467
vtkMultiProcessController::AllReduce
int AllReduce(const short *sendBuffer, short *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
Definition: vtkMultiProcessController.h:1311
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:1278
vtkMultiProcessController::ForceDeepCopy
int ForceDeepCopy
Definition: vtkMultiProcessController.h:1410
vtkProcess
a process that can be launched by a vtkMultiProcessController
Definition: vtkProcess.h:46
vtkMultiProcessController::BreakFlag
int BreakFlag
Definition: vtkMultiProcessController.h:1401
vtkMultiProcessController::AllGather
int AllGather(const float *sendBuffer, float *recvBuffer, vtkIdType length)
Definition: vtkMultiProcessController.h:969
vtkMultiProcessController::Reduce
int Reduce(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, int operation, int destProcessId)
Definition: vtkMultiProcessController.h:1115
vtkMultiProcessController::Broadcast
int Broadcast(short *data, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:481
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:1145
vtkMultiProcessController::Gather
int Gather(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, int destProcessId)
Definition: vtkMultiProcessController.h:563
vtkMultiProcessController::Errors
Errors
Definition: vtkMultiProcessController.h:357
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:1226
vtkMultiProcessController::ScatterV
int ScatterV(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
Definition: vtkMultiProcessController.h:855
vtkMultiProcessController::Gather
int Gather(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length, int destProcessId)
Definition: vtkMultiProcessController.h:604
vtkMultiProcessController::AllReduce
int AllReduce(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, int operation)
Definition: vtkMultiProcessController.h:1259
vtkMultiProcessController::AllReduce
int AllReduce(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, int operation)
Definition: vtkMultiProcessController.h:1286
vtkMultiProcessController::AllReduce
int AllReduce(const char *sendBuffer, char *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
Definition: vtkMultiProcessController.h:1336
vtkMultiProcessController::Gather
int Gather(const float *sendBuffer, float *recvBuffer, vtkIdType length, int destProcessId)
Definition: vtkMultiProcessController.h:591
vtkMultiProcessController::ScatterV
int ScatterV(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
Definition: vtkMultiProcessController.h:897
vtkMultiProcessController::Scatter
int Scatter(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:803
vtkMultiProcessController::AllReduce
int AllReduce(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, int operation)
Definition: vtkMultiProcessController.h:1264
vtkMultiProcessController::AllGather
int AllGather(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length)
Definition: vtkMultiProcessController.h:965
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:1051
vtkMultiProcessController::OutputWindow
vtkOutputWindow * OutputWindow
Definition: vtkMultiProcessController.h:1417
vtkMultiProcessController::AllGather
int AllGather(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length)
Definition: vtkMultiProcessController.h:957
vtkMultiProcessController::ScatterV
int ScatterV(const double *sendBuffer, double *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
Definition: vtkMultiProcessController.h:909
vtkMultiProcessController::Gather
int Gather(const short *sendBuffer, short *recvBuffer, vtkIdType length, int destProcessId)
Definition: vtkMultiProcessController.h:559
vtkMultiProcessController::GetBreakRMITag
static int GetBreakRMITag()
Accessor to some default tags.
Definition: vtkMultiProcessController.h:353
vtkMultiProcessController::AllReduce
int AllReduce(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, int operation)
Definition: vtkMultiProcessController.h:1250
vtkMultiProcessController::GatherV
int GatherV(const float *sendBuffer, float *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
Definition: vtkMultiProcessController.h:714
vtkMultiProcessController::RemoveRMI
virtual void RemoveRMI(vtkRMIFunctionType f, void *arg, int tag)
Take an RMI away.
Definition: vtkMultiProcessController.h:232
vtkMultiProcessController::SingleData
void * SingleData
Definition: vtkMultiProcessController.h:1395
vtkMultiProcessController::Scatter
int Scatter(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, int srcProcessId)
Definition: vtkMultiProcessController.h:835
vtkMultiProcessController::Scatter
int Scatter(const float *sendBuffer, float *recvBuffer, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:817
vtkMultiProcessController::Gather
int Gather(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, int destProcessId)
Definition: vtkMultiProcessController.h:554
vtkMultiProcessController::Gather
int Gather(const double *sendBuffer, double *recvBuffer, vtkIdType length, int destProcessId)
Definition: vtkMultiProcessController.h:595
vtkMultiProcessController::RMI_TAG_ERROR
Definition: vtkMultiProcessController.h:360
vtkMultiProcessController::Reduce
int Reduce(const float *sendBuffer, float *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Definition: vtkMultiProcessController.h:1206
vtkMultiProcessController::TriggerRMI
void TriggerRMI(int remoteProcessId, int tag)
Convenience method when there is no argument.
Definition: vtkMultiProcessController.h:281
vtkMultiProcessController::AllReduce
int AllReduce(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
Definition: vtkMultiProcessController.h:1331
vtkMultiProcessController::GatherV
int GatherV(const char *sendBuffer, char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
Definition: vtkMultiProcessController.h:702
vtkDataObject
general representation of visualization data
Definition: vtkDataObject.h:58
vtkMultiProcessController::Broadcast
int Broadcast(char *data, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:501
vtkMultiProcessController::Scatter
int Scatter(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, int srcProcessId)
Definition: vtkMultiProcessController.h:780
vtkX3D::index
Definition: vtkX3D.h:252
vtkMultiProcessController::GatherV
int GatherV(const double *sendBuffer, double *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
Definition: vtkMultiProcessController.h:720
vtkMultiProcessController::Reduce
int Reduce(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, int operation, int destProcessId)
Definition: vtkMultiProcessController.h:1125
vtkMultiProcessController::ScatterV
int ScatterV(const short *sendBuffer, short *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
Definition: vtkMultiProcessController.h:861
vtkMultiProcessController::Reduce
int Reduce(const float *sendBuffer, float *recvBuffer, vtkIdType length, int operation, int destProcessId)
Definition: vtkMultiProcessController.h:1130
vtkMultiProcessController::Reduce
int Reduce(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Definition: vtkMultiProcessController.h:1191
vtkMultiProcessController::AllReduce
int AllReduce(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
Definition: vtkMultiProcessController.h:1306
vtkMultiProcessController::Reduce
int Reduce(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, int operation, int destProcessId)
Definition: vtkMultiProcessController.h:1100
vtkMultiProcessController::TriggerRMI
void TriggerRMI(int remoteProcessId, const char *arg, int tag)
Convenience method when the arg is a string.
Definition: vtkMultiProcessController.h:273
vtkMultiProcessController::AllGatherV
int AllGatherV(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Definition: vtkMultiProcessController.h:1026
vtkMultiProcessController::Gather
int Gather(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, int destProcessId)
Definition: vtkMultiProcessController.h:572
vtkMultiProcessController::AllGatherV
int AllGatherV(const double *sendBuffer, double *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Definition: vtkMultiProcessController.h:1046
vtkMultiProcessController::AllGather
int AllGather(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length)
Definition: vtkMultiProcessController.h:953
vtkMultiProcessController::ScatterV
int ScatterV(const long long *sendBuffer, long long *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
Definition: vtkMultiProcessController.h:915
vtkMultiProcessController::GatherV
int GatherV(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
Definition: vtkMultiProcessController.h:732
vtkMultiProcessController::AllReduce
int AllReduce(const char *sendBuffer, char *recvBuffer, vtkIdType length, int operation)
Definition: vtkMultiProcessController.h:1269
vtkMultiProcessController::GetCount
vtkIdType GetCount()
Returns the number of words received by the most recent Receive().
Definition: vtkMultiProcessController.h:1868
vtkMultiProcessController::Gather
int Gather(const vtkMultiProcessStream &sendBuffer, std::vector< vtkMultiProcessStream > &recvBuffer, int destProcessId)
Gathers vtkMultiProcessStream (sendBuffer) from all ranks to the destProcessId.
Definition: vtkMultiProcessController.h:642
vtkMultiProcessController::GatherV
int GatherV(const long long *sendBuffer, long long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
Definition: vtkMultiProcessController.h:726
vtkMultiProcessController::Reduce
int Reduce(const char *sendBuffer, char *recvBuffer, vtkIdType length, int operation, int destProcessId)
Definition: vtkMultiProcessController.h:1120
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:1085
vtkMultiProcessController::Reduce
int Reduce(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Definition: vtkMultiProcessController.h:1176