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 =========================================================================*/
34 #ifndef vtkCommunicator_h
35 #define vtkCommunicator_h
36 
37 #include "vtkParallelCoreModule.h" // For export macro
38 #include "vtkObject.h"
39 #include "vtkSmartPointer.h"
40 
41 class vtkBoundingBox;
42 class vtkCharArray;
43 class vtkDataArray;
44 class vtkDataObject;
45 class vtkDataSet;
46 class vtkIdTypeArray;
47 class vtkImageData;
50 
52 {
53 
54 public:
55 
56  vtkTypeMacro(vtkCommunicator, vtkObject);
57  void PrintSelf(ostream& os, vtkIndent indent);
58 
60 
63  virtual void SetNumberOfProcesses(int num);
64  vtkGetMacro(NumberOfProcesses, int);
66 
68 
69  vtkGetMacro(LocalProcessId, int);
71 
72 //BTX
73 
74  enum Tags
75  {
76  BROADCAST_TAG = 10,
77  GATHER_TAG = 11,
78  GATHERV_TAG = 12,
79  SCATTER_TAG = 13,
80  SCATTERV_TAG = 14,
81  REDUCE_TAG = 15,
82  BARRIER_TAG = 16
83  };
84 
86  {
96  BITWISE_XOR_OP
97  };
98 
100 
102  class Operation
103  {
104  public:
106 
107 
116  virtual void Function(const void *A, void *B, vtkIdType length,
117  int datatype) = 0;
119 
122  virtual int Commutative() = 0;
123 
124  virtual ~Operation() {}
125  };
126 
127 //ETX
128 
131  int Send(vtkDataObject* data, int remoteHandle, int tag);
132 
135  int Send(vtkDataArray* data, int remoteHandle, int tag);
136 
138 
142  virtual int SendVoidArray(const void *data, vtkIdType length, int type,
143  int remoteHandle, int tag) = 0;
145 
147 
148  int Send(const int* data, vtkIdType length, int remoteHandle, int tag) {
149  return this->SendVoidArray(data, length, VTK_INT, remoteHandle, tag);
150  }
151  int Send(const unsigned int* data, vtkIdType length, int remoteHandle, int tag) {
152  return this->SendVoidArray(data, length, VTK_INT, remoteHandle, tag);
153  }
154  int Send(const short* data, vtkIdType length, int remoteHandle, int tag) {
155  return this->SendVoidArray(data, length, VTK_SHORT, remoteHandle, tag);
156  }
157  int Send(const unsigned short* data, vtkIdType length, int remoteHandle, int tag) {
158  return this->SendVoidArray(data, length, VTK_UNSIGNED_SHORT, remoteHandle, tag);
159  }
160  int Send(const long* data, vtkIdType length,
161  int remoteHandle, int tag) {
162  return this->SendVoidArray(data, length,VTK_LONG,remoteHandle,tag);
163  }
164  int Send(const unsigned long* data, vtkIdType length,
165  int remoteHandle, int tag) {
166  return this->SendVoidArray(data, length,VTK_UNSIGNED_LONG,remoteHandle,tag);
167  }
168  int Send(const unsigned char* data, vtkIdType length,
169  int remoteHandle, int tag) {
170  return this->SendVoidArray(data, length,VTK_UNSIGNED_CHAR,remoteHandle,tag);
171  }
172  int Send(const char* data, vtkIdType length, int remoteHandle, int tag) {
173  return this->SendVoidArray(data, length, VTK_CHAR, remoteHandle, tag);
174  }
175  int Send(const signed char* data, vtkIdType length, int remoteHandle, int tag) {
176  return this->SendVoidArray(data, length, VTK_SIGNED_CHAR, remoteHandle, tag);
177  }
178  int Send(const float* data, vtkIdType length, int remoteHandle, int tag) {
179  return this->SendVoidArray(data, length, VTK_FLOAT, remoteHandle, tag);
180  }
181  int Send(const double* data, vtkIdType length, int remoteHandle, int tag) {
182  return this->SendVoidArray(data, length, VTK_DOUBLE, remoteHandle, tag);
183  }
184 #ifdef VTK_USE_64BIT_IDS
185  int Send(const vtkIdType* data, vtkIdType length, int remoteHandle, int tag) {
186  return this->SendVoidArray(data, length, VTK_ID_TYPE, remoteHandle, tag);
187  }
188 #else
189  int Send(const long long* data, vtkIdType length, int remoteHandle, int tag) {
190  return this->SendVoidArray(data, length, VTK_LONG_LONG, remoteHandle, tag);
191  }
192 #endif
193  int Send(const unsigned long long* data, vtkIdType length, int remoteHandle, int tag) {
194  return this->SendVoidArray(data, length, VTK_UNSIGNED_LONG_LONG, remoteHandle, tag);
195  }
196 //BTX
197  int Send(const vtkMultiProcessStream& stream, int remoteId, int tag);
198 //ETX
200 
201 
204  int Receive(vtkDataObject* data, int remoteHandle, int tag);
205 
208  vtkDataObject *ReceiveDataObject(int remoteHandle, int tag);
209 
212  int Receive(vtkDataArray* data, int remoteHandle, int tag);
213 
215 
223  virtual int ReceiveVoidArray(void *data, vtkIdType maxlength, int type,
224  int remoteHandle, int tag) = 0;
226 
228 
229  int Receive(int* data, vtkIdType maxlength, int remoteHandle, int tag) {
230  return this->ReceiveVoidArray(data, maxlength, VTK_INT, remoteHandle, tag);
231  }
232  int Receive(unsigned int* data, vtkIdType maxlength, int remoteHandle, int tag) {
233  return this->ReceiveVoidArray(data, maxlength, VTK_INT, remoteHandle, tag);
234  }
235  int Receive(short* data, vtkIdType maxlength, int remoteHandle, int tag) {
236  return this->ReceiveVoidArray(data, maxlength, VTK_SHORT, remoteHandle, tag);
237  }
238  int Receive(unsigned short* data, vtkIdType maxlength, int remoteHandle, int tag) {
239  return this->ReceiveVoidArray(data, maxlength, VTK_UNSIGNED_SHORT, remoteHandle, tag);
240  }
241  int Receive(long* data, vtkIdType maxlength, int remoteHandle, int tag) {
242  return this->ReceiveVoidArray(data, maxlength, VTK_LONG, remoteHandle, tag);
243  }
244  int Receive(unsigned long* data, vtkIdType maxlength, int remoteHandle, int tag){
245  return this->ReceiveVoidArray(data, maxlength, VTK_UNSIGNED_LONG, remoteHandle,
246  tag);
247  }
248  int Receive(unsigned char* data, vtkIdType maxlength, int remoteHandle, int tag){
249  return this->ReceiveVoidArray(data, maxlength, VTK_UNSIGNED_CHAR, remoteHandle,
250  tag);
251  }
252  int Receive(char* data, vtkIdType maxlength, int remoteHandle, int tag) {
253  return this->ReceiveVoidArray(data, maxlength, VTK_CHAR, remoteHandle, tag);
254  }
255  int Receive(signed char* data, vtkIdType maxlength, int remoteHandle, int tag) {
256  return this->ReceiveVoidArray(data, maxlength, VTK_SIGNED_CHAR, remoteHandle, tag);
257  }
258  int Receive(float* data, vtkIdType maxlength, int remoteHandle, int tag) {
259  return this->ReceiveVoidArray(data, maxlength, VTK_FLOAT, remoteHandle, tag);
260  }
261  int Receive(double* data, vtkIdType maxlength, int remoteHandle, int tag) {
262  return this->ReceiveVoidArray(data, maxlength, VTK_DOUBLE, remoteHandle, tag);
263  }
264 #ifdef VTK_USE_64BIT_IDS
265  int Receive(vtkIdType* data, vtkIdType maxlength, int remoteHandle, int tag) {
266  return this->ReceiveVoidArray(data, maxlength, VTK_ID_TYPE, remoteHandle, tag);
267  }
268 #else
269  int Receive(long long* data, vtkIdType maxlength, int remoteHandle, int tag) {
270  return this->ReceiveVoidArray(data, maxlength, VTK_LONG_LONG, remoteHandle, tag);
271  }
272 #endif
273  int Receive(unsigned long long* data, vtkIdType maxlength, int remoteHandle, int tag) {
274  return this->ReceiveVoidArray(data, maxlength, VTK_UNSIGNED_LONG_LONG, remoteHandle, tag);
275  }
276 //BTX
277  int Receive(vtkMultiProcessStream& stream, int remoteId, int tag);
278 //ETX
280 
282 
289  vtkGetMacro(Count, vtkIdType);
291 
292  //---------------------- Collective Operations ----------------------
293 
296  virtual void Barrier();
297 
299 
302  int Broadcast(int *data, vtkIdType length, int srcProcessId) {
303  return this->BroadcastVoidArray(data, length, VTK_INT, srcProcessId);
304  }
305  int Broadcast(unsigned int *data, vtkIdType length, int srcProcessId) {
306  return this->BroadcastVoidArray(data, length, VTK_UNSIGNED_INT, srcProcessId);
307  }
308  int Broadcast(short *data, vtkIdType length, int srcProcessId) {
309  return this->BroadcastVoidArray(data, length, VTK_SHORT, srcProcessId);
310  }
311  int Broadcast(unsigned short *data, vtkIdType length, int srcProcessId) {
312  return this->BroadcastVoidArray(data, length, VTK_UNSIGNED_SHORT, srcProcessId);
313  }
314  int Broadcast(long *data, vtkIdType length, int srcProcessId) {
315  return this->BroadcastVoidArray(data, length, VTK_LONG, srcProcessId);
316  }
317  int Broadcast(unsigned long *data, vtkIdType length, int srcProcessId) {
318  return this->BroadcastVoidArray(data,length,VTK_UNSIGNED_LONG,srcProcessId);
319  }
320  int Broadcast(unsigned char *data, vtkIdType length, int srcProcessId) {
321  return this->BroadcastVoidArray(data,length,VTK_UNSIGNED_CHAR,srcProcessId);
322  }
323  int Broadcast(char *data, vtkIdType length, int srcProcessId) {
324  return this->BroadcastVoidArray(data, length, VTK_CHAR, srcProcessId);
325  }
326  int Broadcast(signed char *data, vtkIdType length, int srcProcessId) {
327  return this->BroadcastVoidArray(data, length, VTK_SIGNED_CHAR, srcProcessId);
328  }
329  int Broadcast(float *data, vtkIdType length, int srcProcessId) {
330  return this->BroadcastVoidArray(data, length, VTK_FLOAT, srcProcessId);
331  }
332  int Broadcast(double *data, vtkIdType length, int srcProcessId) {
333  return this->BroadcastVoidArray(data, length, VTK_DOUBLE, srcProcessId);
334  }
335 #ifdef VTK_USE_64BIT_IDS
336  int Broadcast(vtkIdType *data, vtkIdType length, int srcProcessId) {
337  return this->BroadcastVoidArray(data, length, VTK_ID_TYPE, srcProcessId);
338  }
339 #else
340  int Broadcast(long long *data, vtkIdType length, int srcProcessId) {
341  return this->BroadcastVoidArray(data, length, VTK_LONG_LONG, srcProcessId);
342  }
343 #endif
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);
349 //BTX
350  int Broadcast(vtkMultiProcessStream& stream, int srcProcessId);
351 //ETX
353 
355 
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 #ifdef VTK_USE_64BIT_IDS
419  int Gather(const vtkIdType *sendBuffer, vtkIdType *recvBuffer,
420  vtkIdType length, int destProcessId) {
421  return this->GatherVoidArray(sendBuffer, recvBuffer, length,
422  VTK_ID_TYPE, destProcessId);
423  }
424 #else
425  int Gather(const long long *sendBuffer, long long *recvBuffer,
426  vtkIdType length, int destProcessId) {
427  return this->GatherVoidArray(sendBuffer, recvBuffer, length,
428  VTK_LONG_LONG, destProcessId);
429  }
430 #endif
431  int Gather(const unsigned long long *sendBuffer, unsigned long long *recvBuffer,
432  vtkIdType length, int destProcessId) {
433  return this->GatherVoidArray(sendBuffer, recvBuffer, length,
434  VTK_UNSIGNED_LONG_LONG, destProcessId);
435  }
436  int Gather(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
437  int destProcessId);
439 
441 
451  int GatherV(const int* sendBuffer, int* recvBuffer,
452  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
453  int destProcessId) {
454  return this->GatherVVoidArray(sendBuffer, recvBuffer,
455  sendLength, recvLengths,
456  offsets, VTK_INT, destProcessId);
457  }
458  int GatherV(const unsigned int* sendBuffer, unsigned int* recvBuffer,
459  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
460  int destProcessId) {
461  return this->GatherVVoidArray(sendBuffer, recvBuffer,
462  sendLength, recvLengths,
463  offsets, VTK_UNSIGNED_INT, destProcessId);
464  }
465  int GatherV(const short* sendBuffer, short* recvBuffer,
466  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
467  int destProcessId) {
468  return this->GatherVVoidArray(sendBuffer, recvBuffer,
469  sendLength, recvLengths,
470  offsets, VTK_SHORT, destProcessId);
471  }
472  int GatherV(const unsigned short* sendBuffer, unsigned short* recvBuffer,
473  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
474  int destProcessId) {
475  return this->GatherVVoidArray(sendBuffer, recvBuffer,
476  sendLength, recvLengths,
477  offsets, VTK_UNSIGNED_SHORT, destProcessId);
478  }
479  int GatherV(const long* sendBuffer, long* recvBuffer,
480  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
481  int destProcessId) {
482  return this->GatherVVoidArray(sendBuffer, recvBuffer,
483  sendLength, recvLengths,
484  offsets, VTK_LONG, destProcessId);
485  }
486  int GatherV(const unsigned long* sendBuffer, unsigned long* recvBuffer,
487  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
488  int destProcessId) {
489  return this->GatherVVoidArray(sendBuffer, recvBuffer,
490  sendLength, recvLengths,
491  offsets, VTK_UNSIGNED_LONG, destProcessId);
492  }
493  int GatherV(const unsigned char* sendBuffer, unsigned char* recvBuffer,
494  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
495  int destProcessId) {
496  return this->GatherVVoidArray(sendBuffer, recvBuffer,
497  sendLength, recvLengths,
498  offsets, VTK_UNSIGNED_CHAR, destProcessId);
499  }
500  int GatherV(const char* sendBuffer, char* recvBuffer,
501  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
502  int destProcessId) {
503  return this->GatherVVoidArray(sendBuffer, recvBuffer,
504  sendLength, recvLengths,
505  offsets, VTK_CHAR, destProcessId);
506  }
507  int GatherV(const signed char* sendBuffer, signed char* recvBuffer,
508  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
509  int destProcessId) {
510  return this->GatherVVoidArray(sendBuffer, recvBuffer,
511  sendLength, recvLengths,
512  offsets, VTK_SIGNED_CHAR, destProcessId);
513  }
514  int GatherV(const float* sendBuffer, float* recvBuffer,
515  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
516  int destProcessId) {
517  return this->GatherVVoidArray(sendBuffer, recvBuffer,
518  sendLength, recvLengths,
519  offsets, VTK_FLOAT, destProcessId);
520  }
521  int GatherV(const double* sendBuffer, double* recvBuffer,
522  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
523  int destProcessId) {
524  return this->GatherVVoidArray(sendBuffer, recvBuffer,
525  sendLength, recvLengths,
526  offsets, VTK_DOUBLE, destProcessId);
527  }
528 #ifdef VTK_USE_64BIT_IDS
529  int GatherV(const vtkIdType* sendBuffer, vtkIdType* recvBuffer,
530  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
531  int destProcessId) {
532  return this->GatherVVoidArray(sendBuffer, recvBuffer,
533  sendLength, recvLengths,
534  offsets, VTK_ID_TYPE, destProcessId);
535  }
536 #else
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 #endif
545  int GatherV(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
546  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
547  int destProcessId) {
548  return this->GatherVVoidArray(sendBuffer, recvBuffer,
549  sendLength, recvLengths,
550  offsets, VTK_UNSIGNED_LONG_LONG, destProcessId);
551  }
553 
554 
562  int GatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
563  vtkIdType *recvLengths, vtkIdType *offsets,
564  int destProcessId);
565  int GatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
566  vtkIdTypeArray* recvLengths,
567  vtkIdTypeArray* offsets,
568  int destProcessId);
569  int GatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
570  int destProcessId);
572 
573 
578  int GatherV(vtkDataObject* sendData, vtkSmartPointer<vtkDataObject>* recvData,
579  int destProcessId);
581 
583 
588  int Scatter(const int *sendBuffer, int *recvBuffer,
589  vtkIdType length, int srcProcessId) {
590  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
591  VTK_INT, srcProcessId);
592  }
593  int Scatter(const unsigned int *sendBuffer, unsigned int *recvBuffer,
594  vtkIdType length, int srcProcessId) {
595  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
596  VTK_UNSIGNED_INT, srcProcessId);
597  }
598  int Scatter(const short *sendBuffer, short *recvBuffer,
599  vtkIdType length, int srcProcessId) {
600  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
601  VTK_SHORT, srcProcessId);
602  }
603  int Scatter(const unsigned short *sendBuffer, unsigned short *recvBuffer,
604  vtkIdType length, int srcProcessId) {
605  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
606  VTK_UNSIGNED_SHORT, srcProcessId);
607  }
608  int Scatter(const long *sendBuffer, long *recvBuffer,
609  vtkIdType length, int srcProcessId) {
610  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
611  VTK_INT, srcProcessId);
612  }
613  int Scatter(const unsigned long *sendBuffer, unsigned long *recvBuffer,
614  vtkIdType length, int srcProcessId) {
615  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
616  VTK_UNSIGNED_LONG, srcProcessId);
617  }
618  int Scatter(const unsigned char *sendBuffer, unsigned char *recvBuffer,
619  vtkIdType length, int srcProcessId) {
620  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
621  VTK_UNSIGNED_CHAR, srcProcessId);
622  }
623  int Scatter(const char *sendBuffer, char *recvBuffer,
624  vtkIdType length, int srcProcessId) {
625  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
626  VTK_CHAR, srcProcessId);
627  }
628  int Scatter(const signed char *sendBuffer, signed char *recvBuffer,
629  vtkIdType length, int srcProcessId) {
630  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
631  VTK_SIGNED_CHAR, srcProcessId);
632  }
633  int Scatter(const float *sendBuffer, float *recvBuffer,
634  vtkIdType length, int srcProcessId) {
635  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
636  VTK_FLOAT, srcProcessId);
637  }
638  int Scatter(const double *sendBuffer, double *recvBuffer,
639  vtkIdType length, int srcProcessId) {
640  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
641  VTK_DOUBLE, srcProcessId);
642  }
643 #ifdef VTK_USE_64BIT_IDS
644  int Scatter(const vtkIdType *sendBuffer, vtkIdType *recvBuffer,
645  vtkIdType length, int srcProcessId) {
646  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
647  VTK_ID_TYPE, srcProcessId);
648  }
649 #else
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 #endif
656  int Scatter(const unsigned long long *sendBuffer, unsigned long long *recvBuffer,
657  vtkIdType length, int srcProcessId) {
658  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
659  VTK_UNSIGNED_LONG_LONG, srcProcessId);
660  }
661  int Scatter(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
662  int srcProcessId);
664 
666 
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 #ifdef VTK_USE_64BIT_IDS
750  int ScatterV(const vtkIdType *sendBuffer, vtkIdType *recvBuffer,
751  vtkIdType *sendLengths, vtkIdType *offsets,
752  vtkIdType recvLength, int srcProcessId) {
753  return this->ScatterVVoidArray(sendBuffer, recvBuffer,
754  sendLengths, offsets, recvLength,
755  VTK_ID_TYPE, srcProcessId);
756  }
757 #else
758  int ScatterV(const long long *sendBuffer, long long *recvBuffer,
759  vtkIdType *sendLengths, vtkIdType *offsets,
760  vtkIdType recvLength, int srcProcessId) {
761  return this->ScatterVVoidArray(sendBuffer, recvBuffer,
762  sendLengths, offsets, recvLength,
763  VTK_LONG_LONG, srcProcessId);
764  }
765 #endif
766  int ScatterV(const unsigned long long *sendBuffer, unsigned long long *recvBuffer,
767  vtkIdType *sendLengths, vtkIdType *offsets,
768  vtkIdType recvLength, int srcProcessId) {
769  return this->ScatterVVoidArray(sendBuffer, recvBuffer,
770  sendLengths, offsets, recvLength,
771  VTK_UNSIGNED_LONG_LONG, srcProcessId);
772  }
774 
776 
777  int AllGather(const int *sendBuffer, int *recvBuffer, vtkIdType length) {
778  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_INT);
779  }
780  int AllGather(const unsigned int *sendBuffer, unsigned int *recvBuffer,
781  vtkIdType length) {
782  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length,
784  }
785  int AllGather(const short *sendBuffer, short *recvBuffer, vtkIdType length) {
786  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_SHORT);
787  }
788  int AllGather(const unsigned short *sendBuffer, unsigned short *recvBuffer,
789  vtkIdType length) {
790  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length,
792  }
793  int AllGather(const long *sendBuffer, long *recvBuffer, vtkIdType length) {
794  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_LONG);
795  }
796  int AllGather(const unsigned long *sendBuffer,
797  unsigned long *recvBuffer, vtkIdType length) {
798  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length,
800  }
801  int AllGather(const unsigned char *sendBuffer,
802  unsigned char *recvBuffer, vtkIdType length) {
803  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length,
805  }
806  int AllGather(const char *sendBuffer, char *recvBuffer, vtkIdType length) {
807  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_CHAR);
808  }
809  int AllGather(const signed char *sendBuffer, signed char *recvBuffer,
810  vtkIdType length) {
811  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length,
813  }
814  int AllGather(const float *sendBuffer, float *recvBuffer, vtkIdType length) {
815  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_FLOAT);
816  }
817  int AllGather(const double *sendBuffer,
818  double *recvBuffer, vtkIdType length) {
819  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_DOUBLE);
820  }
821 #ifdef VTK_USE_64BIT_IDS
822  int AllGather(const vtkIdType *sendBuffer, vtkIdType *recvBuffer,
823  vtkIdType length) {
824  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length,
825  VTK_ID_TYPE);
826  }
827 #else
828  int AllGather(const long long *sendBuffer, long long *recvBuffer,
829  vtkIdType length) {
830  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length,
831  VTK_LONG_LONG);
832  }
833 #endif
834  int AllGather(const unsigned long long *sendBuffer,
835  unsigned long long *recvBuffer, vtkIdType length) {
836  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length,
838  }
839  int AllGather(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer);
841 
843 
844  int AllGatherV(const int* sendBuffer, int* recvBuffer,
845  vtkIdType sendLength, vtkIdType* recvLengths,
846  vtkIdType* offsets) {
847  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
848  sendLength, recvLengths,
849  offsets, VTK_INT);
850  }
851  int AllGatherV(const unsigned int* sendBuffer, unsigned int* recvBuffer,
852  vtkIdType sendLength, vtkIdType* recvLengths,
853  vtkIdType* offsets) {
854  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
855  sendLength, recvLengths,
856  offsets, VTK_UNSIGNED_INT);
857  }
858  int AllGatherV(const short* sendBuffer, short* recvBuffer,
859  vtkIdType sendLength, vtkIdType* recvLengths,
860  vtkIdType* offsets) {
861  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
862  sendLength, recvLengths,
863  offsets, VTK_SHORT);
864  }
865  int AllGatherV(const unsigned short* sendBuffer, unsigned short* recvBuffer,
866  vtkIdType sendLength, vtkIdType* recvLengths,
867  vtkIdType* offsets) {
868  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
869  sendLength, recvLengths,
870  offsets, VTK_UNSIGNED_SHORT);
871  }
872  int AllGatherV(const long* sendBuffer, long* recvBuffer,
873  vtkIdType sendLength, vtkIdType* recvLengths,
874  vtkIdType* offsets) {
875  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
876  sendLength, recvLengths,
877  offsets, VTK_LONG);
878  }
879  int AllGatherV(const unsigned long* sendBuffer, unsigned long* recvBuffer,
880  vtkIdType sendLength, vtkIdType* recvLengths,
881  vtkIdType* offsets) {
882  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
883  sendLength, recvLengths,
884  offsets, VTK_UNSIGNED_LONG);
885  }
886  int AllGatherV(const unsigned char* sendBuffer, unsigned 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 char* sendBuffer, char* recvBuffer,
894  vtkIdType sendLength, vtkIdType* recvLengths,
895  vtkIdType* offsets) {
896  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
897  sendLength, recvLengths,
898  offsets, VTK_CHAR);
899  }
900  int AllGatherV(const signed char* sendBuffer, signed char* recvBuffer,
901  vtkIdType sendLength, vtkIdType* recvLengths,
902  vtkIdType* offsets) {
903  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
904  sendLength, recvLengths,
905  offsets, VTK_UNSIGNED_CHAR);
906  }
907  int AllGatherV(const float* sendBuffer, float* recvBuffer,
908  vtkIdType sendLength, vtkIdType* recvLengths,
909  vtkIdType* offsets) {
910  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
911  sendLength, recvLengths,
912  offsets, VTK_FLOAT);
913  }
914  int AllGatherV(const double* sendBuffer, double* recvBuffer,
915  vtkIdType sendLength, vtkIdType* recvLengths,
916  vtkIdType* offsets) {
917  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
918  sendLength, recvLengths,
919  offsets, VTK_DOUBLE);
920  }
921 #ifdef VTK_USE_64BIT_IDS
922  int AllGatherV(const vtkIdType* sendBuffer, vtkIdType* recvBuffer,
923  vtkIdType sendLength, vtkIdType* recvLengths,
924  vtkIdType* offsets) {
925  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
926  sendLength, recvLengths,
927  offsets, VTK_ID_TYPE);
928  }
929 #else
930  int AllGatherV(const long long* sendBuffer, long long* recvBuffer,
931  vtkIdType sendLength, vtkIdType* recvLengths,
932  vtkIdType* offsets) {
933  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
934  sendLength, recvLengths,
935  offsets, VTK_LONG_LONG);
936  }
937 #endif
938  int AllGatherV(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
939  vtkIdType sendLength, vtkIdType* recvLengths,
940  vtkIdType* offsets) {
941  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
942  sendLength, recvLengths,
943  offsets, VTK_UNSIGNED_LONG_LONG);
944  }
945  int AllGatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
946  vtkIdType *recvLengths, vtkIdType *offsets);
947  int AllGatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer);
949 
951 
954  int Reduce(const int *sendBuffer, int *recvBuffer,
955  vtkIdType length, int operation, int destProcessId) {
956  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
957  VTK_INT, operation, destProcessId);
958  }
959  int Reduce(const unsigned int *sendBuffer, unsigned int *recvBuffer,
960  vtkIdType length, int operation, int destProcessId) {
961  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
962  VTK_UNSIGNED_INT, operation, destProcessId);
963  }
964  int Reduce(const short *sendBuffer, short *recvBuffer,
965  vtkIdType length, int operation, int destProcessId) {
966  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
967  VTK_SHORT, operation, destProcessId);
968  }
969  int Reduce(const unsigned short *sendBuffer, unsigned short *recvBuffer,
970  vtkIdType length, int operation, int destProcessId) {
971  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
972  VTK_UNSIGNED_SHORT, operation, destProcessId);
973  }
974  int Reduce(const long *sendBuffer, long *recvBuffer,
975  vtkIdType length, int operation, int destProcessId) {
976  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
977  VTK_LONG, operation, destProcessId);
978  }
979  int Reduce(const unsigned long *sendBuffer, unsigned long *recvBuffer,
980  vtkIdType length, int operation, int destProcessId) {
981  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
982  VTK_UNSIGNED_LONG, operation, destProcessId);
983  }
984  int Reduce(const unsigned char *sendBuffer, unsigned char *recvBuffer,
985  vtkIdType length, int operation, int destProcessId) {
986  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
987  VTK_UNSIGNED_CHAR, operation, destProcessId);
988  }
989  int Reduce(const char *sendBuffer, char *recvBuffer,
990  vtkIdType length, int operation, int destProcessId) {
991  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
992  VTK_CHAR, operation, destProcessId);
993  }
994  int Reduce(const signed char *sendBuffer, signed char *recvBuffer,
995  vtkIdType length, int operation, int destProcessId) {
996  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
997  VTK_SIGNED_CHAR, operation, destProcessId);
998  }
999  int Reduce(const float *sendBuffer, float *recvBuffer,
1000  vtkIdType length, int operation, int destProcessId) {
1001  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1002  VTK_FLOAT, operation, destProcessId);
1003  }
1004  int Reduce(const double *sendBuffer, double *recvBuffer,
1005  vtkIdType length, int operation, int destProcessId) {
1006  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1007  VTK_DOUBLE, operation, destProcessId);
1008  }
1009 #ifdef VTK_USE_64BIT_IDS
1010  int Reduce(const vtkIdType *sendBuffer, vtkIdType *recvBuffer,
1011  vtkIdType length, int operation, int destProcessId) {
1012  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1013  VTK_ID_TYPE, operation, destProcessId);
1014  }
1015 #else
1016  int Reduce(const long long *sendBuffer, long long *recvBuffer,
1017  vtkIdType length, int operation, int destProcessId) {
1018  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1019  VTK_LONG_LONG, operation, destProcessId);
1020  }
1021 #endif
1022  int Reduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer,
1023  vtkIdType length, int operation, int destProcessId) {
1024  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1025  VTK_UNSIGNED_LONG_LONG, operation, destProcessId);
1026  }
1027  int Reduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
1028  int operation, int destProcessId);
1030 
1032 
1035  int Reduce(const int *sendBuffer, int *recvBuffer,
1036  vtkIdType length, Operation *operation, int destProcessId) {
1037  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1038  VTK_INT, operation, destProcessId);
1039  }
1040  int Reduce(const unsigned int *sendBuffer, unsigned int *recvBuffer,
1041  vtkIdType length, Operation *operation, int destProcessId) {
1042  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1043  VTK_UNSIGNED_INT, operation, destProcessId);
1044  }
1045  int Reduce(const short *sendBuffer, short *recvBuffer,
1046  vtkIdType length, Operation *operation, int destProcessId) {
1047  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1048  VTK_SHORT, operation, destProcessId);
1049  }
1050  int Reduce(const unsigned short *sendBuffer, unsigned short *recvBuffer,
1051  vtkIdType length, Operation *operation, int destProcessId) {
1052  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1053  VTK_UNSIGNED_SHORT, operation, destProcessId);
1054  }
1055  int Reduce(const long *sendBuffer, long *recvBuffer,
1056  vtkIdType length, Operation *operation, int destProcessId) {
1057  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1058  VTK_LONG, operation, destProcessId);
1059  }
1060  int Reduce(const unsigned long *sendBuffer, unsigned long *recvBuffer,
1061  vtkIdType length, Operation *operation, int destProcessId) {
1062  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1063  VTK_UNSIGNED_LONG, operation, destProcessId);
1064  }
1065  int Reduce(const unsigned char *sendBuffer, unsigned char *recvBuffer,
1066  vtkIdType length, Operation *operation, int destProcessId) {
1067  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1068  VTK_UNSIGNED_CHAR, operation, destProcessId);
1069  }
1070  int Reduce(const char *sendBuffer, char *recvBuffer,
1071  vtkIdType length, Operation *operation, int destProcessId) {
1072  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1073  VTK_CHAR, operation, destProcessId);
1074  }
1075  int Reduce(const signed char *sendBuffer, signed char *recvBuffer,
1076  vtkIdType length, Operation *operation, int destProcessId) {
1077  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1078  VTK_SIGNED_CHAR, operation, destProcessId);
1079  }
1080  int Reduce(const float *sendBuffer, float *recvBuffer,
1081  vtkIdType length, Operation *operation, int destProcessId) {
1082  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1083  VTK_FLOAT, operation, destProcessId);
1084  }
1085  int Reduce(const double *sendBuffer, double *recvBuffer,
1086  vtkIdType length, Operation *operation, int destProcessId) {
1087  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1088  VTK_DOUBLE, operation, destProcessId);
1089  }
1090 #ifdef VTK_USE_64BIT_IDS
1091  int Reduce(const vtkIdType *sendBuffer, vtkIdType *recvBuffer,
1092  vtkIdType length, Operation *operation, int destProcessId) {
1093  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1094  VTK_ID_TYPE, operation, destProcessId);
1095  }
1096 #else
1097  int Reduce(const long long *sendBuffer, long long *recvBuffer,
1098  vtkIdType length, Operation *operation, int destProcessId) {
1099  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1100  VTK_LONG_LONG, operation, destProcessId);
1101  }
1102 #endif
1103  int Reduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer,
1104  vtkIdType length, Operation *operation, int destProcessId) {
1105  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1106  VTK_UNSIGNED_LONG_LONG, operation, destProcessId);
1107  }
1108  int Reduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
1109  Operation *operation, int destProcessId);
1111 
1113 
1115  int AllReduce(const int *sendBuffer, int *recvBuffer,
1116  vtkIdType length, int operation) {
1117  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1118  VTK_INT, operation);
1119  }
1120  int AllReduce(const unsigned int *sendBuffer, unsigned int *recvBuffer,
1121  vtkIdType length, int operation) {
1122  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1123  VTK_UNSIGNED_INT, operation);
1124  }
1125  int AllReduce(const short *sendBuffer, short *recvBuffer,
1126  vtkIdType length, int operation) {
1127  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1128  VTK_SHORT, operation);
1129  }
1130  int AllReduce(const unsigned short *sendBuffer, unsigned short *recvBuffer,
1131  vtkIdType length, int operation) {
1132  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1133  VTK_UNSIGNED_SHORT, operation);
1134  }
1135  int AllReduce(const long *sendBuffer, long *recvBuffer,
1136  vtkIdType length, int operation) {
1137  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1138  VTK_LONG, operation);
1139  }
1140  int AllReduce(const unsigned long *sendBuffer, unsigned long *recvBuffer,
1141  vtkIdType length, int operation) {
1142  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1143  VTK_UNSIGNED_LONG, operation);
1144  }
1145  int AllReduce(const unsigned char *sendBuffer, unsigned char *recvBuffer,
1146  vtkIdType length, int operation) {
1147  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1148  VTK_UNSIGNED_CHAR, operation);
1149  }
1150  int AllReduce(const char *sendBuffer, char *recvBuffer,
1151  vtkIdType length, int operation) {
1152  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1153  VTK_CHAR, operation);
1154  }
1155  int AllReduce(const signed char *sendBuffer, signed char *recvBuffer,
1156  vtkIdType length, int operation) {
1157  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1158  VTK_SIGNED_CHAR, operation);
1159  }
1160  int AllReduce(const float *sendBuffer, float *recvBuffer,
1161  vtkIdType length, int operation) {
1162  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1163  VTK_FLOAT, operation);
1164  }
1165  int AllReduce(const double *sendBuffer, double *recvBuffer,
1166  vtkIdType length, int operation) {
1167  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1168  VTK_DOUBLE, operation);
1169  }
1170 #ifdef VTK_USE_64BIT_IDS
1171  int AllReduce(const vtkIdType *sendBuffer, vtkIdType *recvBuffer,
1172  vtkIdType length, int operation) {
1173  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1174  VTK_ID_TYPE, operation);
1175  }
1176 #else
1177  int AllReduce(const long long *sendBuffer, long long *recvBuffer,
1178  vtkIdType length, int operation) {
1179  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1180  VTK_LONG_LONG, operation);
1181  }
1182 #endif
1183  int AllReduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer,
1184  vtkIdType length, int operation) {
1185  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1186  VTK_UNSIGNED_LONG_LONG, operation);
1187  }
1188  int AllReduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
1189  int operation);
1190  int AllReduce(const int *sendBuffer, int *recvBuffer,
1191  vtkIdType length, Operation *operation) {
1192  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1193  VTK_INT, operation);
1194  }
1195  int AllReduce(const unsigned int *sendBuffer, unsigned int *recvBuffer,
1196  vtkIdType length, Operation *operation) {
1197  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1198  VTK_UNSIGNED_INT, operation);
1199  }
1200  int AllReduce(const short *sendBuffer, short *recvBuffer,
1201  vtkIdType length, Operation *operation) {
1202  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1203  VTK_SHORT, operation);
1204  }
1205  int AllReduce(const unsigned short *sendBuffer, unsigned short *recvBuffer,
1206  vtkIdType length, Operation *operation) {
1207  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1208  VTK_UNSIGNED_SHORT, operation);
1209  }
1210  int AllReduce(const long *sendBuffer, long *recvBuffer,
1211  vtkIdType length, Operation *operation) {
1212  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1213  VTK_LONG, operation);
1214  }
1215  int AllReduce(const unsigned long *sendBuffer, unsigned long *recvBuffer,
1216  vtkIdType length, Operation *operation) {
1217  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1218  VTK_UNSIGNED_LONG, operation);
1219  }
1220  int AllReduce(const unsigned char *sendBuffer, unsigned char *recvBuffer,
1221  vtkIdType length, Operation *operation) {
1222  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1223  VTK_UNSIGNED_CHAR, operation);
1224  }
1225  int AllReduce(const char *sendBuffer, char *recvBuffer,
1226  vtkIdType length, Operation *operation) {
1227  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1228  VTK_CHAR, operation);
1229  }
1230  int AllReduce(const signed char *sendBuffer, signed char *recvBuffer,
1231  vtkIdType length, Operation *operation) {
1232  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1233  VTK_SIGNED_CHAR, operation);
1234  }
1235  int AllReduce(const float *sendBuffer, float *recvBuffer,
1236  vtkIdType length, Operation *operation) {
1237  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1238  VTK_FLOAT, operation);
1239  }
1240  int AllReduce(const double *sendBuffer, double *recvBuffer,
1241  vtkIdType length, Operation *operation) {
1242  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1243  VTK_DOUBLE, operation);
1244  }
1245 #ifdef VTK_USE_64BIT_IDS
1246  int AllReduce(const vtkIdType *sendBuffer, vtkIdType *recvBuffer,
1247  vtkIdType length, Operation *operation) {
1248  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1249  VTK_ID_TYPE, operation);
1250  }
1251 #else
1252  int AllReduce(const long long *sendBuffer, long long *recvBuffer,
1253  vtkIdType length, Operation *operation) {
1254  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1255  VTK_LONG_LONG, operation);
1256  }
1257 #endif
1258  int AllReduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer,
1259  vtkIdType length, Operation *operation) {
1260  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1261  VTK_UNSIGNED_LONG_LONG, operation);
1262  }
1263  int AllReduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
1264  Operation *operation);
1266 
1268 
1270  virtual int BroadcastVoidArray(void *data, vtkIdType length, int type,
1271  int srcProcessId);
1272  virtual int GatherVoidArray(const void *sendBuffer, void *recvBuffer,
1273  vtkIdType length, int type, int destProcessId);
1274  virtual int GatherVVoidArray(const void *sendBuffer, void *recvBuffer,
1275  vtkIdType sendLength, vtkIdType *recvLengths,
1276  vtkIdType *offsets, int type, int destProcessId);
1277  virtual int ScatterVoidArray(const void *sendBuffer, void *recvBuffer,
1278  vtkIdType length, int type, int srcProcessId);
1279  virtual int ScatterVVoidArray(const void *sendBuffer, void *recvBuffer,
1280  vtkIdType *sendLengths, vtkIdType *offsets,
1281  vtkIdType recvLength, int type,
1282  int srcProcessId);
1283  virtual int AllGatherVoidArray(const void *sendBuffer, void *recvBuffer,
1284  vtkIdType length, int type);
1285  virtual int AllGatherVVoidArray(const void *sendBuffer, void *recvBuffer,
1286  vtkIdType sendLength, vtkIdType *recvLengths,
1287  vtkIdType *offsets, int type);
1288  virtual int ReduceVoidArray(const void *sendBuffer, void *recvBuffer,
1289  vtkIdType length, int type,
1290  int operation, int destProcessId);
1291  virtual int ReduceVoidArray(const void *sendBuffer, void *recvBuffer,
1292  vtkIdType length, int type,
1293  Operation *operation, int destProcessId);
1294  virtual int AllReduceVoidArray(const void *sendBuffer, void *recvBuffer,
1295  vtkIdType length, int type,
1296  int operation);
1297  virtual int AllReduceVoidArray(const void *sendBuffer, void *recvBuffer,
1298  vtkIdType length, int type,
1299  Operation *operation);
1301 
1302  static void SetUseCopy(int useCopy);
1303 
1304 //BTX
1306 
1314  virtual int ComputeGlobalBounds(int processorId, int numProcesses,
1315  vtkBoundingBox *bounds,
1316  int *rightHasBounds = 0,
1317  int *leftHasBounds = 0,
1318  int hasBoundsTag = 288402,
1319  int localBoundsTag = 288403,
1320  int globalBoundsTag = 288404);
1321 //ETX
1323 
1325 
1328  static int GetParentProcessor(int pid);
1329  static int GetLeftChildProcessor(int pid);
1331 
1333 
1336  static int MarshalDataObject(vtkDataObject *object, vtkCharArray *buffer);
1337  static int UnMarshalDataObject(vtkCharArray *buffer, vtkDataObject *object);
1339 
1340 protected:
1341 
1342  int WriteDataArray(vtkDataArray *object);
1343  int ReadDataArray(vtkDataArray *object);
1344 
1345  vtkCommunicator();
1346  ~vtkCommunicator();
1347 
1348  // Internal methods called by Send/Receive(vtkDataObject *... ) above.
1349  int SendElementalDataObject(vtkDataObject* data, int remoteHandle, int tag);
1351 
1357  int GatherV(vtkDataArray *sendArray, vtkDataArray* recvArray,
1358  vtkSmartPointer<vtkDataArray>* recvArrays, int destProcessId);
1359  int GatherVElementalDataObject(vtkDataObject* sendData,
1360  vtkSmartPointer<vtkDataObject>* receiveData,
1361  int destProcessId);
1363 
1364  int ReceiveDataObject(vtkDataObject* data,
1365  int remoteHandle, int tag, int type=-1);
1366  int ReceiveElementalDataObject(vtkDataObject* data,
1367  int remoteHandle, int tag);
1368  int ReceiveMultiBlockDataSet(
1369  vtkMultiBlockDataSet* data, int remoteHandle, int tag);
1370 
1373 
1375 
1376  static int UseCopy;
1377 
1379 
1380 private:
1381  vtkCommunicator(const vtkCommunicator&); // Not implemented.
1382  void operator=(const vtkCommunicator&); // Not implemented.
1383 };
1384 
1385 #endif // vtkCommunicator_h
1386 // VTK-HeaderTest-Exclude: vtkCommunicator.h
int Receive(double *data, vtkIdType maxlength, int remoteHandle, int tag)
int Receive(unsigned int *data, vtkIdType maxlength, int remoteHandle, int tag)
int AllGather(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length)
int Broadcast(float *data, vtkIdType length, int srcProcessId)
int AllReduce(const char *sendBuffer, char *recvBuffer, vtkIdType length, Operation *operation)
int Gather(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, int destProcessId)
int ScatterV(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
int ScatterV(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
int Gather(const int *sendBuffer, int *recvBuffer, vtkIdType length, int destProcessId)
int GatherV(const double *sendBuffer, double *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
int AllReduce(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, int operation)
int AllGatherV(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
int Send(const short *data, vtkIdType length, int remoteHandle, int tag)
int Reduce(const long *sendBuffer, long *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
int ScatterV(const double *sendBuffer, double *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
int AllReduce(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, int operation)
#define VTK_UNSIGNED_INT
Definition: vtkType.h:32
int Send(const int *data, vtkIdType length, int remoteHandle, int tag)
abstract base class for most VTK objects
Definition: vtkObject.h:61
int GatherV(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
int Receive(unsigned char *data, vtkIdType maxlength, int remoteHandle, int tag)
int Scatter(const double *sendBuffer, double *recvBuffer, vtkIdType length, int srcProcessId)
int AllGather(const long long *sendBuffer, long long *recvBuffer, vtkIdType length)
stream used to pass data across processes using vtkMultiProcessController.
int Gather(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, int destProcessId)
int Receive(long long *data, vtkIdType maxlength, int remoteHandle, int tag)
int GatherV(const char *sendBuffer, char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
#define VTKPARALLELCORE_EXPORT
int Gather(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, int destProcessId)
#define VTK_UNSIGNED_SHORT
Definition: vtkType.h:30
int AllGatherV(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
abstract class to specify dataset behavior
Definition: vtkDataSet.h:61
int Gather(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, int destProcessId)
int AllReduce(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, int operation)
int AllReduce(const double *sendBuffer, double *recvBuffer, vtkIdType length, Operation *operation)
int AllReduce(const float *sendBuffer, float *recvBuffer, vtkIdType length, Operation *operation)
int Reduce(const float *sendBuffer, float *recvBuffer, vtkIdType length, int operation, int destProcessId)
int Reduce(const double *sendBuffer, double *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
int Scatter(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, int srcProcessId)
int Reduce(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
int ScatterV(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
int Scatter(const long *sendBuffer, long *recvBuffer, vtkIdType length, int srcProcessId)
int Send(const float *data, vtkIdType length, int remoteHandle, int tag)
int Scatter(const char *sendBuffer, char *recvBuffer, vtkIdType length, int srcProcessId)
int AllReduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length, Operation *operation)
int Broadcast(unsigned short *data, vtkIdType length, int srcProcessId)
int Send(const unsigned short *data, vtkIdType length, int remoteHandle, int tag)
int Scatter(const short *sendBuffer, short *recvBuffer, vtkIdType length, int srcProcessId)
int ScatterV(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
int Broadcast(signed char *data, vtkIdType length, int srcProcessId)
int GatherV(const long long *sendBuffer, long long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
int AllReduce(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, Operation *operation)
int Send(const signed char *data, vtkIdType length, int remoteHandle, int tag)
int Reduce(const int *sendBuffer, int *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
int GatherV(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
int AllReduce(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, Operation *operation)
dynamic, self-adjusting array of vtkIdType
int Reduce(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
int vtkIdType
Definition: vtkType.h:247
int AllGatherV(const int *sendBuffer, int *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
int AllReduce(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, Operation *operation)
int Broadcast(char *data, vtkIdType length, int srcProcessId)
int AllGather(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length)
int AllGather(const double *sendBuffer, double *recvBuffer, vtkIdType length)
#define VTK_LONG_LONG
Definition: vtkType.h:44
int Send(const double *data, vtkIdType length, int remoteHandle, int tag)
int ScatterV(const short *sendBuffer, short *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
int AllGatherV(const long long *sendBuffer, long long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
int ScatterV(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
int GatherV(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
int AllReduce(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, Operation *operation)
int AllReduce(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, int operation)
int ScatterV(const int *sendBuffer, int *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
int Reduce(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, int operation, int destProcessId)
int Scatter(const float *sendBuffer, float *recvBuffer, vtkIdType length, int srcProcessId)
int AllReduce(const char *sendBuffer, char *recvBuffer, vtkIdType length, int operation)
#define VTK_DOUBLE
Definition: vtkType.h:36
int Broadcast(unsigned long long *data, vtkIdType length, int srcProcessId)
int Reduce(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, int operation, int destProcessId)
int ScatterV(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
dynamic, self-adjusting array of char
Definition: vtkCharArray.h:42
#define VTK_FLOAT
Definition: vtkType.h:35
int Broadcast(long *data, vtkIdType length, int srcProcessId)
int AllGather(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length)
int AllGather(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length)
int AllGatherV(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
int Gather(const double *sendBuffer, double *recvBuffer, vtkIdType length, int destProcessId)
int Receive(char *data, vtkIdType maxlength, int remoteHandle, int tag)
int Send(const unsigned int *data, vtkIdType length, int remoteHandle, int tag)
virtual void PrintSelf(ostream &os, vtkIndent indent)
int Send(const unsigned long long *data, vtkIdType length, int remoteHandle, int tag)
int Reduce(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
int Scatter(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, int srcProcessId)
int AllGatherV(const float *sendBuffer, float *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
int Gather(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, int destProcessId)
int AllGatherV(const short *sendBuffer, short *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
int Reduce(const float *sendBuffer, float *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
a simple class to control print indentation
Definition: vtkIndent.h:38
int AllReduce(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, int operation)
int Receive(short *data, vtkIdType maxlength, int remoteHandle, int tag)
int ScatterV(const char *sendBuffer, char *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
int AllGatherV(const char *sendBuffer, char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
int Receive(long *data, vtkIdType maxlength, int remoteHandle, int tag)
int GatherV(const short *sendBuffer, short *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
topologically and geometrically regular array of data
Definition: vtkImageData.h:44
int GatherV(const long *sendBuffer, long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
int Receive(signed char *data, vtkIdType maxlength, int remoteHandle, int tag)
int AllReduce(const long *sendBuffer, long *recvBuffer, vtkIdType length, int operation)
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:54
int AllGather(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length)
int Reduce(const int *sendBuffer, int *recvBuffer, vtkIdType length, int operation, int destProcessId)
int Gather(const short *sendBuffer, short *recvBuffer, vtkIdType length, int destProcessId)
int AllReduce(const double *sendBuffer, double *recvBuffer, vtkIdType length, int operation)
int Reduce(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, int operation, int destProcessId)
#define VTK_SHORT
Definition: vtkType.h:29
#define VTK_CHAR
Definition: vtkType.h:26
int AllGather(const float *sendBuffer, float *recvBuffer, vtkIdType length)
#define VTK_LONG
Definition: vtkType.h:33
int AllReduce(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, Operation *operation)
int Reduce(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, int operation, int destProcessId)
int Send(const unsigned long *data, vtkIdType length, int remoteHandle, int tag)
int Gather(const char *sendBuffer, char *recvBuffer, vtkIdType length, int destProcessId)
int AllGatherV(const double *sendBuffer, double *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
int Scatter(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, int srcProcessId)
int Gather(const float *sendBuffer, float *recvBuffer, vtkIdType length, int destProcessId)
int AllGatherV(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
int Reduce(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, int operation, int destProcessId)
int GatherV(const int *sendBuffer, int *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
int Broadcast(unsigned long *data, vtkIdType length, int srcProcessId)
int AllGather(const long *sendBuffer, long *recvBuffer, vtkIdType length)
int ScatterV(const long long *sendBuffer, long long *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
int AllReduce(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, int operation)
int Scatter(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, int srcProcessId)
int Broadcast(long long *data, vtkIdType length, int srcProcessId)
int Reduce(const char *sendBuffer, char *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
int Broadcast(short *data, vtkIdType length, int srcProcessId)
int Scatter(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, int srcProcessId)
int AllGatherV(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
int AllGather(const int *sendBuffer, int *recvBuffer, vtkIdType length)
int Broadcast(double *data, vtkIdType length, int srcProcessId)
#define VTK_SIGNED_CHAR
Definition: vtkType.h:27
int AllReduce(const int *sendBuffer, int *recvBuffer, vtkIdType length, Operation *operation)
int Reduce(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
int Send(const long *data, vtkIdType length, int remoteHandle, int tag)
int Receive(float *data, vtkIdType maxlength, int remoteHandle, int tag)
int Send(const long long *data, vtkIdType length, int remoteHandle, int tag)
int Scatter(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, int srcProcessId)
int Send(const unsigned char *data, vtkIdType length, int remoteHandle, int tag)
#define VTK_UNSIGNED_CHAR
Definition: vtkType.h:28
int ScatterV(const float *sendBuffer, float *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
int Gather(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, int destProcessId)
int AllReduce(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, Operation *operation)
int Reduce(const char *sendBuffer, char *recvBuffer, vtkIdType length, int operation, int destProcessId)
int Gather(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length, int destProcessId)
int AllGather(const short *sendBuffer, short *recvBuffer, vtkIdType length)
int AllGather(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length)
Composite dataset that organizes datasets into blocks.
int AllReduce(const float *sendBuffer, float *recvBuffer, vtkIdType length, int operation)
int AllGatherV(const long *sendBuffer, long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
int Receive(int *data, vtkIdType maxlength, int remoteHandle, int tag)
int Reduce(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
int Receive(unsigned long long *data, vtkIdType maxlength, int remoteHandle, int tag)
int Reduce(const short *sendBuffer, short *recvBuffer, vtkIdType length, int operation, int destProcessId)
int GatherV(const float *sendBuffer, float *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
#define VTK_ID_TYPE
Definition: vtkType.h:37
int Reduce(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, int operation, int destProcessId)
int Broadcast(unsigned char *data, vtkIdType length, int srcProcessId)
#define VTK_UNSIGNED_LONG
Definition: vtkType.h:34
int Receive(unsigned long *data, vtkIdType maxlength, int remoteHandle, int tag)
int Broadcast(int *data, vtkIdType length, int srcProcessId)
int GatherV(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
int Reduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length, int operation, int destProcessId)
int AllGather(const char *sendBuffer, char *recvBuffer, vtkIdType length)
int Reduce(const long *sendBuffer, long *recvBuffer, vtkIdType length, int operation, int destProcessId)
Used to send/receive messages in a multiprocess environment.
int Reduce(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
int AllGatherV(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
int Scatter(const int *sendBuffer, int *recvBuffer, vtkIdType length, int srcProcessId)
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)
int AllReduce(const long *sendBuffer, long *recvBuffer, vtkIdType length, Operation *operation)
int Send(const char *data, vtkIdType length, int remoteHandle, int tag)
int Reduce(const short *sendBuffer, short *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
int AllReduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length, int operation)
int ScatterV(const long *sendBuffer, long *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
#define VTK_UNSIGNED_LONG_LONG
Definition: vtkType.h:45
int AllReduce(const int *sendBuffer, int *recvBuffer, vtkIdType length, int operation)
int Receive(unsigned short *data, vtkIdType maxlength, int remoteHandle, int tag)
int AllReduce(const short *sendBuffer, short *recvBuffer, vtkIdType length, int operation)
#define VTK_INT
Definition: vtkType.h:31
int Scatter(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length, int srcProcessId)
int Broadcast(unsigned int *data, vtkIdType length, int srcProcessId)
int Reduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
Fast Simple Class for dealing with 3D bounds.
int AllReduce(const short *sendBuffer, short *recvBuffer, vtkIdType length, Operation *operation)
int Reduce(const double *sendBuffer, double *recvBuffer, vtkIdType length, int operation, int destProcessId)
int GatherV(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
int Gather(const long *sendBuffer, long *recvBuffer, vtkIdType length, int destProcessId)