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;
48 class vtkMultiBlockDataSet;
49 class vtkMultiProcessStream;
50 
51 class VTKPARALLELCORE_EXPORT vtkCommunicator : public vtkObject
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 
85  enum StandardOperations
86  {
87  MAX_OP,
88  MIN_OP,
89  SUM_OP,
90  PRODUCT_OP,
91  LOGICAL_AND_OP,
92  BITWISE_AND_OP,
93  LOGICAL_OR_OP,
94  BITWISE_OR_OP,
95  LOGICAL_XOR_OP,
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 #elif defined(VTK_TYPE_USE_LONG_LONG)
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 #ifdef VTK_TYPE_USE_LONG_LONG
194  int Send(const unsigned long long* data, vtkIdType length, int remoteHandle, int tag) {
195  return this->SendVoidArray(data, length, VTK_UNSIGNED_LONG_LONG, remoteHandle, tag);
196  }
197 #endif
198 //BTX
199  int Send(const vtkMultiProcessStream& stream, int remoteId, int tag);
200 //ETX
202 
203 
206  int Receive(vtkDataObject* data, int remoteHandle, int tag);
207 
210  vtkDataObject *ReceiveDataObject(int remoteHandle, int tag);
211 
214  int Receive(vtkDataArray* data, int remoteHandle, int tag);
215 
217 
225  virtual int ReceiveVoidArray(void *data, vtkIdType maxlength, int type,
226  int remoteHandle, int tag) = 0;
228 
230 
231  int Receive(int* data, vtkIdType maxlength, int remoteHandle, int tag) {
232  return this->ReceiveVoidArray(data, maxlength, VTK_INT, remoteHandle, tag);
233  }
234  int Receive(unsigned int* data, vtkIdType maxlength, int remoteHandle, int tag) {
235  return this->ReceiveVoidArray(data, maxlength, VTK_INT, remoteHandle, tag);
236  }
237  int Receive(short* data, vtkIdType maxlength, int remoteHandle, int tag) {
238  return this->ReceiveVoidArray(data, maxlength, VTK_SHORT, remoteHandle, tag);
239  }
240  int Receive(unsigned short* data, vtkIdType maxlength, int remoteHandle, int tag) {
241  return this->ReceiveVoidArray(data, maxlength, VTK_UNSIGNED_SHORT, remoteHandle, tag);
242  }
243  int Receive(long* data, vtkIdType maxlength, int remoteHandle, int tag) {
244  return this->ReceiveVoidArray(data, maxlength, VTK_LONG, remoteHandle, tag);
245  }
246  int Receive(unsigned long* data, vtkIdType maxlength, int remoteHandle, int tag){
247  return this->ReceiveVoidArray(data, maxlength, VTK_UNSIGNED_LONG, remoteHandle,
248  tag);
249  }
250  int Receive(unsigned char* data, vtkIdType maxlength, int remoteHandle, int tag){
251  return this->ReceiveVoidArray(data, maxlength, VTK_UNSIGNED_CHAR, remoteHandle,
252  tag);
253  }
254  int Receive(char* data, vtkIdType maxlength, int remoteHandle, int tag) {
255  return this->ReceiveVoidArray(data, maxlength, VTK_CHAR, remoteHandle, tag);
256  }
257  int Receive(signed char* data, vtkIdType maxlength, int remoteHandle, int tag) {
258  return this->ReceiveVoidArray(data, maxlength, VTK_SIGNED_CHAR, remoteHandle, tag);
259  }
260  int Receive(float* data, vtkIdType maxlength, int remoteHandle, int tag) {
261  return this->ReceiveVoidArray(data, maxlength, VTK_FLOAT, remoteHandle, tag);
262  }
263  int Receive(double* data, vtkIdType maxlength, int remoteHandle, int tag) {
264  return this->ReceiveVoidArray(data, maxlength, VTK_DOUBLE, remoteHandle, tag);
265  }
266 #ifdef VTK_USE_64BIT_IDS
267  int Receive(vtkIdType* data, vtkIdType maxlength, int remoteHandle, int tag) {
268  return this->ReceiveVoidArray(data, maxlength, VTK_ID_TYPE, remoteHandle, tag);
269  }
270 #elif defined(VTK_TYPE_USE_LONG_LONG)
271  int Receive(long long* data, vtkIdType maxlength, int remoteHandle, int tag) {
272  return this->ReceiveVoidArray(data, maxlength, VTK_LONG_LONG, remoteHandle, tag);
273  }
274 #endif
275 #ifdef VTK_TYPE_USE_LONG_LONG
276  int Receive(unsigned long long* data, vtkIdType maxlength, int remoteHandle, int tag) {
277  return this->ReceiveVoidArray(data, maxlength, VTK_UNSIGNED_LONG_LONG, remoteHandle, tag);
278  }
279 #endif
280 //BTX
281  int Receive(vtkMultiProcessStream& stream, int remoteId, int tag);
282 //ETX
284 
286 
293  vtkGetMacro(Count, vtkIdType);
295 
296  //---------------------- Collective Operations ----------------------
297 
300  virtual void Barrier();
301 
303 
306  int Broadcast(int *data, vtkIdType length, int srcProcessId) {
307  return this->BroadcastVoidArray(data, length, VTK_INT, srcProcessId);
308  }
309  int Broadcast(unsigned int *data, vtkIdType length, int srcProcessId) {
310  return this->BroadcastVoidArray(data, length, VTK_UNSIGNED_INT, srcProcessId);
311  }
312  int Broadcast(short *data, vtkIdType length, int srcProcessId) {
313  return this->BroadcastVoidArray(data, length, VTK_SHORT, srcProcessId);
314  }
315  int Broadcast(unsigned short *data, vtkIdType length, int srcProcessId) {
316  return this->BroadcastVoidArray(data, length, VTK_UNSIGNED_SHORT, srcProcessId);
317  }
318  int Broadcast(long *data, vtkIdType length, int srcProcessId) {
319  return this->BroadcastVoidArray(data, length, VTK_LONG, srcProcessId);
320  }
321  int Broadcast(unsigned long *data, vtkIdType length, int srcProcessId) {
322  return this->BroadcastVoidArray(data,length,VTK_UNSIGNED_LONG,srcProcessId);
323  }
324  int Broadcast(unsigned char *data, vtkIdType length, int srcProcessId) {
325  return this->BroadcastVoidArray(data,length,VTK_UNSIGNED_CHAR,srcProcessId);
326  }
327  int Broadcast(char *data, vtkIdType length, int srcProcessId) {
328  return this->BroadcastVoidArray(data, length, VTK_CHAR, srcProcessId);
329  }
330  int Broadcast(signed char *data, vtkIdType length, int srcProcessId) {
331  return this->BroadcastVoidArray(data, length, VTK_SIGNED_CHAR, srcProcessId);
332  }
333  int Broadcast(float *data, vtkIdType length, int srcProcessId) {
334  return this->BroadcastVoidArray(data, length, VTK_FLOAT, srcProcessId);
335  }
336  int Broadcast(double *data, vtkIdType length, int srcProcessId) {
337  return this->BroadcastVoidArray(data, length, VTK_DOUBLE, srcProcessId);
338  }
339 #ifdef VTK_USE_64BIT_IDS
340  int Broadcast(vtkIdType *data, vtkIdType length, int srcProcessId) {
341  return this->BroadcastVoidArray(data, length, VTK_ID_TYPE, srcProcessId);
342  }
343 #elif defined(VTK_TYPE_USE_LONG_LONG)
344  int Broadcast(long long *data, vtkIdType length, int srcProcessId) {
345  return this->BroadcastVoidArray(data, length, VTK_LONG_LONG, srcProcessId);
346  }
347 #endif
348 #ifdef VTK_TYPE_USE_LONG_LONG
349  int Broadcast(unsigned long long *data, vtkIdType length, int srcProcessId) {
350  return this->BroadcastVoidArray(data, length, VTK_UNSIGNED_LONG_LONG, srcProcessId);
351  }
352 #endif
353  int Broadcast(vtkDataObject *data, int srcProcessId);
354  int Broadcast(vtkDataArray *data, int srcProcessId);
355 //BTX
356  int Broadcast(vtkMultiProcessStream& stream, int srcProcessId);
357 //ETX
359 
361 
369  int Gather(const int *sendBuffer, int *recvBuffer,
370  vtkIdType length, int destProcessId) {
371  return this->GatherVoidArray(sendBuffer, recvBuffer, length,
372  VTK_INT, destProcessId);
373  }
374  int Gather(const unsigned int *sendBuffer, unsigned int *recvBuffer,
375  vtkIdType length, int destProcessId) {
376  return this->GatherVoidArray(sendBuffer, recvBuffer, length,
377  VTK_UNSIGNED_INT, destProcessId);
378  }
379  int Gather(const short *sendBuffer, short *recvBuffer,
380  vtkIdType length, int destProcessId) {
381  return this->GatherVoidArray(sendBuffer, recvBuffer, length,
382  VTK_SHORT, destProcessId);
383  }
384  int Gather(const unsigned short *sendBuffer, unsigned short *recvBuffer,
385  vtkIdType length, int destProcessId) {
386  return this->GatherVoidArray(sendBuffer, recvBuffer, length,
387  VTK_UNSIGNED_SHORT, destProcessId);
388  }
389  int Gather(const long *sendBuffer, long *recvBuffer,
390  vtkIdType length, int destProcessId) {
391  return this->GatherVoidArray(sendBuffer, recvBuffer, length,
392  VTK_LONG, destProcessId);
393  }
394  int Gather(const unsigned long *sendBuffer, unsigned long *recvBuffer,
395  vtkIdType length, int destProcessId) {
396  return this->GatherVoidArray(sendBuffer, recvBuffer, length,
397  VTK_UNSIGNED_LONG, destProcessId);
398  }
399  int Gather(const unsigned char *sendBuffer, unsigned char *recvBuffer,
400  vtkIdType length, int destProcessId) {
401  return this->GatherVoidArray(sendBuffer, recvBuffer, length,
402  VTK_UNSIGNED_CHAR, destProcessId);
403  }
404  int Gather(const char *sendBuffer, char *recvBuffer,
405  vtkIdType length, int destProcessId) {
406  return this->GatherVoidArray(sendBuffer, recvBuffer, length,
407  VTK_CHAR, destProcessId);
408  }
409  int Gather(const signed char *sendBuffer, signed char *recvBuffer,
410  vtkIdType length, int destProcessId) {
411  return this->GatherVoidArray(sendBuffer, recvBuffer, length,
412  VTK_SIGNED_CHAR, destProcessId);
413  }
414  int Gather(const float *sendBuffer, float *recvBuffer,
415  vtkIdType length, int destProcessId) {
416  return this->GatherVoidArray(sendBuffer, recvBuffer, length,
417  VTK_FLOAT, destProcessId);
418  }
419  int Gather(const double *sendBuffer, double *recvBuffer,
420  vtkIdType length, int destProcessId) {
421  return this->GatherVoidArray(sendBuffer, recvBuffer, length,
422  VTK_DOUBLE, destProcessId);
423  }
424 #ifdef VTK_USE_64BIT_IDS
425  int Gather(const vtkIdType *sendBuffer, vtkIdType *recvBuffer,
426  vtkIdType length, int destProcessId) {
427  return this->GatherVoidArray(sendBuffer, recvBuffer, length,
428  VTK_ID_TYPE, destProcessId);
429  }
430 #elif defined(VTK_TYPE_USE_LONG_LONG)
431  int Gather(const long long *sendBuffer, long long *recvBuffer,
432  vtkIdType length, int destProcessId) {
433  return this->GatherVoidArray(sendBuffer, recvBuffer, length,
434  VTK_LONG_LONG, destProcessId);
435  }
436 #endif
437 #ifdef VTK_TYPE_USE_LONG_LONG
438  int Gather(const unsigned long long *sendBuffer, unsigned long long *recvBuffer,
439  vtkIdType length, int destProcessId) {
440  return this->GatherVoidArray(sendBuffer, recvBuffer, length,
441  VTK_UNSIGNED_LONG_LONG, destProcessId);
442  }
443 #endif
444  int Gather(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
445  int destProcessId);
447 
449 
459  int GatherV(const int* sendBuffer, int* recvBuffer,
460  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
461  int destProcessId) {
462  return this->GatherVVoidArray(sendBuffer, recvBuffer,
463  sendLength, recvLengths,
464  offsets, VTK_INT, destProcessId);
465  }
466  int GatherV(const unsigned int* sendBuffer, unsigned int* recvBuffer,
467  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
468  int destProcessId) {
469  return this->GatherVVoidArray(sendBuffer, recvBuffer,
470  sendLength, recvLengths,
471  offsets, VTK_UNSIGNED_INT, destProcessId);
472  }
473  int GatherV(const short* sendBuffer, short* recvBuffer,
474  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
475  int destProcessId) {
476  return this->GatherVVoidArray(sendBuffer, recvBuffer,
477  sendLength, recvLengths,
478  offsets, VTK_SHORT, destProcessId);
479  }
480  int GatherV(const unsigned short* sendBuffer, unsigned short* recvBuffer,
481  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
482  int destProcessId) {
483  return this->GatherVVoidArray(sendBuffer, recvBuffer,
484  sendLength, recvLengths,
485  offsets, VTK_UNSIGNED_SHORT, destProcessId);
486  }
487  int GatherV(const long* sendBuffer, long* recvBuffer,
488  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
489  int destProcessId) {
490  return this->GatherVVoidArray(sendBuffer, recvBuffer,
491  sendLength, recvLengths,
492  offsets, VTK_LONG, destProcessId);
493  }
494  int GatherV(const unsigned long* sendBuffer, unsigned long* recvBuffer,
495  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
496  int destProcessId) {
497  return this->GatherVVoidArray(sendBuffer, recvBuffer,
498  sendLength, recvLengths,
499  offsets, VTK_UNSIGNED_LONG, destProcessId);
500  }
501  int GatherV(const unsigned char* sendBuffer, unsigned char* recvBuffer,
502  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
503  int destProcessId) {
504  return this->GatherVVoidArray(sendBuffer, recvBuffer,
505  sendLength, recvLengths,
506  offsets, VTK_UNSIGNED_CHAR, destProcessId);
507  }
508  int GatherV(const char* sendBuffer, char* recvBuffer,
509  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
510  int destProcessId) {
511  return this->GatherVVoidArray(sendBuffer, recvBuffer,
512  sendLength, recvLengths,
513  offsets, VTK_CHAR, destProcessId);
514  }
515  int GatherV(const signed char* sendBuffer, signed char* recvBuffer,
516  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
517  int destProcessId) {
518  return this->GatherVVoidArray(sendBuffer, recvBuffer,
519  sendLength, recvLengths,
520  offsets, VTK_SIGNED_CHAR, destProcessId);
521  }
522  int GatherV(const float* sendBuffer, float* recvBuffer,
523  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
524  int destProcessId) {
525  return this->GatherVVoidArray(sendBuffer, recvBuffer,
526  sendLength, recvLengths,
527  offsets, VTK_FLOAT, destProcessId);
528  }
529  int GatherV(const double* sendBuffer, double* recvBuffer,
530  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
531  int destProcessId) {
532  return this->GatherVVoidArray(sendBuffer, recvBuffer,
533  sendLength, recvLengths,
534  offsets, VTK_DOUBLE, destProcessId);
535  }
536 #ifdef VTK_USE_64BIT_IDS
537  int GatherV(const vtkIdType* sendBuffer, vtkIdType* recvBuffer,
538  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
539  int destProcessId) {
540  return this->GatherVVoidArray(sendBuffer, recvBuffer,
541  sendLength, recvLengths,
542  offsets, VTK_ID_TYPE, destProcessId);
543  }
544 #elif defined(VTK_TYPE_USE_LONG_LONG)
545  int GatherV(const long long* sendBuffer, 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_LONG_LONG, destProcessId);
551  }
552 #endif
553 #ifdef VTK_TYPE_USE_LONG_LONG
554  int GatherV(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
555  vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
556  int destProcessId) {
557  return this->GatherVVoidArray(sendBuffer, recvBuffer,
558  sendLength, recvLengths,
559  offsets, VTK_UNSIGNED_LONG_LONG, destProcessId);
560  }
561 #endif
562 
563 
564 
572  int GatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
573  vtkIdType *recvLengths, vtkIdType *offsets,
574  int destProcessId);
575  int GatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
576  vtkIdTypeArray* recvLengths,
577  vtkIdTypeArray* offsets,
578  int destProcessId);
579  int GatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
580  int destProcessId);
582 
583 
588  int GatherV(vtkDataObject* sendData, vtkSmartPointer<vtkDataObject>* recvData,
589  int destProcessId);
591 
593 
598  int Scatter(const int *sendBuffer, int *recvBuffer,
599  vtkIdType length, int srcProcessId) {
600  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
601  VTK_INT, srcProcessId);
602  }
603  int Scatter(const unsigned int *sendBuffer, unsigned int *recvBuffer,
604  vtkIdType length, int srcProcessId) {
605  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
606  VTK_UNSIGNED_INT, srcProcessId);
607  }
608  int Scatter(const short *sendBuffer, short *recvBuffer,
609  vtkIdType length, int srcProcessId) {
610  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
611  VTK_SHORT, srcProcessId);
612  }
613  int Scatter(const unsigned short *sendBuffer, unsigned short *recvBuffer,
614  vtkIdType length, int srcProcessId) {
615  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
616  VTK_UNSIGNED_SHORT, srcProcessId);
617  }
618  int Scatter(const long *sendBuffer, long *recvBuffer,
619  vtkIdType length, int srcProcessId) {
620  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
621  VTK_INT, srcProcessId);
622  }
623  int Scatter(const unsigned long *sendBuffer, unsigned long *recvBuffer,
624  vtkIdType length, int srcProcessId) {
625  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
626  VTK_UNSIGNED_LONG, srcProcessId);
627  }
628  int Scatter(const unsigned char *sendBuffer, unsigned char *recvBuffer,
629  vtkIdType length, int srcProcessId) {
630  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
631  VTK_UNSIGNED_CHAR, srcProcessId);
632  }
633  int Scatter(const char *sendBuffer, char *recvBuffer,
634  vtkIdType length, int srcProcessId) {
635  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
636  VTK_CHAR, srcProcessId);
637  }
638  int Scatter(const signed char *sendBuffer, signed char *recvBuffer,
639  vtkIdType length, int srcProcessId) {
640  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
641  VTK_SIGNED_CHAR, srcProcessId);
642  }
643  int Scatter(const float *sendBuffer, float *recvBuffer,
644  vtkIdType length, int srcProcessId) {
645  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
646  VTK_FLOAT, srcProcessId);
647  }
648  int Scatter(const double *sendBuffer, double *recvBuffer,
649  vtkIdType length, int srcProcessId) {
650  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
651  VTK_DOUBLE, srcProcessId);
652  }
653 #ifdef VTK_USE_64BIT_IDS
654  int Scatter(const vtkIdType *sendBuffer, vtkIdType *recvBuffer,
655  vtkIdType length, int srcProcessId) {
656  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
657  VTK_ID_TYPE, srcProcessId);
658  }
659 #elif defined(VTK_TYPE_USE_LONG_LONG)
660  int Scatter(const long long *sendBuffer, long long *recvBuffer,
661  vtkIdType length, int srcProcessId) {
662  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
663  VTK_LONG_LONG, srcProcessId);
664  }
665 #endif
666 #ifdef VTK_TYPE_USE_LONG_LONG
667  int Scatter(const unsigned long long *sendBuffer, unsigned long long *recvBuffer,
668  vtkIdType length, int srcProcessId) {
669  return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
670  VTK_UNSIGNED_LONG_LONG, srcProcessId);
671  }
672 #endif
673  int Scatter(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
674  int srcProcessId);
676 
678 
684  int ScatterV(const int *sendBuffer, int *recvBuffer,
685  vtkIdType *sendLengths, vtkIdType *offsets,
686  vtkIdType recvLength, int srcProcessId) {
687  return this->ScatterVVoidArray(sendBuffer, recvBuffer,
688  sendLengths, offsets, recvLength,
689  VTK_INT, srcProcessId);
690  }
691  int ScatterV(const unsigned int *sendBuffer, unsigned int *recvBuffer,
692  vtkIdType *sendLengths, vtkIdType *offsets,
693  vtkIdType recvLength, int srcProcessId) {
694  return this->ScatterVVoidArray(sendBuffer, recvBuffer,
695  sendLengths, offsets, recvLength,
696  VTK_UNSIGNED_INT, srcProcessId);
697  }
698  int ScatterV(const short *sendBuffer, short *recvBuffer,
699  vtkIdType *sendLengths, vtkIdType *offsets,
700  vtkIdType recvLength, int srcProcessId) {
701  return this->ScatterVVoidArray(sendBuffer, recvBuffer,
702  sendLengths, offsets, recvLength,
703  VTK_SHORT, srcProcessId);
704  }
705  int ScatterV(const unsigned short *sendBuffer, unsigned short *recvBuffer,
706  vtkIdType *sendLengths, vtkIdType *offsets,
707  vtkIdType recvLength, int srcProcessId) {
708  return this->ScatterVVoidArray(sendBuffer, recvBuffer,
709  sendLengths, offsets, recvLength,
710  VTK_UNSIGNED_SHORT, srcProcessId);
711  }
712  int ScatterV(const long *sendBuffer, long *recvBuffer,
713  vtkIdType *sendLengths, vtkIdType *offsets,
714  vtkIdType recvLength, int srcProcessId) {
715  return this->ScatterVVoidArray(sendBuffer, recvBuffer,
716  sendLengths, offsets, recvLength,
717  VTK_LONG, srcProcessId);
718  }
719  int ScatterV(const unsigned long *sendBuffer, unsigned long *recvBuffer,
720  vtkIdType *sendLengths, vtkIdType *offsets,
721  vtkIdType recvLength, int srcProcessId) {
722  return this->ScatterVVoidArray(sendBuffer, recvBuffer,
723  sendLengths, offsets, recvLength,
724  VTK_UNSIGNED_LONG, srcProcessId);
725  }
726  int ScatterV(const unsigned char *sendBuffer, unsigned char *recvBuffer,
727  vtkIdType *sendLengths, vtkIdType *offsets,
728  vtkIdType recvLength, int srcProcessId) {
729  return this->ScatterVVoidArray(sendBuffer, recvBuffer,
730  sendLengths, offsets, recvLength,
731  VTK_UNSIGNED_CHAR, srcProcessId);
732  }
733  int ScatterV(const char *sendBuffer, char *recvBuffer,
734  vtkIdType *sendLengths, vtkIdType *offsets,
735  vtkIdType recvLength, int srcProcessId) {
736  return this->ScatterVVoidArray(sendBuffer, recvBuffer,
737  sendLengths, offsets, recvLength,
738  VTK_CHAR, srcProcessId);
739  }
740  int ScatterV(const signed char *sendBuffer, signed char *recvBuffer,
741  vtkIdType *sendLengths, vtkIdType *offsets,
742  vtkIdType recvLength, int srcProcessId) {
743  return this->ScatterVVoidArray(sendBuffer, recvBuffer,
744  sendLengths, offsets, recvLength,
745  VTK_SIGNED_CHAR, srcProcessId);
746  }
747  int ScatterV(const float *sendBuffer, float *recvBuffer,
748  vtkIdType *sendLengths, vtkIdType *offsets,
749  vtkIdType recvLength, int srcProcessId) {
750  return this->ScatterVVoidArray(sendBuffer, recvBuffer,
751  sendLengths, offsets, recvLength,
752  VTK_FLOAT, srcProcessId);
753  }
754  int ScatterV(const double *sendBuffer, double *recvBuffer,
755  vtkIdType *sendLengths, vtkIdType *offsets,
756  vtkIdType recvLength, int srcProcessId) {
757  return this->ScatterVVoidArray(sendBuffer, recvBuffer,
758  sendLengths, offsets, recvLength,
759  VTK_DOUBLE, srcProcessId);
760  }
761 #ifdef VTK_USE_64BIT_IDS
762  int ScatterV(const vtkIdType *sendBuffer, vtkIdType *recvBuffer,
763  vtkIdType *sendLengths, vtkIdType *offsets,
764  vtkIdType recvLength, int srcProcessId) {
765  return this->ScatterVVoidArray(sendBuffer, recvBuffer,
766  sendLengths, offsets, recvLength,
767  VTK_ID_TYPE, srcProcessId);
768  }
769 #elif defined(VTK_TYPE_USE_LONG_LONG)
770  int ScatterV(const long long *sendBuffer, long long *recvBuffer,
771  vtkIdType *sendLengths, vtkIdType *offsets,
772  vtkIdType recvLength, int srcProcessId) {
773  return this->ScatterVVoidArray(sendBuffer, recvBuffer,
774  sendLengths, offsets, recvLength,
775  VTK_LONG_LONG, srcProcessId);
776  }
777 #endif
778 #ifdef VTK_TYPE_USE_LONG_LONG
779  int ScatterV(const unsigned long long *sendBuffer, unsigned long long *recvBuffer,
780  vtkIdType *sendLengths, vtkIdType *offsets,
781  vtkIdType recvLength, int srcProcessId) {
782  return this->ScatterVVoidArray(sendBuffer, recvBuffer,
783  sendLengths, offsets, recvLength,
784  VTK_UNSIGNED_LONG_LONG, srcProcessId);
785  }
786 #endif
787 
788 
790 
791  int AllGather(const int *sendBuffer, int *recvBuffer, vtkIdType length) {
792  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_INT);
793  }
794  int AllGather(const unsigned int *sendBuffer, unsigned int *recvBuffer,
795  vtkIdType length) {
796  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length,
797  VTK_UNSIGNED_INT);
798  }
799  int AllGather(const short *sendBuffer, short *recvBuffer, vtkIdType length) {
800  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_SHORT);
801  }
802  int AllGather(const unsigned short *sendBuffer, unsigned short *recvBuffer,
803  vtkIdType length) {
804  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length,
805  VTK_UNSIGNED_SHORT);
806  }
807  int AllGather(const long *sendBuffer, long *recvBuffer, vtkIdType length) {
808  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_LONG);
809  }
810  int AllGather(const unsigned long *sendBuffer,
811  unsigned long *recvBuffer, vtkIdType length) {
812  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length,
813  VTK_UNSIGNED_LONG);
814  }
815  int AllGather(const unsigned char *sendBuffer,
816  unsigned char *recvBuffer, vtkIdType length) {
817  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length,
818  VTK_UNSIGNED_CHAR);
819  }
820  int AllGather(const char *sendBuffer, char *recvBuffer, vtkIdType length) {
821  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_CHAR);
822  }
823  int AllGather(const signed char *sendBuffer, signed char *recvBuffer,
824  vtkIdType length) {
825  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length,
826  VTK_SIGNED_CHAR);
827  }
828  int AllGather(const float *sendBuffer, float *recvBuffer, vtkIdType length) {
829  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_FLOAT);
830  }
831  int AllGather(const double *sendBuffer,
832  double *recvBuffer, vtkIdType length) {
833  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_DOUBLE);
834  }
835 #ifdef VTK_USE_64BIT_IDS
836  int AllGather(const vtkIdType *sendBuffer, vtkIdType *recvBuffer,
837  vtkIdType length) {
838  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length,
839  VTK_ID_TYPE);
840  }
841 #elif defined(VTK_TYPE_USE_LONG_LONG)
842  int AllGather(const long long *sendBuffer, long long *recvBuffer,
843  vtkIdType length) {
844  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length,
845  VTK_LONG_LONG);
846  }
847 #endif
848 #ifdef VTK_TYPE_USE_LONG_LONG
849  int AllGather(const unsigned long long *sendBuffer,
850  unsigned long long *recvBuffer, vtkIdType length) {
851  return this->AllGatherVoidArray(sendBuffer, recvBuffer, length,
852  VTK_UNSIGNED_LONG_LONG);
853  }
854 #endif
855  int AllGather(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer);
857 
859 
860  int AllGatherV(const int* sendBuffer, int* recvBuffer,
861  vtkIdType sendLength, vtkIdType* recvLengths,
862  vtkIdType* offsets) {
863  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
864  sendLength, recvLengths,
865  offsets, VTK_INT);
866  }
867  int AllGatherV(const unsigned int* sendBuffer, unsigned int* recvBuffer,
868  vtkIdType sendLength, vtkIdType* recvLengths,
869  vtkIdType* offsets) {
870  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
871  sendLength, recvLengths,
872  offsets, VTK_UNSIGNED_INT);
873  }
874  int AllGatherV(const short* sendBuffer, short* recvBuffer,
875  vtkIdType sendLength, vtkIdType* recvLengths,
876  vtkIdType* offsets) {
877  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
878  sendLength, recvLengths,
879  offsets, VTK_SHORT);
880  }
881  int AllGatherV(const unsigned short* sendBuffer, unsigned short* recvBuffer,
882  vtkIdType sendLength, vtkIdType* recvLengths,
883  vtkIdType* offsets) {
884  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
885  sendLength, recvLengths,
886  offsets, VTK_UNSIGNED_SHORT);
887  }
888  int AllGatherV(const long* sendBuffer, long* recvBuffer,
889  vtkIdType sendLength, vtkIdType* recvLengths,
890  vtkIdType* offsets) {
891  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
892  sendLength, recvLengths,
893  offsets, VTK_LONG);
894  }
895  int AllGatherV(const unsigned long* sendBuffer, unsigned long* recvBuffer,
896  vtkIdType sendLength, vtkIdType* recvLengths,
897  vtkIdType* offsets) {
898  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
899  sendLength, recvLengths,
900  offsets, VTK_UNSIGNED_LONG);
901  }
902  int AllGatherV(const unsigned char* sendBuffer, unsigned char* recvBuffer,
903  vtkIdType sendLength, vtkIdType* recvLengths,
904  vtkIdType* offsets) {
905  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
906  sendLength, recvLengths,
907  offsets, VTK_UNSIGNED_CHAR);
908  }
909  int AllGatherV(const char* sendBuffer, char* recvBuffer,
910  vtkIdType sendLength, vtkIdType* recvLengths,
911  vtkIdType* offsets) {
912  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
913  sendLength, recvLengths,
914  offsets, VTK_CHAR);
915  }
916  int AllGatherV(const signed char* sendBuffer, signed char* recvBuffer,
917  vtkIdType sendLength, vtkIdType* recvLengths,
918  vtkIdType* offsets) {
919  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
920  sendLength, recvLengths,
921  offsets, VTK_UNSIGNED_CHAR);
922  }
923  int AllGatherV(const float* sendBuffer, float* recvBuffer,
924  vtkIdType sendLength, vtkIdType* recvLengths,
925  vtkIdType* offsets) {
926  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
927  sendLength, recvLengths,
928  offsets, VTK_FLOAT);
929  }
930  int AllGatherV(const double* sendBuffer, double* recvBuffer,
931  vtkIdType sendLength, vtkIdType* recvLengths,
932  vtkIdType* offsets) {
933  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
934  sendLength, recvLengths,
935  offsets, VTK_DOUBLE);
936  }
937 #ifdef VTK_USE_64BIT_IDS
938  int AllGatherV(const vtkIdType* sendBuffer, vtkIdType* recvBuffer,
939  vtkIdType sendLength, vtkIdType* recvLengths,
940  vtkIdType* offsets) {
941  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
942  sendLength, recvLengths,
943  offsets, VTK_ID_TYPE);
944  }
945 #elif defined(VTK_TYPE_USE_LONG_LONG)
946  int AllGatherV(const long long* sendBuffer, long long* recvBuffer,
947  vtkIdType sendLength, vtkIdType* recvLengths,
948  vtkIdType* offsets) {
949  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
950  sendLength, recvLengths,
951  offsets, VTK_LONG_LONG);
952  }
953 #endif
954 #ifdef VTK_TYPE_USE_LONG_LONG
955  int AllGatherV(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
956  vtkIdType sendLength, vtkIdType* recvLengths,
957  vtkIdType* offsets) {
958  return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
959  sendLength, recvLengths,
960  offsets, VTK_UNSIGNED_LONG_LONG);
961  }
962 #endif
963  int AllGatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
964  vtkIdType *recvLengths, vtkIdType *offsets);
965  int AllGatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer);
967 
969 
972  int Reduce(const int *sendBuffer, int *recvBuffer,
973  vtkIdType length, int operation, int destProcessId) {
974  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
975  VTK_INT, operation, destProcessId);
976  }
977  int Reduce(const unsigned int *sendBuffer, unsigned int *recvBuffer,
978  vtkIdType length, int operation, int destProcessId) {
979  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
980  VTK_UNSIGNED_INT, operation, destProcessId);
981  }
982  int Reduce(const short *sendBuffer, short *recvBuffer,
983  vtkIdType length, int operation, int destProcessId) {
984  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
985  VTK_SHORT, operation, destProcessId);
986  }
987  int Reduce(const unsigned short *sendBuffer, unsigned short *recvBuffer,
988  vtkIdType length, int operation, int destProcessId) {
989  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
990  VTK_UNSIGNED_SHORT, operation, destProcessId);
991  }
992  int Reduce(const long *sendBuffer, long *recvBuffer,
993  vtkIdType length, int operation, int destProcessId) {
994  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
995  VTK_LONG, operation, destProcessId);
996  }
997  int Reduce(const unsigned long *sendBuffer, unsigned long *recvBuffer,
998  vtkIdType length, int operation, int destProcessId) {
999  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1000  VTK_UNSIGNED_LONG, operation, destProcessId);
1001  }
1002  int Reduce(const unsigned char *sendBuffer, unsigned char *recvBuffer,
1003  vtkIdType length, int operation, int destProcessId) {
1004  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1005  VTK_UNSIGNED_CHAR, operation, destProcessId);
1006  }
1007  int Reduce(const char *sendBuffer, char *recvBuffer,
1008  vtkIdType length, int operation, int destProcessId) {
1009  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1010  VTK_CHAR, operation, destProcessId);
1011  }
1012  int Reduce(const signed char *sendBuffer, signed char *recvBuffer,
1013  vtkIdType length, int operation, int destProcessId) {
1014  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1015  VTK_SIGNED_CHAR, operation, destProcessId);
1016  }
1017  int Reduce(const float *sendBuffer, float *recvBuffer,
1018  vtkIdType length, int operation, int destProcessId) {
1019  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1020  VTK_FLOAT, operation, destProcessId);
1021  }
1022  int Reduce(const double *sendBuffer, double *recvBuffer,
1023  vtkIdType length, int operation, int destProcessId) {
1024  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1025  VTK_DOUBLE, operation, destProcessId);
1026  }
1027 #ifdef VTK_USE_64BIT_IDS
1028  int Reduce(const vtkIdType *sendBuffer, vtkIdType *recvBuffer,
1029  vtkIdType length, int operation, int destProcessId) {
1030  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1031  VTK_ID_TYPE, operation, destProcessId);
1032  }
1033 #elif defined(VTK_TYPE_USE_LONG_LONG)
1034  int Reduce(const long long *sendBuffer, long long *recvBuffer,
1035  vtkIdType length, int operation, int destProcessId) {
1036  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1037  VTK_LONG_LONG, operation, destProcessId);
1038  }
1039 #endif
1040 #ifdef VTK_TYPE_USE_LONG_LONG
1041  int Reduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer,
1042  vtkIdType length, int operation, int destProcessId) {
1043  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1044  VTK_UNSIGNED_LONG_LONG, operation, destProcessId);
1045  }
1046 #endif
1047  int Reduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
1048  int operation, int destProcessId);
1050 
1052 
1055  int Reduce(const int *sendBuffer, int *recvBuffer,
1056  vtkIdType length, Operation *operation, int destProcessId) {
1057  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1058  VTK_INT, operation, destProcessId);
1059  }
1060  int Reduce(const unsigned int *sendBuffer, unsigned int *recvBuffer,
1061  vtkIdType length, Operation *operation, int destProcessId) {
1062  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1063  VTK_UNSIGNED_INT, operation, destProcessId);
1064  }
1065  int Reduce(const short *sendBuffer, short *recvBuffer,
1066  vtkIdType length, Operation *operation, int destProcessId) {
1067  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1068  VTK_SHORT, operation, destProcessId);
1069  }
1070  int Reduce(const unsigned short *sendBuffer, unsigned short *recvBuffer,
1071  vtkIdType length, Operation *operation, int destProcessId) {
1072  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1073  VTK_UNSIGNED_SHORT, operation, destProcessId);
1074  }
1075  int Reduce(const long *sendBuffer, long *recvBuffer,
1076  vtkIdType length, Operation *operation, int destProcessId) {
1077  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1078  VTK_LONG, operation, destProcessId);
1079  }
1080  int Reduce(const unsigned long *sendBuffer, unsigned long *recvBuffer,
1081  vtkIdType length, Operation *operation, int destProcessId) {
1082  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1083  VTK_UNSIGNED_LONG, operation, destProcessId);
1084  }
1085  int Reduce(const unsigned char *sendBuffer, unsigned char *recvBuffer,
1086  vtkIdType length, Operation *operation, int destProcessId) {
1087  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1088  VTK_UNSIGNED_CHAR, operation, destProcessId);
1089  }
1090  int Reduce(const char *sendBuffer, char *recvBuffer,
1091  vtkIdType length, Operation *operation, int destProcessId) {
1092  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1093  VTK_CHAR, operation, destProcessId);
1094  }
1095  int Reduce(const signed char *sendBuffer, signed char *recvBuffer,
1096  vtkIdType length, Operation *operation, int destProcessId) {
1097  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1098  VTK_SIGNED_CHAR, operation, destProcessId);
1099  }
1100  int Reduce(const float *sendBuffer, float *recvBuffer,
1101  vtkIdType length, Operation *operation, int destProcessId) {
1102  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1103  VTK_FLOAT, operation, destProcessId);
1104  }
1105  int Reduce(const double *sendBuffer, double *recvBuffer,
1106  vtkIdType length, Operation *operation, int destProcessId) {
1107  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1108  VTK_DOUBLE, operation, destProcessId);
1109  }
1110 #ifdef VTK_USE_64BIT_IDS
1111  int Reduce(const vtkIdType *sendBuffer, vtkIdType *recvBuffer,
1112  vtkIdType length, Operation *operation, int destProcessId) {
1113  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1114  VTK_ID_TYPE, operation, destProcessId);
1115  }
1116 #elif defined(VTK_TYPE_USE_LONG_LONG)
1117  int Reduce(const long long *sendBuffer, long long *recvBuffer,
1118  vtkIdType length, Operation *operation, int destProcessId) {
1119  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1120  VTK_LONG_LONG, operation, destProcessId);
1121  }
1122 #endif
1123 #ifdef VTK_TYPE_USE_LONG_LONG
1124  int Reduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer,
1125  vtkIdType length, Operation *operation, int destProcessId) {
1126  return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
1127  VTK_UNSIGNED_LONG_LONG, operation, destProcessId);
1128  }
1129 #endif
1130  int Reduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
1131  Operation *operation, int destProcessId);
1133 
1135 
1137  int AllReduce(const int *sendBuffer, int *recvBuffer,
1138  vtkIdType length, int operation) {
1139  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1140  VTK_INT, operation);
1141  }
1142  int AllReduce(const unsigned int *sendBuffer, unsigned int *recvBuffer,
1143  vtkIdType length, int operation) {
1144  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1145  VTK_UNSIGNED_INT, operation);
1146  }
1147  int AllReduce(const short *sendBuffer, short *recvBuffer,
1148  vtkIdType length, int operation) {
1149  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1150  VTK_SHORT, operation);
1151  }
1152  int AllReduce(const unsigned short *sendBuffer, unsigned short *recvBuffer,
1153  vtkIdType length, int operation) {
1154  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1155  VTK_UNSIGNED_SHORT, operation);
1156  }
1157  int AllReduce(const long *sendBuffer, long *recvBuffer,
1158  vtkIdType length, int operation) {
1159  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1160  VTK_LONG, operation);
1161  }
1162  int AllReduce(const unsigned long *sendBuffer, unsigned long *recvBuffer,
1163  vtkIdType length, int operation) {
1164  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1165  VTK_UNSIGNED_LONG, operation);
1166  }
1167  int AllReduce(const unsigned char *sendBuffer, unsigned char *recvBuffer,
1168  vtkIdType length, int operation) {
1169  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1170  VTK_UNSIGNED_CHAR, operation);
1171  }
1172  int AllReduce(const char *sendBuffer, char *recvBuffer,
1173  vtkIdType length, int operation) {
1174  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1175  VTK_CHAR, operation);
1176  }
1177  int AllReduce(const signed char *sendBuffer, signed char *recvBuffer,
1178  vtkIdType length, int operation) {
1179  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1180  VTK_SIGNED_CHAR, operation);
1181  }
1182  int AllReduce(const float *sendBuffer, float *recvBuffer,
1183  vtkIdType length, int operation) {
1184  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1185  VTK_FLOAT, operation);
1186  }
1187  int AllReduce(const double *sendBuffer, double *recvBuffer,
1188  vtkIdType length, int operation) {
1189  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1190  VTK_DOUBLE, operation);
1191  }
1192 #ifdef VTK_USE_64BIT_IDS
1193  int AllReduce(const vtkIdType *sendBuffer, vtkIdType *recvBuffer,
1194  vtkIdType length, int operation) {
1195  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1196  VTK_ID_TYPE, operation);
1197  }
1198 #elif defined(VTK_TYPE_USE_LONG_LONG)
1199  int AllReduce(const long long *sendBuffer, long long *recvBuffer,
1200  vtkIdType length, int operation) {
1201  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1202  VTK_LONG_LONG, operation);
1203  }
1204 #endif
1205 #ifdef VTK_TYPE_USE_LONG_LONG
1206  int AllReduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer,
1207  vtkIdType length, int operation) {
1208  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1209  VTK_UNSIGNED_LONG_LONG, operation);
1210  }
1211 #endif
1212  int AllReduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
1213  int operation);
1214  int AllReduce(const int *sendBuffer, int *recvBuffer,
1215  vtkIdType length, Operation *operation) {
1216  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1217  VTK_INT, operation);
1218  }
1219  int AllReduce(const unsigned int *sendBuffer, unsigned int *recvBuffer,
1220  vtkIdType length, Operation *operation) {
1221  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1222  VTK_UNSIGNED_INT, operation);
1223  }
1224  int AllReduce(const short *sendBuffer, short *recvBuffer,
1225  vtkIdType length, Operation *operation) {
1226  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1227  VTK_SHORT, operation);
1228  }
1229  int AllReduce(const unsigned short *sendBuffer, unsigned short *recvBuffer,
1230  vtkIdType length, Operation *operation) {
1231  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1232  VTK_UNSIGNED_SHORT, operation);
1233  }
1234  int AllReduce(const long *sendBuffer, long *recvBuffer,
1235  vtkIdType length, Operation *operation) {
1236  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1237  VTK_LONG, operation);
1238  }
1239  int AllReduce(const unsigned long *sendBuffer, unsigned long *recvBuffer,
1240  vtkIdType length, Operation *operation) {
1241  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1242  VTK_UNSIGNED_LONG, operation);
1243  }
1244  int AllReduce(const unsigned char *sendBuffer, unsigned char *recvBuffer,
1245  vtkIdType length, Operation *operation) {
1246  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1247  VTK_UNSIGNED_CHAR, operation);
1248  }
1249  int AllReduce(const char *sendBuffer, char *recvBuffer,
1250  vtkIdType length, Operation *operation) {
1251  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1252  VTK_CHAR, operation);
1253  }
1254  int AllReduce(const signed char *sendBuffer, signed char *recvBuffer,
1255  vtkIdType length, Operation *operation) {
1256  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1257  VTK_SIGNED_CHAR, operation);
1258  }
1259  int AllReduce(const float *sendBuffer, float *recvBuffer,
1260  vtkIdType length, Operation *operation) {
1261  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1262  VTK_FLOAT, operation);
1263  }
1264  int AllReduce(const double *sendBuffer, double *recvBuffer,
1265  vtkIdType length, Operation *operation) {
1266  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1267  VTK_DOUBLE, operation);
1268  }
1269 #ifdef VTK_USE_64BIT_IDS
1270  int AllReduce(const vtkIdType *sendBuffer, vtkIdType *recvBuffer,
1271  vtkIdType length, Operation *operation) {
1272  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1273  VTK_ID_TYPE, operation);
1274  }
1275 #elif defined(VTK_TYPE_USE_LONG_LONG)
1276  int AllReduce(const long long *sendBuffer, long long *recvBuffer,
1277  vtkIdType length, Operation *operation) {
1278  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1279  VTK_LONG_LONG, operation);
1280  }
1281 #endif
1282 #ifdef VTK_TYPE_USE_LONG_LONG
1283  int AllReduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer,
1284  vtkIdType length, Operation *operation) {
1285  return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
1286  VTK_UNSIGNED_LONG_LONG, operation);
1287  }
1288 #endif
1289  int AllReduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
1290  Operation *operation);
1292 
1294 
1296  virtual int BroadcastVoidArray(void *data, vtkIdType length, int type,
1297  int srcProcessId);
1298  virtual int GatherVoidArray(const void *sendBuffer, void *recvBuffer,
1299  vtkIdType length, int type, int destProcessId);
1300  virtual int GatherVVoidArray(const void *sendBuffer, void *recvBuffer,
1301  vtkIdType sendLength, vtkIdType *recvLengths,
1302  vtkIdType *offsets, int type, int destProcessId);
1303  virtual int ScatterVoidArray(const void *sendBuffer, void *recvBuffer,
1304  vtkIdType length, int type, int srcProcessId);
1305  virtual int ScatterVVoidArray(const void *sendBuffer, void *recvBuffer,
1306  vtkIdType *sendLengths, vtkIdType *offsets,
1307  vtkIdType recvLength, int type,
1308  int srcProcessId);
1309  virtual int AllGatherVoidArray(const void *sendBuffer, void *recvBuffer,
1310  vtkIdType length, int type);
1311  virtual int AllGatherVVoidArray(const void *sendBuffer, void *recvBuffer,
1312  vtkIdType sendLength, vtkIdType *recvLengths,
1313  vtkIdType *offsets, int type);
1314  virtual int ReduceVoidArray(const void *sendBuffer, void *recvBuffer,
1315  vtkIdType length, int type,
1316  int operation, int destProcessId);
1317  virtual int ReduceVoidArray(const void *sendBuffer, void *recvBuffer,
1318  vtkIdType length, int type,
1319  Operation *operation, int destProcessId);
1320  virtual int AllReduceVoidArray(const void *sendBuffer, void *recvBuffer,
1321  vtkIdType length, int type,
1322  int operation);
1323  virtual int AllReduceVoidArray(const void *sendBuffer, void *recvBuffer,
1324  vtkIdType length, int type,
1325  Operation *operation);
1327 
1328  static void SetUseCopy(int useCopy);
1329 
1330 //BTX
1332 
1340  virtual int ComputeGlobalBounds(int processorId, int numProcesses,
1341  vtkBoundingBox *bounds,
1342  int *rightHasBounds = 0,
1343  int *leftHasBounds = 0,
1344  int hasBoundsTag = 288402,
1345  int localBoundsTag = 288403,
1346  int globalBoundsTag = 288404);
1347 //ETX
1349 
1351 
1354  static int GetParentProcessor(int pid);
1355  static int GetLeftChildProcessor(int pid);
1357 
1359 
1362  static int MarshalDataObject(vtkDataObject *object, vtkCharArray *buffer);
1363  static int UnMarshalDataObject(vtkCharArray *buffer, vtkDataObject *object);
1365 
1366 protected:
1367 
1368  int WriteDataArray(vtkDataArray *object);
1369  int ReadDataArray(vtkDataArray *object);
1370 
1371  vtkCommunicator();
1372  ~vtkCommunicator();
1373 
1374  // Internal methods called by Send/Receive(vtkDataObject *... ) above.
1375  int SendElementalDataObject(vtkDataObject* data, int remoteHandle, int tag);
1377 
1383  int GatherV(vtkDataArray *sendArray, vtkDataArray* recvArray,
1384  vtkSmartPointer<vtkDataArray>* recvArrays, int destProcessId);
1385  int GatherVElementalDataObject(vtkDataObject* sendData,
1386  vtkSmartPointer<vtkDataObject>* receiveData,
1387  int destProcessId);
1389 
1390  int ReceiveDataObject(vtkDataObject* data,
1391  int remoteHandle, int tag, int type=-1);
1392  int ReceiveElementalDataObject(vtkDataObject* data,
1393  int remoteHandle, int tag);
1394  int ReceiveMultiBlockDataSet(
1395  vtkMultiBlockDataSet* data, int remoteHandle, int tag);
1396 
1397  int MaximumNumberOfProcesses;
1398  int NumberOfProcesses;
1399 
1400  int LocalProcessId;
1401 
1402  static int UseCopy;
1403 
1404  vtkIdType Count;
1405 
1406 private:
1407  vtkCommunicator(const vtkCommunicator&); // Not implemented.
1408  void operator=(const vtkCommunicator&); // Not implemented.
1409 };
1410 
1411 #endif // vtkCommunicator_h
1412 // VTK-HeaderTest-Exclude: vtkCommunicator.h
vtkCommunicator::Receive
int Receive(unsigned short *data, vtkIdType maxlength, int remoteHandle, int tag)
Definition: vtkCommunicator.h:240
vtkCommunicator::AllGatherV
int AllGatherV(const char *sendBuffer, char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Definition: vtkCommunicator.h:909
vtkCommunicator::Send
int Send(const long *data, vtkIdType length, int remoteHandle, int tag)
Definition: vtkCommunicator.h:160
vtkCommunicator::GatherV
int GatherV(const short *sendBuffer, short *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
Definition: vtkCommunicator.h:473
vtkCommunicator::AllGather
int AllGather(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length)
Definition: vtkCommunicator.h:794
vtkCommunicator::Receive
int Receive(vtkDataObject *data, int remoteHandle, int tag)
vtkCommunicator::LOGICAL_AND_OP
@ LOGICAL_AND_OP
Definition: vtkCommunicator.h:91
vtkCommunicator::AllReduce
int AllReduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, int operation)
vtkCommunicator::Operation::~Operation
virtual ~Operation()
Definition: vtkCommunicator.h:124
vtkCommunicator::AllReduce
int AllReduce(const float *sendBuffer, float *recvBuffer, vtkIdType length, int operation)
Definition: vtkCommunicator.h:1182
vtkgl::data
GLsizei GLsizei GLenum GLenum const GLvoid * data
Definition: vtkgl.h:11339
vtkCommunicator::Receive
int Receive(unsigned char *data, vtkIdType maxlength, int remoteHandle, int tag)
Definition: vtkCommunicator.h:250
vtkCommunicator::Gather
int Gather(const short *sendBuffer, short *recvBuffer, vtkIdType length, int destProcessId)
Definition: vtkCommunicator.h:379
vtkCommunicator::Reduce
int Reduce(const int *sendBuffer, int *recvBuffer, vtkIdType length, int operation, int destProcessId)
Definition: vtkCommunicator.h:972
vtkCommunicator::Reduce
int Reduce(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
Definition: vtkCommunicator.h:1095
vtkCommunicator::Receive
int Receive(double *data, vtkIdType maxlength, int remoteHandle, int tag)
Definition: vtkCommunicator.h:263
vtkCommunicator::Receive
int Receive(int *data, vtkIdType maxlength, int remoteHandle, int tag)
Definition: vtkCommunicator.h:231
VTK_UNSIGNED_LONG_LONG
#define VTK_UNSIGNED_LONG_LONG
Definition: vtkType.h:46
vtkCommunicator::SUM_OP
@ SUM_OP
Definition: vtkCommunicator.h:89
vtkCommunicator::Gather
int Gather(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, int destProcessId)
Definition: vtkCommunicator.h:374
vtkCommunicator::GatherV
int GatherV(const int *sendBuffer, int *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
Definition: vtkCommunicator.h:459
vtkCommunicator::Gather
int Gather(const int *sendBuffer, int *recvBuffer, vtkIdType length, int destProcessId)
Definition: vtkCommunicator.h:369
vtkCommunicator::LOGICAL_OR_OP
@ LOGICAL_OR_OP
Definition: vtkCommunicator.h:93
vtkCommunicator::ReduceVoidArray
virtual int ReduceVoidArray(const void *sendBuffer, void *recvBuffer, vtkIdType length, int type, Operation *operation, int destProcessId)
vtkCommunicator::ComputeGlobalBounds
virtual int ComputeGlobalBounds(int processorId, int numProcesses, vtkBoundingBox *bounds, int *rightHasBounds=0, int *leftHasBounds=0, int hasBoundsTag=288402, int localBoundsTag=288403, int globalBoundsTag=288404)
vtkCommunicator::AllReduce
int AllReduce(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, Operation *operation)
Definition: vtkCommunicator.h:1219
vtkCommunicator::AllReduce
int AllReduce(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, int operation)
Definition: vtkCommunicator.h:1152
vtkCommunicator
Used to send/receive messages in a multiprocess environment.
Definition: vtkCommunicator.h:52
vtkIdType
int vtkIdType
Definition: vtkType.h:275
vtkCommunicator::GetParentProcessor
static int GetParentProcessor(int pid)
vtkCommunicator::Reduce
int Reduce(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, int operation, int destProcessId)
Definition: vtkCommunicator.h:997
vtkCommunicator::Broadcast
int Broadcast(unsigned char *data, vtkIdType length, int srcProcessId)
Definition: vtkCommunicator.h:324
vtkCommunicator::SendVoidArray
virtual int SendVoidArray(const void *data, vtkIdType length, int type, int remoteHandle, int tag)=0
vtkCommunicator::Gather
int Gather(const double *sendBuffer, double *recvBuffer, vtkIdType length, int destProcessId)
Definition: vtkCommunicator.h:419
VTK_UNSIGNED_INT
#define VTK_UNSIGNED_INT
Definition: vtkType.h:32
vtkCommunicator::Reduce
int Reduce(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, int operation, int destProcessId)
Definition: vtkCommunicator.h:987
vtkCommunicator::ReceiveVoidArray
virtual int ReceiveVoidArray(void *data, vtkIdType maxlength, int type, int remoteHandle, int tag)=0
vtkCommunicator::ScatterVoidArray
virtual int ScatterVoidArray(const void *sendBuffer, void *recvBuffer, vtkIdType length, int type, int srcProcessId)
vtkCommunicator::AllGather
int AllGather(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length)
Definition: vtkCommunicator.h:802
vtkCommunicator::Operation
Definition: vtkCommunicator.h:103
vtkCommunicator::AllReduce
int AllReduce(const long *sendBuffer, long *recvBuffer, vtkIdType length, Operation *operation)
Definition: vtkCommunicator.h:1234
vtkCommunicator::AllGatherV
int AllGatherV(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Definition: vtkCommunicator.h:902
vtkMultiProcessStream
stream used to pass data across processes using vtkMultiProcessController.
Definition: vtkMultiProcessStream.h:40
vtkCommunicator::AllGatherV
int AllGatherV(const float *sendBuffer, float *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Definition: vtkCommunicator.h:923
VTK_UNSIGNED_SHORT
#define VTK_UNSIGNED_SHORT
Definition: vtkType.h:30
vtkCommunicator::Receive
int Receive(char *data, vtkIdType maxlength, int remoteHandle, int tag)
Definition: vtkCommunicator.h:254
vtkCommunicator::Reduce
int Reduce(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
Definition: vtkCommunicator.h:1085
vtkCommunicator::WriteDataArray
int WriteDataArray(vtkDataArray *object)
vtkCommunicator::GatherVoidArray
virtual int GatherVoidArray(const void *sendBuffer, void *recvBuffer, vtkIdType length, int type, int destProcessId)
vtkTypeMacro
#define vtkTypeMacro(thisClass, superclass)
Definition: vtkSetGet.h:642
vtkCommunicator::Receive
int Receive(signed char *data, vtkIdType maxlength, int remoteHandle, int tag)
Definition: vtkCommunicator.h:257
vtkgl::stream
GLuint GLuint stream
Definition: vtkgl.h:14154
vtkCommunicator::Barrier
virtual void Barrier()
vtkCommunicator::Reduce
int Reduce(const float *sendBuffer, float *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
Definition: vtkCommunicator.h:1100
vtkCommunicator::ScatterV
int ScatterV(const float *sendBuffer, float *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
Definition: vtkCommunicator.h:747
vtkCommunicator::AllReduce
int AllReduce(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, Operation *operation)
Definition: vtkCommunicator.h:1229
vtkCommunicator::AllGatherV
int AllGatherV(const int *sendBuffer, int *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Definition: vtkCommunicator.h:860
vtkSmartPointer< vtkDataObject >
vtkObject
abstract base class for most VTK objects
Definition: vtkObject.h:62
vtkCommunicator::AllReduce
int AllReduce(const double *sendBuffer, double *recvBuffer, vtkIdType length, Operation *operation)
Definition: vtkCommunicator.h:1264
vtkCommunicator::AllReduce
int AllReduce(const short *sendBuffer, short *recvBuffer, vtkIdType length, int operation)
Definition: vtkCommunicator.h:1147
vtkCommunicator::PRODUCT_OP
@ PRODUCT_OP
Definition: vtkCommunicator.h:90
vtkCommunicator::Reduce
int Reduce(const double *sendBuffer, double *recvBuffer, vtkIdType length, int operation, int destProcessId)
Definition: vtkCommunicator.h:1022
vtkCommunicator::Reduce
int Reduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, Operation *operation, int destProcessId)
vtkCommunicator::AllGatherV
int AllGatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer)
vtkCommunicator::Broadcast
int Broadcast(vtkDataObject *data, int srcProcessId)
vtkCommunicator::AllReduce
int AllReduce(const long *sendBuffer, long *recvBuffer, vtkIdType length, int operation)
Definition: vtkCommunicator.h:1157
vtkCommunicator::MaximumNumberOfProcesses
int MaximumNumberOfProcesses
Definition: vtkCommunicator.h:1397
vtkCommunicator::Reduce
int Reduce(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, int operation, int destProcessId)
Definition: vtkCommunicator.h:1012
vtkCommunicator::AllReduceVoidArray
virtual int AllReduceVoidArray(const void *sendBuffer, void *recvBuffer, vtkIdType length, int type, int operation)
vtkDataArray
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:55
vtkCommunicator::ScatterV
int ScatterV(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
Definition: vtkCommunicator.h:740
vtkCommunicator::Scatter
int Scatter(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, int srcProcessId)
Definition: vtkCommunicator.h:628
vtkCommunicator::AllGatherV
int AllGatherV(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Definition: vtkCommunicator.h:895
vtkCommunicator::BITWISE_AND_OP
@ BITWISE_AND_OP
Definition: vtkCommunicator.h:92
vtkCommunicator::ScatterV
int ScatterV(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
Definition: vtkCommunicator.h:705
vtkCommunicator::AllGather
int AllGather(const float *sendBuffer, float *recvBuffer, vtkIdType length)
Definition: vtkCommunicator.h:828
vtkCommunicator::GatherV
int GatherV(const double *sendBuffer, double *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
Definition: vtkCommunicator.h:529
vtkCommunicator::LocalProcessId
int LocalProcessId
Definition: vtkCommunicator.h:1400
vtkCommunicator::Send
int Send(const unsigned long *data, vtkIdType length, int remoteHandle, int tag)
Definition: vtkCommunicator.h:164
VTK_LONG_LONG
#define VTK_LONG_LONG
Definition: vtkType.h:45
vtkCommunicator::Scatter
int Scatter(const short *sendBuffer, short *recvBuffer, vtkIdType length, int srcProcessId)
Definition: vtkCommunicator.h:608
vtkMultiBlockDataSet
Composite dataset that organizes datasets into blocks.
Definition: vtkMultiBlockDataSet.h:51
vtkgl::length
GLuint GLsizei GLsizei * length
Definition: vtkgl.h:11992
vtkCommunicator::ScatterV
int ScatterV(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
Definition: vtkCommunicator.h:691
vtkCommunicator::AllGather
int AllGather(const long *sendBuffer, long *recvBuffer, vtkIdType length)
Definition: vtkCommunicator.h:807
vtkCommunicator::Receive
int Receive(unsigned long *data, vtkIdType maxlength, int remoteHandle, int tag)
Definition: vtkCommunicator.h:246
vtkCommunicator::GatherV
int GatherV(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
Definition: vtkCommunicator.h:494
vtkCommunicator::Receive
int Receive(vtkMultiProcessStream &stream, int remoteId, int tag)
vtkCommunicator::UnMarshalDataObject
static int UnMarshalDataObject(vtkCharArray *buffer, vtkDataObject *object)
vtkCommunicator::AllGatherV
int AllGatherV(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Definition: vtkCommunicator.h:867
vtkCommunicator::ReceiveDataObject
vtkDataObject * ReceiveDataObject(int remoteHandle, int tag)
vtkCommunicator::AllGather
int AllGather(const char *sendBuffer, char *recvBuffer, vtkIdType length)
Definition: vtkCommunicator.h:820
vtkCommunicator::AllGatherVoidArray
virtual int AllGatherVoidArray(const void *sendBuffer, void *recvBuffer, vtkIdType length, int type)
vtkCommunicator::Reduce
int Reduce(const long *sendBuffer, long *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
Definition: vtkCommunicator.h:1075
vtkCommunicator::Send
int Send(const short *data, vtkIdType length, int remoteHandle, int tag)
Definition: vtkCommunicator.h:154
vtkCommunicator::ScatterV
int ScatterV(const double *sendBuffer, double *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
Definition: vtkCommunicator.h:754
vtkCommunicator::LOGICAL_XOR_OP
@ LOGICAL_XOR_OP
Definition: vtkCommunicator.h:95
vtkCommunicator::AllGather
int AllGather(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer)
vtkCommunicator::Broadcast
int Broadcast(double *data, vtkIdType length, int srcProcessId)
Definition: vtkCommunicator.h:336
vtkCommunicator::Reduce
int Reduce(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
Definition: vtkCommunicator.h:1060
vtkCommunicator::Send
int Send(const unsigned int *data, vtkIdType length, int remoteHandle, int tag)
Definition: vtkCommunicator.h:151
vtkCommunicator::Tags
Tags
Definition: vtkCommunicator.h:75
vtkBoundingBox
Fast Simple Class for dealing with 3D bounds.
Definition: vtkBoundingBox.h:35
vtkCharArray
dynamic, self-adjusting array of char
Definition: vtkCharArray.h:46
vtkCommunicator::GatherV
int GatherV(const char *sendBuffer, char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
Definition: vtkCommunicator.h:508
vtkCommunicator::Broadcast
int Broadcast(vtkMultiProcessStream &stream, int srcProcessId)
vtkCommunicator::Send
int Send(const char *data, vtkIdType length, int remoteHandle, int tag)
Definition: vtkCommunicator.h:172
vtkCommunicator::AllReduce
int AllReduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, Operation *operation)
vtkCommunicator::Gather
int Gather(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, int destProcessId)
Definition: vtkCommunicator.h:409
vtkCommunicator::BITWISE_OR_OP
@ BITWISE_OR_OP
Definition: vtkCommunicator.h:94
vtkCommunicator::Scatter
int Scatter(const double *sendBuffer, double *recvBuffer, vtkIdType length, int srcProcessId)
Definition: vtkCommunicator.h:648
vtkCommunicator::AllReduce
int AllReduce(const int *sendBuffer, int *recvBuffer, vtkIdType length, int operation)
Definition: vtkCommunicator.h:1137
vtkCommunicator::Broadcast
int Broadcast(vtkDataArray *data, int srcProcessId)
vtkCommunicator::ScatterV
int ScatterV(const char *sendBuffer, char *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
Definition: vtkCommunicator.h:733
vtkCommunicator::Operation::Commutative
virtual int Commutative()=0
vtkCommunicator::Receive
int Receive(float *data, vtkIdType maxlength, int remoteHandle, int tag)
Definition: vtkCommunicator.h:260
vtkCommunicator::AllGatherV
int AllGatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, vtkIdType *recvLengths, vtkIdType *offsets)
vtkCommunicator::Scatter
int Scatter(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, int srcProcessId)
Definition: vtkCommunicator.h:603
vtkCommunicator::ReceiveMultiBlockDataSet
int ReceiveMultiBlockDataSet(vtkMultiBlockDataSet *data, int remoteHandle, int tag)
vtkCommunicator::MarshalDataObject
static int MarshalDataObject(vtkDataObject *object, vtkCharArray *buffer)
vtkCommunicator::AllGather
int AllGather(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length)
Definition: vtkCommunicator.h:815
vtkCommunicator::AllReduce
int AllReduce(const double *sendBuffer, double *recvBuffer, vtkIdType length, int operation)
Definition: vtkCommunicator.h:1187
vtkCommunicator::SetUseCopy
static void SetUseCopy(int useCopy)
vtkCommunicator::vtkCommunicator
vtkCommunicator()
vtkCommunicator::AllReduce
int AllReduce(const char *sendBuffer, char *recvBuffer, vtkIdType length, int operation)
Definition: vtkCommunicator.h:1172
vtkCommunicator::GatherV
int GatherV(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
Definition: vtkCommunicator.h:466
vtkCommunicator::Count
vtkIdType Count
Definition: vtkCommunicator.h:1404
vtkCommunicator::Broadcast
int Broadcast(unsigned short *data, vtkIdType length, int srcProcessId)
Definition: vtkCommunicator.h:315
vtkCommunicator::ScatterV
int ScatterV(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
Definition: vtkCommunicator.h:726
vtkCommunicator::GatherV
int GatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, int destProcessId)
VTK_CHAR
#define VTK_CHAR
Definition: vtkType.h:26
vtkCommunicator::Reduce
int Reduce(const short *sendBuffer, short *recvBuffer, vtkIdType length, int operation, int destProcessId)
Definition: vtkCommunicator.h:982
vtkCommunicator::AllGather
int AllGather(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length)
Definition: vtkCommunicator.h:823
vtkCommunicator::Scatter
int Scatter(const long *sendBuffer, long *recvBuffer, vtkIdType length, int srcProcessId)
Definition: vtkCommunicator.h:618
vtkCommunicator::Send
int Send(const float *data, vtkIdType length, int remoteHandle, int tag)
Definition: vtkCommunicator.h:178
vtkCommunicator::AllGatherV
int AllGatherV(const long *sendBuffer, long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Definition: vtkCommunicator.h:888
vtkCommunicator::AllGatherV
int AllGatherV(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Definition: vtkCommunicator.h:916
vtkCommunicator::AllReduce
int AllReduce(const char *sendBuffer, char *recvBuffer, vtkIdType length, Operation *operation)
Definition: vtkCommunicator.h:1249
vtkgl::num
GLuint GLuint num
Definition: vtkgl.h:16907
vtkCommunicator::GatherV
int GatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, vtkIdTypeArray *recvLengths, vtkIdTypeArray *offsets, int destProcessId)
vtkCommunicator::Reduce
int Reduce(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, int operation, int destProcessId)
Definition: vtkCommunicator.h:977
vtkImageData
topologically and geometrically regular array of data
Definition: vtkImageData.h:45
vtkIndent
a simple class to control print indentation
Definition: vtkIndent.h:39
vtkCommunicator::ScatterVVoidArray
virtual int ScatterVVoidArray(const void *sendBuffer, void *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int type, int srcProcessId)
vtkCommunicator::GatherV
int GatherV(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
Definition: vtkCommunicator.h:515
vtkCommunicator::Receive
int Receive(vtkDataArray *data, int remoteHandle, int tag)
vtkParallelCoreModule.h
vtkCommunicator::AllReduce
int AllReduce(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, Operation *operation)
Definition: vtkCommunicator.h:1254
vtkCommunicator::AllReduceVoidArray
virtual int AllReduceVoidArray(const void *sendBuffer, void *recvBuffer, vtkIdType length, int type, Operation *operation)
vtkCommunicator::MIN_OP
@ MIN_OP
Definition: vtkCommunicator.h:88
vtkCommunicator::Receive
int Receive(short *data, vtkIdType maxlength, int remoteHandle, int tag)
Definition: vtkCommunicator.h:237
VTK_FLOAT
#define VTK_FLOAT
Definition: vtkType.h:35
VTK_DOUBLE
#define VTK_DOUBLE
Definition: vtkType.h:36
vtkSmartPointer.h
VTKPARALLELCORE_EXPORT
#define VTKPARALLELCORE_EXPORT
Definition: vtkParallelCoreModule.h:15
vtkCommunicator::SetNumberOfProcesses
virtual void SetNumberOfProcesses(int num)
vtkCommunicator::GatherVVoidArray
virtual int GatherVVoidArray(const void *sendBuffer, void *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int type, int destProcessId)
vtkCommunicator::Reduce
int Reduce(const int *sendBuffer, int *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
Definition: vtkCommunicator.h:1055
vtkCommunicator::Send
int Send(const int *data, vtkIdType length, int remoteHandle, int tag)
Definition: vtkCommunicator.h:148
VTK_UNSIGNED_CHAR
#define VTK_UNSIGNED_CHAR
Definition: vtkType.h:28
vtkCommunicator::Operation::Function
virtual void Function(const void *A, void *B, vtkIdType length, int datatype)=0
vtkCommunicator::ScatterV
int ScatterV(const long *sendBuffer, long *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
Definition: vtkCommunicator.h:712
vtkCommunicator::Reduce
int Reduce(const short *sendBuffer, short *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
Definition: vtkCommunicator.h:1065
VTK_LONG
#define VTK_LONG
Definition: vtkType.h:33
vtkCommunicator::AllGather
int AllGather(const int *sendBuffer, int *recvBuffer, vtkIdType length)
Definition: vtkCommunicator.h:791
vtkGetMacro
#define vtkGetMacro(name, type)
Definition: vtkSetGet.h:93
vtkCommunicator::GatherV
int GatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
vtkCommunicator::AllGather
int AllGather(const double *sendBuffer, double *recvBuffer, vtkIdType length)
Definition: vtkCommunicator.h:831
vtkCommunicator::Reduce
int Reduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, int operation, int destProcessId)
vtkCommunicator::ReceiveDataObject
int ReceiveDataObject(vtkDataObject *data, int remoteHandle, int tag, int type=-1)
vtkCommunicator::Gather
int Gather(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, int destProcessId)
Definition: vtkCommunicator.h:384
vtkCommunicator::Gather
int Gather(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, int destProcessId)
Definition: vtkCommunicator.h:394
vtkObject.h
vtkCommunicator::Gather
int Gather(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, int destProcessId)
Definition: vtkCommunicator.h:399
vtkCommunicator::Send
int Send(const vtkMultiProcessStream &stream, int remoteId, int tag)
vtkDataSet
abstract class to specify dataset behavior
Definition: vtkDataSet.h:62
vtkCommunicator::Broadcast
int Broadcast(unsigned int *data, vtkIdType length, int srcProcessId)
Definition: vtkCommunicator.h:309
VTK_UNSIGNED_LONG
#define VTK_UNSIGNED_LONG
Definition: vtkType.h:34
vtkCommunicator::AllGatherVVoidArray
virtual int AllGatherVVoidArray(const void *sendBuffer, void *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int type)
vtkCommunicator::SendElementalDataObject
int SendElementalDataObject(vtkDataObject *data, int remoteHandle, int tag)
vtkCommunicator::Reduce
int Reduce(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
Definition: vtkCommunicator.h:1080
vtkCommunicator::ScatterV
int ScatterV(const int *sendBuffer, int *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
Definition: vtkCommunicator.h:684
vtkCommunicator::~vtkCommunicator
~vtkCommunicator()
vtkCommunicator::AllGather
int AllGather(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length)
Definition: vtkCommunicator.h:810
vtkCommunicator::GatherVElementalDataObject
int GatherVElementalDataObject(vtkDataObject *sendData, vtkSmartPointer< vtkDataObject > *receiveData, int destProcessId)
vtkCommunicator::Scatter
int Scatter(const float *sendBuffer, float *recvBuffer, vtkIdType length, int srcProcessId)
Definition: vtkCommunicator.h:643
vtkCommunicator::Scatter
int Scatter(const char *sendBuffer, char *recvBuffer, vtkIdType length, int srcProcessId)
Definition: vtkCommunicator.h:633
VTK_SHORT
#define VTK_SHORT
Definition: vtkType.h:29
vtkCommunicator::PrintSelf
void PrintSelf(ostream &os, vtkIndent indent)
vtkCommunicator::Gather
int Gather(const long *sendBuffer, long *recvBuffer, vtkIdType length, int destProcessId)
Definition: vtkCommunicator.h:389
vtkIdTypeArray
dynamic, self-adjusting array of vtkIdType
Definition: vtkIdTypeArray.h:49
vtkCommunicator::Send
int Send(vtkDataObject *data, int remoteHandle, int tag)
vtkCommunicator::Send
int Send(const unsigned short *data, vtkIdType length, int remoteHandle, int tag)
Definition: vtkCommunicator.h:157
vtkgl::buffer
GLuint buffer
Definition: vtkgl.h:11839
vtkCommunicator::Reduce
int Reduce(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
Definition: vtkCommunicator.h:1070
vtkCommunicator::Broadcast
int Broadcast(short *data, vtkIdType length, int srcProcessId)
Definition: vtkCommunicator.h:312
vtkCommunicator::GatherV
int GatherV(vtkDataObject *sendData, vtkSmartPointer< vtkDataObject > *recvData, int destProcessId)
vtkCommunicator::GatherV
int GatherV(const float *sendBuffer, float *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
Definition: vtkCommunicator.h:522
vtkCommunicator::AllGatherV
int AllGatherV(const short *sendBuffer, short *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Definition: vtkCommunicator.h:874
vtkCommunicator::AllReduce
int AllReduce(const int *sendBuffer, int *recvBuffer, vtkIdType length, Operation *operation)
Definition: vtkCommunicator.h:1214
vtkCommunicator::Send
int Send(const signed char *data, vtkIdType length, int remoteHandle, int tag)
Definition: vtkCommunicator.h:175
VTK_SIGNED_CHAR
#define VTK_SIGNED_CHAR
Definition: vtkType.h:27
vtkCommunicator::Receive
int Receive(long *data, vtkIdType maxlength, int remoteHandle, int tag)
Definition: vtkCommunicator.h:243
vtkCommunicator::ReduceVoidArray
virtual int ReduceVoidArray(const void *sendBuffer, void *recvBuffer, vtkIdType length, int type, int operation, int destProcessId)
vtkCommunicator::AllReduce
int AllReduce(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, int operation)
Definition: vtkCommunicator.h:1162
vtkCommunicator::StandardOperations
StandardOperations
Definition: vtkCommunicator.h:86
vtkCommunicator::GatherV
int GatherV(const long *sendBuffer, long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
Definition: vtkCommunicator.h:487
vtkCommunicator::Send
int Send(const unsigned char *data, vtkIdType length, int remoteHandle, int tag)
Definition: vtkCommunicator.h:168
VTK_ID_TYPE
#define VTK_ID_TYPE
Definition: vtkType.h:37
vtkCommunicator::Reduce
int Reduce(const long *sendBuffer, long *recvBuffer, vtkIdType length, int operation, int destProcessId)
Definition: vtkCommunicator.h:992
vtkCommunicator::AllReduce
int AllReduce(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, Operation *operation)
Definition: vtkCommunicator.h:1244
vtkCommunicator::Reduce
int Reduce(const char *sendBuffer, char *recvBuffer, vtkIdType length, int operation, int destProcessId)
Definition: vtkCommunicator.h:1007
vtkCommunicator::MAX_OP
@ MAX_OP
Definition: vtkCommunicator.h:87
vtkCommunicator::AllReduce
int AllReduce(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, int operation)
Definition: vtkCommunicator.h:1167
vtkCommunicator::Scatter
int Scatter(const int *sendBuffer, int *recvBuffer, vtkIdType length, int srcProcessId)
Definition: vtkCommunicator.h:598
vtkCommunicator::Broadcast
int Broadcast(char *data, vtkIdType length, int srcProcessId)
Definition: vtkCommunicator.h:327
vtkCommunicator::AllGather
int AllGather(const short *sendBuffer, short *recvBuffer, vtkIdType length)
Definition: vtkCommunicator.h:799
vtkCommunicator::Gather
int Gather(const char *sendBuffer, char *recvBuffer, vtkIdType length, int destProcessId)
Definition: vtkCommunicator.h:404
vtkCommunicator::AllGatherV
int AllGatherV(const double *sendBuffer, double *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Definition: vtkCommunicator.h:930
vtkCommunicator::ReceiveElementalDataObject
int ReceiveElementalDataObject(vtkDataObject *data, int remoteHandle, int tag)
vtkCommunicator::AllReduce
int AllReduce(const float *sendBuffer, float *recvBuffer, vtkIdType length, Operation *operation)
Definition: vtkCommunicator.h:1259
vtkCommunicator::Reduce
int Reduce(const float *sendBuffer, float *recvBuffer, vtkIdType length, int operation, int destProcessId)
Definition: vtkCommunicator.h:1017
vtkCommunicator::ScatterV
int ScatterV(const short *sendBuffer, short *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
Definition: vtkCommunicator.h:698
vtkCommunicator::Send
int Send(const double *data, vtkIdType length, int remoteHandle, int tag)
Definition: vtkCommunicator.h:181
VTK_INT
#define VTK_INT
Definition: vtkType.h:31
vtkCommunicator::Reduce
int Reduce(const double *sendBuffer, double *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
Definition: vtkCommunicator.h:1105
vtkCommunicator::AllReduce
int AllReduce(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, Operation *operation)
Definition: vtkCommunicator.h:1239
vtkCommunicator::GatherV
int GatherV(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
Definition: vtkCommunicator.h:480
vtkCommunicator::BroadcastVoidArray
virtual int BroadcastVoidArray(void *data, vtkIdType length, int type, int srcProcessId)
vtkCommunicator::Send
int Send(vtkDataArray *data, int remoteHandle, int tag)
vtkCommunicator::GetLeftChildProcessor
static int GetLeftChildProcessor(int pid)
vtkCommunicator::GatherV
int GatherV(vtkDataArray *sendArray, vtkDataArray *recvArray, vtkSmartPointer< vtkDataArray > *recvArrays, int destProcessId)
vtkDataObject
general representation of visualization data
Definition: vtkDataObject.h:65
vtkCommunicator::AllReduce
int AllReduce(const short *sendBuffer, short *recvBuffer, vtkIdType length, Operation *operation)
Definition: vtkCommunicator.h:1224
vtkCommunicator::ScatterV
int ScatterV(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
Definition: vtkCommunicator.h:719
vtkCommunicator::Reduce
int Reduce(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, int operation, int destProcessId)
Definition: vtkCommunicator.h:1002
vtkCommunicator::Gather
int Gather(const float *sendBuffer, float *recvBuffer, vtkIdType length, int destProcessId)
Definition: vtkCommunicator.h:414
vtkgl::type
GLuint GLuint GLsizei GLenum type
Definition: vtkgl.h:11315
vtkCommunicator::AllReduce
int AllReduce(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, int operation)
Definition: vtkCommunicator.h:1177
vtkCommunicator::Broadcast
int Broadcast(int *data, vtkIdType length, int srcProcessId)
Definition: vtkCommunicator.h:306
vtkCommunicator::NumberOfProcesses
int NumberOfProcesses
Definition: vtkCommunicator.h:1398
vtkCommunicator::Gather
int Gather(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, int destProcessId)
vtkCommunicator::Broadcast
int Broadcast(unsigned long *data, vtkIdType length, int srcProcessId)
Definition: vtkCommunicator.h:321
vtkCommunicator::Broadcast
int Broadcast(long *data, vtkIdType length, int srcProcessId)
Definition: vtkCommunicator.h:318
vtkCommunicator::Reduce
int Reduce(const char *sendBuffer, char *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
Definition: vtkCommunicator.h:1090
vtkCommunicator::Receive
int Receive(unsigned int *data, vtkIdType maxlength, int remoteHandle, int tag)
Definition: vtkCommunicator.h:234
vtkCommunicator::UseCopy
static int UseCopy
Definition: vtkCommunicator.h:1402
vtkCommunicator::Scatter
int Scatter(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, int srcProcessId)
Definition: vtkCommunicator.h:623
vtkCommunicator::Broadcast
int Broadcast(signed char *data, vtkIdType length, int srcProcessId)
Definition: vtkCommunicator.h:330
vtkCommunicator::Broadcast
int Broadcast(float *data, vtkIdType length, int srcProcessId)
Definition: vtkCommunicator.h:333
vtkCommunicator::ReadDataArray
int ReadDataArray(vtkDataArray *object)
vtkCommunicator::Scatter
int Scatter(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, int srcProcessId)
Definition: vtkCommunicator.h:638
vtkCommunicator::AllGatherV
int AllGatherV(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Definition: vtkCommunicator.h:881
vtkCommunicator::GatherV
int GatherV(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
Definition: vtkCommunicator.h:501
vtkCommunicator::Scatter
int Scatter(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, int srcProcessId)
vtkCommunicator::Scatter
int Scatter(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, int srcProcessId)
Definition: vtkCommunicator.h:613
vtkCommunicator::AllReduce
int AllReduce(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, int operation)
Definition: vtkCommunicator.h:1142
Generated by doxygen 1.8.20