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