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=========================================================================*/
54
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
63class vtkBoundingBox;
64class vtkCollection;
65class vtkDataObject;
66class vtkDataSet;
67class vtkImageData;
70class vtkOutputWindow;
71class vtkProcessGroup;
72class vtkProcess;
74
75// The type of function that gets called when new processes are initiated.
76typedef void (*vtkProcessFunctionType)(vtkMultiProcessController* controller, void* userData);
77
78// The type of function that gets called when an RMI is triggered.
79typedef void (*vtkRMIFunctionType)(
80 void* localArg, void* remoteArg, int remoteArgLength, int remoteProcessId);
81
82class VTKPARALLELCORE_EXPORT vtkMultiProcessController : public vtkObject
83{
84public:
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);
126
134
141
147 virtual void SingleMethodExecute() = 0;
148
155 void SetMultipleMethod(int index, vtkProcessFunctionType, void* data);
156
162 virtual void MultipleMethodExecute() = 0;
163
168
176
182 virtual void CreateOutputWindow() = 0;
183
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
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);
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
370
372 {
375 };
376
384
388 void Barrier();
389
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
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 }
540
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 }
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 }
580 const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length, int destProcessId)
581 {
582 return this->Communicator->Gather(sendBuffer, recvBuffer, length, destProcessId);
583 }
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 }
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 }
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 }
620
621
631 int Gather(vtkDataObject* sendBuffer, std::vector<vtkSmartPointer<vtkDataObject>>& recvBuffer,
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 }
742
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 }
770
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 }
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 }
803 const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length, int srcProcessId)
804 {
805 return this->Communicator->Scatter(sendBuffer, recvBuffer, length, srcProcessId);
806 }
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 }
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 }
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 }
843
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 }
931
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 }
994
995
1003 int AllGather(vtkDataObject* sendBuffer, std::vector<vtkSmartPointer<vtkDataObject>>& recvBuffer)
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 }
1095
1096
1103 int AllGatherV(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer)
1104 {
1105 return this->Communicator->AllGatherV(sendBuffer, recvBuffer);
1106 }
1107
1109
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 }
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 }
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 }
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 }
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 }
1183
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 }
1260
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 }
1328
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,
1391 vtkIdType length, vtkCommunicator::Operation* operation)
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
1414 vtkDataArraySelection* sendBuffer, vtkDataArraySelection* recvBuffer, int destProcessId);
1417
1418 // Internally implemented RMI to break the process loop.
1419
1420protected:
1423
1430 int remoteProcessId, void* arg, int argLength, int rmiTag, bool propagate);
1431
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.
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
1471private:
1473 void operator=(const vtkMultiProcessController&) = delete;
1474
1475 unsigned long RMICount;
1476
1477 class vtkInternal;
1478 vtkInternal* Internal;
1479};
1480
1481inline 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
1493inline 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
1684inline 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
1708inline 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
1889inline 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
Fast, simple class for representing and operating on 3D bounds.
create and manipulate ordered lists of objects
A custom operation to use in a reduce command.
Used to send/receive messages in a multiprocess environment.
Store on/off settings for data arrays, etc.
general representation of visualization data
abstract class to specify dataset behavior
Definition vtkDataSet.h:63
dynamic, self-adjusting array of vtkIdType
topologically and geometrically regular array of data
a simple class to control print indentation
Definition vtkIndent.h:40
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)
vtkIdType GetCount()
Returns the number of words received by the most recent Receive().
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)
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)
static vtkMultiProcessController * GetGlobalController()
This convenience method returns the controller associated with the local 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.
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)
virtual vtkMultiProcessController * PartitionController(int localColor, int localKey)
Partitions this controller based on a coloring.
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 ...
virtual vtkMultiProcessController * GetLocalController()
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 AllGather(vtkDataObject *sendBuffer, std::vector< vtkSmartPointer< vtkDataObject > > &recvBuffer)
Gathers vtkDataObject (sendBuffer) from all ranks to all raks.
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 Gather(vtkDataObject *sendBuffer, std::vector< vtkSmartPointer< vtkDataObject > > &recvBuffer, int destProcessId)
Gathers vtkDataObject (sendBuffer) from all ranks to the destProcessId.
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 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.
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:50
Hold a reference to a vtkObjectBase instance.
#define vtkDataArray
void(* vtkProcessFunctionType)(vtkMultiProcessController *controller, void *userData)
void(* vtkRMIFunctionType)(void *localArg, void *remoteArg, int remoteArgLength, int remoteProcessId)
int vtkIdType
Definition vtkType.h:332