VTK  9.1.0
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;
68 
69 // The type of function that gets called when new processes are initiated.
70 typedef void (*vtkProcessFunctionType)(vtkMultiProcessController* controller, void* userData);
71 
72 // The type of function that gets called when an RMI is triggered.
73 typedef void (*vtkRMIFunctionType)(
74  void* localArg, void* remoteArg, int remoteArgLength, int remoteProcessId);
75 
76 class VTKPARALLELCORE_EXPORT vtkMultiProcessController : public vtkObject
77 {
78 public:
80  void PrintSelf(ostream& os, vtkIndent indent) override;
81 
87  virtual void Initialize(int* vtkNotUsed(argc), char*** vtkNotUsed(argv)) = 0;
88 
94  virtual void Initialize(
95  int* vtkNotUsed(argc), char*** vtkNotUsed(argv), int initializedExternally) = 0;
96 
102  virtual void Finalize() = 0;
103 
109  virtual void Finalize(int finalizedExternally) = 0;
110 
112 
117  void SetNumberOfProcesses(int num);
120 
128 
135 
141  virtual void SingleMethodExecute() = 0;
142 
150 
156  virtual void MultipleMethodExecute() = 0;
157 
162 
170 
176  virtual void CreateOutputWindow() = 0;
177 
190 
201  virtual vtkMultiProcessController* PartitionController(int localColor, int localKey);
202 
203  //------------------ RMIs --------------------
204 
217  virtual unsigned long AddRMI(vtkRMIFunctionType, void* localArg, int tag);
218 
222  virtual int RemoveFirstRMI(int tag);
223 
228  virtual int RemoveRMI(unsigned long id);
229 
233  virtual void RemoveRMI(vtkRMIFunctionType f, void* arg, int tag)
234  {
235  (void)f;
236  (void)arg;
237  (void)tag;
238  vtkErrorMacro("RemoveRMI Not Implemented Yet");
239  }
240 
246  virtual unsigned long AddRMICallback(vtkRMIFunctionType, void* localArg, int tag);
247 
253  virtual void RemoveAllRMICallbacks(int tag);
254 
258  virtual bool RemoveRMICallback(unsigned long id);
259 
263  void TriggerRMI(int remoteProcessId, void* arg, int argLength, int tag);
264 
270 
274  void TriggerRMI(int remoteProcessId, const char* arg, int tag)
275  {
276  this->TriggerRMI(remoteProcessId, (void*)arg, static_cast<int>(strlen(arg)) + 1, tag);
277  }
278 
282  void TriggerRMI(int remoteProcessId, int tag)
283  {
284  this->TriggerRMI(remoteProcessId, nullptr, 0, tag);
285  }
286 
288 
296  void TriggerRMIOnAllChildren(void* arg, int argLength, int tag);
297  void TriggerRMIOnAllChildren(const char* arg, int tag)
298  {
299  this->TriggerRMIOnAllChildren((void*)arg, static_cast<int>(strlen(arg)) + 1, tag);
300  }
301  void TriggerRMIOnAllChildren(int tag) { this->TriggerRMIOnAllChildren(nullptr, 0, tag); }
302  void BroadcastTriggerRMIOnAllChildren(void* arg, int argLength, int tag);
304 
306 
317  int ProcessRMIs(int reportErrors, int dont_loop = 0);
318  int ProcessRMIs();
319  int BroadcastProcessRMIs(int reportErrors, int dont_loop = 0);
321 
323 
328  vtkSetMacro(BreakFlag, int);
329  vtkGetMacro(BreakFlag, int);
331 
333 
338  vtkSetMacro(BroadcastTriggerRMI, bool);
339  vtkGetMacro(BroadcastTriggerRMI, bool);
340  vtkBooleanMacro(BroadcastTriggerRMI, bool);
342 
344 
348  vtkGetObjectMacro(Communicator, vtkCommunicator);
350 
354  static int GetBreakRMITag() { return BREAK_RMI_TAG; }
355  static int GetRMITag() { return RMI_TAG; }
356  static int GetRMIArgTag() { return RMI_ARG_TAG; }
357 
358  enum Errors
359  {
362  RMI_ARG_ERROR
363  };
364 
365  enum Consts
366  {
367  ANY_SOURCE = -1,
368  INVALID_SOURCE = -2
369  };
370 
371  enum Tags
372  {
373  RMI_TAG = 1,
374  RMI_ARG_TAG = 2,
375  BREAK_RMI_TAG = 3,
376  XML_WRITER_DATA_INFO = 4
377  };
378 
382  void Barrier();
383 
385 
386  //------------------ Communication --------------------
387 
389 
396  int Send(const int* data, vtkIdType length, int remoteProcessId, int tag);
397  int Send(const short* data, vtkIdType length, int remoteProcessId, int tag);
398  int Send(const unsigned short* data, vtkIdType length, int remoteProcessId, int tag);
399  int Send(const unsigned int* data, vtkIdType length, int remoteProcessId, int tag);
400  int Send(const unsigned long* data, vtkIdType length, int remoteProcessId, int tag);
401  int Send(const long* data, vtkIdType length, int remoteProcessId, int tag);
402  int Send(const signed char* data, vtkIdType length, int remoteProcessId, int tag);
403  int Send(const char* data, vtkIdType length, int remoteProcessId, int tag);
404  int Send(const unsigned char* data, vtkIdType length, int remoteProcessId, int tag);
405  int Send(const float* data, vtkIdType length, int remoteProcessId, int tag);
406  int Send(const double* data, vtkIdType length, int remoteProcessId, int tag);
407  int Send(const long long* data, vtkIdType length, int remoteProcessId, int tag);
408  int Send(const unsigned long long* data, vtkIdType length, int remoteProcessId, int tag);
409  int Send(vtkDataObject* data, int remoteId, int tag);
410  int Send(vtkDataArray* data, int remoteId, int tag);
412 
420  int Send(const vtkMultiProcessStream& stream, int remoteId, int tag);
421 
423 
432  int Receive(int* data, vtkIdType maxlength, int remoteProcessId, int tag);
433  int Receive(unsigned int* data, vtkIdType maxlength, int remoteProcessId, int tag);
434  int Receive(short* data, vtkIdType maxlength, int remoteProcessId, int tag);
435  int Receive(unsigned short* data, vtkIdType maxlength, int remoteProcessId, int tag);
436  int Receive(long* data, vtkIdType maxlength, int remoteProcessId, int tag);
437  int Receive(unsigned long* data, vtkIdType maxlength, int remoteProcessId, int tag);
438  int Receive(char* data, vtkIdType maxlength, int remoteProcessId, int tag);
439  int Receive(unsigned char* data, vtkIdType maxlength, int remoteProcessId, int tag);
440  int Receive(signed char* data, vtkIdType maxlength, int remoteProcessId, int tag);
441  int Receive(float* data, vtkIdType maxlength, int remoteProcessId, int tag);
442  int Receive(double* data, vtkIdType maxlength, int remoteProcessId, int tag);
443  int Receive(long long* data, vtkIdType maxLength, int remoteProcessId, int tag);
444  int Receive(unsigned long long* data, vtkIdType maxLength, int remoteProcessId, int tag);
445  int Receive(vtkDataObject* data, int remoteId, int tag);
446  int Receive(vtkDataArray* data, int remoteId, int tag);
448 
452  int Receive(vtkMultiProcessStream& stream, int remoteId, int tag);
453 
454  vtkDataObject* ReceiveDataObject(int remoteId, int tag);
455 
464  vtkIdType GetCount();
465 
466  //---------------------- Collective Operations ----------------------
467 
469 
474  int Broadcast(int* data, vtkIdType length, int srcProcessId)
475  {
476  return this->Communicator->Broadcast(data, length, srcProcessId);
477  }
478  int Broadcast(unsigned int* data, vtkIdType length, int srcProcessId)
479  {
480  return this->Communicator->Broadcast(data, length, srcProcessId);
481  }
482  int Broadcast(short* data, vtkIdType length, int srcProcessId)
483  {
484  return this->Communicator->Broadcast(data, length, srcProcessId);
485  }
486  int Broadcast(unsigned short* data, vtkIdType length, int srcProcessId)
487  {
488  return this->Communicator->Broadcast(data, length, srcProcessId);
489  }
490  int Broadcast(long* data, vtkIdType length, int srcProcessId)
491  {
492  return this->Communicator->Broadcast(data, length, srcProcessId);
493  }
494  int Broadcast(unsigned long* data, vtkIdType length, int srcProcessId)
495  {
496  return this->Communicator->Broadcast(data, length, srcProcessId);
497  }
498  int Broadcast(unsigned char* data, vtkIdType length, int srcProcessId)
499  {
500  return this->Communicator->Broadcast(data, length, srcProcessId);
501  }
502  int Broadcast(char* data, vtkIdType length, int srcProcessId)
503  {
504  return this->Communicator->Broadcast(data, length, srcProcessId);
505  }
506  int Broadcast(signed char* data, vtkIdType length, int srcProcessId)
507  {
508  return this->Communicator->Broadcast(data, length, srcProcessId);
509  }
510  int Broadcast(float* data, vtkIdType length, int srcProcessId)
511  {
512  return this->Communicator->Broadcast(data, length, srcProcessId);
513  }
514  int Broadcast(double* data, vtkIdType length, int srcProcessId)
515  {
516  return this->Communicator->Broadcast(data, length, srcProcessId);
517  }
518  int Broadcast(long long* data, vtkIdType length, int srcProcessId)
519  {
520  return this->Communicator->Broadcast(data, length, srcProcessId);
521  }
522  int Broadcast(unsigned long long* data, vtkIdType length, int srcProcessId)
523  {
524  return this->Communicator->Broadcast(data, length, srcProcessId);
525  }
526  int Broadcast(vtkDataObject* data, int srcProcessId)
527  {
528  return this->Communicator->Broadcast(data, srcProcessId);
529  }
530  int Broadcast(vtkDataArray* data, int srcProcessId)
531  {
532  return this->Communicator->Broadcast(data, srcProcessId);
533  }
535 
536  int Broadcast(vtkMultiProcessStream& stream, int srcProcessId)
537  {
538  return this->Communicator->Broadcast(stream, srcProcessId);
539  }
540 
542 
551  int Gather(const int* sendBuffer, int* recvBuffer, vtkIdType length, int destProcessId)
552  {
553  return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
554  }
555  int Gather(
556  const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType length, int destProcessId)
557  {
558  return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
559  }
560  int Gather(const short* sendBuffer, short* recvBuffer, vtkIdType length, int destProcessId)
561  {
562  return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
563  }
564  int Gather(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType length,
565  int destProcessId)
566  {
567  return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
568  }
569  int Gather(const long* sendBuffer, long* recvBuffer, vtkIdType length, int destProcessId)
570  {
571  return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
572  }
573  int Gather(
574  const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length, int destProcessId)
575  {
576  return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
577  }
578  int Gather(
579  const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType length, int destProcessId)
580  {
581  return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
582  }
583  int Gather(const char* sendBuffer, char* recvBuffer, vtkIdType length, int destProcessId)
584  {
585  return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
586  }
587  int Gather(
588  const signed char* sendBuffer, signed char* recvBuffer, vtkIdType length, int destProcessId)
589  {
590  return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
591  }
592  int Gather(const float* sendBuffer, float* recvBuffer, vtkIdType length, int destProcessId)
593  {
594  return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
595  }
596  int Gather(const double* sendBuffer, double* recvBuffer, vtkIdType length, int destProcessId)
597  {
598  return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
599  }
600  int Gather(
601  const long long* sendBuffer, long long* recvBuffer, vtkIdType length, int destProcessId)
602  {
603  return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
604  }
605  int Gather(const unsigned long long* sendBuffer, unsigned long long* recvBuffer, vtkIdType length,
606  int destProcessId)
607  {
608  return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
609  }
610  int Gather(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, int destProcessId)
611  {
612  return this->Communicator->Gather(sendBuffer, recvBuffer, destProcessId);
613  }
615 
626  int destProcessId)
627  {
628  return this->Communicator->Gather(sendBuffer, recvBuffer, destProcessId);
629  }
630 
640  int Gather(const vtkMultiProcessStream& sendBuffer,
641  std::vector<vtkMultiProcessStream>& recvBuffer, int destProcessId)
642  {
643  return this->Communicator->Gather(sendBuffer, recvBuffer, destProcessId);
644  }
645 
647 
658  int GatherV(const int* sendBuffer, int* recvBuffer, vtkIdType sendLength, vtkIdType* recvLengths,
659  vtkIdType* offsets, int destProcessId)
660  {
661  return this->Communicator->GatherV(
662  sendBuffer, recvBuffer, sendLength, recvLengths, offsets, destProcessId);
663  }
664  int GatherV(const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType sendLength,
665  vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
666  {
667  return this->Communicator->GatherV(
668  sendBuffer, recvBuffer, sendLength, recvLengths, offsets, destProcessId);
669  }
670  int GatherV(const short* sendBuffer, short* 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 unsigned short* sendBuffer, unsigned 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 long* sendBuffer, long* 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 unsigned long* sendBuffer, unsigned 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 char* sendBuffer, unsigned char* 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 char* sendBuffer, 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 signed char* sendBuffer, signed 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 float* sendBuffer, float* 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 double* sendBuffer, double* 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 long long* sendBuffer, long long* 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 unsigned long long* sendBuffer, unsigned long long* recvBuffer,
731  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
732  {
733  return this->Communicator->GatherV(
734  sendBuffer, recvBuffer, sendLength, recvLengths, offsets, destProcessId);
735  }
737 
738  int GatherV(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, vtkIdType* recvLengths,
739  vtkIdType* offsets, int destProcessId)
740  {
741  return this->Communicator->GatherV(sendBuffer, recvBuffer, recvLengths, offsets, destProcessId);
742  }
743  int GatherV(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, vtkIdTypeArray* recvLengths,
744  vtkIdTypeArray* offsets, int destProcessId)
745  {
746  return this->Communicator->GatherV(sendBuffer, recvBuffer, recvLengths, offsets, destProcessId);
747  }
748 
750 
756  int GatherV(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, int destProcessId)
757  {
758  return this->Communicator->GatherV(sendBuffer, recvBuffer, destProcessId);
759  }
760  int GatherV(vtkDataObject* sendData, vtkSmartPointer<vtkDataObject>* recvData, int destProcessId)
761  {
762  return this->Communicator->GatherV(sendData, recvData, destProcessId);
763  }
765 
767 
774  int Scatter(const int* sendBuffer, int* recvBuffer, vtkIdType length, int srcProcessId)
775  {
776  return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
777  }
778  int Scatter(
779  const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType length, int srcProcessId)
780  {
781  return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
782  }
783  int Scatter(const short* sendBuffer, short* recvBuffer, vtkIdType length, int srcProcessId)
784  {
785  return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
786  }
787  int Scatter(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType length,
788  int srcProcessId)
789  {
790  return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
791  }
792  int Scatter(const long* sendBuffer, long* recvBuffer, vtkIdType length, int srcProcessId)
793  {
794  return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
795  }
796  int Scatter(
797  const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length, int srcProcessId)
798  {
799  return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
800  }
801  int Scatter(
802  const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType length, int srcProcessId)
803  {
804  return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
805  }
806  int Scatter(const char* sendBuffer, char* recvBuffer, vtkIdType length, int srcProcessId)
807  {
808  return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
809  }
810  int Scatter(
811  const signed char* sendBuffer, signed char* recvBuffer, vtkIdType length, int srcProcessId)
812  {
813  return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
814  }
815  int Scatter(const float* sendBuffer, float* recvBuffer, vtkIdType length, int srcProcessId)
816  {
817  return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
818  }
819  int Scatter(const double* sendBuffer, double* recvBuffer, vtkIdType length, int srcProcessId)
820  {
821  return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
822  }
823  int Scatter(
824  const long long* sendBuffer, long long* recvBuffer, vtkIdType length, int srcProcessId)
825  {
826  return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
827  }
828  int Scatter(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
829  vtkIdType length, int srcProcessId)
830  {
831  return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
832  }
833  int Scatter(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, int srcProcessId)
834  {
835  return this->Communicator->Scatter(sendBuffer, recvBuffer, srcProcessId);
836  }
838 
840 
847  int ScatterV(const int* sendBuffer, int* recvBuffer, vtkIdType* sendLengths, vtkIdType* offsets,
848  vtkIdType recvLength, int srcProcessId)
849  {
850  return this->Communicator->ScatterV(
851  sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
852  }
853  int ScatterV(const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType* sendLengths,
854  vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
855  {
856  return this->Communicator->ScatterV(
857  sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
858  }
859  int ScatterV(const short* sendBuffer, short* 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 unsigned short* sendBuffer, unsigned 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 long* sendBuffer, long* recvBuffer, vtkIdType* sendLengths, vtkIdType* offsets,
872  vtkIdType recvLength, int srcProcessId)
873  {
874  return this->Communicator->ScatterV(
875  sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
876  }
877  int ScatterV(const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType* sendLengths,
878  vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
879  {
880  return this->Communicator->ScatterV(
881  sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
882  }
883  int ScatterV(const unsigned char* sendBuffer, unsigned char* 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 char* sendBuffer, char* recvBuffer, vtkIdType* sendLengths, vtkIdType* offsets,
890  vtkIdType recvLength, int srcProcessId)
891  {
892  return this->Communicator->ScatterV(
893  sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
894  }
895  int ScatterV(const signed char* sendBuffer, signed char* recvBuffer, vtkIdType* sendLengths,
896  vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
897  {
898  return this->Communicator->ScatterV(
899  sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
900  }
901  int ScatterV(const float* sendBuffer, float* 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 double* sendBuffer, double* 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 long long* sendBuffer, long long* 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 unsigned long long* sendBuffer, unsigned long long* recvBuffer,
920  vtkIdType* sendLengths, vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
921  {
922  return this->Communicator->ScatterV(
923  sendBuffer, recvBuffer, sendLengths, offsets, recvLength, srcProcessId);
924  }
926 
928 
931  int AllGather(const int* sendBuffer, int* recvBuffer, vtkIdType length)
932  {
933  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
934  }
935  int AllGather(const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType length)
936  {
937  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
938  }
939  int AllGather(const short* sendBuffer, short* recvBuffer, vtkIdType length)
940  {
941  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
942  }
943  int AllGather(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType length)
944  {
945  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
946  }
947  int AllGather(const long* sendBuffer, long* recvBuffer, vtkIdType length)
948  {
949  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
950  }
951  int AllGather(const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length)
952  {
953  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
954  }
955  int AllGather(const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType length)
956  {
957  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
958  }
959  int AllGather(const char* sendBuffer, char* recvBuffer, vtkIdType length)
960  {
961  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
962  }
963  int AllGather(const signed char* sendBuffer, signed char* recvBuffer, vtkIdType length)
964  {
965  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
966  }
967  int AllGather(const float* sendBuffer, float* recvBuffer, vtkIdType length)
968  {
969  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
970  }
971  int AllGather(const double* sendBuffer, double* recvBuffer, vtkIdType length)
972  {
973  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
974  }
975  int AllGather(const long long* sendBuffer, long long* recvBuffer, vtkIdType length)
976  {
977  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
978  }
980  const unsigned long long* sendBuffer, unsigned long long* recvBuffer, vtkIdType length)
981  {
982  return this->Communicator->AllGather(sendBuffer, recvBuffer, length);
983  }
984  int AllGather(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer)
985  {
986  return this->Communicator->AllGather(sendBuffer, recvBuffer);
987  }
989 
998  {
999  return this->Communicator->AllGather(sendBuffer, recvBuffer);
1000  }
1001 
1010  const vtkMultiProcessStream& sendBuffer, std::vector<vtkMultiProcessStream>& recvBuffer)
1011  {
1012  return this->Communicator->AllGather(sendBuffer, recvBuffer);
1013  }
1014 
1016 
1019  int AllGatherV(const int* sendBuffer, int* recvBuffer, vtkIdType sendLength,
1020  vtkIdType* recvLengths, vtkIdType* offsets)
1021  {
1022  return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
1023  }
1024  int AllGatherV(const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType sendLength,
1025  vtkIdType* recvLengths, vtkIdType* offsets)
1026  {
1027  return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
1028  }
1029  int AllGatherV(const short* sendBuffer, short* recvBuffer, vtkIdType sendLength,
1030  vtkIdType* recvLengths, vtkIdType* offsets)
1031  {
1032  return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
1033  }
1034  int AllGatherV(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType sendLength,
1035  vtkIdType* recvLengths, vtkIdType* offsets)
1036  {
1037  return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
1038  }
1039  int AllGatherV(const long* sendBuffer, long* recvBuffer, vtkIdType sendLength,
1040  vtkIdType* recvLengths, vtkIdType* offsets)
1041  {
1042  return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
1043  }
1044  int AllGatherV(const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType sendLength,
1045  vtkIdType* recvLengths, vtkIdType* offsets)
1046  {
1047  return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
1048  }
1049  int AllGatherV(const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType sendLength,
1050  vtkIdType* recvLengths, vtkIdType* offsets)
1051  {
1052  return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
1053  }
1054  int AllGatherV(const char* sendBuffer, char* recvBuffer, vtkIdType sendLength,
1055  vtkIdType* recvLengths, vtkIdType* offsets)
1056  {
1057  return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
1058  }
1059  int AllGatherV(const signed char* sendBuffer, signed char* recvBuffer, vtkIdType sendLength,
1060  vtkIdType* recvLengths, vtkIdType* offsets)
1061  {
1062  return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
1063  }
1064  int AllGatherV(const float* sendBuffer, float* recvBuffer, vtkIdType sendLength,
1065  vtkIdType* recvLengths, vtkIdType* offsets)
1066  {
1067  return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
1068  }
1069  int AllGatherV(const double* sendBuffer, double* recvBuffer, vtkIdType sendLength,
1070  vtkIdType* recvLengths, vtkIdType* offsets)
1071  {
1072  return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
1073  }
1074  int AllGatherV(const long long* sendBuffer, long long* recvBuffer, vtkIdType sendLength,
1075  vtkIdType* recvLengths, vtkIdType* offsets)
1076  {
1077  return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
1078  }
1079  int AllGatherV(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
1080  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets)
1081  {
1082  return this->Communicator->AllGatherV(sendBuffer, recvBuffer, sendLength, recvLengths, offsets);
1083  }
1085  vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, vtkIdType* recvLengths, vtkIdType* offsets)
1086  {
1087  return this->Communicator->AllGatherV(sendBuffer, recvBuffer, recvLengths, offsets);
1088  }
1090 
1097  int AllGatherV(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer)
1098  {
1099  return this->Communicator->AllGatherV(sendBuffer, recvBuffer);
1100  }
1101 
1103 
1108  int Reduce(
1109  const int* sendBuffer, int* recvBuffer, vtkIdType length, int operation, int destProcessId)
1110  {
1111  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1112  }
1113  int Reduce(const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType length,
1114  int operation, int destProcessId)
1115  {
1116  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1117  }
1118  int Reduce(
1119  const short* sendBuffer, short* recvBuffer, vtkIdType length, int operation, int destProcessId)
1120  {
1121  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1122  }
1123  int Reduce(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType length,
1124  int operation, int destProcessId)
1125  {
1126  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1127  }
1128  int Reduce(
1129  const long* sendBuffer, long* recvBuffer, vtkIdType length, int operation, int destProcessId)
1130  {
1131  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1132  }
1133  int Reduce(const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length,
1134  int operation, int destProcessId)
1135  {
1136  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1137  }
1138  int Reduce(const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType length,
1139  int operation, int destProcessId)
1140  {
1141  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1142  }
1143  int Reduce(
1144  const char* sendBuffer, char* recvBuffer, vtkIdType length, int operation, int destProcessId)
1145  {
1146  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1147  }
1148  int Reduce(const signed char* sendBuffer, signed char* recvBuffer, vtkIdType length,
1149  int operation, int destProcessId)
1150  {
1151  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1152  }
1153  int Reduce(
1154  const float* sendBuffer, float* recvBuffer, vtkIdType length, int operation, int destProcessId)
1155  {
1156  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1157  }
1158  int Reduce(const double* sendBuffer, double* recvBuffer, vtkIdType length, int operation,
1159  int destProcessId)
1160  {
1161  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1162  }
1163  int Reduce(const long long* sendBuffer, long long* recvBuffer, vtkIdType length, int operation,
1164  int destProcessId)
1165  {
1166  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1167  }
1168  int Reduce(const unsigned long long* sendBuffer, unsigned long long* recvBuffer, vtkIdType length,
1169  int operation, int destProcessId)
1170  {
1171  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1172  }
1173  int Reduce(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, int operation, int destProcessId)
1174  {
1175  return this->Communicator->Reduce(sendBuffer, recvBuffer, operation, destProcessId);
1176  }
1178 
1180 
1184  int Reduce(const int* sendBuffer, int* recvBuffer, vtkIdType length,
1185  vtkCommunicator::Operation* operation, int destProcessId)
1186  {
1187  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1188  }
1189  int Reduce(const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType length,
1190  vtkCommunicator::Operation* operation, int destProcessId)
1191  {
1192  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1193  }
1194  int Reduce(const short* sendBuffer, short* recvBuffer, vtkIdType length,
1195  vtkCommunicator::Operation* operation, int destProcessId)
1196  {
1197  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1198  }
1199  int Reduce(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType length,
1200  vtkCommunicator::Operation* operation, int destProcessId)
1201  {
1202  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1203  }
1204  int Reduce(const long* sendBuffer, long* recvBuffer, vtkIdType length,
1205  vtkCommunicator::Operation* operation, int destProcessId)
1206  {
1207  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1208  }
1209  int Reduce(const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length,
1210  vtkCommunicator::Operation* operation, int destProcessId)
1211  {
1212  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1213  }
1214  int Reduce(const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType length,
1215  vtkCommunicator::Operation* operation, int destProcessId)
1216  {
1217  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1218  }
1219  int Reduce(const char* sendBuffer, char* recvBuffer, vtkIdType length,
1220  vtkCommunicator::Operation* operation, int destProcessId)
1221  {
1222  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1223  }
1224  int Reduce(const signed char* sendBuffer, signed char* recvBuffer, vtkIdType length,
1225  vtkCommunicator::Operation* operation, int destProcessId)
1226  {
1227  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1228  }
1229  int Reduce(const float* sendBuffer, float* recvBuffer, vtkIdType length,
1230  vtkCommunicator::Operation* operation, int destProcessId)
1231  {
1232  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1233  }
1234  int Reduce(const double* sendBuffer, double* recvBuffer, vtkIdType length,
1235  vtkCommunicator::Operation* operation, int destProcessId)
1236  {
1237  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1238  }
1239  int Reduce(const long long* sendBuffer, long long* recvBuffer, vtkIdType length,
1240  vtkCommunicator::Operation* operation, int destProcessId)
1241  {
1242  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1243  }
1244  int Reduce(const unsigned long long* sendBuffer, unsigned long long* recvBuffer, vtkIdType length,
1245  vtkCommunicator::Operation* operation, int destProcessId)
1246  {
1247  return this->Communicator->Reduce(sendBuffer, recvBuffer, length, operation, destProcessId);
1248  }
1249  int Reduce(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer,
1250  vtkCommunicator::Operation* operation, int destProcessId)
1251  {
1252  return this->Communicator->Reduce(sendBuffer, recvBuffer, operation, destProcessId);
1253  }
1255 
1257 
1260  int AllReduce(const int* sendBuffer, int* recvBuffer, vtkIdType length, int operation)
1261  {
1262  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1263  }
1265  const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType length, int operation)
1266  {
1267  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1268  }
1269  int AllReduce(const short* sendBuffer, short* recvBuffer, vtkIdType length, int operation)
1270  {
1271  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1272  }
1274  const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType length, int operation)
1275  {
1276  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1277  }
1278  int AllReduce(const long* sendBuffer, long* recvBuffer, vtkIdType length, int operation)
1279  {
1280  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1281  }
1283  const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length, int operation)
1284  {
1285  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1286  }
1288  const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType length, int operation)
1289  {
1290  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1291  }
1292  int AllReduce(const char* sendBuffer, char* recvBuffer, vtkIdType length, int operation)
1293  {
1294  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1295  }
1297  const signed char* sendBuffer, signed char* recvBuffer, vtkIdType length, int operation)
1298  {
1299  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1300  }
1301  int AllReduce(const float* sendBuffer, float* recvBuffer, vtkIdType length, int operation)
1302  {
1303  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1304  }
1305  int AllReduce(const double* sendBuffer, double* recvBuffer, vtkIdType length, int operation)
1306  {
1307  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1308  }
1309  int AllReduce(const long long* sendBuffer, long long* recvBuffer, vtkIdType length, int operation)
1310  {
1311  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1312  }
1313  int AllReduce(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
1314  vtkIdType length, int operation)
1315  {
1316  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1317  }
1318  int AllReduce(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, int operation)
1319  {
1320  return this->Communicator->AllReduce(sendBuffer, recvBuffer, operation);
1321  }
1323 
1325  const int* sendBuffer, int* recvBuffer, vtkIdType length, vtkCommunicator::Operation* operation)
1326  {
1327  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1328  }
1329  int AllReduce(const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType length,
1330  vtkCommunicator::Operation* operation)
1331  {
1332  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1333  }
1334  int AllReduce(const short* sendBuffer, short* recvBuffer, vtkIdType length,
1335  vtkCommunicator::Operation* operation)
1336  {
1337  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1338  }
1339  int AllReduce(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType length,
1340  vtkCommunicator::Operation* operation)
1341  {
1342  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1343  }
1344  int AllReduce(const long* sendBuffer, long* recvBuffer, vtkIdType length,
1345  vtkCommunicator::Operation* operation)
1346  {
1347  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1348  }
1349  int AllReduce(const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length,
1350  vtkCommunicator::Operation* operation)
1351  {
1352  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1353  }
1354  int AllReduce(const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType length,
1355  vtkCommunicator::Operation* operation)
1356  {
1357  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1358  }
1359  int AllReduce(const char* sendBuffer, char* recvBuffer, vtkIdType length,
1360  vtkCommunicator::Operation* operation)
1361  {
1362  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1363  }
1364  int AllReduce(const signed char* sendBuffer, signed char* recvBuffer, vtkIdType length,
1365  vtkCommunicator::Operation* operation)
1366  {
1367  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1368  }
1369  int AllReduce(const float* sendBuffer, float* recvBuffer, vtkIdType length,
1370  vtkCommunicator::Operation* operation)
1371  {
1372  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1373  }
1374  int AllReduce(const double* sendBuffer, double* recvBuffer, vtkIdType length,
1375  vtkCommunicator::Operation* operation)
1376  {
1377  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1378  }
1379  int AllReduce(const long long* sendBuffer, long long* recvBuffer, vtkIdType length,
1380  vtkCommunicator::Operation* operation)
1381  {
1382  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1383  }
1384  int AllReduce(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
1386  {
1387  return this->Communicator->AllReduce(sendBuffer, recvBuffer, length, operation);
1388  }
1390  vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, vtkCommunicator::Operation* operation)
1391  {
1392  return this->Communicator->AllReduce(sendBuffer, recvBuffer, operation);
1393  }
1394 
1396 
1399  int Reduce(const vtkBoundingBox& sendBuffer, vtkBoundingBox& recvBuffer, int destProcessId);
1400  int AllReduce(const vtkBoundingBox& sendBuffer, vtkBoundingBox& recvBuffer);
1402 
1404 
1407  int Reduce(
1408  vtkDataArraySelection* sendBuffer, vtkDataArraySelection* recvBuffer, int destProcessId);
1411 
1412  // Internally implemented RMI to break the process loop.
1413 
1414 protected:
1417 
1423  virtual void TriggerRMIInternal(
1424  int remoteProcessId, void* arg, int argLength, int rmiTag, bool propagate);
1425 
1427  void* SingleData;
1428 
1430 
1431  // This is a flag that can be used by the ports to break
1432  // their update loop. (same as ProcessRMIs)
1434 
1435  void ProcessRMI(int remoteProcessId, void* arg, int argLength, int rmiTag);
1436 
1437  // This method implements "GetGlobalController".
1438  // It needs to be virtual and static.
1440 
1441  // This flag can force deep copies during send.
1443 
1444  // This flag can be used to indicate that an MPI Broadcast will be used
1445  // when calling TriggerRMIOnAllChildren(), instead of the binary tree
1446  // propagation of the data to the satellite ranks from rank 0.
1448 
1450 
1451  // Note that since the communicators can be created differently
1452  // depending on the type of controller, the subclasses are
1453  // responsible of deleting them.
1455 
1456  // Communicator which is a copy of the current user
1457  // level communicator except the context; i.e. even if the tags
1458  // are the same, the RMI messages will not interfere with user
1459  // level messages.
1460  // Note that since the communicators can be created differently
1461  // depending on the type of controller, the subclasses are
1462  // responsible of deleting them.
1464 
1465 private:
1467  void operator=(const vtkMultiProcessController&) = delete;
1468 
1469  unsigned long RMICount;
1470 
1471  class vtkInternal;
1472  vtkInternal* Internal;
1473 };
1474 
1475 inline int vtkMultiProcessController::Send(vtkDataObject* data, int remoteProcessId, int tag)
1476 {
1477  if (this->Communicator)
1478  {
1479  return this->Communicator->Send(data, remoteProcessId, tag);
1480  }
1481  else
1482  {
1483  return 0;
1484  }
1485 }
1486 
1487 inline int vtkMultiProcessController::Send(vtkDataArray* data, int remoteProcessId, int tag)
1488 {
1489  if (this->Communicator)
1490  {
1491  return this->Communicator->Send(data, remoteProcessId, tag);
1492  }
1493  else
1494  {
1495  return 0;
1496  }
1497 }
1498 
1500  const int* data, vtkIdType length, int remoteProcessId, int tag)
1501 {
1502  if (this->Communicator)
1503  {
1504  return this->Communicator->Send(data, length, remoteProcessId, tag);
1505  }
1506  else
1507  {
1508  return 0;
1509  }
1510 }
1511 
1513  const short* data, vtkIdType length, int remoteProcessId, int tag)
1514 {
1515  if (this->Communicator)
1516  {
1517  return this->Communicator->Send(data, length, remoteProcessId, tag);
1518  }
1519  else
1520  {
1521  return 0;
1522  }
1523 }
1524 
1526  const unsigned short* data, vtkIdType length, int remoteProcessId, int tag)
1527 {
1528  if (this->Communicator)
1529  {
1530  return this->Communicator->Send(data, length, remoteProcessId, tag);
1531  }
1532  else
1533  {
1534  return 0;
1535  }
1536 }
1537 
1539  const unsigned int* data, vtkIdType length, int remoteProcessId, int tag)
1540 {
1541  if (this->Communicator)
1542  {
1543  return this->Communicator->Send(data, length, remoteProcessId, tag);
1544  }
1545  else
1546  {
1547  return 0;
1548  }
1549 }
1550 
1552  const unsigned long* data, vtkIdType length, int remoteProcessId, int tag)
1553 {
1554  if (this->Communicator)
1555  {
1556  return this->Communicator->Send(data, length, remoteProcessId, tag);
1557  }
1558  else
1559  {
1560  return 0;
1561  }
1562 }
1563 
1565  const long* data, vtkIdType length, int remoteProcessId, int tag)
1566 {
1567  if (this->Communicator)
1568  {
1569  return this->Communicator->Send(data, length, remoteProcessId, tag);
1570  }
1571  else
1572  {
1573  return 0;
1574  }
1575 }
1576 
1578  const signed char* data, vtkIdType length, int remoteProcessId, int tag)
1579 {
1580  if (this->Communicator)
1581  {
1582  return this->Communicator->Send(data, length, remoteProcessId, tag);
1583  }
1584  else
1585  {
1586  return 0;
1587  }
1588 }
1589 
1591  const char* data, vtkIdType length, int remoteProcessId, int tag)
1592 {
1593  if (this->Communicator)
1594  {
1595  return this->Communicator->Send(data, length, remoteProcessId, tag);
1596  }
1597  else
1598  {
1599  return 0;
1600  }
1601 }
1602 
1604  const unsigned char* data, vtkIdType length, int remoteProcessId, int tag)
1605 {
1606  if (this->Communicator)
1607  {
1608  return this->Communicator->Send(data, length, remoteProcessId, tag);
1609  }
1610  else
1611  {
1612  return 0;
1613  }
1614 }
1615 
1617  const float* data, vtkIdType length, int remoteProcessId, int tag)
1618 {
1619  if (this->Communicator)
1620  {
1621  return this->Communicator->Send(data, length, remoteProcessId, tag);
1622  }
1623  else
1624  {
1625  return 0;
1626  }
1627 }
1628 
1630  const double* data, vtkIdType length, int remoteProcessId, int tag)
1631 {
1632  if (this->Communicator)
1633  {
1634  return this->Communicator->Send(data, length, remoteProcessId, tag);
1635  }
1636  else
1637  {
1638  return 0;
1639  }
1640 }
1641 
1643  const long long* data, vtkIdType length, int remoteProcessId, int tag)
1644 {
1645  if (this->Communicator)
1646  {
1647  return this->Communicator->Send(data, length, remoteProcessId, tag);
1648  }
1649  else
1650  {
1651  return 0;
1652  }
1653 }
1654 
1656  const unsigned long long* data, vtkIdType length, int remoteProcessId, int tag)
1657 {
1658  if (this->Communicator)
1659  {
1660  return this->Communicator->Send(data, length, remoteProcessId, tag);
1661  }
1662  else
1663  {
1664  return 0;
1665  }
1666 }
1667 
1669  const vtkMultiProcessStream& stream, int remoteId, int tag)
1670 {
1671  if (this->Communicator)
1672  {
1673  return this->Communicator->Send(stream, remoteId, tag);
1674  }
1675  return 0;
1676 }
1677 
1678 inline int vtkMultiProcessController::Receive(vtkDataObject* data, int remoteProcessId, int tag)
1679 {
1680  if (this->Communicator)
1681  {
1682  return this->Communicator->Receive(data, remoteProcessId, tag);
1683  }
1684  else
1685  {
1686  return 0;
1687  }
1688 }
1689 
1691 {
1692  if (this->Communicator)
1693  {
1694  return this->Communicator->ReceiveDataObject(remoteProcessId, tag);
1695  }
1696  else
1697  {
1698  return nullptr;
1699  }
1700 }
1701 
1702 inline int vtkMultiProcessController::Receive(vtkDataArray* data, int remoteProcessId, int tag)
1703 {
1704  if (this->Communicator)
1705  {
1706  return this->Communicator->Receive(data, remoteProcessId, tag);
1707  }
1708  else
1709  {
1710  return 0;
1711  }
1712 }
1713 
1715  int* data, vtkIdType length, int remoteProcessId, int tag)
1716 {
1717  if (this->Communicator)
1718  {
1719  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1720  }
1721  else
1722  {
1723  return 0;
1724  }
1725 }
1726 
1728  unsigned int* data, vtkIdType length, int remoteProcessId, int tag)
1729 {
1730  if (this->Communicator)
1731  {
1732  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1733  }
1734  else
1735  {
1736  return 0;
1737  }
1738 }
1739 
1741  short* data, vtkIdType length, int remoteProcessId, int tag)
1742 {
1743  if (this->Communicator)
1744  {
1745  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1746  }
1747  else
1748  {
1749  return 0;
1750  }
1751 }
1752 
1754  unsigned short* data, vtkIdType length, int remoteProcessId, int tag)
1755 {
1756  if (this->Communicator)
1757  {
1758  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1759  }
1760  else
1761  {
1762  return 0;
1763  }
1764 }
1765 
1767  long* data, vtkIdType length, int remoteProcessId, int tag)
1768 {
1769  if (this->Communicator)
1770  {
1771  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1772  }
1773  else
1774  {
1775  return 0;
1776  }
1777 }
1778 
1780  unsigned long* data, vtkIdType length, int remoteProcessId, int tag)
1781 {
1782  if (this->Communicator)
1783  {
1784  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1785  }
1786  else
1787  {
1788  return 0;
1789  }
1790 }
1791 
1793  char* data, vtkIdType length, int remoteProcessId, int tag)
1794 {
1795  if (this->Communicator)
1796  {
1797  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1798  }
1799  else
1800  {
1801  return 0;
1802  }
1803 }
1804 
1806  unsigned char* data, vtkIdType length, int remoteProcessId, int tag)
1807 {
1808  if (this->Communicator)
1809  {
1810  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1811  }
1812  else
1813  {
1814  return 0;
1815  }
1816 }
1817 
1819  signed char* data, vtkIdType length, int remoteProcessId, int tag)
1820 {
1821  if (this->Communicator)
1822  {
1823  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1824  }
1825  else
1826  {
1827  return 0;
1828  }
1829 }
1830 
1832  float* data, vtkIdType length, int remoteProcessId, int tag)
1833 {
1834  if (this->Communicator)
1835  {
1836  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1837  }
1838  else
1839  {
1840  return 0;
1841  }
1842 }
1843 
1845  double* data, vtkIdType length, int remoteProcessId, int tag)
1846 {
1847  if (this->Communicator)
1848  {
1849  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1850  }
1851  else
1852  {
1853  return 0;
1854  }
1855 }
1856 
1858  long long* data, vtkIdType length, int remoteProcessId, int tag)
1859 {
1860  if (this->Communicator)
1861  {
1862  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1863  }
1864  else
1865  {
1866  return 0;
1867  }
1868 }
1869 
1871  unsigned long long* data, vtkIdType length, int remoteProcessId, int tag)
1872 {
1873  if (this->Communicator)
1874  {
1875  return this->Communicator->Receive(data, length, remoteProcessId, tag);
1876  }
1877  else
1878  {
1879  return 0;
1880  }
1881 }
1882 
1883 inline int vtkMultiProcessController::Receive(vtkMultiProcessStream& stream, int remoteId, int tag)
1884 {
1885  if (this->Communicator)
1886  {
1887  return this->Communicator->Receive(stream, remoteId, tag);
1888  }
1889  return 0;
1890 }
1891 
1893 {
1894  if (this->Communicator)
1895  {
1896  this->Communicator->Barrier();
1897  }
1898 }
1899 
1901 {
1902  if (this->Communicator)
1903  {
1904  return this->Communicator->GetCount();
1905  }
1906  return 0;
1907 }
1908 
1909 #endif
Fast, simple class for representing and operating on 3D bounds.
create and manipulate ordered lists of objects
Definition: vtkCollection.h:53
A custom operation to use in a reduce command.
Used to send/receive messages in a multiprocess environment.
virtual void Barrier()
Will block the processes until all other processes reach the Barrier function.
int Send(vtkDataObject *data, int remoteHandle, int tag)
This method sends a data object to a destination.
int Receive(vtkDataObject *data, int remoteHandle, int tag)
This method receives a data object from a corresponding send.
virtual vtkIdType GetCount()
Returns the number of words received by the most recent Receive().
vtkDataObject * ReceiveDataObject(int remoteHandle, int tag)
The caller does not have to know the data type before this call is made.
Store on/off settings for data arrays for a vtkSource.
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:50
general representation of visualization data
Definition: vtkDataObject.h:60
abstract class to specify dataset behavior
Definition: vtkDataSet.h:57
dynamic, self-adjusting array of vtkIdType
topologically and geometrically regular array of data
Definition: vtkImageData.h:48
a simple class to control print indentation
Definition: vtkIndent.h:34
Multiprocessing communication superclass.
int Gather(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
void TriggerBreakRMIs()
A convenience method.
void TriggerRMI(int remoteProcessId, const char *arg, int tag)
Convenience method when the arg is a string.
vtkDataObject * ReceiveDataObject(int remoteId, int tag)
int AllGather(vtkDataObject *sendBuffer, std::vector< vtkSmartPointer< vtkDataObject >> &recvBuffer)
Gathers vtkDataObject (sendBuffer) from all ranks to all raks.
vtkIdType GetCount()
Returns the number of words received by the most recent Receive().
virtual vtkMultiProcessController * PartitionController(int localColor, int localKey)
Partitions this controller based on a coloring.
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 Reduce(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Reduce an array to the given destination process.
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 Reduce(const double *sendBuffer, double *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
int Broadcast(vtkMultiProcessStream &stream, int srcProcessId)
int AllReduce(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
virtual vtkMultiProcessController * GetLocalController()
int Gather(const short *sendBuffer, short *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
virtual unsigned long AddRMI(vtkRMIFunctionType, void *localArg, int tag)
Register remote method invocation in the receiving process which makes the call.
int Send(const int *data, vtkIdType length, int remoteProcessId, int tag)
This method sends data to another process.
void TriggerRMIOnAllChildren(void *arg, int argLength, int tag)
This is a convenicence method to trigger an RMI call on all the "children" of the current node.
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 GetNumberOfProcesses()
Set the number of processes you will be using.
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 AllGather(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
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.
virtual int RemoveFirstRMI(int tag)
Remove the first RMI matching the tag.
int Gather(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
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 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.
int GatherV(const char *sendBuffer, char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
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 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 Broadcast(vtkDataArray *data, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes.
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 Reduce(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Reduce an array to the given destination process.
static void SetGlobalController(vtkMultiProcessController *controller)
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 vtkBoundingBox &sendBuffer, vtkBoundingBox &recvBuffer)
Convenience methods to reduce bounds.
int AllReduce(const char *sendBuffer, char *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
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 Broadcast(vtkDataObject *data, 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, vtkCommunicator::Operation *operation, int destProcessId)
Reduce an array to the given destination process.
int AllGather(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
int AllReduce(const long *sendBuffer, long *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
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.
virtual void RemoveRMI(vtkRMIFunctionType f, void *arg, int tag)
Take an RMI away.
int AllGather(const long long *sendBuffer, long long *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
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 ProcessRMIs(int reportErrors, int dont_loop=0)
Calling this method gives control to the controller to start processing RMIs.
int ScatterV(const long *sendBuffer, long *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
int AllGather(const char *sendBuffer, char *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
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 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 *sendBuffer, long *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
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 Gather(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
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.
void SetMultipleMethod(int index, vtkProcessFunctionType, void *data)
Set the MultipleMethod to f() and the UserData of the for the method to be executed by the process in...
int AllReduce(vtkDataArraySelection *sendBuffer, vtkDataArraySelection *recvBuffer)
Convenience methods to reduce vtkDataArraySelection.
virtual void TriggerRMIInternal(int remoteProcessId, void *arg, int argLength, int rmiTag, bool propagate)
Implementation for TriggerRMI() provides subclasses an opportunity to modify the behaviour eg.
int Reduce(vtkDataArraySelection *sendBuffer, vtkDataArraySelection *recvBuffer, int destProcessId)
Convenience methods to reduce vtkDataArraySelection.
int Reduce(const int *sendBuffer, int *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
int AllGather(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on 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.
void SetSingleProcessObject(vtkProcess *p)
Object-oriented flavor of SetSingleMethod().
int AllReduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, int operation)
Same as Reduce except that the result is placed in all of the processes.
int Scatter(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
int Gather(const float *sendBuffer, float *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id 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.
virtual void RemoveAllRMICallbacks(int tag)
These methods are a part of the newer API to add multiple rmi callbacks.
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 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(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.
int AllGather(const float *sendBuffer, float *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
int Reduce(const short *sendBuffer, short *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
static int GetBreakRMITag()
Accessor to some default tags.
int Scatter(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
virtual vtkMultiProcessController * CreateSubController(vtkProcessGroup *group)
Creates a new controller with the processes specified by the given group.
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 signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
int Gather(const long *sendBuffer, long *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
int Reduce(const long *sendBuffer, long *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Reduce an array to the given destination process.
int Gather(const int *sendBuffer, int *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
virtual void SingleMethodExecute()=0
Execute the SingleMethod (as define by SetSingleMethod) using this->NumberOfProcesses processes.
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 Reduce(const float *sendBuffer, float *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Reduce an array to the given destination process.
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 Broadcast(float *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 long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
int Gather(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
int ScatterV(const double *sendBuffer, double *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
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.
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 AllReduce(const double *sendBuffer, double *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
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 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.
void BroadcastTriggerRMIOnAllChildren(void *arg, int argLength, int tag)
This is a convenicence method to trigger an RMI call on all the "children" of the current node.
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 AllGatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer)
This special form of AllGatherV will automatically determine recvLengths and offsets to tightly pack ...
static vtkMultiProcessController * GetGlobalController()
This convenience method returns the controller associated with the local process.
void TriggerRMI(int remoteProcessId, int tag)
Convenience method when there is no argument.
int Reduce(const double *sendBuffer, double *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Reduce an array to the given destination process.
int Gather(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
virtual void Initialize(int *vtkNotUsed(argc), char ***vtkNotUsed(argv))=0
This method is for setting up 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(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer)
Same as gather except that the result ends up on all processes.
int AllReduce(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
int 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 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 Reduce(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Reduce an array to the given destination process.
virtual void Initialize(int *vtkNotUsed(argc), char ***vtkNotUsed(argv), int initializedExternally)=0
This method is for setting up the processes.
void Barrier()
This method can be used to synchronize processes.
int Gather(const double *sendBuffer, double *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
int AllReduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, vtkCommunicator::Operation *operation)
int Broadcast(unsigned char *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes.
int Broadcast(int *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes.
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 AllReduce(const float *sendBuffer, float *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
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 ScatterV(const float *sendBuffer, float *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
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 AllGather(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
~vtkMultiProcessController() override
int BroadcastProcessRMIs(int reportErrors, int dont_loop=0)
Calling this method gives control to the controller to start processing RMIs.
int AllReduce(const int *sendBuffer, int *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
int AllReduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
int ScatterV(const char *sendBuffer, char *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
int ScatterV(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
virtual void Finalize(int finalizedExternally)=0
This method is for cleaning up.
int Reduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, int operation, int destProcessId)
Reduce an array to the given destination process.
int Reduce(const long *sendBuffer, long *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
int AllReduce(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
int GatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
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(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, vtkCommunicator::Operation *operation, int destProcessId)
Reduce an array to the given destination process.
int GatherV(const int *sendBuffer, int *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
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.
void SetNumberOfProcesses(int num)
Set the number of processes you will be using.
int GatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, vtkIdTypeArray *recvLengths, vtkIdTypeArray *offsets, int destProcessId)
virtual int RemoveRMI(unsigned long id)
Remove the RMI matching the id.
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 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 GetLocalProcessId()
Tells you which process [0, NumProcess) you are in.
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 AllGather(const vtkMultiProcessStream &sendBuffer, std::vector< vtkMultiProcessStream > &recvBuffer)
Gathers vtkMultiProcessStream (sendBuffer) from all ranks to the destProcessId.
void ProcessRMI(int remoteProcessId, void *arg, int argLength, int rmiTag)
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 ScatterV(const short *sendBuffer, short *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
int Scatter(const float *sendBuffer, float *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
int Reduce(const vtkBoundingBox &sendBuffer, vtkBoundingBox &recvBuffer, int destProcessId)
Convenience methods to reduce bounds.
int GatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, int destProcessId)
This special form of GatherV will automatically determine recvLengths and offsets to tightly pack the...
int AllGather(const short *sendBuffer, short *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
int AllGatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, vtkIdType *recvLengths, vtkIdType *offsets)
Same as GatherV except that the result is placed in all processes.
int Gather(const char *sendBuffer, char *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
int Gather(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
void SetSingleMethod(vtkProcessFunctionType, void *data)
Set the SingleMethod to f() and the UserData of the for the method to be executed by all of the proce...
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 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 unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
void TriggerRMIOnAllChildren(int tag)
This is a convenicence method to trigger an RMI call on all the "children" of the current node.
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 Reduce(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
int Receive(int *data, vtkIdType maxlength, int remoteProcessId, int tag)
This method receives data from a corresponding send.
int GatherV(const float *sendBuffer, float *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
int GatherV(const long *sendBuffer, long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
int AllReduce(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
virtual void MultipleMethodExecute()=0
Execute the MultipleMethods (as define by calling SetMultipleMethod for each of the required this->Nu...
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 Reduce(const float *sendBuffer, float *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
void GetMultipleMethod(int index, vtkProcessFunctionType &func, void *&data)
int AllReduce(const short *sendBuffer, short *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
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 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 GatherV(const short *sendBuffer, short *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
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 Gather(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, int destProcessId)
Gather collects arrays in the process with id destProcessId.
virtual unsigned long AddRMICallback(vtkRMIFunctionType, void *localArg, int tag)
These methods are a part of the newer API to add multiple rmi callbacks.
int AllReduce(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
int AllGather(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
int Gather(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
int Reduce(const char *sendBuffer, char *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Reduce an array to the given destination process.
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 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 Reduce(const short *sendBuffer, short *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Reduce an array to the given destination process.
int Gather(vtkDataObject *sendBuffer, std::vector< vtkSmartPointer< vtkDataObject >> &recvBuffer, int destProcessId)
Gathers vtkDataObject (sendBuffer) from all ranks to the 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 AllGather(const int *sendBuffer, int *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
int ScatterV(const int *sendBuffer, int *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
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.
void TriggerRMI(int remoteProcessId, void *arg, int argLength, int tag)
A method to trigger a method invocation in another process.
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 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 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 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.
virtual void CreateOutputWindow()=0
This method can be used to tell the controller to create a special output window in which all message...
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 AllReduce(const int *sendBuffer, int *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
virtual void Finalize()=0
This method is for cleaning up.
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 GatherV(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
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 ProcessRMIs()
Calling this method gives control to the controller to start processing RMIs.
int AllReduce(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation)
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 Scatter(const int *sendBuffer, int *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
int Gather(const vtkMultiProcessStream &sendBuffer, std::vector< vtkMultiProcessStream > &recvBuffer, int destProcessId)
Gathers vtkMultiProcessStream (sendBuffer) from all ranks to the destProcessId.
int Reduce(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
int Reduce(const int *sendBuffer, int *recvBuffer, vtkIdType length, vtkCommunicator::Operation *operation, int destProcessId)
Reduce an array to the given destination process.
int Reduce(const char *sendBuffer, char *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
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 long long *sendBuffer, long long *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
virtual bool RemoveRMICallback(unsigned long id)
Remove a callback.
int AllGather(const long *sendBuffer, long *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
int Reduce(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
int ScatterV(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
stream used to pass data across processes using vtkMultiProcessController.
abstract base class for most VTK objects
Definition: vtkObject.h:63
base class for writing debug output to a console
A subgroup of processes from a communicator.
a process that can be launched by a vtkMultiProcessController
Definition: vtkProcess.h:47
@ vector
Definition: vtkX3D.h:243
@ length
Definition: vtkX3D.h:399
@ index
Definition: vtkX3D.h:252
@ data
Definition: vtkX3D.h:321
void(* vtkProcessFunctionType)(vtkMultiProcessController *controller, void *userData)
void(* vtkRMIFunctionType)(void *localArg, void *remoteArg, int remoteArgLength, int remoteProcessId)
int vtkIdType
Definition: vtkType.h:332