VTK  9.2.6
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 =========================================================================*/
55 #ifndef vtkMultiProcessController_h
56 #define vtkMultiProcessController_h
57 
58 #include "vtkObject.h"
59 #include "vtkParallelCoreModule.h" // For export macro
60 
61 #include "vtkCommunicator.h" // Needed for direct access to communicator
62 
63 class vtkBoundingBox;
64 class vtkCollection;
65 class vtkDataObject;
66 class vtkDataSet;
67 class vtkImageData;
70 class vtkOutputWindow;
71 class vtkProcessGroup;
72 class vtkProcess;
74 
75 // The type of function that gets called when new processes are initiated.
76 typedef void (*vtkProcessFunctionType)(vtkMultiProcessController* controller, void* userData);
77 
78 // The type of function that gets called when an RMI is triggered.
79 typedef void (*vtkRMIFunctionType)(
80  void* localArg, void* remoteArg, int remoteArgLength, int remoteProcessId);
81 
82 class VTKPARALLELCORE_EXPORT vtkMultiProcessController : public vtkObject
83 {
84 public:
86  void PrintSelf(ostream& os, vtkIndent indent) override;
87 
93  virtual void Initialize(int* vtkNotUsed(argc), char*** vtkNotUsed(argv)) = 0;
94 
100  virtual void Initialize(
101  int* vtkNotUsed(argc), char*** vtkNotUsed(argv), int initializedExternally) = 0;
102 
108  virtual void Finalize() = 0;
109 
115  virtual void Finalize(int finalizedExternally) = 0;
116 
118 
123  void SetNumberOfProcesses(int num);
124  int GetNumberOfProcesses();
126 
133  void SetSingleMethod(vtkProcessFunctionType, void* data);
134 
140  void SetSingleProcessObject(vtkProcess* p);
141 
147  virtual void SingleMethodExecute() = 0;
148 
155  void SetMultipleMethod(int index, vtkProcessFunctionType, void* data);
156 
162  virtual void MultipleMethodExecute() = 0;
163 
167  int GetLocalProcessId();
168 
175  static vtkMultiProcessController* GetGlobalController();
176 
182  virtual void CreateOutputWindow() = 0;
183 
195  virtual vtkMultiProcessController* CreateSubController(vtkProcessGroup* group);
196 
207  virtual vtkMultiProcessController* PartitionController(int localColor, int localKey);
208 
209  //------------------ RMIs --------------------
210 
223  virtual unsigned long AddRMI(vtkRMIFunctionType, void* localArg, int tag);
224 
228  virtual int RemoveFirstRMI(int tag);
229 
234  virtual int RemoveRMI(unsigned long id);
235 
239  virtual void RemoveRMI(vtkRMIFunctionType f, void* arg, int tag)
240  {
241  (void)f;
242  (void)arg;
243  (void)tag;
244  vtkErrorMacro("RemoveRMI Not Implemented Yet");
245  }
246 
252  virtual unsigned long AddRMICallback(vtkRMIFunctionType, void* localArg, int tag);
253 
259  virtual void RemoveAllRMICallbacks(int tag);
260 
264  virtual bool RemoveRMICallback(unsigned long id);
265 
269  void TriggerRMI(int remoteProcessId, void* arg, int argLength, int tag);
270 
275  void TriggerBreakRMIs();
276 
280  void TriggerRMI(int remoteProcessId, const char* arg, int tag)
281  {
282  this->TriggerRMI(remoteProcessId, (void*)arg, static_cast<int>(strlen(arg)) + 1, tag);
283  }
284 
288  void TriggerRMI(int remoteProcessId, int tag)
289  {
290  this->TriggerRMI(remoteProcessId, nullptr, 0, tag);
291  }
292 
294 
302  void TriggerRMIOnAllChildren(void* arg, int argLength, int tag);
303  void TriggerRMIOnAllChildren(const char* arg, int tag)
304  {
305  this->TriggerRMIOnAllChildren((void*)arg, static_cast<int>(strlen(arg)) + 1, tag);
306  }
307  void TriggerRMIOnAllChildren(int tag) { this->TriggerRMIOnAllChildren(nullptr, 0, tag); }
308  void BroadcastTriggerRMIOnAllChildren(void* arg, int argLength, int tag);
310 
312 
323  int ProcessRMIs(int reportErrors, int dont_loop = 0);
324  int ProcessRMIs();
325  int BroadcastProcessRMIs(int reportErrors, int dont_loop = 0);
327 
329 
334  vtkSetMacro(BreakFlag, int);
335  vtkGetMacro(BreakFlag, int);
337 
339 
344  vtkSetMacro(BroadcastTriggerRMI, bool);
345  vtkGetMacro(BroadcastTriggerRMI, bool);
346  vtkBooleanMacro(BroadcastTriggerRMI, bool);
348 
350 
354  vtkGetObjectMacro(Communicator, vtkCommunicator);
356 
360  static int GetBreakRMITag() { return BREAK_RMI_TAG; }
361  static int GetRMITag() { return RMI_TAG; }
362  static int GetRMIArgTag() { return RMI_ARG_TAG; }
363 
364  enum Errors
365  {
368  RMI_ARG_ERROR
369  };
370 
371  enum Consts
372  {
373  ANY_SOURCE = -1,
374  INVALID_SOURCE = -2
375  };
376 
377  enum Tags
378  {
379  RMI_TAG = 1,
380  RMI_ARG_TAG = 2,
381  BREAK_RMI_TAG = 3,
382  XML_WRITER_DATA_INFO = 4
383  };
384 
388  void Barrier();
389 
390  static void SetGlobalController(vtkMultiProcessController* controller);
391 
392  //------------------ Communication --------------------
393 
395 
402  int Send(const int* data, vtkIdType length, int remoteProcessId, int tag);
403  int Send(const short* data, vtkIdType length, int remoteProcessId, int tag);
404  int Send(const unsigned short* data, vtkIdType length, int remoteProcessId, int tag);
405  int Send(const unsigned int* data, vtkIdType length, int remoteProcessId, int tag);
406  int Send(const unsigned long* data, vtkIdType length, int remoteProcessId, int tag);
407  int Send(const long* data, vtkIdType length, int remoteProcessId, int tag);
408  int Send(const signed char* data, vtkIdType length, int remoteProcessId, int tag);
409  int Send(const char* data, vtkIdType length, int remoteProcessId, int tag);
410  int Send(const unsigned char* data, vtkIdType length, int remoteProcessId, int tag);
411  int Send(const float* data, vtkIdType length, int remoteProcessId, int tag);
412  int Send(const double* data, vtkIdType length, int remoteProcessId, int tag);
413  int Send(const long long* data, vtkIdType length, int remoteProcessId, int tag);
414  int Send(const unsigned long long* data, vtkIdType length, int remoteProcessId, int tag);
415  int Send(vtkDataObject* data, int remoteId, int tag);
416  int Send(vtkDataArray* data, int remoteId, int tag);
418 
426  int Send(const vtkMultiProcessStream& stream, int remoteId, int tag);
427 
429 
438  int Receive(int* data, vtkIdType maxlength, int remoteProcessId, int tag);
439  int Receive(unsigned int* data, vtkIdType maxlength, int remoteProcessId, int tag);
440  int Receive(short* data, vtkIdType maxlength, int remoteProcessId, int tag);
441  int Receive(unsigned short* data, vtkIdType maxlength, int remoteProcessId, int tag);
442  int Receive(long* data, vtkIdType maxlength, int remoteProcessId, int tag);
443  int Receive(unsigned long* data, vtkIdType maxlength, int remoteProcessId, int tag);
444  int Receive(char* data, vtkIdType maxlength, int remoteProcessId, int tag);
445  int Receive(unsigned char* data, vtkIdType maxlength, int remoteProcessId, int tag);
446  int Receive(signed char* data, vtkIdType maxlength, int remoteProcessId, int tag);
447  int Receive(float* data, vtkIdType maxlength, int remoteProcessId, int tag);
448  int Receive(double* data, vtkIdType maxlength, int remoteProcessId, int tag);
449  int Receive(long long* data, vtkIdType maxLength, int remoteProcessId, int tag);
450  int Receive(unsigned long long* data, vtkIdType maxLength, int remoteProcessId, int tag);
451  int Receive(vtkDataObject* data, int remoteId, int tag);
452  int Receive(vtkDataArray* data, int remoteId, int tag);
454 
458  int Receive(vtkMultiProcessStream& stream, int remoteId, int tag);
459 
460  vtkDataObject* ReceiveDataObject(int remoteId, int tag);
461 
470  vtkIdType GetCount();
471 
472  //---------------------- Collective Operations ----------------------
473 
475 
480  int Broadcast(int* data, vtkIdType length, int srcProcessId)
481  {
482  return this->Communicator->Broadcast(data, length, srcProcessId);
483  }
484  int Broadcast(unsigned int* data, vtkIdType length, int srcProcessId)
485  {
486  return this->Communicator->Broadcast(data, length, srcProcessId);
487  }
488  int Broadcast(short* data, vtkIdType length, int srcProcessId)
489  {
490  return this->Communicator->Broadcast(data, length, srcProcessId);
491  }
492  int Broadcast(unsigned short* data, vtkIdType length, int srcProcessId)
493  {
494  return this->Communicator->Broadcast(data, length, srcProcessId);
495  }
496  int Broadcast(long* data, vtkIdType length, int srcProcessId)
497  {
498  return this->Communicator->Broadcast(data, length, srcProcessId);
499  }
500  int Broadcast(unsigned long* data, vtkIdType length, int srcProcessId)
501  {
502  return this->Communicator->Broadcast(data, length, srcProcessId);
503  }
504  int Broadcast(unsigned char* data, vtkIdType length, int srcProcessId)
505  {
506  return this->Communicator->Broadcast(data, length, srcProcessId);
507  }
508  int Broadcast(char* data, vtkIdType length, int srcProcessId)
509  {
510  return this->Communicator->Broadcast(data, length, srcProcessId);
511  }
512  int Broadcast(signed char* data, vtkIdType length, int srcProcessId)
513  {
514  return this->Communicator->Broadcast(data, length, srcProcessId);
515  }
516  int Broadcast(float* data, vtkIdType length, int srcProcessId)
517  {
518  return this->Communicator->Broadcast(data, length, srcProcessId);
519  }
520  int Broadcast(double* data, vtkIdType length, int srcProcessId)
521  {
522  return this->Communicator->Broadcast(data, length, srcProcessId);
523  }
524  int Broadcast(long long* data, vtkIdType length, int srcProcessId)
525  {
526  return this->Communicator->Broadcast(data, length, srcProcessId);
527  }
528  int Broadcast(unsigned long long* data, vtkIdType length, int srcProcessId)
529  {
530  return this->Communicator->Broadcast(data, length, srcProcessId);
531  }
532  int Broadcast(vtkDataObject* data, int srcProcessId)
533  {
534  return this->Communicator->Broadcast(data, srcProcessId);
535  }
536  int Broadcast(vtkDataArray* data, int srcProcessId)
537  {
538  return this->Communicator->Broadcast(data, srcProcessId);
539  }
541 
542  int Broadcast(vtkMultiProcessStream& stream, int srcProcessId)
543  {
544  return this->Communicator->Broadcast(stream, srcProcessId);
545  }
546 
548 
557  int Gather(const int* sendBuffer, int* recvBuffer, vtkIdType length, int destProcessId)
558  {
559  return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
560  }
561  int Gather(
562  const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType length, int destProcessId)
563  {
564  return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
565  }
566  int Gather(const short* sendBuffer, short* recvBuffer, vtkIdType length, int destProcessId)
567  {
568  return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
569  }
570  int Gather(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType length,
571  int destProcessId)
572  {
573  return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
574  }
575  int Gather(const long* sendBuffer, long* recvBuffer, vtkIdType length, int destProcessId)
576  {
577  return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
578  }
579  int Gather(
580  const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length, int destProcessId)
581  {
582  return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
583  }
584  int Gather(
585  const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType length, int destProcessId)
586  {
587  return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
588  }
589  int Gather(const char* sendBuffer, char* recvBuffer, vtkIdType length, int destProcessId)
590  {
591  return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
592  }
593  int Gather(
594  const signed char* sendBuffer, signed char* recvBuffer, vtkIdType length, int destProcessId)
595  {
596  return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
597  }
598  int Gather(const float* sendBuffer, float* recvBuffer, vtkIdType length, int destProcessId)
599  {
600  return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
601  }
602  int Gather(const double* sendBuffer, double* recvBuffer, vtkIdType length, int destProcessId)
603  {
604  return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
605  }
606  int Gather(
607  const long long* sendBuffer, long long* recvBuffer, vtkIdType length, int destProcessId)
608  {
609  return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
610  }
611  int Gather(const unsigned long long* sendBuffer, unsigned long long* recvBuffer, vtkIdType length,
612  int destProcessId)
613  {
614  return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
615  }
616  int Gather(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, int destProcessId)
617  {
618  return this->Communicator->Gather(sendBuffer, recvBuffer, destProcessId);
619  }
621 
632  int destProcessId)
633  {
634  return this->Communicator->Gather(sendBuffer, recvBuffer, destProcessId);
635  }
636 
646  int Gather(const vtkMultiProcessStream& sendBuffer,
647  std::vector<vtkMultiProcessStream>& recvBuffer, int destProcessId)
648  {
649  return this->Communicator->Gather(sendBuffer, recvBuffer, destProcessId);
650  }
651 
653 
664  int GatherV(const int* sendBuffer, int* recvBuffer, vtkIdType sendLength, vtkIdType* recvLengths,
665  vtkIdType* offsets, int destProcessId)
666  {
667  return this->Communicator->GatherV(
668  sendBuffer, recvBuffer, sendLength, recvLengths, offsets, destProcessId);
669  }
670  int GatherV(const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType sendLength,
671  vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
672  {
673  return this->Communicator->GatherV(
674  sendBuffer, recvBuffer, sendLength, recvLengths, offsets, destProcessId);
675  }
676  int GatherV(const short* sendBuffer, short* recvBuffer, vtkIdType sendLength,
677  vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
678  {
679  return this->Communicator->GatherV(
680  sendBuffer, recvBuffer, sendLength, recvLengths, offsets, destProcessId);
681  }
682  int GatherV(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType sendLength,
683  vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
684  {
685  return this->Communicator->GatherV(
686  sendBuffer, recvBuffer, sendLength, recvLengths, offsets, destProcessId);
687  }
688  int GatherV(const long* sendBuffer, long* recvBuffer, vtkIdType sendLength,
689  vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
690  {
691  return this->Communicator->GatherV(
692  sendBuffer, recvBuffer, sendLength, recvLengths, offsets, destProcessId);
693  }
694  int GatherV(const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType sendLength,
695  vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
696  {
697  return this->Communicator->GatherV(
698  sendBuffer, recvBuffer, sendLength, recvLengths, offsets, destProcessId);
699  }
700  int GatherV(const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType sendLength,
701  vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
702  {
703  return this->Communicator->GatherV(
704  sendBuffer, recvBuffer, sendLength, recvLengths, offsets, destProcessId);
705  }
706  int GatherV(const char* sendBuffer, char* recvBuffer, vtkIdType sendLength,
707  vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
708  {
709  return this->Communicator->GatherV(
710  sendBuffer, recvBuffer, sendLength, recvLengths, offsets, destProcessId);
711  }
712  int GatherV(const signed char* sendBuffer, signed char* recvBuffer, vtkIdType sendLength,
713  vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
714  {
715  return this->Communicator->GatherV(
716  sendBuffer, recvBuffer, sendLength, recvLengths, offsets, destProcessId);
717  }
718  int GatherV(const float* sendBuffer, float* recvBuffer, vtkIdType sendLength,
719  vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
720  {
721  return this->Communicator->GatherV(
722  sendBuffer, recvBuffer, sendLength, recvLengths, offsets, destProcessId);
723  }
724  int GatherV(const double* sendBuffer, double* recvBuffer, vtkIdType sendLength,
725  vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
726  {
727  return this->Communicator->GatherV(
728  sendBuffer, recvBuffer, sendLength, recvLengths, offsets, destProcessId);
729  }
730  int GatherV(const long long* sendBuffer, long long* recvBuffer, vtkIdType sendLength,
731  vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
732  {
733  return this->Communicator->GatherV(
734  sendBuffer, recvBuffer, sendLength, recvLengths, offsets, destProcessId);
735  }
736  int GatherV(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
737  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
738  {
739  return this->Communicator->GatherV(
740  sendBuffer, recvBuffer, sendLength, recvLengths, offsets, destProcessId);
741  }
743 
744  int GatherV(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, vtkIdType* recvLengths,
745  vtkIdType* offsets, int destProcessId)
746  {
747  return this->Communicator->GatherV(sendBuffer, recvBuffer, recvLengths, offsets, destProcessId);
748  }
749  int GatherV(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, vtkIdTypeArray* recvLengths,
750  vtkIdTypeArray* offsets, int destProcessId)
751  {
752  return this->Communicator->GatherV(sendBuffer, recvBuffer, recvLengths, offsets, destProcessId);
753  }
754 
756 
762  int GatherV(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, int destProcessId)
763  {
764  return this->Communicator->GatherV(sendBuffer, recvBuffer, destProcessId);
765  }
766  int GatherV(vtkDataObject* sendData, vtkSmartPointer<vtkDataObject>* recvData, int destProcessId)
767  {
768  return this->Communicator->GatherV(sendData, recvData, destProcessId);
769  }
771 
773 
780  int Scatter(const int* sendBuffer, int* recvBuffer, vtkIdType length, int srcProcessId)
781  {
782  return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
783  }
784  int Scatter(
785  const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType length, int srcProcessId)
786  {
787  return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
788  }
789  int Scatter(const short* sendBuffer, short* recvBuffer, vtkIdType length, int srcProcessId)
790  {
791  return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
792  }
793  int Scatter(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType length,
794  int srcProcessId)
795  {
796  return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
797  }
798  int Scatter(const long* sendBuffer, long* recvBuffer, vtkIdType length, int srcProcessId)
799  {
800  return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
801  }
802  int Scatter(
803  const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length, int srcProcessId)
804  {
805  return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
806  }
807  int Scatter(
808  const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType length, int srcProcessId)
809  {
810  return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
811  }
812  int Scatter(const char* sendBuffer, char* recvBuffer, vtkIdType length, int srcProcessId)
813  {
814  return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
815  }
816  int Scatter(
817  const signed char* sendBuffer, signed char* recvBuffer, vtkIdType length, int srcProcessId)
818  {
819  return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
820  }
821  int Scatter(const float* sendBuffer, float* recvBuffer, vtkIdType length, int srcProcessId)
822  {
823  return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
824  }
825  int Scatter(const double* sendBuffer, double* recvBuffer, vtkIdType length, int srcProcessId)
826  {
827  return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
828  }
829  int Scatter(
830  const long long* sendBuffer, long long* recvBuffer, vtkIdType length, int srcProcessId)
831  {
832  return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
833  }
834  int Scatter(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
835  vtkIdType length, int srcProcessId)
836  {
837  return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
838  }
839  int Scatter(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, int srcProcessId)
840  {
841  return this->Communicator->Scatter(sendBuffer, recvBuffer, srcProcessId);
842  }
844 
846 
853  int ScatterV(const int* sendBuffer, int* recvBuffer, vtkIdType* sendLengths, vtkIdType* offsets,
854  vtkIdType recvLength, int srcProcessId)
855  {
856  return this->Communicator->ScatterV(
857  sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
858  }
859  int ScatterV(const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType* sendLengths,
860  vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
861  {
862  return this->Communicator->ScatterV(
863  sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
864  }
865  int ScatterV(const short* sendBuffer, short* recvBuffer, vtkIdType* sendLengths,
866  vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
867  {
868  return this->Communicator->ScatterV(
869  sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
870  }
871  int ScatterV(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType* sendLengths,
872  vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
873  {
874  return this->Communicator->ScatterV(
875  sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
876  }
877  int ScatterV(const long* sendBuffer, long* recvBuffer, vtkIdType* sendLengths, vtkIdType* offsets,
878  vtkIdType recvLength, int srcProcessId)
879  {
880  return this->Communicator->ScatterV(
881  sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
882  }
883  int ScatterV(const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType* sendLengths,
884  vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
885  {
886  return this->Communicator->ScatterV(
887  sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
888  }
889  int ScatterV(const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType* sendLengths,
890  vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
891  {
892  return this->Communicator->ScatterV(
893  sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
894  }
895  int ScatterV(const char* sendBuffer, char* recvBuffer, vtkIdType* sendLengths, vtkIdType* offsets,
896  vtkIdType recvLength, int srcProcessId)
897  {
898  return this->Communicator->ScatterV(
899  sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
900  }
901  int ScatterV(const signed char* sendBuffer, signed char* recvBuffer, vtkIdType* sendLengths,
902  vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
903  {
904  return this->Communicator->ScatterV(
905  sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
906  }
907  int ScatterV(const float* sendBuffer, float* recvBuffer, vtkIdType* sendLengths,
908  vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
909  {
910  return this->Communicator->ScatterV(
911  sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
912  }
913  int ScatterV(const double* sendBuffer, double* recvBuffer, vtkIdType* sendLengths,
914  vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
915  {
916  return this->Communicator->ScatterV(
917  sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
918  }
919  int ScatterV(const long long* sendBuffer, long long* recvBuffer, vtkIdType* sendLengths,
920  vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
921  {
922  return this->Communicator->ScatterV(
923  sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
924  }
925  int ScatterV(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
926  vtkIdType* sendLengths, vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
927  {
928  return this->Communicator->ScatterV(
929  sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
930  }
932 
934 
937  int AllGather(const int* sendBuffer, int* recvBuffer, vtkIdType length)
938  {
939  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
940  }
941  int AllGather(const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType length)
942  {
943  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
944  }
945  int AllGather(const short* sendBuffer, short* recvBuffer, vtkIdType length)
946  {
947  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
948  }
949  int AllGather(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType length)
950  {
951  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
952  }
953  int AllGather(const long* sendBuffer, long* recvBuffer, vtkIdType length)
954  {
955  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
956  }
957  int AllGather(const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length)
958  {
959  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
960  }
961  int AllGather(const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType length)
962  {
963  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
964  }
965  int AllGather(const char* sendBuffer, char* recvBuffer, vtkIdType length)
966  {
967  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
968  }
969  int AllGather(const signed char* sendBuffer, signed char* recvBuffer, vtkIdType length)
970  {
971  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
972  }
973  int AllGather(const float* sendBuffer, float* recvBuffer, vtkIdType length)
974  {
975  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
976  }
977  int AllGather(const double* sendBuffer, double* recvBuffer, vtkIdType length)
978  {
979  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
980  }
981  int AllGather(const long long* sendBuffer, long long* recvBuffer, vtkIdType length)
982  {
983  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
984  }
986  const unsigned long long* sendBuffer, unsigned long long* recvBuffer, vtkIdType length)
987  {
988  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
989  }
990  int AllGather(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer)
991  {
992  return this->Communicator->AllGather(sendBuffer, recvBuffer);
993  }
995 
1004  {
1005  return this->Communicator->AllGather(sendBuffer, recvBuffer);
1006  }
1007 
1016  const vtkMultiProcessStream& sendBuffer, std::vector<vtkMultiProcessStream>& recvBuffer)
1017  {
1018  return this->Communicator->AllGather(sendBuffer, recvBuffer);
1019  }
1020 
1022 
1025  int AllGatherV(const int* sendBuffer, int* recvBuffer, vtkIdType sendLength,
1026  vtkIdType* recvLengths, vtkIdType* offsets)
1027  {
1028  return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
1029  }
1030  int AllGatherV(const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType sendLength,
1031  vtkIdType* recvLengths, vtkIdType* offsets)
1032  {
1033  return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
1034  }
1035  int AllGatherV(const short* sendBuffer, short* recvBuffer, vtkIdType sendLength,
1036  vtkIdType* recvLengths, vtkIdType* offsets)
1037  {
1038  return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
1039  }
1040  int AllGatherV(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType sendLength,
1041  vtkIdType* recvLengths, vtkIdType* offsets)
1042  {
1043  return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
1044  }
1045  int AllGatherV(const long* sendBuffer, long* recvBuffer, vtkIdType sendLength,
1046  vtkIdType* recvLengths, vtkIdType* offsets)
1047  {
1048  return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
1049  }
1050  int AllGatherV(const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType sendLength,
1051  vtkIdType* recvLengths, vtkIdType* offsets)
1052  {
1053  return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
1054  }
1055  int AllGatherV(const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType sendLength,
1056  vtkIdType* recvLengths, vtkIdType* offsets)
1057  {
1058  return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
1059  }
1060  int AllGatherV(const char* sendBuffer, char* recvBuffer, vtkIdType sendLength,
1061  vtkIdType* recvLengths, vtkIdType* offsets)
1062  {
1063  return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
1064  }
1065  int AllGatherV(const signed char* sendBuffer, signed char* recvBuffer, vtkIdType sendLength,
1066  vtkIdType* recvLengths, vtkIdType* offsets)
1067  {
1068  return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
1069  }
1070  int AllGatherV(const float* sendBuffer, float* recvBuffer, vtkIdType sendLength,
1071  vtkIdType* recvLengths, vtkIdType* offsets)
1072  {
1073  return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
1074  }
1075  int AllGatherV(const double* sendBuffer, double* recvBuffer, vtkIdType sendLength,
1076  vtkIdType* recvLengths, vtkIdType* offsets)
1077  {
1078  return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
1079  }
1080  int AllGatherV(const long long* sendBuffer, long long* recvBuffer, vtkIdType sendLength,
1081  vtkIdType* recvLengths, vtkIdType* offsets)
1082  {
1083  return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
1084  }
1085  int AllGatherV(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
1086  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets)
1087  {
1088  return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
1089  }
1091  vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, vtkIdType* recvLengths, vtkIdType* offsets)
1092  {
1093  return this->Communicator->AllGatherV(sendBuffer, recvBuffer, recvLengths, offsets);
1094  }
1096 
1103  int AllGatherV(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer)
1104  {
1105  return this->Communicator->AllGatherV(sendBuffer, recvBuffer);
1106  }
1107 
1109 
1114  int Reduce(
1115  const int* sendBuffer, int* recvBuffer, vtkIdType length, int operation, int destProcessId)
1116  {
1117  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1118  }
1119  int Reduce(const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType length,
1120  int operation, int destProcessId)
1121  {
1122  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1123  }
1124  int Reduce(
1125  const short* sendBuffer, short* recvBuffer, vtkIdType length, int operation, int destProcessId)
1126  {
1127  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1128  }
1129  int Reduce(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType length,
1130  int operation, int destProcessId)
1131  {
1132  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1133  }
1134  int Reduce(
1135  const long* sendBuffer, long* recvBuffer, vtkIdType length, int operation, int destProcessId)
1136  {
1137  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1138  }
1139  int Reduce(const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length,
1140  int operation, int destProcessId)
1141  {
1142  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1143  }
1144  int Reduce(const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType length,
1145  int operation, int destProcessId)
1146  {
1147  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1148  }
1149  int Reduce(
1150  const char* sendBuffer, char* recvBuffer, vtkIdType length, int operation, int destProcessId)
1151  {
1152  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1153  }
1154  int Reduce(const signed char* sendBuffer, signed char* recvBuffer, vtkIdType length,
1155  int operation, int destProcessId)
1156  {
1157  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1158  }
1159  int Reduce(
1160  const float* sendBuffer, float* recvBuffer, vtkIdType length, int operation, int destProcessId)
1161  {
1162  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1163  }
1164  int Reduce(const double* sendBuffer, double* recvBuffer, vtkIdType length, int operation,
1165  int destProcessId)
1166  {
1167  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1168  }
1169  int Reduce(const long long* sendBuffer, long long* recvBuffer, vtkIdType length, int operation,
1170  int destProcessId)
1171  {
1172  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1173  }
1174  int Reduce(const unsigned long long* sendBuffer, unsigned long long* recvBuffer, vtkIdType length,
1175  int operation, int destProcessId)
1176  {
1177  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1178  }
1179  int Reduce(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, int operation, int destProcessId)
1180  {
1181  return this->Communicator->Reduce(sendBuffer, recvBuffer, operation, destProcessId);
1182  }
1184 
1186 
1190  int Reduce(const int* sendBuffer, int* recvBuffer, vtkIdType length,
1191  vtkCommunicator::Operation* operation, int destProcessId)
1192  {
1193  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1194  }
1195  int Reduce(const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType length,
1196  vtkCommunicator::Operation* operation, int destProcessId)
1197  {
1198  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1199  }
1200  int Reduce(const short* sendBuffer, short* recvBuffer, vtkIdType length,
1201  vtkCommunicator::Operation* operation, int destProcessId)
1202  {
1203  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1204  }
1205  int Reduce(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType length,
1206  vtkCommunicator::Operation* operation, int destProcessId)
1207  {
1208  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1209  }
1210  int Reduce(const long* sendBuffer, long* recvBuffer, vtkIdType length,
1211  vtkCommunicator::Operation* operation, int destProcessId)
1212  {
1213  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1214  }
1215  int Reduce(const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length,
1216  vtkCommunicator::Operation* operation, int destProcessId)
1217  {
1218  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1219  }
1220  int Reduce(const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType length,
1221  vtkCommunicator::Operation* operation, int destProcessId)
1222  {
1223  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1224  }
1225  int Reduce(const char* sendBuffer, char* recvBuffer, vtkIdType length,
1226  vtkCommunicator::Operation* operation, int destProcessId)
1227  {
1228  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1229  }
1230  int Reduce(const signed char* sendBuffer, signed char* recvBuffer, vtkIdType length,
1231  vtkCommunicator::Operation* operation, int destProcessId)
1232  {
1233  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1234  }
1235  int Reduce(const float* sendBuffer, float* recvBuffer, vtkIdType length,
1236  vtkCommunicator::Operation* operation, int destProcessId)
1237  {
1238  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1239  }
1240  int Reduce(const double* sendBuffer, double* recvBuffer, vtkIdType length,
1241  vtkCommunicator::Operation* operation, int destProcessId)
1242  {
1243  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1244  }
1245  int Reduce(const long long* sendBuffer, long long* recvBuffer, vtkIdType length,
1246  vtkCommunicator::Operation* operation, int destProcessId)
1247  {
1248  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1249  }
1250  int Reduce(const unsigned long long* sendBuffer, unsigned long long* recvBuffer, vtkIdType length,
1251  vtkCommunicator::Operation* operation, int destProcessId)
1252  {
1253  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1254  }
1255  int Reduce(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer,
1256  vtkCommunicator::Operation* operation, int destProcessId)
1257  {
1258  return this->Communicator->Reduce(sendBuffer, recvBuffer, operation, destProcessId);
1259  }
1261 
1263 
1266  int AllReduce(const int* sendBuffer, int* recvBuffer, vtkIdType length, int operation)
1267  {
1268  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1269  }
1271  const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType length, int operation)
1272  {
1273  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1274  }
1275  int AllReduce(const short* sendBuffer, short* recvBuffer, vtkIdType length, int operation)
1276  {
1277  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1278  }
1280  const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType length, int operation)
1281  {
1282  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1283  }
1284  int AllReduce(const long* sendBuffer, long* recvBuffer, vtkIdType length, int operation)
1285  {
1286  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1287  }
1289  const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length, int operation)
1290  {
1291  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1292  }
1294  const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType length, int operation)
1295  {
1296  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1297  }
1298  int AllReduce(const char* sendBuffer, char* recvBuffer, vtkIdType length, int operation)
1299  {
1300  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1301  }
1303  const signed char* sendBuffer, signed char* recvBuffer, vtkIdType length, int operation)
1304  {
1305  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1306  }
1307  int AllReduce(const float* sendBuffer, float* recvBuffer, vtkIdType length, int operation)
1308  {
1309  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1310  }
1311  int AllReduce(const double* sendBuffer, double* recvBuffer, vtkIdType length, int operation)
1312  {
1313  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1314  }
1315  int AllReduce(const long long* sendBuffer, long long* recvBuffer, vtkIdType length, int operation)
1316  {
1317  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1318  }
1319  int AllReduce(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
1320  vtkIdType length, int operation)
1321  {
1322  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1323  }
1324  int AllReduce(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, int operation)
1325  {
1326  return this->Communicator->AllReduce(sendBuffer, recvBuffer, operation);
1327  }
1329 
1331  const int* sendBuffer, int* recvBuffer, vtkIdType length, vtkCommunicator::Operation* operation)
1332  {
1333  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1334  }
1335  int AllReduce(const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType length,
1336  vtkCommunicator::Operation* operation)
1337  {
1338  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1339  }
1340  int AllReduce(const short* sendBuffer, short* recvBuffer, vtkIdType length,
1341  vtkCommunicator::Operation* operation)
1342  {
1343  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1344  }
1345  int AllReduce(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType length,
1346  vtkCommunicator::Operation* operation)
1347  {
1348  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1349  }
1350  int AllReduce(const long* sendBuffer, long* recvBuffer, vtkIdType length,
1351  vtkCommunicator::Operation* operation)
1352  {
1353  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1354  }
1355  int AllReduce(const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length,
1356  vtkCommunicator::Operation* operation)
1357  {
1358  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1359  }
1360  int AllReduce(const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType length,
1361  vtkCommunicator::Operation* operation)
1362  {
1363  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1364  }
1365  int AllReduce(const char* sendBuffer, char* recvBuffer, vtkIdType length,
1366  vtkCommunicator::Operation* operation)
1367  {
1368  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1369  }
1370  int AllReduce(const signed char* sendBuffer, signed char* recvBuffer, vtkIdType length,
1371  vtkCommunicator::Operation* operation)
1372  {
1373  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1374  }
1375  int AllReduce(const float* sendBuffer, float* recvBuffer, vtkIdType length,
1376  vtkCommunicator::Operation* operation)
1377  {
1378  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1379  }
1380  int AllReduce(const double* sendBuffer, double* recvBuffer, vtkIdType length,
1381  vtkCommunicator::Operation* operation)
1382  {
1383  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1384  }
1385  int AllReduce(const long long* sendBuffer, long long* recvBuffer, vtkIdType length,
1386  vtkCommunicator::Operation* operation)
1387  {
1388  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1389  }
1390  int AllReduce(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
1392  {
1393  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1394  }
1396  vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, vtkCommunicator::Operation* operation)
1397  {
1398  return this->Communicator->AllReduce(sendBuffer, recvBuffer, operation);
1399  }
1400 
1402 
1405  int Reduce(const vtkBoundingBox& sendBuffer, vtkBoundingBox& recvBuffer, int destProcessId);
1406  int AllReduce(const vtkBoundingBox& sendBuffer, vtkBoundingBox& recvBuffer);
1408 
1410 
1413  int Reduce(
1414  vtkDataArraySelection* sendBuffer, vtkDataArraySelection* recvBuffer, int destProcessId);
1415  int AllReduce(vtkDataArraySelection* sendBuffer, vtkDataArraySelection* recvBuffer);
1417 
1418  // Internally implemented RMI to break the process loop.
1419 
1420 protected:
1422  ~vtkMultiProcessController() override;
1423 
1429  virtual void TriggerRMIInternal(
1430  int remoteProcessId, void* arg, int argLength, int rmiTag, bool propagate);
1431 
1433  void* SingleData;
1434 
1435  void GetMultipleMethod(int index, vtkProcessFunctionType& func, void*& data);
1436 
1437  // This is a flag that can be used by the ports to break
1438  // their update loop. (same as ProcessRMIs)
1440 
1441  void ProcessRMI(int remoteProcessId, void* arg, int argLength, int rmiTag);
1442 
1443  // This method implements "GetGlobalController".
1444  // It needs to be virtual and static.
1445  virtual vtkMultiProcessController* GetLocalController();
1446 
1447  // This flag can force deep copies during send.
1449 
1450  // This flag can be used to indicate that an MPI Broadcast will be used
1451  // when calling TriggerRMIOnAllChildren(), instead of the binary tree
1452  // propagation of the data to the satellite ranks from rank 0.
1454 
1456 
1457  // Note that since the communicators can be created differently
1458  // depending on the type of controller, the subclasses are
1459  // responsible of deleting them.
1461 
1462  // Communicator which is a copy of the current user
1463  // level communicator except the context; i.e. even if the tags
1464  // are the same, the RMI messages will not interfere with user
1465  // level messages.
1466  // Note that since the communicators can be created differently
1467  // depending on the type of controller, the subclasses are
1468  // responsible of deleting them.
1470 
1471 private:
1473  void operator=(const vtkMultiProcessController&) = delete;
1474 
1475  unsigned long RMICount;
1476 
1477  class vtkInternal;
1478  vtkInternal* Internal;
1479 };
1480 
1481 inline int vtkMultiProcessController::Send(vtkDataObject* data, int remoteProcessId, int tag)
1482 {
1483  if (this->Communicator)
1484  {
1485  return this->Communicator->Send(data, remoteProcessId, tag);
1486  }
1487  else
1488  {
1489  return 0;
1490  }
1491 }
1492 
1493 inline int vtkMultiProcessController::Send(vtkDataArray* data, int remoteProcessId, int tag)
1494 {
1495  if (this->Communicator)
1496  {
1497  return this->Communicator->Send(data, remoteProcessId, tag);
1498  }
1499  else
1500  {
1501  return 0;
1502  }
1503 }
1504 
1506  const int* data, vtkIdType length, int remoteProcessId, int tag)
1507 {
1508  if (this->Communicator)
1509  {
1510  return this->Communicator->Send(data, length, remoteProcessId, tag);
1511  }
1512  else
1513  {
1514  return 0;
1515  }
1516 }
1517 
1519  const short* data, vtkIdType length, int remoteProcessId, int tag)
1520 {
1521  if (this->Communicator)
1522  {
1523  return this->Communicator->Send(data, length, remoteProcessId, tag);
1524  }
1525  else
1526  {
1527  return 0;
1528  }
1529 }
1530 
1532  const unsigned short* data, vtkIdType length, int remoteProcessId, int tag)
1533 {
1534  if (this->Communicator)
1535  {
1536  return this->Communicator->Send(data, length, remoteProcessId, tag);
1537  }
1538  else
1539  {
1540  return 0;
1541  }
1542 }
1543 
1545  const unsigned int* data, vtkIdType length, int remoteProcessId, int tag)
1546 {
1547  if (this->Communicator)
1548  {
1549  return this->Communicator->Send(data, length, remoteProcessId, tag);
1550  }
1551  else
1552  {
1553  return 0;
1554  }
1555 }
1556 
1558  const unsigned long* data, vtkIdType length, int remoteProcessId, int tag)
1559 {
1560  if (this->Communicator)
1561  {
1562  return this->Communicator->Send(data, length, remoteProcessId, tag);
1563  }
1564  else
1565  {
1566  return 0;
1567  }
1568 }
1569 
1571  const long* data, vtkIdType length, int remoteProcessId, int tag)
1572 {
1573  if (this->Communicator)
1574  {
1575  return this->Communicator->Send(data, length, remoteProcessId, tag);
1576  }
1577  else
1578  {
1579  return 0;
1580  }
1581 }
1582 
1584  const signed char* data, vtkIdType length, int remoteProcessId, int tag)
1585 {
1586  if (this->Communicator)
1587  {
1588  return this->Communicator->Send(data, length, remoteProcessId, tag);
1589  }
1590  else
1591  {
1592  return 0;
1593  }
1594 }
1595 
1597  const char* data, vtkIdType length, int remoteProcessId, int tag)
1598 {
1599  if (this->Communicator)
1600  {
1601  return this->Communicator->Send(data, length, remoteProcessId, tag);
1602  }
1603  else
1604  {
1605  return 0;
1606  }
1607 }
1608 
1610  const unsigned char* data, vtkIdType length, int remoteProcessId, int tag)
1611 {
1612  if (this->Communicator)
1613  {
1614  return this->Communicator->Send(data, length, remoteProcessId, tag);
1615  }
1616  else
1617  {
1618  return 0;
1619  }
1620 }
1621 
1623  const float* data, vtkIdType length, int remoteProcessId, int tag)
1624 {
1625  if (this->Communicator)
1626  {
1627  return this->Communicator->Send(data, length, remoteProcessId, tag);
1628  }
1629  else
1630  {
1631  return 0;
1632  }
1633 }
1634 
1636  const double* data, vtkIdType length, int remoteProcessId, int tag)
1637 {
1638  if (this->Communicator)
1639  {
1640  return this->Communicator->Send(data, length, remoteProcessId, tag);
1641  }
1642  else
1643  {
1644  return 0;
1645  }
1646 }
1647 
1649  const long long* data, vtkIdType length, int remoteProcessId, int tag)
1650 {
1651  if (this->Communicator)
1652  {
1653  return this->Communicator->Send(data, length, remoteProcessId, tag);
1654  }
1655  else
1656  {
1657  return 0;
1658  }
1659 }
1660 
1662  const unsigned long long* data, vtkIdType length, int remoteProcessId, int tag)
1663 {
1664  if (this->Communicator)
1665  {
1666  return this->Communicator->Send(data, length, remoteProcessId, tag);
1667  }
1668  else
1669  {
1670  return 0;
1671  }
1672 }
1673 
1675  const vtkMultiProcessStream& stream, int remoteId, int tag)
1676 {
1677  if (this->Communicator)
1678  {
1679  return this->Communicator->Send(stream, remoteId, tag);
1680  }
1681  return 0;
1682 }
1683 
1684 inline int vtkMultiProcessController::Receive(vtkDataObject* data, int remoteProcessId, int tag)
1685 {
1686  if (this->Communicator)
1687  {
1688  return this->Communicator->Receive(data, remoteProcessId, tag);
1689  }
1690  else
1691  {
1692  return 0;
1693  }
1694 }
1695 
1697 {
1698  if (this->Communicator)
1699  {
1700  return this->Communicator->ReceiveDataObject(remoteProcessId, tag);
1701  }
1702  else
1703  {
1704  return nullptr;
1705  }
1706 }
1707 
1708 inline int vtkMultiProcessController::Receive(vtkDataArray* data, int remoteProcessId, int tag)
1709 {
1710  if (this->Communicator)
1711  {
1712  return this->Communicator->Receive(data, remoteProcessId, tag);
1713  }
1714  else
1715  {
1716  return 0;
1717  }
1718 }
1719 
1721  int* data, vtkIdType length, int remoteProcessId, int tag)
1722 {
1723  if (this->Communicator)
1724  {
1725  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1726  }
1727  else
1728  {
1729  return 0;
1730  }
1731 }
1732 
1734  unsigned int* data, vtkIdType length, int remoteProcessId, int tag)
1735 {
1736  if (this->Communicator)
1737  {
1738  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1739  }
1740  else
1741  {
1742  return 0;
1743  }
1744 }
1745 
1747  short* data, vtkIdType length, int remoteProcessId, int tag)
1748 {
1749  if (this->Communicator)
1750  {
1751  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1752  }
1753  else
1754  {
1755  return 0;
1756  }
1757 }
1758 
1760  unsigned short* data, vtkIdType length, int remoteProcessId, int tag)
1761 {
1762  if (this->Communicator)
1763  {
1764  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1765  }
1766  else
1767  {
1768  return 0;
1769  }
1770 }
1771 
1773  long* data, vtkIdType length, int remoteProcessId, int tag)
1774 {
1775  if (this->Communicator)
1776  {
1777  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1778  }
1779  else
1780  {
1781  return 0;
1782  }
1783 }
1784 
1786  unsigned long* data, vtkIdType length, int remoteProcessId, int tag)
1787 {
1788  if (this->Communicator)
1789  {
1790  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1791  }
1792  else
1793  {
1794  return 0;
1795  }
1796 }
1797 
1799  char* data, vtkIdType length, int remoteProcessId, int tag)
1800 {
1801  if (this->Communicator)
1802  {
1803  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1804  }
1805  else
1806  {
1807  return 0;
1808  }
1809 }
1810 
1812  unsigned char* data, vtkIdType length, int remoteProcessId, int tag)
1813 {
1814  if (this->Communicator)
1815  {
1816  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1817  }
1818  else
1819  {
1820  return 0;
1821  }
1822 }
1823 
1825  signed char* data, vtkIdType length, int remoteProcessId, int tag)
1826 {
1827  if (this->Communicator)
1828  {
1829  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1830  }
1831  else
1832  {
1833  return 0;
1834  }
1835 }
1836 
1838  float* data, vtkIdType length, int remoteProcessId, int tag)
1839 {
1840  if (this->Communicator)
1841  {
1842  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1843  }
1844  else
1845  {
1846  return 0;
1847  }
1848 }
1849 
1851  double* data, vtkIdType length, int remoteProcessId, int tag)
1852 {
1853  if (this->Communicator)
1854  {
1855  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1856  }
1857  else
1858  {
1859  return 0;
1860  }
1861 }
1862 
1864  long long* data, vtkIdType length, int remoteProcessId, int tag)
1865 {
1866  if (this->Communicator)
1867  {
1868  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1869  }
1870  else
1871  {
1872  return 0;
1873  }
1874 }
1875 
1877  unsigned long long* data, vtkIdType length, int remoteProcessId, int tag)
1878 {
1879  if (this->Communicator)
1880  {
1881  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1882  }
1883  else
1884  {
1885  return 0;
1886  }
1887 }
1888 
1889 inline int vtkMultiProcessController::Receive(vtkMultiProcessStream& stream, int remoteId, int tag)
1890 {
1891  if (this->Communicator)
1892  {
1893  return this->Communicator->Receive(stream, remoteId, tag);
1894  }
1895  return 0;
1896 }
1897 
1899 {
1900  if (this->Communicator)
1901  {
1902  this->Communicator->Barrier();
1903  }
1904 }
1905 
1907 {
1908  if (this->Communicator)
1909  {
1910  return this->Communicator->GetCount();
1911  }
1912  return 0;
1913 }
1914 
1915 #endif
int Gather(vtkDataObject *sendBuffer, std::vector< vtkSmartPointer< vtkDataObject >> &recvBuffer, int destProcessId)
Gathers vtkDataObject (sendBuffer) from all ranks to the destProcessId.
int AllGather(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
int AllGather(const float *sendBuffer, float *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
int Scatter(const int *sendBuffer, int *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
void TriggerRMI(int remoteProcessId, int tag)
Convenience method when there is no argument.
void(* vtkProcessFunctionType)(vtkMultiProcessController *controller, void *userData)
int Broadcast(short *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes...
int Reduce(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
int Reduce(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
int Send(vtkDataObject *data, int remoteHandle, int tag)
This method sends a data object to a destination.
int Scatter(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
int AllGatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, vtkIdType *recvLengths, vtkIdType *offsets)
Same as GatherV except that the result is placed in all processes.
A custom operation to use in a reduce command.
int ScatterV(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
int Reduce(const long *sendBuffer, long *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
int AllReduce(const int *sendBuffer, int *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
int Reduce(const long *sendBuffer, long *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Reduce an array to the given destination process.
int Reduce(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
abstract base class for most VTK objects
Definition: vtkObject.h:62
int Gather(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
int AllGather(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
int AllGatherV(const double *sendBuffer, double *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Same as GatherV except that the result is placed in all processes.
int AllReduce(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
int Scatter(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
int ScatterV(const long long *sendBuffer, long long *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
int Reduce(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Reduce an array to the given destination process.
int AllReduce(const char *sendBuffer, char *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
int AllGatherV(const long long *sendBuffer, long long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Same as GatherV except that the result is placed in all processes.
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
int Scatter(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
int Reduce(const int *sendBuffer, int *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
int AllGather(const long *sendBuffer, long *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
int GatherV(const int *sendBuffer, int *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
stream used to pass data across processes using vtkMultiProcessController.
int Reduce(const char *sendBuffer, char *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Reduce an array to the given destination process.
void TriggerRMIOnAllChildren(const char *arg, int tag)
This is a convenicence method to trigger an RMI call on all the "children" of the current node...
int ScatterV(const double *sendBuffer, double *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
int Scatter(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
abstract class to specify dataset behavior
Definition: vtkDataSet.h:62
int AllGatherV(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Same as GatherV except that the result is placed in all processes.
void TriggerRMIOnAllChildren(int tag)
This is a convenicence method to trigger an RMI call on all the "children" of the current node...
int AllReduce(const float *sendBuffer, float *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
int GatherV(vtkDataObject *sendData, vtkSmartPointer< vtkDataObject > *recvData, int destProcessId)
This special form of GatherV will automatically determine recvLengths and offsets to tightly pack the...
int AllGatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer)
This special form of AllGatherV will automatically determine recvLengths and offsets to tightly pack ...
int Gather(const long *sendBuffer, long *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
int AllGather(const vtkMultiProcessStream &sendBuffer, std::vector< vtkMultiProcessStream > &recvBuffer)
Gathers vtkMultiProcessStream (sendBuffer) from all ranks to the destProcessId.
int AllReduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, vtkCommunicator::Operation *operation)
int AllGather(vtkDataObject *sendBuffer, std::vector< vtkSmartPointer< vtkDataObject >> &recvBuffer)
Gathers vtkDataObject (sendBuffer) from all ranks to all raks.
a process that can be launched by a vtkMultiProcessController
Definition: vtkProcess.h:49
int GatherV(const double *sendBuffer, double *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
int AllReduce(const int *sendBuffer, int *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
int Reduce(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Reduce an array to the given destination process.
int Reduce(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Reduce an array to the given destination process.
int ScatterV(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
int Gather(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
int Gather(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
int AllGatherV(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Same as GatherV except that the result is placed in all processes.
int Reduce(const short *sendBuffer, short *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
int Broadcast(int *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes...
int AllReduce(const char *sendBuffer, char *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
int AllGather(const short *sendBuffer, short *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
int AllReduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, int operation)
Same as Reduce except that the result is placed in all of the processes.
dynamic, self-adjusting array of vtkIdType
int AllReduce(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
int AllGather(const double *sendBuffer, double *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
int AllGather(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
int vtkIdType
Definition: vtkType.h:332
int ScatterV(const char *sendBuffer, char *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
int GatherV(const long long *sendBuffer, long long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
int Gather(const short *sendBuffer, short *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
int Broadcast(unsigned long long *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes...
int AllReduce(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
int Reduce(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Reduce an array to the given destination process.
int AllReduce(const long *sendBuffer, long *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
static int GetBreakRMITag()
Accessor to some default tags.
int Receive(vtkDataObject *data, int remoteHandle, int tag)
This method receives a data object from a corresponding send.
int Broadcast(vtkMultiProcessStream &stream, int srcProcessId)
int Reduce(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Reduce an array to the given destination process.
int Scatter(const short *sendBuffer, short *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
int ScatterV(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
int AllGather(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
int AllGather(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
int Reduce(const double *sendBuffer, double *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Reduce an array to the given destination process.
int AllGatherV(const int *sendBuffer, int *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Same as GatherV except that the result is placed in all processes.
int Gather(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
int AllReduce(const long *sendBuffer, long *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
int Broadcast(char *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes...
int AllReduce(const short *sendBuffer, short *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
int Scatter(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
vtkDataObject * ReceiveDataObject(int remoteHandle, int tag)
The caller does not have to know the data type before this call is made.
int ScatterV(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
int Gather(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, int destProcessId)
Gather collects arrays in the process with id destProcessId.
int AllReduce(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
void(* vtkRMIFunctionType)(void *localArg, void *remoteArg, int remoteArgLength, int remoteProcessId)
int Gather(const float *sendBuffer, float *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
int Reduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, int operation, int destProcessId)
Reduce an array to the given destination process.
void TriggerRMI(int remoteProcessId, const char *arg, int tag)
Convenience method when the arg is a string.
int GatherV(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
int Reduce(const int *sendBuffer, int *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Reduce an array to the given destination process.
int AllReduce(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
int Broadcast(float *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes...
a simple class to control print indentation
Definition: vtkIndent.h:39
int GatherV(const short *sendBuffer, short *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
int AllReduce(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
int AllReduce(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
topologically and geometrically regular array of data
Definition: vtkImageData.h:53
virtual void RemoveRMI(vtkRMIFunctionType f, void *arg, int tag)
Take an RMI away.
Store on/off settings for data arrays, etc.
int Reduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Reduce an array to the given destination process.
virtual vtkIdType GetCount()
Returns the number of words received by the most recent Receive().
int AllReduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:55
A subgroup of processes from a communicator.
int AllReduce(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
int AllGatherV(const long *sendBuffer, long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Same as GatherV except that the result is placed in all processes.
int Broadcast(vtkDataObject *data, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes...
int Reduce(const short *sendBuffer, short *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Reduce an array to the given destination process.
int AllGatherV(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Same as GatherV except that the result is placed in all processes.
vtkDataObject * ReceiveDataObject(int remoteId, int tag)
int GatherV(const char *sendBuffer, char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
int AllReduce(const double *sendBuffer, double *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
int AllGather(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer)
Same as gather except that the result ends up on all processes.
int AllGather(const int *sendBuffer, int *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
int GatherV(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
int ScatterV(const short *sendBuffer, short *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
void Barrier()
This method can be used to synchronize processes.
int Broadcast(unsigned int *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes...
int Scatter(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
int GatherV(const long *sendBuffer, long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
base class for writing debug output to a console
int AllGatherV(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Same as GatherV except that the result is placed in all processes.
int AllReduce(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
int AllReduce(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
int Gather(const vtkMultiProcessStream &sendBuffer, std::vector< vtkMultiProcessStream > &recvBuffer, int destProcessId)
Gathers vtkMultiProcessStream (sendBuffer) from all ranks to the destProcessId.
int Broadcast(unsigned char *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes...
int Reduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, vtkCommunicator::Operation *operation, int destProcessId)
Reduce an array to the given destination process.
int GatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, vtkIdTypeArray *recvLengths, vtkIdTypeArray *offsets, int destProcessId)
int GatherV(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
int AllReduce(const double *sendBuffer, double *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
int AllGatherV(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Same as GatherV except that the result is placed in all processes.
int AllReduce(const short *sendBuffer, short *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
int AllReduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
int Reduce(const double *sendBuffer, double *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
virtual void Barrier()
Will block the processes until all other processes reach the Barrier function.
int GatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
int GatherV(const float *sendBuffer, float *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
int ScatterV(const float *sendBuffer, float *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
int ScatterV(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
int Send(const int *data, vtkIdType length, int remoteProcessId, int tag)
This method sends data to another process.
create and manipulate ordered lists of objects
Definition: vtkCollection.h:55
int AllReduce(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
int Scatter(const float *sendBuffer, float *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
int Gather(const double *sendBuffer, double *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
int AllGatherV(const float *sendBuffer, float *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Same as GatherV except that the result is placed in all processes.
int Reduce(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Reduce an array to the given destination process.
int Broadcast(vtkDataArray *data, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes...
int Receive(int *data, vtkIdType maxlength, int remoteProcessId, int tag)
This method receives data from a corresponding send.
int AllGather(const long long *sendBuffer, long long *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
int Reduce(const float *sendBuffer, float *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
int Broadcast(double *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes...
int Reduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
int Reduce(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
int Broadcast(long long *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes...
int AllGather(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
int Broadcast(signed char *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes...
int Reduce(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
int Reduce(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
int Gather(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
int Broadcast(unsigned long *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes...
int Reduce(const float *sendBuffer, float *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Reduce an array to the given destination process.
int Broadcast(unsigned short *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes...
int Scatter(const char *sendBuffer, char *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
int AllGatherV(const char *sendBuffer, char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Same as GatherV except that the result is placed in all processes.
int Scatter(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
int GatherV(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
int AllGatherV(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Same as GatherV except that the result is placed in all processes.
vtkIdType GetCount()
Returns the number of words received by the most recent Receive().
int Reduce(const char *sendBuffer, char *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
int Scatter(const double *sendBuffer, double *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
int ScatterV(const long *sendBuffer, long *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
Used to send/receive messages in a multiprocess environment.
general representation of visualization data
Definition: vtkDataObject.h:65
int Gather(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
int ScatterV(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
int AllGatherV(const short *sendBuffer, short *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Same as GatherV except that the result is placed in all processes.
int AllReduce(const float *sendBuffer, float *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
int Broadcast(long *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes...
int Gather(const int *sendBuffer, int *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
int Scatter(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
int GatherV(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
int GatherV(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
int AllReduce(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
int GatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, int destProcessId)
This special form of GatherV will automatically determine recvLengths and offsets to tightly pack the...
Fast, simple class for representing and operating on 3D bounds.
int Gather(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
int Scatter(const long *sendBuffer, long *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
int ScatterV(const int *sendBuffer, int *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
int Gather(const char *sendBuffer, char *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
int AllGather(const char *sendBuffer, char *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
Multiprocessing communication superclass.