VTK
vtkCommunicator.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: vtkCommunicator.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 =========================================================================*/
35 #ifndef vtkCommunicator_h
36 #define vtkCommunicator_h
37 
38 #include "vtkParallelCoreModule.h" // For export macro
39 #include "vtkObject.h"
40 #include "vtkSmartPointer.h" // needed for vtkSmartPointer.
41 #include <vector> // needed for std::vector
42 
43 class vtkBoundingBox;
44 class vtkCharArray;
45 class vtkDataArray;
46 class vtkDataObject;
47 class vtkDataSet;
48 class vtkIdTypeArray;
49 class vtkImageData;
52 
53 class VTKPARALLELCORE_EXPORT vtkCommunicator : public vtkObject
54 {
55 
56 public:
57 
58  vtkTypeMacro(vtkCommunicator, vtkObject);
59  void PrintSelf(ostream& os, vtkIndent indent) override;
60 
62 
67  virtual void SetNumberOfProcesses(int num);
68  vtkGetMacro(NumberOfProcesses, int);
70 
72 
75  vtkGetMacro(LocalProcessId, int);
77 
78  enum Tags
79  {
80  BROADCAST_TAG = 10,
81  GATHER_TAG = 11,
82  GATHERV_TAG = 12,
83  SCATTER_TAG = 13,
84  SCATTERV_TAG = 14,
85  REDUCE_TAG = 15,
86  BARRIER_TAG = 16
87  };
88 
90  {
100  BITWISE_XOR_OP
101  };
102 
107  class Operation
108  {
109  public:
120  virtual void Function(const void *A, void *B, vtkIdType length,
121  int datatype) = 0;
122 
127  virtual int Commutative() = 0;
128 
129  virtual ~Operation() {}
130  };
131 
137  int Send(vtkDataObject* data, int remoteHandle, int tag);
138 
144  int Send(vtkDataArray* data, int remoteHandle, int tag);
145 
152  virtual int SendVoidArray(const void *data, vtkIdType length, int type,
153  int remoteHandle, int tag) = 0;
154 
156 
159  int Send(const int* data, vtkIdType length, int remoteHandle, int tag) {
160  return this->SendVoidArray(data, length, VTK_INT, remoteHandle, tag);
161  }
162  int Send(const unsigned int* data, vtkIdType length, int remoteHandle, int tag) {
163  return this->SendVoidArray(data, length, VTK_INT, remoteHandle, tag);
164  }
165  int Send(const short* data, vtkIdType length, int remoteHandle, int tag) {
166  return this->SendVoidArray(data, length, VTK_SHORT, remoteHandle, tag);
167  }
168  int Send(const unsigned short* data, vtkIdType length, int remoteHandle, int tag) {
169  return this->SendVoidArray(data, length, VTK_UNSIGNED_SHORT, remoteHandle, tag);
170  }
171  int Send(const long* data, vtkIdType length,
172  int remoteHandle, int tag) {
173  return this->SendVoidArray(data, length,VTK_LONG,remoteHandle,tag);
174  }
175  int Send(const unsigned long* data, vtkIdType length,
176  int remoteHandle, int tag) {
177  return this->SendVoidArray(data, length,VTK_UNSIGNED_LONG,remoteHandle,tag);
178  }
179  int Send(const unsigned char* data, vtkIdType length,
180  int remoteHandle, int tag) {
181  return this->SendVoidArray(data, length,VTK_UNSIGNED_CHAR,remoteHandle,tag);
182  }
183  int Send(const char* data, vtkIdType length, int remoteHandle, int tag) {
184  return this->SendVoidArray(data, length, VTK_CHAR, remoteHandle, tag);
185  }
186  int Send(const signed char* data, vtkIdType length, int remoteHandle, int tag) {
187  return this->SendVoidArray(data, length, VTK_SIGNED_CHAR, remoteHandle, tag);
188  }
189  int Send(const float* data, vtkIdType length, int remoteHandle, int tag) {
190  return this->SendVoidArray(data, length, VTK_FLOAT, remoteHandle, tag);
191  }
192  int Send(const double* data, vtkIdType length, int remoteHandle, int tag) {
193  return this->SendVoidArray(data, length, VTK_DOUBLE, remoteHandle, tag);
194  }
195  int Send(const long long* data, vtkIdType length, int remoteHandle, int tag) {
196  return this->SendVoidArray(data, length, VTK_LONG_LONG, remoteHandle, tag);
197  }
198  int Send(const unsigned long long* data, vtkIdType length, int remoteHandle, int tag) {
199  return this->SendVoidArray(data, length, VTK_UNSIGNED_LONG_LONG, remoteHandle, tag);
200  }
202 
203  int Send(const vtkMultiProcessStream& stream, int remoteId, int tag);
204 
209  int Receive(vtkDataObject* data, int remoteHandle, int tag);
210 
215  vtkDataObject *ReceiveDataObject(int remoteHandle, int tag);
216 
221  int Receive(vtkDataArray* data, int remoteHandle, int tag);
222 
233  virtual int ReceiveVoidArray(void *data, vtkIdType maxlength, int type,
234  int remoteHandle, int tag) = 0;
235 
237 
240  int Receive(int* data, vtkIdType maxlength, int remoteHandle, int tag) {
241  return this->ReceiveVoidArray(data, maxlength, VTK_INT, remoteHandle, tag);
242  }
243  int Receive(unsigned int* data, vtkIdType maxlength, int remoteHandle, int tag) {
244  return this->ReceiveVoidArray(data, maxlength, VTK_INT, remoteHandle, tag);
245  }
246  int Receive(short* data, vtkIdType maxlength, int remoteHandle, int tag) {
247  return this->ReceiveVoidArray(data, maxlength, VTK_SHORT, remoteHandle, tag);
248  }
249  int Receive(unsigned short* data, vtkIdType maxlength, int remoteHandle, int tag) {
250  return this->ReceiveVoidArray(data, maxlength, VTK_UNSIGNED_SHORT, remoteHandle, tag);
251  }
252  int Receive(long* data, vtkIdType maxlength, int remoteHandle, int tag) {
253  return this->ReceiveVoidArray(data, maxlength, VTK_LONG, remoteHandle, tag);
254  }
255  int Receive(unsigned long* data, vtkIdType maxlength, int remoteHandle, int tag){
256  return this->ReceiveVoidArray(data, maxlength, VTK_UNSIGNED_LONG, remoteHandle,
257  tag);
258  }
259  int Receive(unsigned char* data, vtkIdType maxlength, int remoteHandle, int tag){
260  return this->ReceiveVoidArray(data, maxlength, VTK_UNSIGNED_CHAR, remoteHandle,
261  tag);
262  }
263  int Receive(char* data, vtkIdType maxlength, int remoteHandle, int tag) {
264  return this->ReceiveVoidArray(data, maxlength, VTK_CHAR, remoteHandle, tag);
265  }
266  int Receive(signed char* data, vtkIdType maxlength, int remoteHandle, int tag) {
267  return this->ReceiveVoidArray(data, maxlength, VTK_SIGNED_CHAR, remoteHandle, tag);
268  }
269  int Receive(float* data, vtkIdType maxlength, int remoteHandle, int tag) {
270  return this->ReceiveVoidArray(data, maxlength, VTK_FLOAT, remoteHandle, tag);
271  }
272  int Receive(double* data, vtkIdType maxlength, int remoteHandle, int tag) {
273  return this->ReceiveVoidArray(data, maxlength, VTK_DOUBLE, remoteHandle, tag);
274  }
275  int Receive(long long* data, vtkIdType maxlength, int remoteHandle, int tag) {
276  return this->ReceiveVoidArray(data, maxlength, VTK_LONG_LONG, remoteHandle, tag);
277  }
278  int Receive(unsigned long long* data, vtkIdType maxlength, int remoteHandle, int tag) {
279  return this->ReceiveVoidArray(data, maxlength, VTK_UNSIGNED_LONG_LONG, remoteHandle, tag);
280  }
282 
283  int Receive(vtkMultiProcessStream& stream, int remoteId, int tag);
284 
286 
294  vtkGetMacro(Count, vtkIdType);
296 
297  //---------------------- Collective Operations ----------------------
298 
303  virtual void Barrier();
304 
306 
311  int Broadcast(int *data, vtkIdType length, int srcProcessId) {
312  return this->BroadcastVoidArray(data, length, VTK_INT, srcProcessId);
313  }
314  int Broadcast(unsigned int *data, vtkIdType length, int srcProcessId) {
315  return this->BroadcastVoidArray(data, length, VTK_UNSIGNED_INT, srcProcessId);
316  }
317  int Broadcast(short *data, vtkIdType length, int srcProcessId) {
318  return this->BroadcastVoidArray(data, length, VTK_SHORT, srcProcessId);
319  }
320  int Broadcast(unsigned short *data, vtkIdType length, int srcProcessId) {
321  return this->BroadcastVoidArray(data, length, VTK_UNSIGNED_SHORT, srcProcessId);
322  }
323  int Broadcast(long *data, vtkIdType length, int srcProcessId) {
324  return this->BroadcastVoidArray(data, length, VTK_LONG, srcProcessId);
325  }
326  int Broadcast(unsigned long *data, vtkIdType length, int srcProcessId) {
327  return this->BroadcastVoidArray(data,length,VTK_UNSIGNED_LONG,srcProcessId);
328  }
329  int Broadcast(unsigned char *data, vtkIdType length, int srcProcessId) {
330  return this->BroadcastVoidArray(data,length,VTK_UNSIGNED_CHAR,srcProcessId);
331  }
332  int Broadcast(char *data, vtkIdType length, int srcProcessId) {
333  return this->BroadcastVoidArray(data, length, VTK_CHAR, srcProcessId);
334  }
335  int Broadcast(signed char *data, vtkIdType length, int srcProcessId) {
336  return this->BroadcastVoidArray(data, length, VTK_SIGNED_CHAR, srcProcessId);
337  }
338  int Broadcast(float *data, vtkIdType length, int srcProcessId) {
339  return this->BroadcastVoidArray(data, length, VTK_FLOAT, srcProcessId);
340  }
341  int Broadcast(double *data, vtkIdType length, int srcProcessId) {
342  return this->BroadcastVoidArray(data, length, VTK_DOUBLE, srcProcessId);
343  }
344  int Broadcast(long long *data, vtkIdType length, int srcProcessId) {
345  return this->BroadcastVoidArray(data, length, VTK_LONG_LONG, srcProcessId);
346  }
347  int Broadcast(unsigned long long *data, vtkIdType length, int srcProcessId) {
348  return this->BroadcastVoidArray(data, length, VTK_UNSIGNED_LONG_LONG, srcProcessId);
349  }
350  int Broadcast(vtkDataObject *data, int srcProcessId);
351  int Broadcast(vtkDataArray *data, int srcProcessId);
353 
354  int Broadcast(vtkMultiProcessStream& stream, int srcProcessId);
355 
357 
366  int Gather(const int *sendBuffer, int *recvBuffer,
367  vtkIdType length, int destProcessId) {
368  return this->GatherVoidArray(sendBuffer, recvBuffer, length,
369  VTK_INT, destProcessId);
370  }
371  int Gather(const unsigned int *sendBuffer, unsigned int *recvBuffer,
372  vtkIdType length, int destProcessId) {
373  return this->GatherVoidArray(sendBuffer, recvBuffer, length,
374  VTK_UNSIGNED_INT, destProcessId);
375  }
376  int Gather(const short *sendBuffer, short *recvBuffer,
377  vtkIdType length, int destProcessId) {
378  return this->GatherVoidArray(sendBuffer, recvBuffer, length,
379  VTK_SHORT, destProcessId);
380  }
381  int Gather(const unsigned short *sendBuffer, unsigned short *recvBuffer,
382  vtkIdType length, int destProcessId) {
383  return this->GatherVoidArray(sendBuffer, recvBuffer, length,
384  VTK_UNSIGNED_SHORT, destProcessId);
385  }
386  int Gather(const long *sendBuffer, long *recvBuffer,
387  vtkIdType length, int destProcessId) {
388  return this->GatherVoidArray(sendBuffer, recvBuffer, length,
389  VTK_LONG, destProcessId);
390  }
391  int Gather(const unsigned long *sendBuffer, unsigned long *recvBuffer,
392  vtkIdType length, int destProcessId) {
393  return this->GatherVoidArray(sendBuffer, recvBuffer, length,
394  VTK_UNSIGNED_LONG, destProcessId);
395  }
396  int Gather(const unsigned char *sendBuffer, unsigned char *recvBuffer,
397  vtkIdType length, int destProcessId) {
398  return this->GatherVoidArray(sendBuffer, recvBuffer, length,
399  VTK_UNSIGNED_CHAR, destProcessId);
400  }
401  int Gather(const char *sendBuffer, char *recvBuffer,
402  vtkIdType length, int destProcessId) {
403  return this->GatherVoidArray(sendBuffer, recvBuffer, length,
404  VTK_CHAR, destProcessId);
405  }
406  int Gather(const signed char *sendBuffer, signed char *recvBuffer,
407  vtkIdType length, int destProcessId) {
408  return this->GatherVoidArray(sendBuffer, recvBuffer, length,
409  VTK_SIGNED_CHAR, destProcessId);
410  }
411  int Gather(const float *sendBuffer, float *recvBuffer,
412  vtkIdType length, int destProcessId) {
413  return this->GatherVoidArray(sendBuffer, recvBuffer, length,
414  VTK_FLOAT, destProcessId);
415  }
416  int Gather(const double *sendBuffer, double *recvBuffer,
417  vtkIdType length, int destProcessId) {
418  return this->GatherVoidArray(sendBuffer, recvBuffer, length,
419  VTK_DOUBLE, destProcessId);
420  }
421  int Gather(const long long *sendBuffer, long long *recvBuffer,
422  vtkIdType length, int destProcessId) {
423  return this->GatherVoidArray(sendBuffer, recvBuffer, length,
424  VTK_LONG_LONG, destProcessId);
425  }
426  int Gather(const unsigned long long *sendBuffer, unsigned long long *recvBuffer,
427  vtkIdType length, int destProcessId) {
428  return this->GatherVoidArray(sendBuffer, recvBuffer, length,
429  VTK_UNSIGNED_LONG_LONG, destProcessId);
430  }
431  int Gather(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
432  int destProcessId);
434 
447  int Gather(vtkDataObject* sendBuffer,
449  int destProcessId);
450 
452 
463  int GatherV(const int* sendBuffer, int* recvBuffer,
464  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
465  int destProcessId) {
466  return this->GatherVVoidArray(sendBuffer, recvBuffer,
467  sendLength, recvLengths,
468  offsets, VTK_INT, destProcessId);
469  }
470  int GatherV(const unsigned int* sendBuffer, unsigned int* recvBuffer,
471  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
472  int destProcessId) {
473  return this->GatherVVoidArray(sendBuffer, recvBuffer,
474  sendLength, recvLengths,
475  offsets, VTK_UNSIGNED_INT, destProcessId);
476  }
477  int GatherV(const short* sendBuffer, short* recvBuffer,
478  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
479  int destProcessId) {
480  return this->GatherVVoidArray(sendBuffer, recvBuffer,
481  sendLength, recvLengths,
482  offsets, VTK_SHORT, destProcessId);
483  }
484  int GatherV(const unsigned short* sendBuffer, unsigned short* recvBuffer,
485  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
486  int destProcessId) {
487  return this->GatherVVoidArray(sendBuffer, recvBuffer,
488  sendLength, recvLengths,
489  offsets, VTK_UNSIGNED_SHORT, destProcessId);
490  }
491  int GatherV(const long* sendBuffer, long* recvBuffer,
492  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
493  int destProcessId) {
494  return this->GatherVVoidArray(sendBuffer, recvBuffer,
495  sendLength, recvLengths,
496  offsets, VTK_LONG, destProcessId);
497  }
498  int GatherV(const unsigned long* sendBuffer, unsigned long* recvBuffer,
499  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
500  int destProcessId) {
501  return this->GatherVVoidArray(sendBuffer, recvBuffer,
502  sendLength, recvLengths,
503  offsets, VTK_UNSIGNED_LONG, destProcessId);
504  }
505  int GatherV(const unsigned char* sendBuffer, unsigned char* recvBuffer,
506  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
507  int destProcessId) {
508  return this->GatherVVoidArray(sendBuffer, recvBuffer,
509  sendLength, recvLengths,
510  offsets, VTK_UNSIGNED_CHAR, destProcessId);
511  }
512  int GatherV(const char* sendBuffer, char* recvBuffer,
513  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
514  int destProcessId) {
515  return this->GatherVVoidArray(sendBuffer, recvBuffer,
516  sendLength, recvLengths,
517  offsets, VTK_CHAR, destProcessId);
518  }
519  int GatherV(const signed char* sendBuffer, signed char* recvBuffer,
520  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
521  int destProcessId) {
522  return this->GatherVVoidArray(sendBuffer, recvBuffer,
523  sendLength, recvLengths,
524  offsets, VTK_SIGNED_CHAR, destProcessId);
525  }
526  int GatherV(const float* sendBuffer, float* recvBuffer,
527  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
528  int destProcessId) {
529  return this->GatherVVoidArray(sendBuffer, recvBuffer,
530  sendLength, recvLengths,
531  offsets, VTK_FLOAT, destProcessId);
532  }
533  int GatherV(const double* sendBuffer, double* recvBuffer,
534  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
535  int destProcessId) {
536  return this->GatherVVoidArray(sendBuffer, recvBuffer,
537  sendLength, recvLengths,
538  offsets, VTK_DOUBLE, destProcessId);
539  }
540  int GatherV(const long long* sendBuffer, long long* recvBuffer,
541  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
542  int destProcessId) {
543  return this->GatherVVoidArray(sendBuffer, recvBuffer,
544  sendLength, recvLengths,
545  offsets, VTK_LONG_LONG, destProcessId);
546  }
547  int GatherV(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
548  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
549  int destProcessId) {
550  return this->GatherVVoidArray(sendBuffer, recvBuffer,
551  sendLength, recvLengths,
552  offsets, VTK_UNSIGNED_LONG_LONG, destProcessId);
553  }
555 
556 
566  int GatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
567  vtkIdType *recvLengths, vtkIdType *offsets,
568  int destProcessId);
569  int GatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
570  vtkIdTypeArray* recvLengths,
571  vtkIdTypeArray* offsets,
572  int destProcessId);
573  int GatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
574  int destProcessId);
576 
584  int GatherV(vtkDataObject* sendData, vtkSmartPointer<vtkDataObject>* recvData,
585  int destProcessId);
586 
588 
595  int Scatter(const int *sendBuffer, int *recvBuffer,
596  vtkIdType length, int srcProcessId) {
597  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
598  VTK_INT, srcProcessId);
599  }
600  int Scatter(const unsigned int *sendBuffer, unsigned int *recvBuffer,
601  vtkIdType length, int srcProcessId) {
602  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
603  VTK_UNSIGNED_INT, srcProcessId);
604  }
605  int Scatter(const short *sendBuffer, short *recvBuffer,
606  vtkIdType length, int srcProcessId) {
607  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
608  VTK_SHORT, srcProcessId);
609  }
610  int Scatter(const unsigned short *sendBuffer, unsigned short *recvBuffer,
611  vtkIdType length, int srcProcessId) {
612  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
613  VTK_UNSIGNED_SHORT, srcProcessId);
614  }
615  int Scatter(const long *sendBuffer, long *recvBuffer,
616  vtkIdType length, int srcProcessId) {
617  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
618  VTK_INT, srcProcessId);
619  }
620  int Scatter(const unsigned long *sendBuffer, unsigned long *recvBuffer,
621  vtkIdType length, int srcProcessId) {
622  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
623  VTK_UNSIGNED_LONG, srcProcessId);
624  }
625  int Scatter(const unsigned char *sendBuffer, unsigned char *recvBuffer,
626  vtkIdType length, int srcProcessId) {
627  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
628  VTK_UNSIGNED_CHAR, srcProcessId);
629  }
630  int Scatter(const char *sendBuffer, char *recvBuffer,
631  vtkIdType length, int srcProcessId) {
632  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
633  VTK_CHAR, srcProcessId);
634  }
635  int Scatter(const signed char *sendBuffer, signed char *recvBuffer,
636  vtkIdType length, int srcProcessId) {
637  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
638  VTK_SIGNED_CHAR, srcProcessId);
639  }
640  int Scatter(const float *sendBuffer, float *recvBuffer,
641  vtkIdType length, int srcProcessId) {
642  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
643  VTK_FLOAT, srcProcessId);
644  }
645  int Scatter(const double *sendBuffer, double *recvBuffer,
646  vtkIdType length, int srcProcessId) {
647  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
648  VTK_DOUBLE, srcProcessId);
649  }
650  int Scatter(const long long *sendBuffer, long long *recvBuffer,
651  vtkIdType length, int srcProcessId) {
652  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
653  VTK_LONG_LONG, srcProcessId);
654  }
655  int Scatter(const unsigned long long *sendBuffer, unsigned long long *recvBuffer,
656  vtkIdType length, int srcProcessId) {
657  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
658  VTK_UNSIGNED_LONG_LONG, srcProcessId);
659  }
660  int Scatter(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
661  int srcProcessId);
663 
665 
672  int ScatterV(const int *sendBuffer, int *recvBuffer,
673  vtkIdType *sendLengths, vtkIdType *offsets,
674  vtkIdType recvLength, int srcProcessId) {
675  return this->ScatterVVoidArray(sendBuffer, recvBuffer,
676  sendLengths, offsets, recvLength,
677  VTK_INT, srcProcessId);
678  }
679  int ScatterV(const unsigned int *sendBuffer, unsigned int *recvBuffer,
680  vtkIdType *sendLengths, vtkIdType *offsets,
681  vtkIdType recvLength, int srcProcessId) {
682  return this->ScatterVVoidArray(sendBuffer, recvBuffer,
683  sendLengths, offsets, recvLength,
684  VTK_UNSIGNED_INT, srcProcessId);
685  }
686  int ScatterV(const short *sendBuffer, short *recvBuffer,
687  vtkIdType *sendLengths, vtkIdType *offsets,
688  vtkIdType recvLength, int srcProcessId) {
689  return this->ScatterVVoidArray(sendBuffer, recvBuffer,
690  sendLengths, offsets, recvLength,
691  VTK_SHORT, srcProcessId);
692  }
693  int ScatterV(const unsigned short *sendBuffer, unsigned short *recvBuffer,
694  vtkIdType *sendLengths, vtkIdType *offsets,
695  vtkIdType recvLength, int srcProcessId) {
696  return this->ScatterVVoidArray(sendBuffer, recvBuffer,
697  sendLengths, offsets, recvLength,
698  VTK_UNSIGNED_SHORT, srcProcessId);
699  }
700  int ScatterV(const long *sendBuffer, long *recvBuffer,
701  vtkIdType *sendLengths, vtkIdType *offsets,
702  vtkIdType recvLength, int srcProcessId) {
703  return this->ScatterVVoidArray(sendBuffer, recvBuffer,
704  sendLengths, offsets, recvLength,
705  VTK_LONG, srcProcessId);
706  }
707  int ScatterV(const unsigned long *sendBuffer, unsigned long *recvBuffer,
708  vtkIdType *sendLengths, vtkIdType *offsets,
709  vtkIdType recvLength, int srcProcessId) {
710  return this->ScatterVVoidArray(sendBuffer, recvBuffer,
711  sendLengths, offsets, recvLength,
712  VTK_UNSIGNED_LONG, srcProcessId);
713  }
714  int ScatterV(const unsigned char *sendBuffer, unsigned char *recvBuffer,
715  vtkIdType *sendLengths, vtkIdType *offsets,
716  vtkIdType recvLength, int srcProcessId) {
717  return this->ScatterVVoidArray(sendBuffer, recvBuffer,
718  sendLengths, offsets, recvLength,
719  VTK_UNSIGNED_CHAR, srcProcessId);
720  }
721  int ScatterV(const char *sendBuffer, char *recvBuffer,
722  vtkIdType *sendLengths, vtkIdType *offsets,
723  vtkIdType recvLength, int srcProcessId) {
724  return this->ScatterVVoidArray(sendBuffer, recvBuffer,
725  sendLengths, offsets, recvLength,
726  VTK_CHAR, srcProcessId);
727  }
728  int ScatterV(const signed char *sendBuffer, signed char *recvBuffer,
729  vtkIdType *sendLengths, vtkIdType *offsets,
730  vtkIdType recvLength, int srcProcessId) {
731  return this->ScatterVVoidArray(sendBuffer, recvBuffer,
732  sendLengths, offsets, recvLength,
733  VTK_SIGNED_CHAR, srcProcessId);
734  }
735  int ScatterV(const float *sendBuffer, float *recvBuffer,
736  vtkIdType *sendLengths, vtkIdType *offsets,
737  vtkIdType recvLength, int srcProcessId) {
738  return this->ScatterVVoidArray(sendBuffer, recvBuffer,
739  sendLengths, offsets, recvLength,
740  VTK_FLOAT, srcProcessId);
741  }
742  int ScatterV(const double *sendBuffer, double *recvBuffer,
743  vtkIdType *sendLengths, vtkIdType *offsets,
744  vtkIdType recvLength, int srcProcessId) {
745  return this->ScatterVVoidArray(sendBuffer, recvBuffer,
746  sendLengths, offsets, recvLength,
747  VTK_DOUBLE, srcProcessId);
748  }
749  int ScatterV(const long long *sendBuffer, long long *recvBuffer,
750  vtkIdType *sendLengths, vtkIdType *offsets,
751  vtkIdType recvLength, int srcProcessId) {
752  return this->ScatterVVoidArray(sendBuffer, recvBuffer,
753  sendLengths, offsets, recvLength,
754  VTK_LONG_LONG, srcProcessId);
755  }
756  int ScatterV(const unsigned long long *sendBuffer, unsigned long long *recvBuffer,
757  vtkIdType *sendLengths, vtkIdType *offsets,
758  vtkIdType recvLength, int srcProcessId) {
759  return this->ScatterVVoidArray(sendBuffer, recvBuffer,
760  sendLengths, offsets, recvLength,
761  VTK_UNSIGNED_LONG_LONG, srcProcessId);
762  }
764 
766 
769  int AllGather(const int *sendBuffer, int *recvBuffer, vtkIdType length) {
770  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_INT);
771  }
772  int AllGather(const unsigned int *sendBuffer, unsigned int *recvBuffer,
773  vtkIdType length) {
774  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length,
776  }
777  int AllGather(const short *sendBuffer, short *recvBuffer, vtkIdType length) {
778  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_SHORT);
779  }
780  int AllGather(const unsigned short *sendBuffer, unsigned short *recvBuffer,
781  vtkIdType length) {
782  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length,
784  }
785  int AllGather(const long *sendBuffer, long *recvBuffer, vtkIdType length) {
786  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_LONG);
787  }
788  int AllGather(const unsigned long *sendBuffer,
789  unsigned long *recvBuffer, vtkIdType length) {
790  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length,
792  }
793  int AllGather(const unsigned char *sendBuffer,
794  unsigned char *recvBuffer, vtkIdType length) {
795  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length,
797  }
798  int AllGather(const char *sendBuffer, char *recvBuffer, vtkIdType length) {
799  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_CHAR);
800  }
801  int AllGather(const signed char *sendBuffer, signed char *recvBuffer,
802  vtkIdType length) {
803  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length,
805  }
806  int AllGather(const float *sendBuffer, float *recvBuffer, vtkIdType length) {
807  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_FLOAT);
808  }
809  int AllGather(const double *sendBuffer,
810  double *recvBuffer, vtkIdType length) {
811  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_DOUBLE);
812  }
813  int AllGather(const long long *sendBuffer, long long *recvBuffer,
814  vtkIdType length) {
815  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length,
816  VTK_LONG_LONG);
817  }
818  int AllGather(const unsigned long long *sendBuffer,
819  unsigned long long *recvBuffer, vtkIdType length) {
820  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length,
822  }
823  int AllGather(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer);
825 
827 
830  int AllGatherV(const int* sendBuffer, int* recvBuffer,
831  vtkIdType sendLength, vtkIdType* recvLengths,
832  vtkIdType* offsets) {
833  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
834  sendLength, recvLengths,
835  offsets, VTK_INT);
836  }
837  int AllGatherV(const unsigned int* sendBuffer, unsigned int* recvBuffer,
838  vtkIdType sendLength, vtkIdType* recvLengths,
839  vtkIdType* offsets) {
840  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
841  sendLength, recvLengths,
842  offsets, VTK_UNSIGNED_INT);
843  }
844  int AllGatherV(const short* sendBuffer, short* recvBuffer,
845  vtkIdType sendLength, vtkIdType* recvLengths,
846  vtkIdType* offsets) {
847  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
848  sendLength, recvLengths,
849  offsets, VTK_SHORT);
850  }
851  int AllGatherV(const unsigned short* sendBuffer, unsigned short* recvBuffer,
852  vtkIdType sendLength, vtkIdType* recvLengths,
853  vtkIdType* offsets) {
854  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
855  sendLength, recvLengths,
856  offsets, VTK_UNSIGNED_SHORT);
857  }
858  int AllGatherV(const long* sendBuffer, long* recvBuffer,
859  vtkIdType sendLength, vtkIdType* recvLengths,
860  vtkIdType* offsets) {
861  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
862  sendLength, recvLengths,
863  offsets, VTK_LONG);
864  }
865  int AllGatherV(const unsigned long* sendBuffer, unsigned long* recvBuffer,
866  vtkIdType sendLength, vtkIdType* recvLengths,
867  vtkIdType* offsets) {
868  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
869  sendLength, recvLengths,
870  offsets, VTK_UNSIGNED_LONG);
871  }
872  int AllGatherV(const unsigned char* sendBuffer, unsigned char* recvBuffer,
873  vtkIdType sendLength, vtkIdType* recvLengths,
874  vtkIdType* offsets) {
875  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
876  sendLength, recvLengths,
877  offsets, VTK_UNSIGNED_CHAR);
878  }
879  int AllGatherV(const char* sendBuffer, char* recvBuffer,
880  vtkIdType sendLength, vtkIdType* recvLengths,
881  vtkIdType* offsets) {
882  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
883  sendLength, recvLengths,
884  offsets, VTK_CHAR);
885  }
886  int AllGatherV(const signed char* sendBuffer, signed char* recvBuffer,
887  vtkIdType sendLength, vtkIdType* recvLengths,
888  vtkIdType* offsets) {
889  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
890  sendLength, recvLengths,
891  offsets, VTK_UNSIGNED_CHAR);
892  }
893  int AllGatherV(const float* sendBuffer, float* recvBuffer,
894  vtkIdType sendLength, vtkIdType* recvLengths,
895  vtkIdType* offsets) {
896  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
897  sendLength, recvLengths,
898  offsets, VTK_FLOAT);
899  }
900  int AllGatherV(const double* sendBuffer, double* recvBuffer,
901  vtkIdType sendLength, vtkIdType* recvLengths,
902  vtkIdType* offsets) {
903  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
904  sendLength, recvLengths,
905  offsets, VTK_DOUBLE);
906  }
907  int AllGatherV(const long long* sendBuffer, long long* recvBuffer,
908  vtkIdType sendLength, vtkIdType* recvLengths,
909  vtkIdType* offsets) {
910  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
911  sendLength, recvLengths,
912  offsets, VTK_LONG_LONG);
913  }
914  int AllGatherV(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
915  vtkIdType sendLength, vtkIdType* recvLengths,
916  vtkIdType* offsets) {
917  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
918  sendLength, recvLengths,
919  offsets, VTK_UNSIGNED_LONG_LONG);
920  }
921  int AllGatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
922  vtkIdType *recvLengths, vtkIdType *offsets);
923  int AllGatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer);
925 
927 
932  int Reduce(const int *sendBuffer, int *recvBuffer,
933  vtkIdType length, int operation, int destProcessId) {
934  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
935  VTK_INT, operation, destProcessId);
936  }
937  int Reduce(const unsigned int *sendBuffer, unsigned int *recvBuffer,
938  vtkIdType length, int operation, int destProcessId) {
939  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
940  VTK_UNSIGNED_INT, operation, destProcessId);
941  }
942  int Reduce(const short *sendBuffer, short *recvBuffer,
943  vtkIdType length, int operation, int destProcessId) {
944  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
945  VTK_SHORT, operation, destProcessId);
946  }
947  int Reduce(const unsigned short *sendBuffer, unsigned short *recvBuffer,
948  vtkIdType length, int operation, int destProcessId) {
949  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
950  VTK_UNSIGNED_SHORT, operation, destProcessId);
951  }
952  int Reduce(const long *sendBuffer, long *recvBuffer,
953  vtkIdType length, int operation, int destProcessId) {
954  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
955  VTK_LONG, operation, destProcessId);
956  }
957  int Reduce(const unsigned long *sendBuffer, unsigned long *recvBuffer,
958  vtkIdType length, int operation, int destProcessId) {
959  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
960  VTK_UNSIGNED_LONG, operation, destProcessId);
961  }
962  int Reduce(const unsigned char *sendBuffer, unsigned char *recvBuffer,
963  vtkIdType length, int operation, int destProcessId) {
964  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
965  VTK_UNSIGNED_CHAR, operation, destProcessId);
966  }
967  int Reduce(const char *sendBuffer, char *recvBuffer,
968  vtkIdType length, int operation, int destProcessId) {
969  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
970  VTK_CHAR, operation, destProcessId);
971  }
972  int Reduce(const signed char *sendBuffer, signed char *recvBuffer,
973  vtkIdType length, int operation, int destProcessId) {
974  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
975  VTK_SIGNED_CHAR, operation, destProcessId);
976  }
977  int Reduce(const float *sendBuffer, float *recvBuffer,
978  vtkIdType length, int operation, int destProcessId) {
979  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
980  VTK_FLOAT, operation, destProcessId);
981  }
982  int Reduce(const double *sendBuffer, double *recvBuffer,
983  vtkIdType length, int operation, int destProcessId) {
984  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
985  VTK_DOUBLE, operation, destProcessId);
986  }
987  int Reduce(const long long *sendBuffer, long long *recvBuffer,
988  vtkIdType length, int operation, int destProcessId) {
989  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
990  VTK_LONG_LONG, operation, destProcessId);
991  }
992  int Reduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer,
993  vtkIdType length, int operation, int destProcessId) {
994  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
995  VTK_UNSIGNED_LONG_LONG, operation, destProcessId);
996  }
997  int Reduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
998  int operation, int destProcessId);
1000 
1002 
1006  int Reduce(const int *sendBuffer, int *recvBuffer,
1007  vtkIdType length, Operation *operation, int destProcessId) {
1008  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1009  VTK_INT, operation, destProcessId);
1010  }
1011  int Reduce(const unsigned int *sendBuffer, unsigned int *recvBuffer,
1012  vtkIdType length, Operation *operation, int destProcessId) {
1013  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1014  VTK_UNSIGNED_INT, operation, destProcessId);
1015  }
1016  int Reduce(const short *sendBuffer, short *recvBuffer,
1017  vtkIdType length, Operation *operation, int destProcessId) {
1018  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1019  VTK_SHORT, operation, destProcessId);
1020  }
1021  int Reduce(const unsigned short *sendBuffer, unsigned short *recvBuffer,
1022  vtkIdType length, Operation *operation, int destProcessId) {
1023  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1024  VTK_UNSIGNED_SHORT, operation, destProcessId);
1025  }
1026  int Reduce(const long *sendBuffer, long *recvBuffer,
1027  vtkIdType length, Operation *operation, int destProcessId) {
1028  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1029  VTK_LONG, operation, destProcessId);
1030  }
1031  int Reduce(const unsigned long *sendBuffer, unsigned long *recvBuffer,
1032  vtkIdType length, Operation *operation, int destProcessId) {
1033  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1034  VTK_UNSIGNED_LONG, operation, destProcessId);
1035  }
1036  int Reduce(const unsigned char *sendBuffer, unsigned char *recvBuffer,
1037  vtkIdType length, Operation *operation, int destProcessId) {
1038  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1039  VTK_UNSIGNED_CHAR, operation, destProcessId);
1040  }
1041  int Reduce(const char *sendBuffer, char *recvBuffer,
1042  vtkIdType length, Operation *operation, int destProcessId) {
1043  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1044  VTK_CHAR, operation, destProcessId);
1045  }
1046  int Reduce(const signed char *sendBuffer, signed char *recvBuffer,
1047  vtkIdType length, Operation *operation, int destProcessId) {
1048  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1049  VTK_SIGNED_CHAR, operation, destProcessId);
1050  }
1051  int Reduce(const float *sendBuffer, float *recvBuffer,
1052  vtkIdType length, Operation *operation, int destProcessId) {
1053  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1054  VTK_FLOAT, operation, destProcessId);
1055  }
1056  int Reduce(const double *sendBuffer, double *recvBuffer,
1057  vtkIdType length, Operation *operation, int destProcessId) {
1058  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1059  VTK_DOUBLE, operation, destProcessId);
1060  }
1061  int Reduce(const long long *sendBuffer, long long *recvBuffer,
1062  vtkIdType length, Operation *operation, int destProcessId) {
1063  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1064  VTK_LONG_LONG, operation, destProcessId);
1065  }
1066  int Reduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer,
1067  vtkIdType length, Operation *operation, int destProcessId) {
1068  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1069  VTK_UNSIGNED_LONG_LONG, operation, destProcessId);
1070  }
1071  int Reduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
1072  Operation *operation, int destProcessId);
1074 
1076 
1079  int AllReduce(const int *sendBuffer, int *recvBuffer,
1080  vtkIdType length, int operation) {
1081  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1082  VTK_INT, operation);
1083  }
1084  int AllReduce(const unsigned int *sendBuffer, unsigned int *recvBuffer,
1085  vtkIdType length, int operation) {
1086  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1087  VTK_UNSIGNED_INT, operation);
1088  }
1089  int AllReduce(const short *sendBuffer, short *recvBuffer,
1090  vtkIdType length, int operation) {
1091  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1092  VTK_SHORT, operation);
1093  }
1094  int AllReduce(const unsigned short *sendBuffer, unsigned short *recvBuffer,
1095  vtkIdType length, int operation) {
1096  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1097  VTK_UNSIGNED_SHORT, operation);
1098  }
1099  int AllReduce(const long *sendBuffer, long *recvBuffer,
1100  vtkIdType length, int operation) {
1101  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1102  VTK_LONG, operation);
1103  }
1104  int AllReduce(const unsigned long *sendBuffer, unsigned long *recvBuffer,
1105  vtkIdType length, int operation) {
1106  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1107  VTK_UNSIGNED_LONG, operation);
1108  }
1109  int AllReduce(const unsigned char *sendBuffer, unsigned char *recvBuffer,
1110  vtkIdType length, int operation) {
1111  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1112  VTK_UNSIGNED_CHAR, operation);
1113  }
1114  int AllReduce(const char *sendBuffer, char *recvBuffer,
1115  vtkIdType length, int operation) {
1116  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1117  VTK_CHAR, operation);
1118  }
1119  int AllReduce(const signed char *sendBuffer, signed char *recvBuffer,
1120  vtkIdType length, int operation) {
1121  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1122  VTK_SIGNED_CHAR, operation);
1123  }
1124  int AllReduce(const float *sendBuffer, float *recvBuffer,
1125  vtkIdType length, int operation) {
1126  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1127  VTK_FLOAT, operation);
1128  }
1129  int AllReduce(const double *sendBuffer, double *recvBuffer,
1130  vtkIdType length, int operation) {
1131  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1132  VTK_DOUBLE, operation);
1133  }
1134  int AllReduce(const long long *sendBuffer, long long *recvBuffer,
1135  vtkIdType length, int operation) {
1136  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1137  VTK_LONG_LONG, operation);
1138  }
1139  int AllReduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer,
1140  vtkIdType length, int operation) {
1141  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1142  VTK_UNSIGNED_LONG_LONG, operation);
1143  }
1144  int AllReduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
1145  int operation);
1146  int AllReduce(const int *sendBuffer, int *recvBuffer,
1147  vtkIdType length, Operation *operation) {
1148  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1149  VTK_INT, operation);
1150  }
1151  int AllReduce(const unsigned int *sendBuffer, unsigned int *recvBuffer,
1152  vtkIdType length, Operation *operation) {
1153  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1154  VTK_UNSIGNED_INT, operation);
1155  }
1156  int AllReduce(const short *sendBuffer, short *recvBuffer,
1157  vtkIdType length, Operation *operation) {
1158  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1159  VTK_SHORT, operation);
1160  }
1161  int AllReduce(const unsigned short *sendBuffer, unsigned short *recvBuffer,
1162  vtkIdType length, Operation *operation) {
1163  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1164  VTK_UNSIGNED_SHORT, operation);
1165  }
1166  int AllReduce(const long *sendBuffer, long *recvBuffer,
1167  vtkIdType length, Operation *operation) {
1168  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1169  VTK_LONG, operation);
1170  }
1171  int AllReduce(const unsigned long *sendBuffer, unsigned long *recvBuffer,
1172  vtkIdType length, Operation *operation) {
1173  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1174  VTK_UNSIGNED_LONG, operation);
1175  }
1176  int AllReduce(const unsigned char *sendBuffer, unsigned char *recvBuffer,
1177  vtkIdType length, Operation *operation) {
1178  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1179  VTK_UNSIGNED_CHAR, operation);
1180  }
1181  int AllReduce(const char *sendBuffer, char *recvBuffer,
1182  vtkIdType length, Operation *operation) {
1183  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1184  VTK_CHAR, operation);
1185  }
1186  int AllReduce(const signed char *sendBuffer, signed char *recvBuffer,
1187  vtkIdType length, Operation *operation) {
1188  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1189  VTK_SIGNED_CHAR, operation);
1190  }
1191  int AllReduce(const float *sendBuffer, float *recvBuffer,
1192  vtkIdType length, Operation *operation) {
1193  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1194  VTK_FLOAT, operation);
1195  }
1196  int AllReduce(const double *sendBuffer, double *recvBuffer,
1197  vtkIdType length, Operation *operation) {
1198  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1199  VTK_DOUBLE, operation);
1200  }
1201  int AllReduce(const long long *sendBuffer, long long *recvBuffer,
1202  vtkIdType length, Operation *operation) {
1203  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1204  VTK_LONG_LONG, operation);
1205  }
1206  int AllReduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer,
1207  vtkIdType length, Operation *operation) {
1208  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1209  VTK_UNSIGNED_LONG_LONG, operation);
1210  }
1211  int AllReduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
1212  Operation *operation);
1214 
1216 
1220  virtual int BroadcastVoidArray(void *data, vtkIdType length, int type,
1221  int srcProcessId);
1222  virtual int GatherVoidArray(const void *sendBuffer, void *recvBuffer,
1223  vtkIdType length, int type, int destProcessId);
1224  virtual int GatherVVoidArray(const void *sendBuffer, void *recvBuffer,
1225  vtkIdType sendLength, vtkIdType *recvLengths,
1226  vtkIdType *offsets, int type, int destProcessId);
1227  virtual int ScatterVoidArray(const void *sendBuffer, void *recvBuffer,
1228  vtkIdType length, int type, int srcProcessId);
1229  virtual int ScatterVVoidArray(const void *sendBuffer, void *recvBuffer,
1230  vtkIdType *sendLengths, vtkIdType *offsets,
1231  vtkIdType recvLength, int type,
1232  int srcProcessId);
1233  virtual int AllGatherVoidArray(const void *sendBuffer, void *recvBuffer,
1234  vtkIdType length, int type);
1235  virtual int AllGatherVVoidArray(const void *sendBuffer, void *recvBuffer,
1236  vtkIdType sendLength, vtkIdType *recvLengths,
1237  vtkIdType *offsets, int type);
1238  virtual int ReduceVoidArray(const void *sendBuffer, void *recvBuffer,
1239  vtkIdType length, int type,
1240  int operation, int destProcessId);
1241  virtual int ReduceVoidArray(const void *sendBuffer, void *recvBuffer,
1242  vtkIdType length, int type,
1243  Operation *operation, int destProcessId);
1244  virtual int AllReduceVoidArray(const void *sendBuffer, void *recvBuffer,
1245  vtkIdType length, int type,
1246  int operation);
1247  virtual int AllReduceVoidArray(const void *sendBuffer, void *recvBuffer,
1248  vtkIdType length, int type,
1249  Operation *operation);
1251 
1252  static void SetUseCopy(int useCopy);
1253 
1265  virtual int ComputeGlobalBounds(int processorId, int numProcesses,
1266  vtkBoundingBox *bounds,
1267  int *rightHasBounds = nullptr,
1268  int *leftHasBounds = nullptr,
1269  int hasBoundsTag = 288402,
1270  int localBoundsTag = 288403,
1271  int globalBoundsTag = 288404);
1272 
1274 
1279  static int GetParentProcessor(int pid);
1280  static int GetLeftChildProcessor(int pid);
1282 
1284 
1289  static int MarshalDataObject(vtkDataObject *object, vtkCharArray *buffer);
1290  static int UnMarshalDataObject(vtkCharArray *buffer, vtkDataObject *object);
1292 
1299  static vtkSmartPointer<vtkDataObject> UnMarshalDataObject(vtkCharArray* buffer);
1300 
1301 protected:
1302 
1303  int WriteDataArray(vtkDataArray *object);
1304  int ReadDataArray(vtkDataArray *object);
1305 
1306  vtkCommunicator();
1307  ~vtkCommunicator() override;
1308 
1309  // Internal methods called by Send/Receive(vtkDataObject *... ) above.
1310  int SendElementalDataObject(vtkDataObject* data, int remoteHandle, int tag);
1312 
1320  int GatherV(vtkDataArray *sendArray, vtkDataArray* recvArray,
1321  vtkSmartPointer<vtkDataArray>* recvArrays, int destProcessId);
1322  int GatherVElementalDataObject(vtkDataObject* sendData,
1323  vtkSmartPointer<vtkDataObject>* receiveData,
1324  int destProcessId);
1326 
1327  int ReceiveDataObject(vtkDataObject* data,
1328  int remoteHandle, int tag, int type=-1);
1329  int ReceiveElementalDataObject(vtkDataObject* data,
1330  int remoteHandle, int tag);
1331  int ReceiveMultiBlockDataSet(
1332  vtkMultiBlockDataSet* data, int remoteHandle, int tag);
1333 
1336 
1338 
1339  static int UseCopy;
1340 
1342 
1343 private:
1344  vtkCommunicator(const vtkCommunicator&) = delete;
1345  void operator=(const vtkCommunicator&) = delete;
1346 };
1347 
1348 #endif // vtkCommunicator_h
1349 // VTK-HeaderTest-Exclude: vtkCommunicator.h
int Receive(double *data, vtkIdType maxlength, int remoteHandle, int tag)
Convenience methods for receiving data arrays.
int Receive(unsigned int *data, vtkIdType maxlength, int remoteHandle, int tag)
Convenience methods for receiving data arrays.
int AllGather(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all 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 char *sendBuffer, char *recvBuffer, vtkIdType length, Operation *operation)
Same as Reduce except that the result is placed in all of the processes.
int Gather(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
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 ScatterV(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
int Gather(const int *sendBuffer, int *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
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 unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
A custom operation to use in a reduce command.
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 Send(const short *data, vtkIdType length, int remoteHandle, int tag)
Convenience methods for sending data arrays.
int Reduce(const long *sendBuffer, long *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
Reduce an array to the given destination process.
int ScatterV(const double *sendBuffer, double *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
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.
#define VTK_UNSIGNED_INT
Definition: vtkType.h:55
int Send(const int *data, vtkIdType length, int remoteHandle, int tag)
Convenience methods for sending data arrays.
abstract base class for most VTK objects
Definition: vtkObject.h:59
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 Receive(unsigned char *data, vtkIdType maxlength, int remoteHandle, int tag)
Convenience methods for receiving data arrays.
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
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 AllGather(const long long *sendBuffer, long long *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
stream used to pass data across processes using vtkMultiProcessController.
int Gather(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
int Receive(long long *data, vtkIdType maxlength, int remoteHandle, int tag)
Convenience methods for receiving data arrays.
int GatherV(const char *sendBuffer, char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
int Gather(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
#define VTK_UNSIGNED_SHORT
Definition: vtkType.h:53
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.
abstract class to specify dataset behavior
Definition: vtkDataSet.h:62
int Gather(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
int AllReduce(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
int AllReduce(const double *sendBuffer, double *recvBuffer, vtkIdType length, Operation *operation)
Same as Reduce except that the result is placed in all of the processes.
int AllReduce(const float *sendBuffer, float *recvBuffer, vtkIdType length, Operation *operation)
Same as Reduce except that the result is placed in all of the processes.
int Reduce(const float *sendBuffer, float *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
int Reduce(const double *sendBuffer, double *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
Reduce an array to the given destination process.
int Scatter(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
int Reduce(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
Reduce an array to the given destination process.
int ScatterV(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
int Scatter(const long *sendBuffer, long *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
int Send(const float *data, vtkIdType length, int remoteHandle, int tag)
Convenience methods for sending data arrays.
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 AllReduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length, Operation *operation)
Same as Reduce except that the result is placed in all of the processes.
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 Send(const unsigned short *data, vtkIdType length, int remoteHandle, int tag)
Convenience methods for sending data arrays.
int Scatter(const short *sendBuffer, short *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
int ScatterV(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
int Broadcast(signed char *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes...
int GatherV(const long long *sendBuffer, long long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
int AllReduce(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, Operation *operation)
Same as Reduce except that the result is placed in all of the processes.
int Send(const signed char *data, vtkIdType length, int remoteHandle, int tag)
Convenience methods for sending data arrays.
int Reduce(const int *sendBuffer, int *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
Reduce an array to the given destination process.
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 AllReduce(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, Operation *operation)
Same as Reduce except that the result is placed in all of the processes.
dynamic, self-adjusting array of vtkIdType
int Reduce(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
Reduce an array to the given destination process.
int vtkIdType
Definition: vtkType.h:347
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 AllReduce(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, Operation *operation)
Same as Reduce except that the result is placed in all of the processes.
int Broadcast(char *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes...
int AllGather(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
int AllGather(const double *sendBuffer, double *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
#define VTK_LONG_LONG
Definition: vtkType.h:67
int Send(const double *data, vtkIdType length, int remoteHandle, int tag)
Convenience methods for sending data arrays.
int ScatterV(const short *sendBuffer, short *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
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 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 short *sendBuffer, unsigned short *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
int AllReduce(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, Operation *operation)
Same as Reduce except that the result is placed in all of the processes.
int AllReduce(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
int ScatterV(const int *sendBuffer, int *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
int Reduce(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
int Scatter(const float *sendBuffer, float *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
int AllReduce(const char *sendBuffer, char *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
#define VTK_DOUBLE
Definition: vtkType.h:59
int Broadcast(unsigned long long *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes...
int 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 unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
dynamic, self-adjusting array of char
Definition: vtkCharArray.h:38
#define VTK_FLOAT
Definition: vtkType.h:58
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 AllGather(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
int AllGather(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
int 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 Gather(const double *sendBuffer, double *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
int Receive(char *data, vtkIdType maxlength, int remoteHandle, int tag)
Convenience methods for receiving data arrays.
int Send(const unsigned int *data, vtkIdType length, int remoteHandle, int tag)
Convenience methods for sending data arrays.
int Send(const unsigned long long *data, vtkIdType length, int remoteHandle, int tag)
Convenience methods for sending data arrays.
int Reduce(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
Reduce an array to the given destination process.
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 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 Gather(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
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 float *sendBuffer, float *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
Reduce an array to the given destination process.
a simple class to control print indentation
Definition: vtkIndent.h:39
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 Receive(short *data, vtkIdType maxlength, int remoteHandle, int tag)
Convenience methods for receiving data arrays.
int ScatterV(const char *sendBuffer, char *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
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 Receive(long *data, vtkIdType maxlength, int remoteHandle, int tag)
Convenience methods for receiving data arrays.
int GatherV(const short *sendBuffer, short *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
topologically and geometrically regular array of data
Definition: vtkImageData.h:45
int GatherV(const long *sendBuffer, long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
int Receive(signed char *data, vtkIdType maxlength, int remoteHandle, int tag)
Convenience methods for receiving data arrays.
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.
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:54
int AllGather(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
int Reduce(const int *sendBuffer, int *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
int Gather(const short *sendBuffer, short *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
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 Reduce(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
#define VTK_SHORT
Definition: vtkType.h:52
#define VTK_CHAR
Definition: vtkType.h:49
int AllGather(const float *sendBuffer, float *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
#define VTK_LONG
Definition: vtkType.h:56
int AllReduce(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, Operation *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, int operation, int destProcessId)
Reduce an array to the given destination process.
int Send(const unsigned long *data, vtkIdType length, int remoteHandle, int tag)
Convenience methods for sending data arrays.
int Gather(const char *sendBuffer, char *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
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 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 Gather(const float *sendBuffer, float *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
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 Reduce(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, int 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(unsigned long *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes...
int AllGather(const long *sendBuffer, long *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
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 AllReduce(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
int 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 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 Reduce(const char *sendBuffer, char *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
Reduce an array to the given destination process.
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 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 unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Same as GatherV except that the result is placed in all processes.
int AllGather(const int *sendBuffer, int *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
int Broadcast(double *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes...
#define VTK_SIGNED_CHAR
Definition: vtkType.h:50
int AllReduce(const int *sendBuffer, int *recvBuffer, vtkIdType length, Operation *operation)
Same as Reduce except that the result is placed in all of the processes.
int Reduce(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
Reduce an array to the given destination process.
int Send(const long *data, vtkIdType length, int remoteHandle, int tag)
Convenience methods for sending data arrays.
int Receive(float *data, vtkIdType maxlength, int remoteHandle, int tag)
Convenience methods for receiving data arrays.
int Send(const long long *data, vtkIdType length, int remoteHandle, int tag)
Convenience methods for sending data arrays.
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 Send(const unsigned char *data, vtkIdType length, int remoteHandle, int tag)
Convenience methods for sending data arrays.
#define VTK_UNSIGNED_CHAR
Definition: vtkType.h:51
int ScatterV(const float *sendBuffer, float *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
int Gather(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
int AllReduce(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, Operation *operation)
Same as Reduce except that the result is placed in all of the processes.
int Reduce(const char *sendBuffer, char *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
int Gather(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
int AllGather(const short *sendBuffer, short *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
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.
Composite dataset that organizes datasets into blocks.
int AllReduce(const float *sendBuffer, float *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
int 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 Receive(int *data, vtkIdType maxlength, int remoteHandle, int tag)
Convenience methods for receiving data arrays.
int Reduce(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
Reduce an array to the given destination process.
int Receive(unsigned long long *data, vtkIdType maxlength, int remoteHandle, int tag)
Convenience methods for receiving data arrays.
int Reduce(const short *sendBuffer, short *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
int GatherV(const float *sendBuffer, float *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
int Reduce(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
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...
#define VTK_UNSIGNED_LONG
Definition: vtkType.h:57
int Receive(unsigned long *data, vtkIdType maxlength, int remoteHandle, int tag)
Convenience methods for receiving data arrays.
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 GatherV(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
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 AllGather(const char *sendBuffer, char *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
int Reduce(const long *sendBuffer, long *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
Used to send/receive messages in a multiprocess environment.
int Reduce(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
Reduce an array to the given destination process.
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 Scatter(const int *sendBuffer, int *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
general representation of visualization data
Definition: vtkDataObject.h:64
int GatherV(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
int AllReduce(const long *sendBuffer, long *recvBuffer, vtkIdType length, Operation *operation)
Same as Reduce except that the result is placed in all of the processes.
int Send(const char *data, vtkIdType length, int remoteHandle, int tag)
Convenience methods for sending data arrays.
int Reduce(const short *sendBuffer, short *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
Reduce an array to the given destination process.
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 long *sendBuffer, long *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
#define VTK_UNSIGNED_LONG_LONG
Definition: vtkType.h:68
int AllReduce(const int *sendBuffer, int *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
int Receive(unsigned short *data, vtkIdType maxlength, int remoteHandle, int tag)
Convenience methods for receiving data arrays.
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.
#define VTK_INT
Definition: vtkType.h:54
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(unsigned int *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes...
int Reduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
Reduce an array to the given destination process.
Fast Simple Class for dealing with 3D bounds.
int AllReduce(const short *sendBuffer, short *recvBuffer, vtkIdType length, Operation *operation)
Same as Reduce except that the result is placed in all of the processes.
int Reduce(const double *sendBuffer, double *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
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 Gather(const long *sendBuffer, long *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.