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 =========================================================================*/
32 #ifndef vtkCommunicator_h
33 #define vtkCommunicator_h
34 
35 #include "vtkParallelCoreModule.h" // For export macro
36 #include "vtkObject.h"
37 #include "vtkSmartPointer.h" // needed for vtkSmartPointer.
38 #include <vector> // needed for std::vector
39 
40 class vtkBoundingBox;
41 class vtkCharArray;
42 class vtkDataArray;
43 class vtkDataObject;
44 class vtkDataSet;
45 class vtkIdTypeArray;
46 class vtkImageData;
49 
50 class VTKPARALLELCORE_EXPORT vtkCommunicator : public vtkObject
51 {
52 
53 public:
54 
55  vtkTypeMacro(vtkCommunicator, vtkObject);
56  void PrintSelf(ostream& os, vtkIndent indent) override;
57 
59 
64  virtual void SetNumberOfProcesses(int num);
65  vtkGetMacro(NumberOfProcesses, int);
67 
69 
72  vtkGetMacro(LocalProcessId, int);
74 
75  enum Tags
76  {
77  BROADCAST_TAG = 10,
78  GATHER_TAG = 11,
79  GATHERV_TAG = 12,
80  SCATTER_TAG = 13,
81  SCATTERV_TAG = 14,
82  REDUCE_TAG = 15,
83  BARRIER_TAG = 16
84  };
85 
87  {
97  BITWISE_XOR_OP
98  };
99 
104  class Operation
105  {
106  public:
117  virtual void Function(const void *A, void *B, vtkIdType length,
118  int datatype) = 0;
119 
124  virtual int Commutative() = 0;
125 
126  virtual ~Operation() {}
127  };
128 
134  int Send(vtkDataObject* data, int remoteHandle, int tag);
135 
141  int Send(vtkDataArray* data, int remoteHandle, int tag);
142 
149  virtual int SendVoidArray(const void *data, vtkIdType length, int type,
150  int remoteHandle, int tag) = 0;
151 
153 
156  int Send(const int* data, vtkIdType length, int remoteHandle, int tag) {
157  return this->SendVoidArray(data, length, VTK_INT, remoteHandle, tag);
158  }
159  int Send(const unsigned int* data, vtkIdType length, int remoteHandle, int tag) {
160  return this->SendVoidArray(data, length, VTK_INT, remoteHandle, tag);
161  }
162  int Send(const short* data, vtkIdType length, int remoteHandle, int tag) {
163  return this->SendVoidArray(data, length, VTK_SHORT, remoteHandle, tag);
164  }
165  int Send(const unsigned short* data, vtkIdType length, int remoteHandle, int tag) {
166  return this->SendVoidArray(data, length, VTK_UNSIGNED_SHORT, remoteHandle, tag);
167  }
168  int Send(const long* data, vtkIdType length,
169  int remoteHandle, int tag) {
170  return this->SendVoidArray(data, length,VTK_LONG,remoteHandle,tag);
171  }
172  int Send(const unsigned long* data, vtkIdType length,
173  int remoteHandle, int tag) {
174  return this->SendVoidArray(data, length,VTK_UNSIGNED_LONG,remoteHandle,tag);
175  }
176  int Send(const unsigned char* data, vtkIdType length,
177  int remoteHandle, int tag) {
178  return this->SendVoidArray(data, length,VTK_UNSIGNED_CHAR,remoteHandle,tag);
179  }
180  int Send(const char* data, vtkIdType length, int remoteHandle, int tag) {
181  return this->SendVoidArray(data, length, VTK_CHAR, remoteHandle, tag);
182  }
183  int Send(const signed char* data, vtkIdType length, int remoteHandle, int tag) {
184  return this->SendVoidArray(data, length, VTK_SIGNED_CHAR, remoteHandle, tag);
185  }
186  int Send(const float* data, vtkIdType length, int remoteHandle, int tag) {
187  return this->SendVoidArray(data, length, VTK_FLOAT, remoteHandle, tag);
188  }
189  int Send(const double* data, vtkIdType length, int remoteHandle, int tag) {
190  return this->SendVoidArray(data, length, VTK_DOUBLE, remoteHandle, tag);
191  }
192  int Send(const long long* data, vtkIdType length, int remoteHandle, int tag) {
193  return this->SendVoidArray(data, length, VTK_LONG_LONG, remoteHandle, tag);
194  }
195  int Send(const unsigned long long* data, vtkIdType length, int remoteHandle, int tag) {
196  return this->SendVoidArray(data, length, VTK_UNSIGNED_LONG_LONG, remoteHandle, tag);
197  }
199 
200  int Send(const vtkMultiProcessStream& stream, int remoteId, int tag);
201 
206  int Receive(vtkDataObject* data, int remoteHandle, int tag);
207 
212  vtkDataObject *ReceiveDataObject(int remoteHandle, int tag);
213 
218  int Receive(vtkDataArray* data, int remoteHandle, int tag);
219 
230  virtual int ReceiveVoidArray(void *data, vtkIdType maxlength, int type,
231  int remoteHandle, int tag) = 0;
232 
234 
237  int Receive(int* data, vtkIdType maxlength, int remoteHandle, int tag) {
238  return this->ReceiveVoidArray(data, maxlength, VTK_INT, remoteHandle, tag);
239  }
240  int Receive(unsigned int* data, vtkIdType maxlength, int remoteHandle, int tag) {
241  return this->ReceiveVoidArray(data, maxlength, VTK_INT, remoteHandle, tag);
242  }
243  int Receive(short* data, vtkIdType maxlength, int remoteHandle, int tag) {
244  return this->ReceiveVoidArray(data, maxlength, VTK_SHORT, remoteHandle, tag);
245  }
246  int Receive(unsigned short* data, vtkIdType maxlength, int remoteHandle, int tag) {
247  return this->ReceiveVoidArray(data, maxlength, VTK_UNSIGNED_SHORT, remoteHandle, tag);
248  }
249  int Receive(long* data, vtkIdType maxlength, int remoteHandle, int tag) {
250  return this->ReceiveVoidArray(data, maxlength, VTK_LONG, remoteHandle, tag);
251  }
252  int Receive(unsigned long* data, vtkIdType maxlength, int remoteHandle, int tag){
253  return this->ReceiveVoidArray(data, maxlength, VTK_UNSIGNED_LONG, remoteHandle,
254  tag);
255  }
256  int Receive(unsigned char* data, vtkIdType maxlength, int remoteHandle, int tag){
257  return this->ReceiveVoidArray(data, maxlength, VTK_UNSIGNED_CHAR, remoteHandle,
258  tag);
259  }
260  int Receive(char* data, vtkIdType maxlength, int remoteHandle, int tag) {
261  return this->ReceiveVoidArray(data, maxlength, VTK_CHAR, remoteHandle, tag);
262  }
263  int Receive(signed char* data, vtkIdType maxlength, int remoteHandle, int tag) {
264  return this->ReceiveVoidArray(data, maxlength, VTK_SIGNED_CHAR, remoteHandle, tag);
265  }
266  int Receive(float* data, vtkIdType maxlength, int remoteHandle, int tag) {
267  return this->ReceiveVoidArray(data, maxlength, VTK_FLOAT, remoteHandle, tag);
268  }
269  int Receive(double* data, vtkIdType maxlength, int remoteHandle, int tag) {
270  return this->ReceiveVoidArray(data, maxlength, VTK_DOUBLE, remoteHandle, tag);
271  }
272  int Receive(long long* data, vtkIdType maxlength, int remoteHandle, int tag) {
273  return this->ReceiveVoidArray(data, maxlength, VTK_LONG_LONG, remoteHandle, tag);
274  }
275  int Receive(unsigned long long* data, vtkIdType maxlength, int remoteHandle, int tag) {
276  return this->ReceiveVoidArray(data, maxlength, VTK_UNSIGNED_LONG_LONG, remoteHandle, tag);
277  }
279 
280  int Receive(vtkMultiProcessStream& stream, int remoteId, int tag);
281 
283 
291  vtkGetMacro(Count, vtkIdType);
293 
294  //---------------------- Collective Operations ----------------------
295 
300  virtual void Barrier();
301 
303 
308  int Broadcast(int *data, vtkIdType length, int srcProcessId) {
309  return this->BroadcastVoidArray(data, length, VTK_INT, srcProcessId);
310  }
311  int Broadcast(unsigned int *data, vtkIdType length, int srcProcessId) {
312  return this->BroadcastVoidArray(data, length, VTK_UNSIGNED_INT, srcProcessId);
313  }
314  int Broadcast(short *data, vtkIdType length, int srcProcessId) {
315  return this->BroadcastVoidArray(data, length, VTK_SHORT, srcProcessId);
316  }
317  int Broadcast(unsigned short *data, vtkIdType length, int srcProcessId) {
318  return this->BroadcastVoidArray(data, length, VTK_UNSIGNED_SHORT, srcProcessId);
319  }
320  int Broadcast(long *data, vtkIdType length, int srcProcessId) {
321  return this->BroadcastVoidArray(data, length, VTK_LONG, srcProcessId);
322  }
323  int Broadcast(unsigned long *data, vtkIdType length, int srcProcessId) {
324  return this->BroadcastVoidArray(data,length,VTK_UNSIGNED_LONG,srcProcessId);
325  }
326  int Broadcast(unsigned char *data, vtkIdType length, int srcProcessId) {
327  return this->BroadcastVoidArray(data,length,VTK_UNSIGNED_CHAR,srcProcessId);
328  }
329  int Broadcast(char *data, vtkIdType length, int srcProcessId) {
330  return this->BroadcastVoidArray(data, length, VTK_CHAR, srcProcessId);
331  }
332  int Broadcast(signed char *data, vtkIdType length, int srcProcessId) {
333  return this->BroadcastVoidArray(data, length, VTK_SIGNED_CHAR, srcProcessId);
334  }
335  int Broadcast(float *data, vtkIdType length, int srcProcessId) {
336  return this->BroadcastVoidArray(data, length, VTK_FLOAT, srcProcessId);
337  }
338  int Broadcast(double *data, vtkIdType length, int srcProcessId) {
339  return this->BroadcastVoidArray(data, length, VTK_DOUBLE, srcProcessId);
340  }
341  int Broadcast(long long *data, vtkIdType length, int srcProcessId) {
342  return this->BroadcastVoidArray(data, length, VTK_LONG_LONG, srcProcessId);
343  }
344  int Broadcast(unsigned long long *data, vtkIdType length, int srcProcessId) {
345  return this->BroadcastVoidArray(data, length, VTK_UNSIGNED_LONG_LONG, srcProcessId);
346  }
347  int Broadcast(vtkDataObject *data, int srcProcessId);
348  int Broadcast(vtkDataArray *data, int srcProcessId);
350 
351  int Broadcast(vtkMultiProcessStream& stream, int srcProcessId);
352 
354 
363  int Gather(const int *sendBuffer, int *recvBuffer,
364  vtkIdType length, int destProcessId) {
365  return this->GatherVoidArray(sendBuffer, recvBuffer, length,
366  VTK_INT, destProcessId);
367  }
368  int Gather(const unsigned int *sendBuffer, unsigned int *recvBuffer,
369  vtkIdType length, int destProcessId) {
370  return this->GatherVoidArray(sendBuffer, recvBuffer, length,
371  VTK_UNSIGNED_INT, destProcessId);
372  }
373  int Gather(const short *sendBuffer, short *recvBuffer,
374  vtkIdType length, int destProcessId) {
375  return this->GatherVoidArray(sendBuffer, recvBuffer, length,
376  VTK_SHORT, destProcessId);
377  }
378  int Gather(const unsigned short *sendBuffer, unsigned short *recvBuffer,
379  vtkIdType length, int destProcessId) {
380  return this->GatherVoidArray(sendBuffer, recvBuffer, length,
381  VTK_UNSIGNED_SHORT, destProcessId);
382  }
383  int Gather(const long *sendBuffer, long *recvBuffer,
384  vtkIdType length, int destProcessId) {
385  return this->GatherVoidArray(sendBuffer, recvBuffer, length,
386  VTK_LONG, destProcessId);
387  }
388  int Gather(const unsigned long *sendBuffer, unsigned long *recvBuffer,
389  vtkIdType length, int destProcessId) {
390  return this->GatherVoidArray(sendBuffer, recvBuffer, length,
391  VTK_UNSIGNED_LONG, destProcessId);
392  }
393  int Gather(const unsigned char *sendBuffer, unsigned char *recvBuffer,
394  vtkIdType length, int destProcessId) {
395  return this->GatherVoidArray(sendBuffer, recvBuffer, length,
396  VTK_UNSIGNED_CHAR, destProcessId);
397  }
398  int Gather(const char *sendBuffer, char *recvBuffer,
399  vtkIdType length, int destProcessId) {
400  return this->GatherVoidArray(sendBuffer, recvBuffer, length,
401  VTK_CHAR, destProcessId);
402  }
403  int Gather(const signed char *sendBuffer, signed char *recvBuffer,
404  vtkIdType length, int destProcessId) {
405  return this->GatherVoidArray(sendBuffer, recvBuffer, length,
406  VTK_SIGNED_CHAR, destProcessId);
407  }
408  int Gather(const float *sendBuffer, float *recvBuffer,
409  vtkIdType length, int destProcessId) {
410  return this->GatherVoidArray(sendBuffer, recvBuffer, length,
411  VTK_FLOAT, destProcessId);
412  }
413  int Gather(const double *sendBuffer, double *recvBuffer,
414  vtkIdType length, int destProcessId) {
415  return this->GatherVoidArray(sendBuffer, recvBuffer, length,
416  VTK_DOUBLE, destProcessId);
417  }
418  int Gather(const long long *sendBuffer, long long *recvBuffer,
419  vtkIdType length, int destProcessId) {
420  return this->GatherVoidArray(sendBuffer, recvBuffer, length,
421  VTK_LONG_LONG, destProcessId);
422  }
423  int Gather(const unsigned long long *sendBuffer, unsigned long long *recvBuffer,
424  vtkIdType length, int destProcessId) {
425  return this->GatherVoidArray(sendBuffer, recvBuffer, length,
426  VTK_UNSIGNED_LONG_LONG, destProcessId);
427  }
428  int Gather(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
429  int destProcessId);
431 
444  int Gather(vtkDataObject* sendBuffer,
446  int destProcessId);
447 
449 
460  int GatherV(const int* sendBuffer, int* recvBuffer,
461  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
462  int destProcessId) {
463  return this->GatherVVoidArray(sendBuffer, recvBuffer,
464  sendLength, recvLengths,
465  offsets, VTK_INT, destProcessId);
466  }
467  int GatherV(const unsigned int* sendBuffer, unsigned int* recvBuffer,
468  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
469  int destProcessId) {
470  return this->GatherVVoidArray(sendBuffer, recvBuffer,
471  sendLength, recvLengths,
472  offsets, VTK_UNSIGNED_INT, destProcessId);
473  }
474  int GatherV(const short* sendBuffer, short* recvBuffer,
475  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
476  int destProcessId) {
477  return this->GatherVVoidArray(sendBuffer, recvBuffer,
478  sendLength, recvLengths,
479  offsets, VTK_SHORT, destProcessId);
480  }
481  int GatherV(const unsigned short* sendBuffer, unsigned short* recvBuffer,
482  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
483  int destProcessId) {
484  return this->GatherVVoidArray(sendBuffer, recvBuffer,
485  sendLength, recvLengths,
486  offsets, VTK_UNSIGNED_SHORT, destProcessId);
487  }
488  int GatherV(const long* sendBuffer, long* recvBuffer,
489  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
490  int destProcessId) {
491  return this->GatherVVoidArray(sendBuffer, recvBuffer,
492  sendLength, recvLengths,
493  offsets, VTK_LONG, destProcessId);
494  }
495  int GatherV(const unsigned long* sendBuffer, unsigned long* recvBuffer,
496  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
497  int destProcessId) {
498  return this->GatherVVoidArray(sendBuffer, recvBuffer,
499  sendLength, recvLengths,
500  offsets, VTK_UNSIGNED_LONG, destProcessId);
501  }
502  int GatherV(const unsigned char* sendBuffer, unsigned char* recvBuffer,
503  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
504  int destProcessId) {
505  return this->GatherVVoidArray(sendBuffer, recvBuffer,
506  sendLength, recvLengths,
507  offsets, VTK_UNSIGNED_CHAR, destProcessId);
508  }
509  int GatherV(const char* sendBuffer, char* recvBuffer,
510  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
511  int destProcessId) {
512  return this->GatherVVoidArray(sendBuffer, recvBuffer,
513  sendLength, recvLengths,
514  offsets, VTK_CHAR, destProcessId);
515  }
516  int GatherV(const signed char* sendBuffer, signed char* recvBuffer,
517  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
518  int destProcessId) {
519  return this->GatherVVoidArray(sendBuffer, recvBuffer,
520  sendLength, recvLengths,
521  offsets, VTK_SIGNED_CHAR, destProcessId);
522  }
523  int GatherV(const float* sendBuffer, float* recvBuffer,
524  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
525  int destProcessId) {
526  return this->GatherVVoidArray(sendBuffer, recvBuffer,
527  sendLength, recvLengths,
528  offsets, VTK_FLOAT, destProcessId);
529  }
530  int GatherV(const double* sendBuffer, double* recvBuffer,
531  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
532  int destProcessId) {
533  return this->GatherVVoidArray(sendBuffer, recvBuffer,
534  sendLength, recvLengths,
535  offsets, VTK_DOUBLE, destProcessId);
536  }
537  int GatherV(const long long* sendBuffer, long long* recvBuffer,
538  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
539  int destProcessId) {
540  return this->GatherVVoidArray(sendBuffer, recvBuffer,
541  sendLength, recvLengths,
542  offsets, VTK_LONG_LONG, destProcessId);
543  }
544  int GatherV(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
545  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
546  int destProcessId) {
547  return this->GatherVVoidArray(sendBuffer, recvBuffer,
548  sendLength, recvLengths,
549  offsets, VTK_UNSIGNED_LONG_LONG, destProcessId);
550  }
552 
553 
563  int GatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
564  vtkIdType *recvLengths, vtkIdType *offsets,
565  int destProcessId);
566  int GatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
567  vtkIdTypeArray* recvLengths,
568  vtkIdTypeArray* offsets,
569  int destProcessId);
570  int GatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
571  int destProcessId);
573 
581  int GatherV(vtkDataObject* sendData, vtkSmartPointer<vtkDataObject>* recvData,
582  int destProcessId);
583 
585 
592  int Scatter(const int *sendBuffer, int *recvBuffer,
593  vtkIdType length, int srcProcessId) {
594  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
595  VTK_INT, srcProcessId);
596  }
597  int Scatter(const unsigned int *sendBuffer, unsigned int *recvBuffer,
598  vtkIdType length, int srcProcessId) {
599  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
600  VTK_UNSIGNED_INT, srcProcessId);
601  }
602  int Scatter(const short *sendBuffer, short *recvBuffer,
603  vtkIdType length, int srcProcessId) {
604  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
605  VTK_SHORT, srcProcessId);
606  }
607  int Scatter(const unsigned short *sendBuffer, unsigned short *recvBuffer,
608  vtkIdType length, int srcProcessId) {
609  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
610  VTK_UNSIGNED_SHORT, srcProcessId);
611  }
612  int Scatter(const long *sendBuffer, long *recvBuffer,
613  vtkIdType length, int srcProcessId) {
614  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
615  VTK_INT, srcProcessId);
616  }
617  int Scatter(const unsigned long *sendBuffer, unsigned long *recvBuffer,
618  vtkIdType length, int srcProcessId) {
619  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
620  VTK_UNSIGNED_LONG, srcProcessId);
621  }
622  int Scatter(const unsigned char *sendBuffer, unsigned char *recvBuffer,
623  vtkIdType length, int srcProcessId) {
624  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
625  VTK_UNSIGNED_CHAR, srcProcessId);
626  }
627  int Scatter(const char *sendBuffer, char *recvBuffer,
628  vtkIdType length, int srcProcessId) {
629  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
630  VTK_CHAR, srcProcessId);
631  }
632  int Scatter(const signed char *sendBuffer, signed char *recvBuffer,
633  vtkIdType length, int srcProcessId) {
634  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
635  VTK_SIGNED_CHAR, srcProcessId);
636  }
637  int Scatter(const float *sendBuffer, float *recvBuffer,
638  vtkIdType length, int srcProcessId) {
639  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
640  VTK_FLOAT, srcProcessId);
641  }
642  int Scatter(const double *sendBuffer, double *recvBuffer,
643  vtkIdType length, int srcProcessId) {
644  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
645  VTK_DOUBLE, srcProcessId);
646  }
647  int Scatter(const long long *sendBuffer, long long *recvBuffer,
648  vtkIdType length, int srcProcessId) {
649  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
650  VTK_LONG_LONG, srcProcessId);
651  }
652  int Scatter(const unsigned long long *sendBuffer, unsigned long long *recvBuffer,
653  vtkIdType length, int srcProcessId) {
654  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
655  VTK_UNSIGNED_LONG_LONG, srcProcessId);
656  }
657  int Scatter(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
658  int srcProcessId);
660 
662 
669  int ScatterV(const int *sendBuffer, int *recvBuffer,
670  vtkIdType *sendLengths, vtkIdType *offsets,
671  vtkIdType recvLength, int srcProcessId) {
672  return this->ScatterVVoidArray(sendBuffer, recvBuffer,
673  sendLengths, offsets, recvLength,
674  VTK_INT, srcProcessId);
675  }
676  int ScatterV(const unsigned int *sendBuffer, unsigned int *recvBuffer,
677  vtkIdType *sendLengths, vtkIdType *offsets,
678  vtkIdType recvLength, int srcProcessId) {
679  return this->ScatterVVoidArray(sendBuffer, recvBuffer,
680  sendLengths, offsets, recvLength,
681  VTK_UNSIGNED_INT, srcProcessId);
682  }
683  int ScatterV(const short *sendBuffer, short *recvBuffer,
684  vtkIdType *sendLengths, vtkIdType *offsets,
685  vtkIdType recvLength, int srcProcessId) {
686  return this->ScatterVVoidArray(sendBuffer, recvBuffer,
687  sendLengths, offsets, recvLength,
688  VTK_SHORT, srcProcessId);
689  }
690  int ScatterV(const unsigned short *sendBuffer, unsigned short *recvBuffer,
691  vtkIdType *sendLengths, vtkIdType *offsets,
692  vtkIdType recvLength, int srcProcessId) {
693  return this->ScatterVVoidArray(sendBuffer, recvBuffer,
694  sendLengths, offsets, recvLength,
695  VTK_UNSIGNED_SHORT, srcProcessId);
696  }
697  int ScatterV(const long *sendBuffer, long *recvBuffer,
698  vtkIdType *sendLengths, vtkIdType *offsets,
699  vtkIdType recvLength, int srcProcessId) {
700  return this->ScatterVVoidArray(sendBuffer, recvBuffer,
701  sendLengths, offsets, recvLength,
702  VTK_LONG, srcProcessId);
703  }
704  int ScatterV(const unsigned long *sendBuffer, unsigned long *recvBuffer,
705  vtkIdType *sendLengths, vtkIdType *offsets,
706  vtkIdType recvLength, int srcProcessId) {
707  return this->ScatterVVoidArray(sendBuffer, recvBuffer,
708  sendLengths, offsets, recvLength,
709  VTK_UNSIGNED_LONG, srcProcessId);
710  }
711  int ScatterV(const unsigned char *sendBuffer, unsigned char *recvBuffer,
712  vtkIdType *sendLengths, vtkIdType *offsets,
713  vtkIdType recvLength, int srcProcessId) {
714  return this->ScatterVVoidArray(sendBuffer, recvBuffer,
715  sendLengths, offsets, recvLength,
716  VTK_UNSIGNED_CHAR, srcProcessId);
717  }
718  int ScatterV(const char *sendBuffer, char *recvBuffer,
719  vtkIdType *sendLengths, vtkIdType *offsets,
720  vtkIdType recvLength, int srcProcessId) {
721  return this->ScatterVVoidArray(sendBuffer, recvBuffer,
722  sendLengths, offsets, recvLength,
723  VTK_CHAR, srcProcessId);
724  }
725  int ScatterV(const signed char *sendBuffer, signed char *recvBuffer,
726  vtkIdType *sendLengths, vtkIdType *offsets,
727  vtkIdType recvLength, int srcProcessId) {
728  return this->ScatterVVoidArray(sendBuffer, recvBuffer,
729  sendLengths, offsets, recvLength,
730  VTK_SIGNED_CHAR, srcProcessId);
731  }
732  int ScatterV(const float *sendBuffer, float *recvBuffer,
733  vtkIdType *sendLengths, vtkIdType *offsets,
734  vtkIdType recvLength, int srcProcessId) {
735  return this->ScatterVVoidArray(sendBuffer, recvBuffer,
736  sendLengths, offsets, recvLength,
737  VTK_FLOAT, srcProcessId);
738  }
739  int ScatterV(const double *sendBuffer, double *recvBuffer,
740  vtkIdType *sendLengths, vtkIdType *offsets,
741  vtkIdType recvLength, int srcProcessId) {
742  return this->ScatterVVoidArray(sendBuffer, recvBuffer,
743  sendLengths, offsets, recvLength,
744  VTK_DOUBLE, srcProcessId);
745  }
746  int ScatterV(const long long *sendBuffer, long long *recvBuffer,
747  vtkIdType *sendLengths, vtkIdType *offsets,
748  vtkIdType recvLength, int srcProcessId) {
749  return this->ScatterVVoidArray(sendBuffer, recvBuffer,
750  sendLengths, offsets, recvLength,
751  VTK_LONG_LONG, srcProcessId);
752  }
753  int ScatterV(const unsigned long long *sendBuffer, unsigned long long *recvBuffer,
754  vtkIdType *sendLengths, vtkIdType *offsets,
755  vtkIdType recvLength, int srcProcessId) {
756  return this->ScatterVVoidArray(sendBuffer, recvBuffer,
757  sendLengths, offsets, recvLength,
758  VTK_UNSIGNED_LONG_LONG, srcProcessId);
759  }
761 
763 
766  int AllGather(const int *sendBuffer, int *recvBuffer, vtkIdType length) {
767  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_INT);
768  }
769  int AllGather(const unsigned int *sendBuffer, unsigned int *recvBuffer,
770  vtkIdType length) {
771  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length,
773  }
774  int AllGather(const short *sendBuffer, short *recvBuffer, vtkIdType length) {
775  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_SHORT);
776  }
777  int AllGather(const unsigned short *sendBuffer, unsigned short *recvBuffer,
778  vtkIdType length) {
779  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length,
781  }
782  int AllGather(const long *sendBuffer, long *recvBuffer, vtkIdType length) {
783  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_LONG);
784  }
785  int AllGather(const unsigned long *sendBuffer,
786  unsigned long *recvBuffer, vtkIdType length) {
787  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length,
789  }
790  int AllGather(const unsigned char *sendBuffer,
791  unsigned char *recvBuffer, vtkIdType length) {
792  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length,
794  }
795  int AllGather(const char *sendBuffer, char *recvBuffer, vtkIdType length) {
796  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_CHAR);
797  }
798  int AllGather(const signed char *sendBuffer, signed char *recvBuffer,
799  vtkIdType length) {
800  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length,
802  }
803  int AllGather(const float *sendBuffer, float *recvBuffer, vtkIdType length) {
804  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_FLOAT);
805  }
806  int AllGather(const double *sendBuffer,
807  double *recvBuffer, vtkIdType length) {
808  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_DOUBLE);
809  }
810  int AllGather(const long long *sendBuffer, long long *recvBuffer,
811  vtkIdType length) {
812  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length,
813  VTK_LONG_LONG);
814  }
815  int AllGather(const unsigned long long *sendBuffer,
816  unsigned long long *recvBuffer, vtkIdType length) {
817  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length,
819  }
820  int AllGather(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer);
822 
824 
827  int AllGatherV(const int* sendBuffer, int* recvBuffer,
828  vtkIdType sendLength, vtkIdType* recvLengths,
829  vtkIdType* offsets) {
830  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
831  sendLength, recvLengths,
832  offsets, VTK_INT);
833  }
834  int AllGatherV(const unsigned int* sendBuffer, unsigned int* recvBuffer,
835  vtkIdType sendLength, vtkIdType* recvLengths,
836  vtkIdType* offsets) {
837  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
838  sendLength, recvLengths,
839  offsets, VTK_UNSIGNED_INT);
840  }
841  int AllGatherV(const short* sendBuffer, short* recvBuffer,
842  vtkIdType sendLength, vtkIdType* recvLengths,
843  vtkIdType* offsets) {
844  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
845  sendLength, recvLengths,
846  offsets, VTK_SHORT);
847  }
848  int AllGatherV(const unsigned short* sendBuffer, unsigned short* recvBuffer,
849  vtkIdType sendLength, vtkIdType* recvLengths,
850  vtkIdType* offsets) {
851  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
852  sendLength, recvLengths,
853  offsets, VTK_UNSIGNED_SHORT);
854  }
855  int AllGatherV(const long* sendBuffer, long* recvBuffer,
856  vtkIdType sendLength, vtkIdType* recvLengths,
857  vtkIdType* offsets) {
858  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
859  sendLength, recvLengths,
860  offsets, VTK_LONG);
861  }
862  int AllGatherV(const unsigned long* sendBuffer, unsigned long* recvBuffer,
863  vtkIdType sendLength, vtkIdType* recvLengths,
864  vtkIdType* offsets) {
865  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
866  sendLength, recvLengths,
867  offsets, VTK_UNSIGNED_LONG);
868  }
869  int AllGatherV(const unsigned char* sendBuffer, unsigned char* recvBuffer,
870  vtkIdType sendLength, vtkIdType* recvLengths,
871  vtkIdType* offsets) {
872  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
873  sendLength, recvLengths,
874  offsets, VTK_UNSIGNED_CHAR);
875  }
876  int AllGatherV(const char* sendBuffer, char* recvBuffer,
877  vtkIdType sendLength, vtkIdType* recvLengths,
878  vtkIdType* offsets) {
879  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
880  sendLength, recvLengths,
881  offsets, VTK_CHAR);
882  }
883  int AllGatherV(const signed char* sendBuffer, signed char* recvBuffer,
884  vtkIdType sendLength, vtkIdType* recvLengths,
885  vtkIdType* offsets) {
886  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
887  sendLength, recvLengths,
888  offsets, VTK_UNSIGNED_CHAR);
889  }
890  int AllGatherV(const float* sendBuffer, float* recvBuffer,
891  vtkIdType sendLength, vtkIdType* recvLengths,
892  vtkIdType* offsets) {
893  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
894  sendLength, recvLengths,
895  offsets, VTK_FLOAT);
896  }
897  int AllGatherV(const double* sendBuffer, double* recvBuffer,
898  vtkIdType sendLength, vtkIdType* recvLengths,
899  vtkIdType* offsets) {
900  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
901  sendLength, recvLengths,
902  offsets, VTK_DOUBLE);
903  }
904  int AllGatherV(const long long* sendBuffer, long long* recvBuffer,
905  vtkIdType sendLength, vtkIdType* recvLengths,
906  vtkIdType* offsets) {
907  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
908  sendLength, recvLengths,
909  offsets, VTK_LONG_LONG);
910  }
911  int AllGatherV(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
912  vtkIdType sendLength, vtkIdType* recvLengths,
913  vtkIdType* offsets) {
914  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
915  sendLength, recvLengths,
916  offsets, VTK_UNSIGNED_LONG_LONG);
917  }
918  int AllGatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
919  vtkIdType *recvLengths, vtkIdType *offsets);
920  int AllGatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer);
922 
924 
929  int Reduce(const int *sendBuffer, int *recvBuffer,
930  vtkIdType length, int operation, int destProcessId) {
931  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
932  VTK_INT, operation, destProcessId);
933  }
934  int Reduce(const unsigned int *sendBuffer, unsigned int *recvBuffer,
935  vtkIdType length, int operation, int destProcessId) {
936  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
937  VTK_UNSIGNED_INT, operation, destProcessId);
938  }
939  int Reduce(const short *sendBuffer, short *recvBuffer,
940  vtkIdType length, int operation, int destProcessId) {
941  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
942  VTK_SHORT, operation, destProcessId);
943  }
944  int Reduce(const unsigned short *sendBuffer, unsigned short *recvBuffer,
945  vtkIdType length, int operation, int destProcessId) {
946  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
947  VTK_UNSIGNED_SHORT, operation, destProcessId);
948  }
949  int Reduce(const long *sendBuffer, long *recvBuffer,
950  vtkIdType length, int operation, int destProcessId) {
951  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
952  VTK_LONG, operation, destProcessId);
953  }
954  int Reduce(const unsigned long *sendBuffer, unsigned long *recvBuffer,
955  vtkIdType length, int operation, int destProcessId) {
956  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
957  VTK_UNSIGNED_LONG, operation, destProcessId);
958  }
959  int Reduce(const unsigned char *sendBuffer, unsigned char *recvBuffer,
960  vtkIdType length, int operation, int destProcessId) {
961  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
962  VTK_UNSIGNED_CHAR, operation, destProcessId);
963  }
964  int Reduce(const char *sendBuffer, char *recvBuffer,
965  vtkIdType length, int operation, int destProcessId) {
966  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
967  VTK_CHAR, operation, destProcessId);
968  }
969  int Reduce(const signed char *sendBuffer, signed char *recvBuffer,
970  vtkIdType length, int operation, int destProcessId) {
971  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
972  VTK_SIGNED_CHAR, operation, destProcessId);
973  }
974  int Reduce(const float *sendBuffer, float *recvBuffer,
975  vtkIdType length, int operation, int destProcessId) {
976  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
977  VTK_FLOAT, operation, destProcessId);
978  }
979  int Reduce(const double *sendBuffer, double *recvBuffer,
980  vtkIdType length, int operation, int destProcessId) {
981  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
982  VTK_DOUBLE, operation, destProcessId);
983  }
984  int Reduce(const long long *sendBuffer, long long *recvBuffer,
985  vtkIdType length, int operation, int destProcessId) {
986  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
987  VTK_LONG_LONG, operation, destProcessId);
988  }
989  int Reduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer,
990  vtkIdType length, int operation, int destProcessId) {
991  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
992  VTK_UNSIGNED_LONG_LONG, operation, destProcessId);
993  }
994  int Reduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
995  int operation, int destProcessId);
997 
999 
1003  int Reduce(const int *sendBuffer, int *recvBuffer,
1004  vtkIdType length, Operation *operation, int destProcessId) {
1005  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1006  VTK_INT, operation, destProcessId);
1007  }
1008  int Reduce(const unsigned int *sendBuffer, unsigned int *recvBuffer,
1009  vtkIdType length, Operation *operation, int destProcessId) {
1010  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1011  VTK_UNSIGNED_INT, operation, destProcessId);
1012  }
1013  int Reduce(const short *sendBuffer, short *recvBuffer,
1014  vtkIdType length, Operation *operation, int destProcessId) {
1015  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1016  VTK_SHORT, operation, destProcessId);
1017  }
1018  int Reduce(const unsigned short *sendBuffer, unsigned short *recvBuffer,
1019  vtkIdType length, Operation *operation, int destProcessId) {
1020  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1021  VTK_UNSIGNED_SHORT, operation, destProcessId);
1022  }
1023  int Reduce(const long *sendBuffer, long *recvBuffer,
1024  vtkIdType length, Operation *operation, int destProcessId) {
1025  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1026  VTK_LONG, operation, destProcessId);
1027  }
1028  int Reduce(const unsigned long *sendBuffer, unsigned long *recvBuffer,
1029  vtkIdType length, Operation *operation, int destProcessId) {
1030  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1031  VTK_UNSIGNED_LONG, operation, destProcessId);
1032  }
1033  int Reduce(const unsigned char *sendBuffer, unsigned char *recvBuffer,
1034  vtkIdType length, Operation *operation, int destProcessId) {
1035  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1036  VTK_UNSIGNED_CHAR, operation, destProcessId);
1037  }
1038  int Reduce(const char *sendBuffer, char *recvBuffer,
1039  vtkIdType length, Operation *operation, int destProcessId) {
1040  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1041  VTK_CHAR, operation, destProcessId);
1042  }
1043  int Reduce(const signed char *sendBuffer, signed char *recvBuffer,
1044  vtkIdType length, Operation *operation, int destProcessId) {
1045  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1046  VTK_SIGNED_CHAR, operation, destProcessId);
1047  }
1048  int Reduce(const float *sendBuffer, float *recvBuffer,
1049  vtkIdType length, Operation *operation, int destProcessId) {
1050  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1051  VTK_FLOAT, operation, destProcessId);
1052  }
1053  int Reduce(const double *sendBuffer, double *recvBuffer,
1054  vtkIdType length, Operation *operation, int destProcessId) {
1055  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1056  VTK_DOUBLE, operation, destProcessId);
1057  }
1058  int Reduce(const long long *sendBuffer, long long *recvBuffer,
1059  vtkIdType length, Operation *operation, int destProcessId) {
1060  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1061  VTK_LONG_LONG, operation, destProcessId);
1062  }
1063  int Reduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer,
1064  vtkIdType length, Operation *operation, int destProcessId) {
1065  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1066  VTK_UNSIGNED_LONG_LONG, operation, destProcessId);
1067  }
1068  int Reduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
1069  Operation *operation, int destProcessId);
1071 
1073 
1076  int AllReduce(const int *sendBuffer, int *recvBuffer,
1077  vtkIdType length, int operation) {
1078  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1079  VTK_INT, operation);
1080  }
1081  int AllReduce(const unsigned int *sendBuffer, unsigned int *recvBuffer,
1082  vtkIdType length, int operation) {
1083  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1084  VTK_UNSIGNED_INT, operation);
1085  }
1086  int AllReduce(const short *sendBuffer, short *recvBuffer,
1087  vtkIdType length, int operation) {
1088  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1089  VTK_SHORT, operation);
1090  }
1091  int AllReduce(const unsigned short *sendBuffer, unsigned short *recvBuffer,
1092  vtkIdType length, int operation) {
1093  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1094  VTK_UNSIGNED_SHORT, operation);
1095  }
1096  int AllReduce(const long *sendBuffer, long *recvBuffer,
1097  vtkIdType length, int operation) {
1098  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1099  VTK_LONG, operation);
1100  }
1101  int AllReduce(const unsigned long *sendBuffer, unsigned long *recvBuffer,
1102  vtkIdType length, int operation) {
1103  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1104  VTK_UNSIGNED_LONG, operation);
1105  }
1106  int AllReduce(const unsigned char *sendBuffer, unsigned char *recvBuffer,
1107  vtkIdType length, int operation) {
1108  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1109  VTK_UNSIGNED_CHAR, operation);
1110  }
1111  int AllReduce(const char *sendBuffer, char *recvBuffer,
1112  vtkIdType length, int operation) {
1113  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1114  VTK_CHAR, operation);
1115  }
1116  int AllReduce(const signed char *sendBuffer, signed char *recvBuffer,
1117  vtkIdType length, int operation) {
1118  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1119  VTK_SIGNED_CHAR, operation);
1120  }
1121  int AllReduce(const float *sendBuffer, float *recvBuffer,
1122  vtkIdType length, int operation) {
1123  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1124  VTK_FLOAT, operation);
1125  }
1126  int AllReduce(const double *sendBuffer, double *recvBuffer,
1127  vtkIdType length, int operation) {
1128  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1129  VTK_DOUBLE, operation);
1130  }
1131  int AllReduce(const long long *sendBuffer, long long *recvBuffer,
1132  vtkIdType length, int operation) {
1133  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1134  VTK_LONG_LONG, operation);
1135  }
1136  int AllReduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer,
1137  vtkIdType length, int operation) {
1138  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1139  VTK_UNSIGNED_LONG_LONG, operation);
1140  }
1141  int AllReduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
1142  int operation);
1143  int AllReduce(const int *sendBuffer, int *recvBuffer,
1144  vtkIdType length, Operation *operation) {
1145  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1146  VTK_INT, operation);
1147  }
1148  int AllReduce(const unsigned int *sendBuffer, unsigned int *recvBuffer,
1149  vtkIdType length, Operation *operation) {
1150  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1151  VTK_UNSIGNED_INT, operation);
1152  }
1153  int AllReduce(const short *sendBuffer, short *recvBuffer,
1154  vtkIdType length, Operation *operation) {
1155  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1156  VTK_SHORT, operation);
1157  }
1158  int AllReduce(const unsigned short *sendBuffer, unsigned short *recvBuffer,
1159  vtkIdType length, Operation *operation) {
1160  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1161  VTK_UNSIGNED_SHORT, operation);
1162  }
1163  int AllReduce(const long *sendBuffer, long *recvBuffer,
1164  vtkIdType length, Operation *operation) {
1165  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1166  VTK_LONG, operation);
1167  }
1168  int AllReduce(const unsigned long *sendBuffer, unsigned long *recvBuffer,
1169  vtkIdType length, Operation *operation) {
1170  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1171  VTK_UNSIGNED_LONG, operation);
1172  }
1173  int AllReduce(const unsigned char *sendBuffer, unsigned char *recvBuffer,
1174  vtkIdType length, Operation *operation) {
1175  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1176  VTK_UNSIGNED_CHAR, operation);
1177  }
1178  int AllReduce(const char *sendBuffer, char *recvBuffer,
1179  vtkIdType length, Operation *operation) {
1180  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1181  VTK_CHAR, operation);
1182  }
1183  int AllReduce(const signed char *sendBuffer, signed char *recvBuffer,
1184  vtkIdType length, Operation *operation) {
1185  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1186  VTK_SIGNED_CHAR, operation);
1187  }
1188  int AllReduce(const float *sendBuffer, float *recvBuffer,
1189  vtkIdType length, Operation *operation) {
1190  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1191  VTK_FLOAT, operation);
1192  }
1193  int AllReduce(const double *sendBuffer, double *recvBuffer,
1194  vtkIdType length, Operation *operation) {
1195  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1196  VTK_DOUBLE, operation);
1197  }
1198  int AllReduce(const long long *sendBuffer, long long *recvBuffer,
1199  vtkIdType length, Operation *operation) {
1200  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1201  VTK_LONG_LONG, operation);
1202  }
1203  int AllReduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer,
1204  vtkIdType length, Operation *operation) {
1205  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1206  VTK_UNSIGNED_LONG_LONG, operation);
1207  }
1208  int AllReduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
1209  Operation *operation);
1211 
1213 
1217  virtual int BroadcastVoidArray(void *data, vtkIdType length, int type,
1218  int srcProcessId);
1219  virtual int GatherVoidArray(const void *sendBuffer, void *recvBuffer,
1220  vtkIdType length, int type, int destProcessId);
1221  virtual int GatherVVoidArray(const void *sendBuffer, void *recvBuffer,
1222  vtkIdType sendLength, vtkIdType *recvLengths,
1223  vtkIdType *offsets, int type, int destProcessId);
1224  virtual int ScatterVoidArray(const void *sendBuffer, void *recvBuffer,
1225  vtkIdType length, int type, int srcProcessId);
1226  virtual int ScatterVVoidArray(const void *sendBuffer, void *recvBuffer,
1227  vtkIdType *sendLengths, vtkIdType *offsets,
1228  vtkIdType recvLength, int type,
1229  int srcProcessId);
1230  virtual int AllGatherVoidArray(const void *sendBuffer, void *recvBuffer,
1231  vtkIdType length, int type);
1232  virtual int AllGatherVVoidArray(const void *sendBuffer, void *recvBuffer,
1233  vtkIdType sendLength, vtkIdType *recvLengths,
1234  vtkIdType *offsets, int type);
1235  virtual int ReduceVoidArray(const void *sendBuffer, void *recvBuffer,
1236  vtkIdType length, int type,
1237  int operation, int destProcessId);
1238  virtual int ReduceVoidArray(const void *sendBuffer, void *recvBuffer,
1239  vtkIdType length, int type,
1240  Operation *operation, int destProcessId);
1241  virtual int AllReduceVoidArray(const void *sendBuffer, void *recvBuffer,
1242  vtkIdType length, int type,
1243  int operation);
1244  virtual int AllReduceVoidArray(const void *sendBuffer, void *recvBuffer,
1245  vtkIdType length, int type,
1246  Operation *operation);
1248 
1249  static void SetUseCopy(int useCopy);
1250 
1262  virtual int ComputeGlobalBounds(int processorId, int numProcesses,
1263  vtkBoundingBox *bounds,
1264  int *rightHasBounds = nullptr,
1265  int *leftHasBounds = nullptr,
1266  int hasBoundsTag = 288402,
1267  int localBoundsTag = 288403,
1268  int globalBoundsTag = 288404);
1269 
1271 
1276  static int GetParentProcessor(int pid);
1277  static int GetLeftChildProcessor(int pid);
1279 
1281 
1286  static int MarshalDataObject(vtkDataObject *object, vtkCharArray *buffer);
1287  static int UnMarshalDataObject(vtkCharArray *buffer, vtkDataObject *object);
1289 
1296  static vtkSmartPointer<vtkDataObject> UnMarshalDataObject(vtkCharArray* buffer);
1297 
1298 protected:
1299 
1300  int WriteDataArray(vtkDataArray *object);
1301  int ReadDataArray(vtkDataArray *object);
1302 
1303  vtkCommunicator();
1304  ~vtkCommunicator() override;
1305 
1306  // Internal methods called by Send/Receive(vtkDataObject *... ) above.
1307  int SendElementalDataObject(vtkDataObject* data, int remoteHandle, int tag);
1309 
1317  int GatherV(vtkDataArray *sendArray, vtkDataArray* recvArray,
1318  vtkSmartPointer<vtkDataArray>* recvArrays, int destProcessId);
1319  int GatherVElementalDataObject(vtkDataObject* sendData,
1320  vtkSmartPointer<vtkDataObject>* receiveData,
1321  int destProcessId);
1323 
1324  int ReceiveDataObject(vtkDataObject* data,
1325  int remoteHandle, int tag, int type=-1);
1326  int ReceiveElementalDataObject(vtkDataObject* data,
1327  int remoteHandle, int tag);
1328  int ReceiveMultiBlockDataSet(
1329  vtkMultiBlockDataSet* data, int remoteHandle, int tag);
1330 
1333 
1335 
1336  static int UseCopy;
1337 
1339 
1340 private:
1341  vtkCommunicator(const vtkCommunicator&) = delete;
1342  void operator=(const vtkCommunicator&) = delete;
1343 };
1344 
1345 #endif // vtkCommunicator_h
1346 // 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:53
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:56
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:345
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:35
#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:33
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:39
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:48
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:58
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.