VTK: Parallel/Core/vtkCommunicator.h Source File

| VTK 9.3.1

vtkCommunicator.h
Go to the documentation of this file.
1 // SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
2 // SPDX-License-Identifier: BSD-3-Clause
23 #ifndef vtkCommunicator_h
24 #define vtkCommunicator_h
25
26 #include "vtkObject.h"
27 #include "vtkParallelCoreModule.h" // For export macro
28 #include "vtkSmartPointer.h" // needed for vtkSmartPointer.
29 #include <vector> // needed for std::vector
30
31 VTK_ABI_NAMESPACE_BEGIN
32 class vtkBoundingBox;
33 class vtkCharArray;
34 class vtkDataArray;
35 class vtkDataObject;
36 class vtkDataSet;
37 class vtkIdTypeArray;
38 class vtkImageData;
39 class vtkMultiBlockDataSet;
40 class vtkMultiProcessStream;
41
42 class VTKPARALLELCORE_EXPORT vtkCommunicator : public vtkObject
43 {
44
45 public:
46 vtkTypeMacro(vtkCommunicator, vtkObject);
47 void PrintSelf(ostream& os, vtkIndent indent) override;
48
50
55 virtual void SetNumberOfProcesses(int num);
56 vtkGetMacro(NumberOfProcesses, int);
58
60
63 vtkGetMacro(LocalProcessId, int);
65
66 enum Tags
67 {
68 BROADCAST_TAG = 10,
69 GATHER_TAG = 11,
70 GATHERV_TAG = 12,
71 SCATTER_TAG = 13,
72 SCATTERV_TAG = 14,
73 REDUCE_TAG = 15,
74 BARRIER_TAG = 16
75 };
76
77 enum StandardOperations
78 {
79 MAX_OP,
80 MIN_OP,
81 SUM_OP,
82 PRODUCT_OP,
83 LOGICAL_AND_OP,
84 BITWISE_AND_OP,
85 LOGICAL_OR_OP,
86 BITWISE_OR_OP,
87 LOGICAL_XOR_OP,
88 BITWISE_XOR_OP
89 };
90
95 class Operation
96 {
97 public:
108 virtual void Function(const void* A, void* B, vtkIdType length, int datatype) = 0;
109
114 virtual int Commutative() = 0;
115
116 virtual ~Operation() = default;
117 };
118
124 int Send(vtkDataObject* data, int remoteHandle, int tag);
125
131 int Send(vtkDataArray* data, int remoteHandle, int tag);
132
139 virtual int SendVoidArray(
140 const void* data, vtkIdType length, int type, int remoteHandle, int tag) = 0;
141
143
146 int Send(const int* data, vtkIdType length, int remoteHandle, int tag)
147 {
148 return this->SendVoidArray(data, length, VTK_INT, remoteHandle, tag);
149 }
150 int Send(const unsigned int* data, vtkIdType length, int remoteHandle, int tag)
151 {
152 return this->SendVoidArray(data, length, VTK_INT, remoteHandle, tag);
153 }
154 int Send(const short* data, vtkIdType length, int remoteHandle, int tag)
155 {
156 return this->SendVoidArray(data, length, VTK_SHORT, remoteHandle, tag);
157 }
158 int Send(const unsigned short* data, vtkIdType length, int remoteHandle, int tag)
159 {
160 return this->SendVoidArray(data, length, VTK_UNSIGNED_SHORT, remoteHandle, tag);
161 }
162 int Send(const long* data, vtkIdType length, int remoteHandle, int tag)
163 {
164 return this->SendVoidArray(data, length, VTK_LONG, remoteHandle, tag);
165 }
166 int Send(const unsigned long* data, vtkIdType length, int remoteHandle, int tag)
167 {
168 return this->SendVoidArray(data, length, VTK_UNSIGNED_LONG, remoteHandle, tag);
169 }
170 int Send(const unsigned char* data, vtkIdType length, int remoteHandle, int tag)
171 {
172 return this->SendVoidArray(data, length, VTK_UNSIGNED_CHAR, remoteHandle, tag);
173 }
174 int Send(const char* data, vtkIdType length, int remoteHandle, int tag)
175 {
176 return this->SendVoidArray(data, length, VTK_CHAR, remoteHandle, tag);
177 }
178 int Send(const signed char* data, vtkIdType length, int remoteHandle, int tag)
179 {
180 return this->SendVoidArray(data, length, VTK_SIGNED_CHAR, remoteHandle, tag);
181 }
182 int Send(const float* data, vtkIdType length, int remoteHandle, int tag)
183 {
184 return this->SendVoidArray(data, length, VTK_FLOAT, remoteHandle, tag);
185 }
186 int Send(const double* data, vtkIdType length, int remoteHandle, int tag)
187 {
188 return this->SendVoidArray(data, length, VTK_DOUBLE, remoteHandle, tag);
189 }
190 int Send(const long long* data, vtkIdType length, int remoteHandle, int tag)
191 {
192 return this->SendVoidArray(data, length, VTK_LONG_LONG, remoteHandle, tag);
193 }
194 int Send(const unsigned long long* data, vtkIdType length, int remoteHandle, int tag)
195 {
196 return this->SendVoidArray(data, length, VTK_UNSIGNED_LONG_LONG, remoteHandle, tag);
197 }
199
200 int Send(const vtkMultiProcessStream& stream, int remoteId, int tag);
201
206 int Receive(vtkDataObject* data, int remoteHandle, int tag);
207
212 vtkDataObject* ReceiveDataObject(int remoteHandle, int tag);
213
218 int Receive(vtkDataArray* data, int remoteHandle, int tag);
219
230 virtual int ReceiveVoidArray(
231 void* data, vtkIdType maxlength, int type, int remoteHandle, int tag) = 0;
232
234
237 int Receive(int* data, vtkIdType maxlength, int remoteHandle, int tag)
238 {
239 return this->ReceiveVoidArray(data, maxlength, VTK_INT, remoteHandle, tag);
240 }
241 int Receive(unsigned int* data, vtkIdType maxlength, int remoteHandle, int tag)
242 {
243 return this->ReceiveVoidArray(data, maxlength, VTK_INT, remoteHandle, tag);
244 }
245 int Receive(short* data, vtkIdType maxlength, int remoteHandle, int tag)
246 {
247 return this->ReceiveVoidArray(data, maxlength, VTK_SHORT, remoteHandle, tag);
248 }
249 int Receive(unsigned short* data, vtkIdType maxlength, int remoteHandle, int tag)
250 {
251 return this->ReceiveVoidArray(data, maxlength, VTK_UNSIGNED_SHORT, remoteHandle, tag);
252 }
253 int Receive(long* data, vtkIdType maxlength, int remoteHandle, int tag)
254 {
255 return this->ReceiveVoidArray(data, maxlength, VTK_LONG, remoteHandle, tag);
256 }
257 int Receive(unsigned long* data, vtkIdType maxlength, int remoteHandle, int tag)
258 {
259 return this->ReceiveVoidArray(data, maxlength, VTK_UNSIGNED_LONG, remoteHandle, tag);
260 }
261 int Receive(unsigned char* data, vtkIdType maxlength, int remoteHandle, int tag)
262 {
263 return this->ReceiveVoidArray(data, maxlength, VTK_UNSIGNED_CHAR, remoteHandle, tag);
264 }
265 int Receive(char* data, vtkIdType maxlength, int remoteHandle, int tag)
266 {
267 return this->ReceiveVoidArray(data, maxlength, VTK_CHAR, remoteHandle, tag);
268 }
269 int Receive(signed char* data, vtkIdType maxlength, int remoteHandle, int tag)
270 {
271 return this->ReceiveVoidArray(data, maxlength, VTK_SIGNED_CHAR, remoteHandle, tag);
272 }
273 int Receive(float* data, vtkIdType maxlength, int remoteHandle, int tag)
274 {
275 return this->ReceiveVoidArray(data, maxlength, VTK_FLOAT, remoteHandle, tag);
276 }
277 int Receive(double* data, vtkIdType maxlength, int remoteHandle, int tag)
278 {
279 return this->ReceiveVoidArray(data, maxlength, VTK_DOUBLE, remoteHandle, tag);
280 }
281 int Receive(long long* data, vtkIdType maxlength, int remoteHandle, int tag)
282 {
283 return this->ReceiveVoidArray(data, maxlength, VTK_LONG_LONG, remoteHandle, tag);
284 }
285 int Receive(unsigned long long* data, vtkIdType maxlength, int remoteHandle, int tag)
286 {
287 return this->ReceiveVoidArray(data, maxlength, VTK_UNSIGNED_LONG_LONG, remoteHandle, tag);
288 }
290
291 int Receive(vtkMultiProcessStream& stream, int remoteId, int tag);
292
294
302 vtkGetMacro(Count, vtkIdType);
304
305 //---------------------- Collective Operations ----------------------
306
311 virtual void Barrier();
312
314
319 int Broadcast(int* data, vtkIdType length, int srcProcessId)
320 {
321 return this->BroadcastVoidArray(data, length, VTK_INT, srcProcessId);
322 }
323 int Broadcast(unsigned int* data, vtkIdType length, int srcProcessId)
324 {
325 return this->BroadcastVoidArray(data, length, VTK_UNSIGNED_INT, srcProcessId);
326 }
327 int Broadcast(short* data, vtkIdType length, int srcProcessId)
328 {
329 return this->BroadcastVoidArray(data, length, VTK_SHORT, srcProcessId);
330 }
331 int Broadcast(unsigned short* data, vtkIdType length, int srcProcessId)
332 {
333 return this->BroadcastVoidArray(data, length, VTK_UNSIGNED_SHORT, srcProcessId);
334 }
335 int Broadcast(long* data, vtkIdType length, int srcProcessId)
336 {
337 return this->BroadcastVoidArray(data, length, VTK_LONG, srcProcessId);
338 }
339 int Broadcast(unsigned long* data, vtkIdType length, int srcProcessId)
340 {
341 return this->BroadcastVoidArray(data, length, VTK_UNSIGNED_LONG, srcProcessId);
342 }
343 int Broadcast(unsigned char* data, vtkIdType length, int srcProcessId)
344 {
345 return this->BroadcastVoidArray(data, length, VTK_UNSIGNED_CHAR, srcProcessId);
346 }
347 int Broadcast(char* data, vtkIdType length, int srcProcessId)
348 {
349 return this->BroadcastVoidArray(data, length, VTK_CHAR, srcProcessId);
350 }
351 int Broadcast(signed char* data, vtkIdType length, int srcProcessId)
352 {
353 return this->BroadcastVoidArray(data, length, VTK_SIGNED_CHAR, srcProcessId);
354 }
355 int Broadcast(float* data, vtkIdType length, int srcProcessId)
356 {
357 return this->BroadcastVoidArray(data, length, VTK_FLOAT, srcProcessId);
358 }
359 int Broadcast(double* data, vtkIdType length, int srcProcessId)
360 {
361 return this->BroadcastVoidArray(data, length, VTK_DOUBLE, srcProcessId);
362 }
363 int Broadcast(long long* data, vtkIdType length, int srcProcessId)
364 {
365 return this->BroadcastVoidArray(data, length, VTK_LONG_LONG, srcProcessId);
366 }
367 int Broadcast(unsigned long long* data, vtkIdType length, int srcProcessId)
368 {
369 return this->BroadcastVoidArray(data, length, VTK_UNSIGNED_LONG_LONG, srcProcessId);
370 }
371 int Broadcast(vtkDataObject* data, int srcProcessId);
372 int Broadcast(vtkDataArray* data, int srcProcessId);
374
375 int Broadcast(vtkMultiProcessStream& stream, int srcProcessId);
376
378
387 int Gather(const int* sendBuffer, int* recvBuffer, vtkIdType length, int destProcessId)
388 {
389 return this->GatherVoidArray(sendBuffer, recvBuffer, length, VTK_INT, destProcessId);
390 }
391 int Gather(
392 const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType length, int destProcessId)
393 {
394 return this->GatherVoidArray(sendBuffer, recvBuffer, length, VTK_UNSIGNED_INT, destProcessId);
395 }
396 int Gather(const short* sendBuffer, short* recvBuffer, vtkIdType length, int destProcessId)
397 {
398 return this->GatherVoidArray(sendBuffer, recvBuffer, length, VTK_SHORT, destProcessId);
399 }
400 int Gather(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType length,
401 int destProcessId)
402 {
403 return this->GatherVoidArray(sendBuffer, recvBuffer, length, VTK_UNSIGNED_SHORT, destProcessId);
404 }
405 int Gather(const long* sendBuffer, long* recvBuffer, vtkIdType length, int destProcessId)
406 {
407 return this->GatherVoidArray(sendBuffer, recvBuffer, length, VTK_LONG, destProcessId);
408 }
409 int Gather(
410 const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length, int destProcessId)
411 {
412 return this->GatherVoidArray(sendBuffer, recvBuffer, length, VTK_UNSIGNED_LONG, destProcessId);
413 }
414 int Gather(
415 const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType length, int destProcessId)
416 {
417 return this->GatherVoidArray(sendBuffer, recvBuffer, length, VTK_UNSIGNED_CHAR, destProcessId);
418 }
419 int Gather(const char* sendBuffer, char* recvBuffer, vtkIdType length, int destProcessId)
420 {
421 return this->GatherVoidArray(sendBuffer, recvBuffer, length, VTK_CHAR, destProcessId);
422 }
423 int Gather(
424 const signed char* sendBuffer, signed char* recvBuffer, vtkIdType length, int destProcessId)
425 {
426 return this->GatherVoidArray(sendBuffer, recvBuffer, length, VTK_SIGNED_CHAR, destProcessId);
427 }
428 int Gather(const float* sendBuffer, float* recvBuffer, vtkIdType length, int destProcessId)
429 {
430 return this->GatherVoidArray(sendBuffer, recvBuffer, length, VTK_FLOAT, destProcessId);
431 }
432 int Gather(const double* sendBuffer, double* recvBuffer, vtkIdType length, int destProcessId)
433 {
434 return this->GatherVoidArray(sendBuffer, recvBuffer, length, VTK_DOUBLE, destProcessId);
435 }
436 int Gather(
437 const long long* sendBuffer, long long* recvBuffer, vtkIdType length, int destProcessId)
438 {
439 return this->GatherVoidArray(sendBuffer, recvBuffer, length, VTK_LONG_LONG, destProcessId);
440 }
441 int Gather(const unsigned long long* sendBuffer, unsigned long long* recvBuffer, vtkIdType length,
442 int destProcessId)
443 {
444 return this->GatherVoidArray(
445 sendBuffer, recvBuffer, length, VTK_UNSIGNED_LONG_LONG, destProcessId);
446 }
447 int Gather(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, int destProcessId);
449
462 int Gather(vtkDataObject* sendBuffer, std::vector<vtkSmartPointer<vtkDataObject>>& recvBuffer,
463 int destProcessId);
464
474 int Gather(const vtkMultiProcessStream& sendBuffer,
475 std::vector<vtkMultiProcessStream>& recvBuffer, int destProcessId);
476
478
489 int GatherV(const int* sendBuffer, int* recvBuffer, vtkIdType sendLength, vtkIdType* recvLengths,
490 vtkIdType* offsets, int destProcessId)
491 {
492 return this->GatherVVoidArray(
493 sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_INT, destProcessId);
494 }
495 int GatherV(const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType sendLength,
496 vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
497 {
498 return this->GatherVVoidArray(
499 sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_UNSIGNED_INT, destProcessId);
500 }
501 int GatherV(const short* sendBuffer, short* recvBuffer, vtkIdType sendLength,
502 vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
503 {
504 return this->GatherVVoidArray(
505 sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_SHORT, destProcessId);
506 }
507 int GatherV(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType sendLength,
508 vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
509 {
510 return this->GatherVVoidArray(
511 sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_UNSIGNED_SHORT, destProcessId);
512 }
513 int GatherV(const long* sendBuffer, long* recvBuffer, vtkIdType sendLength,
514 vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
515 {
516 return this->GatherVVoidArray(
517 sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_LONG, destProcessId);
518 }
519 int GatherV(const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType sendLength,
520 vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
521 {
522 return this->GatherVVoidArray(
523 sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_UNSIGNED_LONG, destProcessId);
524 }
525 int GatherV(const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType sendLength,
526 vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
527 {
528 return this->GatherVVoidArray(
529 sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_UNSIGNED_CHAR, destProcessId);
530 }
531 int GatherV(const char* sendBuffer, char* recvBuffer, vtkIdType sendLength,
532 vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
533 {
534 return this->GatherVVoidArray(
535 sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_CHAR, destProcessId);
536 }
537 int GatherV(const signed char* sendBuffer, signed char* recvBuffer, vtkIdType sendLength,
538 vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
539 {
540 return this->GatherVVoidArray(
541 sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_SIGNED_CHAR, destProcessId);
542 }
543 int GatherV(const float* sendBuffer, float* recvBuffer, vtkIdType sendLength,
544 vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
545 {
546 return this->GatherVVoidArray(
547 sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_FLOAT, destProcessId);
548 }
549 int GatherV(const double* sendBuffer, double* recvBuffer, vtkIdType sendLength,
550 vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
551 {
552 return this->GatherVVoidArray(
553 sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_DOUBLE, destProcessId);
554 }
555 int GatherV(const long long* sendBuffer, long long* recvBuffer, vtkIdType sendLength,
556 vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
557 {
558 return this->GatherVVoidArray(
559 sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_LONG_LONG, destProcessId);
560 }
561 int GatherV(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
562 vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets, int destProcessId)
563 {
564 return this->GatherVVoidArray(sendBuffer, recvBuffer, sendLength, recvLengths, offsets,
565 VTK_UNSIGNED_LONG_LONG, destProcessId);
566 }
569
579 int GatherV(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, vtkIdType* recvLengths,
580 vtkIdType* offsets, int destProcessId);
581 int GatherV(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, vtkIdTypeArray* recvLengths,
582 vtkIdTypeArray* offsets, int destProcessId);
583 int GatherV(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, int destProcessId);
585
593 int GatherV(vtkDataObject* sendData, vtkSmartPointer<vtkDataObject>* recvData, int destProcessId);
594
596
603 int Scatter(const int* sendBuffer, int* recvBuffer, vtkIdType length, int srcProcessId)
604 {
605 return this->ScatterVoidArray(sendBuffer, recvBuffer, length, VTK_INT, srcProcessId);
606 }
607 int Scatter(
608 const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType length, int srcProcessId)
609 {
610 return this->ScatterVoidArray(sendBuffer, recvBuffer, length, VTK_UNSIGNED_INT, srcProcessId);
611 }
612 int Scatter(const short* sendBuffer, short* recvBuffer, vtkIdType length, int srcProcessId)
613 {
614 return this->ScatterVoidArray(sendBuffer, recvBuffer, length, VTK_SHORT, srcProcessId);
615 }
616 int Scatter(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType length,
617 int srcProcessId)
618 {
619 return this->ScatterVoidArray(sendBuffer, recvBuffer, length, VTK_UNSIGNED_SHORT, srcProcessId);
620 }
621 int Scatter(const long* sendBuffer, long* recvBuffer, vtkIdType length, int srcProcessId)
622 {
623 return this->ScatterVoidArray(sendBuffer, recvBuffer, length, VTK_INT, srcProcessId);
624 }
625 int Scatter(
626 const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length, int srcProcessId)
627 {
628 return this->ScatterVoidArray(sendBuffer, recvBuffer, length, VTK_UNSIGNED_LONG, srcProcessId);
629 }
630 int Scatter(
631 const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType length, int srcProcessId)
632 {
633 return this->ScatterVoidArray(sendBuffer, recvBuffer, length, VTK_UNSIGNED_CHAR, srcProcessId);
634 }
635 int Scatter(const char* sendBuffer, char* recvBuffer, vtkIdType length, int srcProcessId)
636 {
637 return this->ScatterVoidArray(sendBuffer, recvBuffer, length, VTK_CHAR, srcProcessId);
638 }
639 int Scatter(
640 const signed char* sendBuffer, signed char* recvBuffer, vtkIdType length, int srcProcessId)
641 {
642 return this->ScatterVoidArray(sendBuffer, recvBuffer, length, VTK_SIGNED_CHAR, srcProcessId);
643 }
644 int Scatter(const float* sendBuffer, float* recvBuffer, vtkIdType length, int srcProcessId)
645 {
646 return this->ScatterVoidArray(sendBuffer, recvBuffer, length, VTK_FLOAT, srcProcessId);
647 }
648 int Scatter(const double* sendBuffer, double* recvBuffer, vtkIdType length, int srcProcessId)
649 {
650 return this->ScatterVoidArray(sendBuffer, recvBuffer, length, VTK_DOUBLE, srcProcessId);
651 }
652 int Scatter(
653 const long long* sendBuffer, long long* recvBuffer, vtkIdType length, int srcProcessId)
654 {
655 return this->ScatterVoidArray(sendBuffer, recvBuffer, length, VTK_LONG_LONG, srcProcessId);
656 }
657 int Scatter(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
658 vtkIdType length, int srcProcessId)
659 {
660 return this->ScatterVoidArray(
661 sendBuffer, recvBuffer, length, VTK_UNSIGNED_LONG_LONG, srcProcessId);
662 }
663 int Scatter(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, int srcProcessId);
665
667
674 int ScatterV(const int* sendBuffer, int* recvBuffer, vtkIdType* sendLengths, vtkIdType* offsets,
675 vtkIdType recvLength, int srcProcessId)
676 {
677 return this->ScatterVVoidArray(
678 sendBuffer, recvBuffer, sendLengths, offsets, recvLength, VTK_INT, srcProcessId);
679 }
680 int ScatterV(const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType* sendLengths,
681 vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
682 {
683 return this->ScatterVVoidArray(
684 sendBuffer, recvBuffer, sendLengths, offsets, recvLength, VTK_UNSIGNED_INT, srcProcessId);
685 }
686 int ScatterV(const short* sendBuffer, short* recvBuffer, vtkIdType* sendLengths,
687 vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
688 {
689 return this->ScatterVVoidArray(
690 sendBuffer, recvBuffer, sendLengths, offsets, recvLength, VTK_SHORT, srcProcessId);
691 }
692 int ScatterV(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType* sendLengths,
693 vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
694 {
695 return this->ScatterVVoidArray(
696 sendBuffer, recvBuffer, sendLengths, offsets, recvLength, VTK_UNSIGNED_SHORT, srcProcessId);
697 }
698 int ScatterV(const long* sendBuffer, long* recvBuffer, vtkIdType* sendLengths, vtkIdType* offsets,
699 vtkIdType recvLength, int srcProcessId)
700 {
701 return this->ScatterVVoidArray(
702 sendBuffer, recvBuffer, sendLengths, offsets, recvLength, VTK_LONG, srcProcessId);
703 }
704 int ScatterV(const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType* sendLengths,
705 vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
706 {
707 return this->ScatterVVoidArray(
708 sendBuffer, recvBuffer, sendLengths, offsets, recvLength, VTK_UNSIGNED_LONG, srcProcessId);
709 }
710 int ScatterV(const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType* sendLengths,
711 vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
712 {
713 return this->ScatterVVoidArray(
714 sendBuffer, recvBuffer, sendLengths, offsets, recvLength, VTK_UNSIGNED_CHAR, srcProcessId);
715 }
716 int ScatterV(const char* sendBuffer, char* recvBuffer, vtkIdType* sendLengths, vtkIdType* offsets,
717 vtkIdType recvLength, int srcProcessId)
718 {
719 return this->ScatterVVoidArray(
720 sendBuffer, recvBuffer, sendLengths, offsets, recvLength, VTK_CHAR, srcProcessId);
721 }
722 int ScatterV(const signed char* sendBuffer, signed char* recvBuffer, vtkIdType* sendLengths,
723 vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
724 {
725 return this->ScatterVVoidArray(
726 sendBuffer, recvBuffer, sendLengths, offsets, recvLength, VTK_SIGNED_CHAR, srcProcessId);
727 }
728 int ScatterV(const float* sendBuffer, float* recvBuffer, vtkIdType* sendLengths,
729 vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
730 {
731 return this->ScatterVVoidArray(
732 sendBuffer, recvBuffer, sendLengths, offsets, recvLength, VTK_FLOAT, srcProcessId);
733 }
734 int ScatterV(const double* sendBuffer, double* recvBuffer, vtkIdType* sendLengths,
735 vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
736 {
737 return this->ScatterVVoidArray(
738 sendBuffer, recvBuffer, sendLengths, offsets, recvLength, VTK_DOUBLE, srcProcessId);
739 }
740 int ScatterV(const long long* sendBuffer, long long* recvBuffer, vtkIdType* sendLengths,
741 vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
742 {
743 return this->ScatterVVoidArray(
744 sendBuffer, recvBuffer, sendLengths, offsets, recvLength, VTK_LONG_LONG, srcProcessId);
745 }
746 int ScatterV(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
747 vtkIdType* sendLengths, vtkIdType* offsets, vtkIdType recvLength, int srcProcessId)
748 {
749 return this->ScatterVVoidArray(sendBuffer, recvBuffer, sendLengths, offsets, recvLength,
750 VTK_UNSIGNED_LONG_LONG, srcProcessId);
751 }
753
755
758 int AllGather(const int* sendBuffer, int* recvBuffer, vtkIdType length)
759 {
760 return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_INT);
761 }
762 int AllGather(const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType length)
763 {
764 return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_UNSIGNED_INT);
765 }
766 int AllGather(const short* sendBuffer, short* recvBuffer, vtkIdType length)
767 {
768 return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_SHORT);
769 }
770 int AllGather(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType length)
771 {
772 return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_UNSIGNED_SHORT);
773 }
774 int AllGather(const long* sendBuffer, long* recvBuffer, vtkIdType length)
775 {
776 return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_LONG);
777 }
778 int AllGather(const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length)
779 {
780 return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_UNSIGNED_LONG);
781 }
782 int AllGather(const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType length)
783 {
784 return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_UNSIGNED_CHAR);
785 }
786 int AllGather(const char* sendBuffer, char* recvBuffer, vtkIdType length)
787 {
788 return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_CHAR);
789 }
790 int AllGather(const signed char* sendBuffer, signed char* recvBuffer, vtkIdType length)
791 {
792 return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_SIGNED_CHAR);
793 }
794 int AllGather(const float* sendBuffer, float* recvBuffer, vtkIdType length)
795 {
796 return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_FLOAT);
797 }
798 int AllGather(const double* sendBuffer, double* recvBuffer, vtkIdType length)
799 {
800 return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_DOUBLE);
801 }
802 int AllGather(const long long* sendBuffer, long long* recvBuffer, vtkIdType length)
803 {
804 return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_LONG_LONG);
805 }
806 int AllGather(
807 const unsigned long long* sendBuffer, unsigned long long* recvBuffer, vtkIdType length)
808 {
809 return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_UNSIGNED_LONG_LONG);
810 }
811 int AllGather(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer);
812 int AllGather(
813 const vtkMultiProcessStream& sendBuffer, std::vector<vtkMultiProcessStream>& recvBuffer);
815
826 int AllGather(vtkDataObject* sendBuffer, std::vector<vtkSmartPointer<vtkDataObject>>& recvBuffer);
827
829
832 int AllGatherV(const int* sendBuffer, int* recvBuffer, vtkIdType sendLength,
833 vtkIdType* recvLengths, vtkIdType* offsets)
834 {
835 return this->AllGatherVVoidArray(
836 sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_INT);
837 }
838 int AllGatherV(const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType sendLength,
839 vtkIdType* recvLengths, vtkIdType* offsets)
840 {
841 return this->AllGatherVVoidArray(
842 sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_UNSIGNED_INT);
843 }
844 int AllGatherV(const short* sendBuffer, short* recvBuffer, vtkIdType sendLength,
845 vtkIdType* recvLengths, vtkIdType* offsets)
846 {
847 return this->AllGatherVVoidArray(
848 sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_SHORT);
849 }
850 int AllGatherV(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType sendLength,
851 vtkIdType* recvLengths, vtkIdType* offsets)
852 {
853 return this->AllGatherVVoidArray(
854 sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_UNSIGNED_SHORT);
855 }
856 int AllGatherV(const long* sendBuffer, long* recvBuffer, vtkIdType sendLength,
857 vtkIdType* recvLengths, vtkIdType* offsets)
858 {
859 return this->AllGatherVVoidArray(
860 sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_LONG);
861 }
862 int AllGatherV(const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType sendLength,
863 vtkIdType* recvLengths, vtkIdType* offsets)
864 {
865 return this->AllGatherVVoidArray(
866 sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_UNSIGNED_LONG);
867 }
868 int AllGatherV(const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType sendLength,
869 vtkIdType* recvLengths, vtkIdType* offsets)
870 {
871 return this->AllGatherVVoidArray(
872 sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_UNSIGNED_CHAR);
873 }
874 int AllGatherV(const char* sendBuffer, char* recvBuffer, vtkIdType sendLength,
875 vtkIdType* recvLengths, vtkIdType* offsets)
876 {
877 return this->AllGatherVVoidArray(
878 sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_CHAR);
879 }
880 int AllGatherV(const signed char* sendBuffer, signed char* recvBuffer, vtkIdType sendLength,
881 vtkIdType* recvLengths, vtkIdType* offsets)
882 {
883 return this->AllGatherVVoidArray(
884 sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_UNSIGNED_CHAR);
885 }
886 int AllGatherV(const float* sendBuffer, float* recvBuffer, vtkIdType sendLength,
887 vtkIdType* recvLengths, vtkIdType* offsets)
888 {
889 return this->AllGatherVVoidArray(
890 sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_FLOAT);
891 }
892 int AllGatherV(const double* sendBuffer, double* recvBuffer, vtkIdType sendLength,
893 vtkIdType* recvLengths, vtkIdType* offsets)
894 {
895 return this->AllGatherVVoidArray(
896 sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_DOUBLE);
897 }
898 int AllGatherV(const long long* sendBuffer, long long* recvBuffer, vtkIdType sendLength,
899 vtkIdType* recvLengths, vtkIdType* offsets)
900 {
901 return this->AllGatherVVoidArray(
902 sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_LONG_LONG);
903 }
904 int AllGatherV(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
905 vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets)
906 {
907 return this->AllGatherVVoidArray(
908 sendBuffer, recvBuffer, sendLength, recvLengths, offsets, VTK_UNSIGNED_LONG_LONG);
909 }
910 int AllGatherV(
911 vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, vtkIdType* recvLengths, vtkIdType* offsets);
912 int AllGatherV(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer);
914
916
921 int Reduce(
922 const int* sendBuffer, int* recvBuffer, vtkIdType length, int operation, int destProcessId)
923 {
924 return this->ReduceVoidArray(sendBuffer, recvBuffer, length, VTK_INT, operation, destProcessId);
925 }
926 int Reduce(const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType length,
927 int operation, int destProcessId)
928 {
929 return this->ReduceVoidArray(
930 sendBuffer, recvBuffer, length, VTK_UNSIGNED_INT, operation, destProcessId);
931 }
932 int Reduce(
933 const short* sendBuffer, short* recvBuffer, vtkIdType length, int operation, int destProcessId)
934 {
935 return this->ReduceVoidArray(
936 sendBuffer, recvBuffer, length, VTK_SHORT, operation, destProcessId);
937 }
938 int Reduce(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType length,
939 int operation, int destProcessId)
940 {
941 return this->ReduceVoidArray(
942 sendBuffer, recvBuffer, length, VTK_UNSIGNED_SHORT, operation, destProcessId);
943 }
944 int Reduce(
945 const long* sendBuffer, long* recvBuffer, vtkIdType length, int operation, int destProcessId)
946 {
947 return this->ReduceVoidArray(
948 sendBuffer, recvBuffer, length, VTK_LONG, operation, destProcessId);
949 }
950 int Reduce(const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length,
951 int operation, int destProcessId)
952 {
953 return this->ReduceVoidArray(
954 sendBuffer, recvBuffer, length, VTK_UNSIGNED_LONG, operation, destProcessId);
955 }
956 int Reduce(const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType length,
957 int operation, int destProcessId)
958 {
959 return this->ReduceVoidArray(
960 sendBuffer, recvBuffer, length, VTK_UNSIGNED_CHAR, operation, destProcessId);
961 }
962 int Reduce(
963 const char* sendBuffer, char* recvBuffer, vtkIdType length, int operation, int destProcessId)
964 {
965 return this->ReduceVoidArray(
966 sendBuffer, recvBuffer, length, VTK_CHAR, operation, destProcessId);
967 }
968 int Reduce(const signed char* sendBuffer, signed char* recvBuffer, vtkIdType length,
969 int operation, int destProcessId)
970 {
971 return this->ReduceVoidArray(
972 sendBuffer, recvBuffer, length, VTK_SIGNED_CHAR, operation, destProcessId);
973 }
974 int Reduce(
975 const float* sendBuffer, float* recvBuffer, vtkIdType length, int operation, int destProcessId)
976 {
977 return this->ReduceVoidArray(
978 sendBuffer, recvBuffer, length, VTK_FLOAT, operation, destProcessId);
979 }
980 int Reduce(const double* sendBuffer, double* recvBuffer, vtkIdType length, int operation,
981 int destProcessId)
982 {
983 return this->ReduceVoidArray(
984 sendBuffer, recvBuffer, length, VTK_DOUBLE, operation, destProcessId);
985 }
986 int Reduce(const long long* sendBuffer, long long* recvBuffer, vtkIdType length, int operation,
987 int destProcessId)
988 {
989 return this->ReduceVoidArray(
990 sendBuffer, recvBuffer, length, VTK_LONG_LONG, operation, destProcessId);
991 }
992 int Reduce(const unsigned long long* sendBuffer, unsigned long long* recvBuffer, vtkIdType length,
993 int operation, int destProcessId)
994 {
995 return this->ReduceVoidArray(
996 sendBuffer, recvBuffer, length, VTK_UNSIGNED_LONG_LONG, operation, destProcessId);
997 }
998 int Reduce(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, int operation, int destProcessId);
1000
1002
1006 int Reduce(const int* sendBuffer, int* recvBuffer, vtkIdType length, Operation* operation,
1007 int destProcessId)
1008 {
1009 return this->ReduceVoidArray(sendBuffer, recvBuffer, length, VTK_INT, operation, destProcessId);
1010 }
1011 int Reduce(const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType length,
1012 Operation* operation, int destProcessId)
1013 {
1014 return this->ReduceVoidArray(
1015 sendBuffer, recvBuffer, length, VTK_UNSIGNED_INT, operation, destProcessId);
1016 }
1017 int Reduce(const short* sendBuffer, short* recvBuffer, vtkIdType length, Operation* operation,
1018 int destProcessId)
1019 {
1020 return this->ReduceVoidArray(
1021 sendBuffer, recvBuffer, length, VTK_SHORT, operation, destProcessId);
1022 }
1023 int Reduce(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType length,
1024 Operation* operation, int destProcessId)
1025 {
1026 return this->ReduceVoidArray(
1027 sendBuffer, recvBuffer, length, VTK_UNSIGNED_SHORT, operation, destProcessId);
1028 }
1029 int Reduce(const long* sendBuffer, long* recvBuffer, vtkIdType length, Operation* operation,
1030 int destProcessId)
1031 {
1032 return this->ReduceVoidArray(
1033 sendBuffer, recvBuffer, length, VTK_LONG, operation, destProcessId);
1034 }
1035 int Reduce(const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length,
1036 Operation* operation, int destProcessId)
1037 {
1038 return this->ReduceVoidArray(
1039 sendBuffer, recvBuffer, length, VTK_UNSIGNED_LONG, operation, destProcessId);
1040 }
1041 int Reduce(const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType length,
1042 Operation* operation, int destProcessId)
1043 {
1044 return this->ReduceVoidArray(
1045 sendBuffer, recvBuffer, length, VTK_UNSIGNED_CHAR, operation, destProcessId);
1046 }
1047 int Reduce(const char* sendBuffer, char* recvBuffer, vtkIdType length, Operation* operation,
1048 int destProcessId)
1049 {
1050 return this->ReduceVoidArray(
1051 sendBuffer, recvBuffer, length, VTK_CHAR, operation, destProcessId);
1052 }
1053 int Reduce(const signed char* sendBuffer, signed char* recvBuffer, vtkIdType length,
1054 Operation* operation, int destProcessId)
1055 {
1056 return this->ReduceVoidArray(
1057 sendBuffer, recvBuffer, length, VTK_SIGNED_CHAR, operation, destProcessId);
1058 }
1059 int Reduce(const float* sendBuffer, float* recvBuffer, vtkIdType length, Operation* operation,
1060 int destProcessId)
1061 {
1062 return this->ReduceVoidArray(
1063 sendBuffer, recvBuffer, length, VTK_FLOAT, operation, destProcessId);
1064 }
1065 int Reduce(const double* sendBuffer, double* recvBuffer, vtkIdType length, Operation* operation,
1066 int destProcessId)
1067 {
1068 return this->ReduceVoidArray(
1069 sendBuffer, recvBuffer, length, VTK_DOUBLE, operation, destProcessId);
1070 }
1071 int Reduce(const long long* sendBuffer, long long* recvBuffer, vtkIdType length,
1072 Operation* operation, int destProcessId)
1073 {
1074 return this->ReduceVoidArray(
1075 sendBuffer, recvBuffer, length, VTK_LONG_LONG, operation, destProcessId);
1076 }
1077 int Reduce(const unsigned long long* sendBuffer, unsigned long long* recvBuffer, vtkIdType length,
1078 Operation* operation, int destProcessId)
1079 {
1080 return this->ReduceVoidArray(
1081 sendBuffer, recvBuffer, length, VTK_UNSIGNED_LONG_LONG, operation, destProcessId);
1082 }
1083 int Reduce(
1084 vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, Operation* operation, int destProcessId);
1086
1088
1091 int AllReduce(const int* sendBuffer, int* recvBuffer, vtkIdType length, int operation)
1092 {
1093 return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_INT, operation);
1094 }
1095 int AllReduce(
1096 const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType length, int operation)
1097 {
1098 return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_UNSIGNED_INT, operation);
1099 }
1100 int AllReduce(const short* sendBuffer, short* recvBuffer, vtkIdType length, int operation)
1101 {
1102 return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_SHORT, operation);
1103 }
1104 int AllReduce(
1105 const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType length, int operation)
1106 {
1107 return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_UNSIGNED_SHORT, operation);
1108 }
1109 int AllReduce(const long* sendBuffer, long* recvBuffer, vtkIdType length, int operation)
1110 {
1111 return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_LONG, operation);
1112 }
1113 int AllReduce(
1114 const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length, int operation)
1115 {
1116 return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_UNSIGNED_LONG, operation);
1117 }
1118 int AllReduce(
1119 const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType length, int operation)
1120 {
1121 return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_UNSIGNED_CHAR, operation);
1122 }
1123 int AllReduce(const char* sendBuffer, char* recvBuffer, vtkIdType length, int operation)
1124 {
1125 return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_CHAR, operation);
1126 }
1127 int AllReduce(
1128 const signed char* sendBuffer, signed char* recvBuffer, vtkIdType length, int operation)
1129 {
1130 return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_SIGNED_CHAR, operation);
1131 }
1132 int AllReduce(const float* sendBuffer, float* recvBuffer, vtkIdType length, int operation)
1133 {
1134 return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_FLOAT, operation);
1135 }
1136 int AllReduce(const double* sendBuffer, double* recvBuffer, vtkIdType length, int operation)
1137 {
1138 return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_DOUBLE, operation);
1139 }
1140 int AllReduce(const long long* sendBuffer, long long* recvBuffer, vtkIdType length, int operation)
1141 {
1142 return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_LONG_LONG, operation);
1143 }
1144 int AllReduce(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
1145 vtkIdType length, int operation)
1146 {
1147 return this->AllReduceVoidArray(
1148 sendBuffer, recvBuffer, length, VTK_UNSIGNED_LONG_LONG, operation);
1149 }
1150 int AllReduce(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, int operation);
1151 int AllReduce(const int* sendBuffer, int* recvBuffer, vtkIdType length, Operation* operation)
1152 {
1153 return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_INT, operation);
1154 }
1155 int AllReduce(const unsigned int* sendBuffer, unsigned int* recvBuffer, vtkIdType length,
1156 Operation* operation)
1157 {
1158 return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_UNSIGNED_INT, operation);
1159 }
1160 int AllReduce(const short* sendBuffer, short* recvBuffer, vtkIdType length, Operation* operation)
1161 {
1162 return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_SHORT, operation);
1163 }
1164 int AllReduce(const unsigned short* sendBuffer, unsigned short* recvBuffer, vtkIdType length,
1165 Operation* operation)
1166 {
1167 return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_UNSIGNED_SHORT, operation);
1168 }
1169 int AllReduce(const long* sendBuffer, long* recvBuffer, vtkIdType length, Operation* operation)
1170 {
1171 return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_LONG, operation);
1172 }
1173 int AllReduce(const unsigned long* sendBuffer, unsigned long* recvBuffer, vtkIdType length,
1174 Operation* operation)
1175 {
1176 return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_UNSIGNED_LONG, operation);
1177 }
1178 int AllReduce(const unsigned char* sendBuffer, unsigned char* recvBuffer, vtkIdType length,
1179 Operation* operation)
1180 {
1181 return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_UNSIGNED_CHAR, operation);
1182 }
1183 int AllReduce(const char* sendBuffer, char* recvBuffer, vtkIdType length, Operation* operation)
1184 {
1185 return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_CHAR, operation);
1186 }
1187 int AllReduce(
1188 const signed char* sendBuffer, signed char* recvBuffer, vtkIdType length, Operation* operation)
1189 {
1190 return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_SIGNED_CHAR, operation);
1191 }
1192 int AllReduce(const float* sendBuffer, float* recvBuffer, vtkIdType length, Operation* operation)
1193 {
1194 return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_FLOAT, operation);
1195 }
1196 int AllReduce(
1197 const double* sendBuffer, double* recvBuffer, vtkIdType length, Operation* operation)
1198 {
1199 return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_DOUBLE, operation);
1200 }
1201 int AllReduce(
1202 const long long* sendBuffer, long long* recvBuffer, vtkIdType length, Operation* operation)
1203 {
1204 return this->AllReduceVoidArray(sendBuffer, recvBuffer, length, VTK_LONG_LONG, operation);
1205 }
1206 int AllReduce(const unsigned long long* sendBuffer, unsigned long long* recvBuffer,
1207 vtkIdType length, Operation* operation)
1208 {
1209 return this->AllReduceVoidArray(
1210 sendBuffer, recvBuffer, length, VTK_UNSIGNED_LONG_LONG, operation);
1211 }
1212 int AllReduce(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer, Operation* operation);
1214
1216
1220 virtual int BroadcastVoidArray(void* data, vtkIdType length, int type, int srcProcessId);
1221 virtual int GatherVoidArray(
1222 const void* sendBuffer, void* recvBuffer, vtkIdType length, int type, int destProcessId);
1223 virtual int GatherVVoidArray(const void* sendBuffer, void* recvBuffer, vtkIdType sendLength,
1224 vtkIdType* recvLengths, vtkIdType* offsets, int type, int destProcessId);
1225 virtual int ScatterVoidArray(
1226 const void* sendBuffer, void* recvBuffer, vtkIdType length, int type, int srcProcessId);
1227 virtual int ScatterVVoidArray(const void* sendBuffer, void* recvBuffer, vtkIdType* sendLengths,
1228 vtkIdType* offsets, vtkIdType recvLength, int type, int srcProcessId);
1229 virtual int AllGatherVoidArray(
1230 const void* sendBuffer, void* recvBuffer, vtkIdType length, int type);
1231 virtual int AllGatherVVoidArray(const void* sendBuffer, void* recvBuffer, vtkIdType sendLength,
1232 vtkIdType* recvLengths, vtkIdType* offsets, int type);
1233 virtual int ReduceVoidArray(const void* sendBuffer, void* recvBuffer, vtkIdType length, int type,
1234 int operation, int destProcessId);
1235 virtual int ReduceVoidArray(const void* sendBuffer, void* recvBuffer, vtkIdType length, int type,
1236 Operation* operation, int destProcessId);
1237 virtual int AllReduceVoidArray(
1238 const void* sendBuffer, void* recvBuffer, vtkIdType length, int type, int operation);
1239 virtual int AllReduceVoidArray(
1240 const void* sendBuffer, void* recvBuffer, vtkIdType length, int type, Operation* operation);
1242
1251 virtual bool CanProbe() { return false; };
1252
1262 virtual int Probe(int vtkNotUsed(source), int vtkNotUsed(tag), int* vtkNotUsed(actualSource))
1263 {
1264 vtkErrorMacro("Probe not implemented for this controller.");
1265 return 0;
1266 }
1267
1268 static void SetUseCopy(int useCopy);
1269
1281 virtual int ComputeGlobalBounds(int processorId, int numProcesses, vtkBoundingBox* bounds,
1282 int* rightHasBounds = nullptr, int* leftHasBounds = nullptr, int hasBoundsTag = 288402,
1283 int localBoundsTag = 288403, int globalBoundsTag = 288404);
1284
1286
1291 static int GetParentProcessor(int pid);
1292 static int GetLeftChildProcessor(int pid);
1294
1296
1301 static int MarshalDataObject(vtkDataObject* object, vtkCharArray* buffer);
1302 static int UnMarshalDataObject(vtkCharArray* buffer, vtkDataObject* object);
1304
1311 static vtkSmartPointer<vtkDataObject> UnMarshalDataObject(vtkCharArray* buffer);
1312
1313 protected:
1314 int WriteDataArray(vtkDataArray* object);
1315 int ReadDataArray(vtkDataArray* object);
1316
1317 vtkCommunicator();
1318 ~vtkCommunicator() override;
1319
1320 // Internal methods called by Send/Receive(vtkDataObject *... ) above.
1321 int SendElementalDataObject(vtkDataObject* data, int remoteHandle, int tag);
1323
1331 int GatherV(vtkDataArray* sendArray, vtkDataArray* recvArray,
1332 vtkSmartPointer<vtkDataArray>* recvArrays, int destProcessId);
1333 int GatherVElementalDataObject(
1334 vtkDataObject* sendData, vtkSmartPointer<vtkDataObject>* receiveData, int destProcessId);
1336
1338 int AllGatherV(vtkDataArray* sendBuffer, vtkDataArray* recvBuffer,
1339 vtkIdTypeArray* recvLengthsArray, vtkIdTypeArray* offsetsArray);
1340 int AllGatherV(
1341 vtkDataArray* sendArray, vtkDataArray* recvArray, vtkSmartPointer<vtkDataArray>* recvArrays);
1343
1344 int ReceiveDataObject(vtkDataObject* data, int remoteHandle, int tag, int type = -1);
1345 int ReceiveElementalDataObject(vtkDataObject* data, int remoteHandle, int tag);
1346 int ReceiveMultiBlockDataSet(vtkMultiBlockDataSet* data, int remoteHandle, int tag);
1347
1348 int MaximumNumberOfProcesses;
1349 int NumberOfProcesses;
1350
1351 int LocalProcessId;
1352
1353 static int UseCopy;
1354
1355 vtkIdType Count;
1356
1357 private:
1358 vtkCommunicator(const vtkCommunicator&) = delete;
1359 void operator=(const vtkCommunicator&) = delete;
1360 };
1361
1362 VTK_ABI_NAMESPACE_END
1363 #endif // vtkCommunicator_h
vtkBoundingBox
Fast, simple class for representing and operating on 3D bounds.
Definition: vtkBoundingBox.h:38
vtkCharArray
dynamic, self-adjusting array of char
Definition: vtkCharArray.h:50
vtkCommunicator::Operation
A custom operation to use in a reduce command.
Definition: vtkCommunicator.h:96
vtkCommunicator::Operation::Commutative
virtual int Commutative()=0
Subclasses override this method to specify whether their operation is commutative.
vtkCommunicator::Operation::Function
virtual void Function(const void *A, void *B, vtkIdType length, int datatype)=0
Subclasses must overload this method, which performs the actual operations.
vtkCommunicator::Operation::~Operation
virtual ~Operation()=default
vtkCommunicator
Used to send/receive messages in a multiprocess environment.
Definition: vtkCommunicator.h:43
vtkCommunicator::Reduce
int Reduce(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
Definition: vtkCommunicator.h:986
vtkCommunicator::AllReduce
int AllReduce(const double *sendBuffer, double *recvBuffer, vtkIdType length, Operation *operation)
Same as Reduce except that the result is placed in all of the processes.
Definition: vtkCommunicator.h:1196
vtkCommunicator::AllGatherV
int AllGatherV(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Same as GatherV except that the result is placed in all processes.
Definition: vtkCommunicator.h:868
vtkCommunicator::Send
int Send(const unsigned long long *data, vtkIdType length, int remoteHandle, int tag)
Convenience methods for sending data arrays.
Definition: vtkCommunicator.h:194
vtkCommunicator::AllReduce
int AllReduce(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, Operation *operation)
Same as Reduce except that the result is placed in all of the processes.
Definition: vtkCommunicator.h:1187
vtkCommunicator::Count
vtkIdType Count
Definition: vtkCommunicator.h:1355
vtkCommunicator::Receive
int Receive(vtkDataArray *data, int remoteHandle, int tag)
This method receives a data array from a corresponding send.
vtkCommunicator::Reduce
int Reduce(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
Definition: vtkCommunicator.h:938
vtkCommunicator::AllGatherV
int AllGatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer)
Same as GatherV except that the result is placed in all processes.
vtkCommunicator::Send
int Send(const short *data, vtkIdType length, int remoteHandle, int tag)
Convenience methods for sending data arrays.
Definition: vtkCommunicator.h:154
vtkCommunicator::Receive
int Receive(long long *data, vtkIdType maxlength, int remoteHandle, int tag)
Convenience methods for receiving data arrays.
Definition: vtkCommunicator.h:281
vtkCommunicator::ScatterV
int ScatterV(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
Definition: vtkCommunicator.h:680
vtkCommunicator::AllReduce
int AllReduce(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, Operation *operation)
Same as Reduce except that the result is placed in all of the processes.
Definition: vtkCommunicator.h:1178
vtkCommunicator::Receive
int Receive(char *data, vtkIdType maxlength, int remoteHandle, int tag)
Convenience methods for receiving data arrays.
Definition: vtkCommunicator.h:265
vtkCommunicator::SetNumberOfProcesses
virtual void SetNumberOfProcesses(int num)
Set the number of processes you will be using.
vtkCommunicator::GatherV
int GatherV(vtkDataObject *sendData, vtkSmartPointer< vtkDataObject > *recvData, int destProcessId)
Collects data objects in the process with id destProcessId.
vtkCommunicator::GatherV
int GatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
For the first GatherV variant, recvLengths and offsets known on destProcessId and are passed in as pa...
vtkCommunicator::Scatter
int Scatter(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
Definition: vtkCommunicator.h:657
vtkCommunicator::MaximumNumberOfProcesses
int MaximumNumberOfProcesses
Definition: vtkCommunicator.h:1348
vtkCommunicator::AllGather
int AllGather(const long *sendBuffer, long *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
Definition: vtkCommunicator.h:774
vtkCommunicator::AllGather
int AllGather(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
Definition: vtkCommunicator.h:782
vtkCommunicator::ScatterV
int ScatterV(const long *sendBuffer, long *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
Definition: vtkCommunicator.h:698
vtkCommunicator::AllReduce
int AllReduce(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, Operation *operation)
Same as Reduce except that the result is placed in all of the processes.
Definition: vtkCommunicator.h:1173
vtkCommunicator::Receive
int Receive(unsigned long long *data, vtkIdType maxlength, int remoteHandle, int tag)
Convenience methods for receiving data arrays.
Definition: vtkCommunicator.h:285
vtkCommunicator::Reduce
int Reduce(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
Reduce an array to the given destination process.
Definition: vtkCommunicator.h:1053
vtkCommunicator::ScatterV
int ScatterV(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
Definition: vtkCommunicator.h:704
vtkCommunicator::AllGather
int AllGather(const float *sendBuffer, float *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
Definition: vtkCommunicator.h:794
vtkCommunicator::Reduce
int Reduce(const long *sendBuffer, long *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
Reduce an array to the given destination process.
Definition: vtkCommunicator.h:1029
vtkCommunicator::Gather
int Gather(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
Definition: vtkCommunicator.h:441
vtkCommunicator::Gather
int Gather(const short *sendBuffer, short *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
Definition: vtkCommunicator.h:396
vtkCommunicator::GatherV
int GatherV(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
Definition: vtkCommunicator.h:561
vtkCommunicator::PrintSelf
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
vtkCommunicator::Send
int Send(const char *data, vtkIdType length, int remoteHandle, int tag)
Convenience methods for sending data arrays.
Definition: vtkCommunicator.h:174
vtkCommunicator::AllGather
int AllGather(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
Definition: vtkCommunicator.h:778
vtkCommunicator::Scatter
int Scatter(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
Definition: vtkCommunicator.h:607
vtkCommunicator::GatherV
int GatherV(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
Definition: vtkCommunicator.h:537
vtkCommunicator::GatherVVoidArray
virtual int GatherVVoidArray(const void *sendBuffer, void *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int type, int destProcessId)
Subclasses should reimplement these if they have a more efficient implementation.
vtkCommunicator::Scatter
int Scatter(const long *sendBuffer, long *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
Definition: vtkCommunicator.h:621
vtkCommunicator::ScatterV
int ScatterV(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
Definition: vtkCommunicator.h:692
vtkCommunicator::Broadcast
int Broadcast(short *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes.
Definition: vtkCommunicator.h:327
vtkCommunicator::Scatter
int Scatter(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
Definition: vtkCommunicator.h:625
vtkCommunicator::AllGather
int AllGather(const char *sendBuffer, char *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
Definition: vtkCommunicator.h:786
vtkCommunicator::GatherV
int GatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, int destProcessId)
For the first GatherV variant, recvLengths and offsets known on destProcessId and are passed in as pa...
vtkCommunicator::Scatter
int Scatter(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
Definition: vtkCommunicator.h:652
vtkCommunicator::AllGather
int AllGather(const short *sendBuffer, short *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
Definition: vtkCommunicator.h:766
vtkCommunicator::Reduce
int Reduce(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
Definition: vtkCommunicator.h:968
vtkCommunicator::AllReduce
int AllReduce(const int *sendBuffer, int *recvBuffer, vtkIdType length, Operation *operation)
Same as Reduce except that the result is placed in all of the processes.
Definition: vtkCommunicator.h:1151
vtkCommunicator::SetUseCopy
static void SetUseCopy(int useCopy)
vtkCommunicator::Send
int Send(const int *data, vtkIdType length, int remoteHandle, int tag)
Convenience methods for sending data arrays.
Definition: vtkCommunicator.h:146
vtkCommunicator::Send
int Send(vtkDataArray *data, int remoteHandle, int tag)
This method sends a data array to a destination.
vtkCommunicator::Reduce
int Reduce(const char *sendBuffer, char *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
Definition: vtkCommunicator.h:962
vtkCommunicator::ScatterV
int ScatterV(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
Definition: vtkCommunicator.h:722
vtkCommunicator::Gather
int Gather(const int *sendBuffer, int *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
Definition: vtkCommunicator.h:387
vtkCommunicator::WriteDataArray
int WriteDataArray(vtkDataArray *object)
vtkCommunicator::SendVoidArray
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.
vtkCommunicator::Receive
int Receive(float *data, vtkIdType maxlength, int remoteHandle, int tag)
Convenience methods for receiving data arrays.
Definition: vtkCommunicator.h:273
vtkCommunicator::Send
int Send(const long long *data, vtkIdType length, int remoteHandle, int tag)
Convenience methods for sending data arrays.
Definition: vtkCommunicator.h:190
vtkCommunicator::ScatterV
int ScatterV(const float *sendBuffer, float *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
Definition: vtkCommunicator.h:728
vtkCommunicator::Gather
int Gather(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
Definition: vtkCommunicator.h:400
vtkCommunicator::GatherV
int GatherV(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
Definition: vtkCommunicator.h:507
vtkCommunicator::Receive
int Receive(vtkMultiProcessStream &stream, int remoteId, int tag)
vtkCommunicator::AllReduce
int AllReduce(const float *sendBuffer, float *recvBuffer, vtkIdType length, Operation *operation)
Same as Reduce except that the result is placed in all of the processes.
Definition: vtkCommunicator.h:1192
vtkCommunicator::AllReduceVoidArray
virtual int AllReduceVoidArray(const void *sendBuffer, void *recvBuffer, vtkIdType length, int type, Operation *operation)
Subclasses should reimplement these if they have a more efficient implementation.
vtkCommunicator::Reduce
int Reduce(const double *sendBuffer, double *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
Definition: vtkCommunicator.h:980
vtkCommunicator::AllReduce
int AllReduce(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, Operation *operation)
Same as Reduce except that the result is placed in all of the processes.
Definition: vtkCommunicator.h:1201
vtkCommunicator::StandardOperations
StandardOperations
Definition: vtkCommunicator.h:78
vtkCommunicator::SUM_OP
@ SUM_OP
Definition: vtkCommunicator.h:81
vtkCommunicator::LOGICAL_XOR_OP
@ LOGICAL_XOR_OP
Definition: vtkCommunicator.h:87
vtkCommunicator::MAX_OP
@ MAX_OP
Definition: vtkCommunicator.h:79
vtkCommunicator::LOGICAL_AND_OP
@ LOGICAL_AND_OP
Definition: vtkCommunicator.h:83
vtkCommunicator::LOGICAL_OR_OP
@ LOGICAL_OR_OP
Definition: vtkCommunicator.h:85
vtkCommunicator::BITWISE_OR_OP
@ BITWISE_OR_OP
Definition: vtkCommunicator.h:86
vtkCommunicator::BITWISE_AND_OP
@ BITWISE_AND_OP
Definition: vtkCommunicator.h:84
vtkCommunicator::PRODUCT_OP
@ PRODUCT_OP
Definition: vtkCommunicator.h:82
vtkCommunicator::MIN_OP
@ MIN_OP
Definition: vtkCommunicator.h:80
vtkCommunicator::Broadcast
int Broadcast(unsigned char *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes.
Definition: vtkCommunicator.h:343
vtkCommunicator::AllReduceVoidArray
virtual int AllReduceVoidArray(const void *sendBuffer, void *recvBuffer, vtkIdType length, int type, int operation)
Subclasses should reimplement these if they have a more efficient implementation.
vtkCommunicator::ScatterV
int ScatterV(const short *sendBuffer, short *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
Definition: vtkCommunicator.h:686
vtkCommunicator::ReceiveElementalDataObject
int ReceiveElementalDataObject(vtkDataObject *data, int remoteHandle, int tag)
vtkCommunicator::vtkCommunicator
vtkCommunicator()
vtkCommunicator::Tags
Tags
Definition: vtkCommunicator.h:67
vtkCommunicator::ScatterV
int ScatterV(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
Definition: vtkCommunicator.h:710
vtkCommunicator::ScatterV
int ScatterV(const long long *sendBuffer, long long *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
Definition: vtkCommunicator.h:740
vtkCommunicator::Scatter
int Scatter(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
Definition: vtkCommunicator.h:630
vtkCommunicator::Broadcast
int Broadcast(char *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes.
Definition: vtkCommunicator.h:347
vtkCommunicator::Broadcast
int Broadcast(unsigned long long *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes.
Definition: vtkCommunicator.h:367
vtkCommunicator::AllGatherV
int AllGatherV(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Same as GatherV except that the result is placed in all processes.
Definition: vtkCommunicator.h:850
vtkCommunicator::Barrier
virtual void Barrier()
Will block the processes until all other processes reach the Barrier function.
vtkCommunicator::ScatterV
int ScatterV(const int *sendBuffer, int *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
Definition: vtkCommunicator.h:674
vtkCommunicator::AllReduce
int AllReduce(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, Operation *operation)
Same as Reduce except that the result is placed in all of the processes.
Definition: vtkCommunicator.h:1164
vtkCommunicator::UnMarshalDataObject
static vtkSmartPointer< vtkDataObject > UnMarshalDataObject(vtkCharArray *buffer)
Same as UnMarshalDataObject(vtkCharArray*, vtkDataObject*) except that this method doesn't need to kn...
vtkCommunicator::UseCopy
static int UseCopy
Definition: vtkCommunicator.h:1353
vtkCommunicator::Gather
int Gather(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
Definition: vtkCommunicator.h:409
vtkCommunicator::SendElementalDataObject
int SendElementalDataObject(vtkDataObject *data, int remoteHandle, int tag)
vtkCommunicator::Gather
int Gather(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
Definition: vtkCommunicator.h:391
vtkCommunicator::Receive
int Receive(long *data, vtkIdType maxlength, int remoteHandle, int tag)
Convenience methods for receiving data arrays.
Definition: vtkCommunicator.h:253
vtkCommunicator::Reduce
int Reduce(const float *sendBuffer, float *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
Reduce an array to the given destination process.
Definition: vtkCommunicator.h:1059
vtkCommunicator::Gather
int Gather(const double *sendBuffer, double *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
Definition: vtkCommunicator.h:432
vtkCommunicator::Broadcast
int Broadcast(vtkMultiProcessStream &stream, int srcProcessId)
vtkCommunicator::AllGatherV
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.
Definition: vtkCommunicator.h:832
vtkCommunicator::AllGather
int AllGather(const long long *sendBuffer, long long *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
Definition: vtkCommunicator.h:802
vtkCommunicator::Reduce
int Reduce(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
Reduce an array to the given destination process.
Definition: vtkCommunicator.h:1011
vtkCommunicator::UnMarshalDataObject
static int UnMarshalDataObject(vtkCharArray *buffer, vtkDataObject *object)
Convert a data object into a string that can be transmitted and vice versa.
vtkCommunicator::Reduce
int Reduce(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
Reduce an array to the given destination process.
Definition: vtkCommunicator.h:1035
vtkCommunicator::AllReduce
int AllReduce(const short *sendBuffer, short *recvBuffer, vtkIdType length, Operation *operation)
Same as Reduce except that the result is placed in all of the processes.
Definition: vtkCommunicator.h:1160
vtkCommunicator::Reduce
int Reduce(const char *sendBuffer, char *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
Reduce an array to the given destination process.
Definition: vtkCommunicator.h:1047
vtkCommunicator::Scatter
int Scatter(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
vtkCommunicator::GatherV
int GatherV(const long *sendBuffer, long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
Definition: vtkCommunicator.h:513
vtkCommunicator::Reduce
int Reduce(const double *sendBuffer, double *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
Reduce an array to the given destination process.
Definition: vtkCommunicator.h:1065
vtkCommunicator::GatherV
int GatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, vtkIdTypeArray *recvLengths, vtkIdTypeArray *offsets, int destProcessId)
For the first GatherV variant, recvLengths and offsets known on destProcessId and are passed in as pa...
vtkCommunicator::Gather
int Gather(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, int destProcessId)
Gather collects arrays in the process with id destProcessId.
vtkCommunicator::Gather
int Gather(vtkDataObject *sendBuffer, std::vector< vtkSmartPointer< vtkDataObject >> &recvBuffer, int destProcessId)
Gathers vtkDataObject (sendBuffer) from all ranks to the destProcessId.
vtkCommunicator::Broadcast
int Broadcast(signed char *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes.
Definition: vtkCommunicator.h:351
vtkCommunicator::AllReduce
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.
Definition: vtkCommunicator.h:1091
vtkCommunicator::ReceiveVoidArray
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.
vtkCommunicator::Send
int Send(const unsigned long *data, vtkIdType length, int remoteHandle, int tag)
Convenience methods for sending data arrays.
Definition: vtkCommunicator.h:166
vtkCommunicator::GatherVElementalDataObject
int GatherVElementalDataObject(vtkDataObject *sendData, vtkSmartPointer< vtkDataObject > *receiveData, int destProcessId)
GatherV collects arrays in the process with id destProcessId.
vtkCommunicator::AllReduce
int AllReduce(const long *sendBuffer, long *recvBuffer, vtkIdType length, Operation *operation)
Same as Reduce except that the result is placed in all of the processes.
Definition: vtkCommunicator.h:1169
vtkCommunicator::AllReduce
int AllReduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length, Operation *operation)
Same as Reduce except that the result is placed in all of the processes.
Definition: vtkCommunicator.h:1206
vtkCommunicator::GetParentProcessor
static int GetParentProcessor(int pid)
Some helper functions when dealing with heap tree - based algorithms - we don't need a function for g...
vtkCommunicator::AllReduce
int AllReduce(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
Definition: vtkCommunicator.h:1140
vtkCommunicator::Reduce
int Reduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, Operation *operation, int destProcessId)
Reduce an array to the given destination process.
vtkCommunicator::Send
int Send(vtkDataObject *data, int remoteHandle, int tag)
This method sends a data object to a destination.
vtkCommunicator::Broadcast
int Broadcast(long long *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes.
Definition: vtkCommunicator.h:363
vtkCommunicator::Receive
int Receive(vtkDataObject *data, int remoteHandle, int tag)
This method receives a data object from a corresponding send.
vtkCommunicator::ReceiveMultiBlockDataSet
int ReceiveMultiBlockDataSet(vtkMultiBlockDataSet *data, int remoteHandle, int tag)
vtkCommunicator::GatherV
int GatherV(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
Definition: vtkCommunicator.h:525
vtkCommunicator::Reduce
int Reduce(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
Definition: vtkCommunicator.h:950
vtkCommunicator::AllGatherV
int AllGatherV(const double *sendBuffer, double *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Same as GatherV except that the result is placed in all processes.
Definition: vtkCommunicator.h:892
vtkCommunicator::GatherV
int GatherV(vtkDataArray *sendArray, vtkDataArray *recvArray, vtkSmartPointer< vtkDataArray > *recvArrays, int destProcessId)
GatherV collects arrays in the process with id destProcessId.
vtkCommunicator::Scatter
int Scatter(const short *sendBuffer, short *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
Definition: vtkCommunicator.h:612
vtkCommunicator::Gather
int Gather(const long *sendBuffer, long *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
Definition: vtkCommunicator.h:405
vtkCommunicator::AllGatherV
int AllGatherV(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Same as GatherV except that the result is placed in all processes.
Definition: vtkCommunicator.h:838
vtkCommunicator::ReadDataArray
int ReadDataArray(vtkDataArray *object)
vtkCommunicator::Broadcast
int Broadcast(unsigned long *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes.
Definition: vtkCommunicator.h:339
vtkCommunicator::AllReduce
int AllReduce(const char *sendBuffer, char *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
Definition: vtkCommunicator.h:1123
vtkCommunicator::Broadcast
int Broadcast(long *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes.
Definition: vtkCommunicator.h:335
vtkCommunicator::AllReduce
int AllReduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, Operation *operation)
Same as Reduce except that the result is placed in all of the processes.
vtkCommunicator::AllGatherV
int AllGatherV(vtkDataArray *sendArray, vtkDataArray *recvArray, vtkSmartPointer< vtkDataArray > *recvArrays)
vtkCommunicator::Scatter
int Scatter(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
Definition: vtkCommunicator.h:616
vtkCommunicator::Broadcast
int Broadcast(int *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes.
Definition: vtkCommunicator.h:319
vtkCommunicator::AllReduce
int AllReduce(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
Definition: vtkCommunicator.h:1113
vtkCommunicator::AllGatherV
int AllGatherV(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Same as GatherV except that the result is placed in all processes.
Definition: vtkCommunicator.h:880
vtkCommunicator::Scatter
int Scatter(const int *sendBuffer, int *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
Definition: vtkCommunicator.h:603
vtkCommunicator::ReduceVoidArray
virtual int ReduceVoidArray(const void *sendBuffer, void *recvBuffer, vtkIdType length, int type, int operation, int destProcessId)
Subclasses should reimplement these if they have a more efficient implementation.
vtkCommunicator::GatherV
int GatherV(const double *sendBuffer, double *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
Definition: vtkCommunicator.h:549
vtkCommunicator::Reduce
int Reduce(const long *sendBuffer, long *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
Definition: vtkCommunicator.h:944
vtkCommunicator::ScatterV
int ScatterV(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
Definition: vtkCommunicator.h:746
vtkCommunicator::Receive
int Receive(unsigned char *data, vtkIdType maxlength, int remoteHandle, int tag)
Convenience methods for receiving data arrays.
Definition: vtkCommunicator.h:261
vtkCommunicator::Receive
int Receive(signed char *data, vtkIdType maxlength, int remoteHandle, int tag)
Convenience methods for receiving data arrays.
Definition: vtkCommunicator.h:269
vtkCommunicator::AllReduce
int AllReduce(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
Definition: vtkCommunicator.h:1118
vtkCommunicator::Reduce
int Reduce(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
Definition: vtkCommunicator.h:926
vtkCommunicator::Reduce
int Reduce(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
Reduce an array to the given destination process.
Definition: vtkCommunicator.h:1071
vtkCommunicator::ReceiveDataObject
int ReceiveDataObject(vtkDataObject *data, int remoteHandle, int tag, int type=-1)
vtkCommunicator::ComputeGlobalBounds
virtual int ComputeGlobalBounds(int processorId, int numProcesses, vtkBoundingBox *bounds, int *rightHasBounds=nullptr, int *leftHasBounds=nullptr, int hasBoundsTag=288402, int localBoundsTag=288403, int globalBoundsTag=288404)
Determine the global bounds for a set of processes.
vtkCommunicator::Send
int Send(const long *data, vtkIdType length, int remoteHandle, int tag)
Convenience methods for sending data arrays.
Definition: vtkCommunicator.h:162
vtkCommunicator::Gather
int Gather(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
Definition: vtkCommunicator.h:423
vtkCommunicator::AllGatherV
int AllGatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, vtkIdType *recvLengths, vtkIdType *offsets)
Same as GatherV except that the result is placed in all processes.
vtkCommunicator::Send
int Send(const double *data, vtkIdType length, int remoteHandle, int tag)
Convenience methods for sending data arrays.
Definition: vtkCommunicator.h:186
vtkCommunicator::Gather
int Gather(const vtkMultiProcessStream &sendBuffer, std::vector< vtkMultiProcessStream > &recvBuffer, int destProcessId)
Gathers vtkMultiProcessStream (sendBuffer) from all ranks to the destProcessId.
vtkCommunicator::Receive
int Receive(int *data, vtkIdType maxlength, int remoteHandle, int tag)
Convenience methods for receiving data arrays.
Definition: vtkCommunicator.h:237
vtkCommunicator::Gather
int Gather(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
Definition: vtkCommunicator.h:414
vtkCommunicator::AllReduce
int AllReduce(const double *sendBuffer, double *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
Definition: vtkCommunicator.h:1136
vtkCommunicator::ScatterV
int ScatterV(const double *sendBuffer, double *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
Definition: vtkCommunicator.h:734
vtkCommunicator::Gather
int Gather(const char *sendBuffer, char *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
Definition: vtkCommunicator.h:419
vtkCommunicator::Reduce
int Reduce(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
Definition: vtkCommunicator.h:956
vtkCommunicator::ScatterVVoidArray
virtual int ScatterVVoidArray(const void *sendBuffer, void *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int type, int srcProcessId)
Subclasses should reimplement these if they have a more efficient implementation.
vtkCommunicator::AllGatherV
int AllGatherV(const char *sendBuffer, char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Same as GatherV except that the result is placed in all processes.
Definition: vtkCommunicator.h:874
vtkCommunicator::Probe
virtual int Probe(int vtkNotUsed(source), int vtkNotUsed(tag), int *vtkNotUsed(actualSource))
Blocking test for checking for a message tagged with tag from source process (if source == ANY_SOURCE...
Definition: vtkCommunicator.h:1262
vtkCommunicator::Reduce
int Reduce(const int *sendBuffer, int *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
Definition: vtkCommunicator.h:921
vtkCommunicator::AllGather
int AllGather(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
Definition: vtkCommunicator.h:806
vtkCommunicator::Gather
int Gather(const long long *sendBuffer, long long *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
Definition: vtkCommunicator.h:436
vtkCommunicator::Scatter
int Scatter(const double *sendBuffer, double *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
Definition: vtkCommunicator.h:648
vtkCommunicator::GatherV
int GatherV(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
Definition: vtkCommunicator.h:495
vtkCommunicator::ScatterVoidArray
virtual int ScatterVoidArray(const void *sendBuffer, void *recvBuffer, vtkIdType length, int type, int srcProcessId)
Subclasses should reimplement these if they have a more efficient implementation.
vtkCommunicator::AllReduce
int AllReduce(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
Definition: vtkCommunicator.h:1127
vtkCommunicator::GatherV
int GatherV(const int *sendBuffer, int *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
Definition: vtkCommunicator.h:489
vtkCommunicator::Send
int Send(const unsigned char *data, vtkIdType length, int remoteHandle, int tag)
Convenience methods for sending data arrays.
Definition: vtkCommunicator.h:170
vtkCommunicator::AllGather
int AllGather(vtkDataObject *sendBuffer, std::vector< vtkSmartPointer< vtkDataObject >> &recvBuffer)
Gathers vtkDataObject (sendBuffer) from all ranks to all raks.
vtkCommunicator::ReduceVoidArray
virtual int ReduceVoidArray(const void *sendBuffer, void *recvBuffer, vtkIdType length, int type, Operation *operation, int destProcessId)
Subclasses should reimplement these if they have a more efficient implementation.
vtkCommunicator::AllGatherV
int AllGatherV(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Same as GatherV except that the result is placed in all processes.
Definition: vtkCommunicator.h:862
vtkCommunicator::AllReduce
int AllReduce(const char *sendBuffer, char *recvBuffer, vtkIdType length, Operation *operation)
Same as Reduce except that the result is placed in all of the processes.
Definition: vtkCommunicator.h:1183
vtkCommunicator::AllGather
int AllGather(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
Definition: vtkCommunicator.h:762
vtkCommunicator::AllGather
int AllGather(const double *sendBuffer, double *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
Definition: vtkCommunicator.h:798
vtkCommunicator::Gather
int Gather(const float *sendBuffer, float *recvBuffer, vtkIdType length, int destProcessId)
Gather collects arrays in the process with id destProcessId.
Definition: vtkCommunicator.h:428
vtkCommunicator::AllReduce
int AllReduce(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, Operation *operation)
Same as Reduce except that the result is placed in all of the processes.
Definition: vtkCommunicator.h:1155
vtkCommunicator::GatherV
int GatherV(const char *sendBuffer, char *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
Definition: vtkCommunicator.h:531
vtkCommunicator::AllReduce
int AllReduce(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
Definition: vtkCommunicator.h:1104
vtkCommunicator::Scatter
int Scatter(const char *sendBuffer, char *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
Definition: vtkCommunicator.h:635
vtkCommunicator::~vtkCommunicator
~vtkCommunicator() override
vtkCommunicator::Receive
int Receive(short *data, vtkIdType maxlength, int remoteHandle, int tag)
Convenience methods for receiving data arrays.
Definition: vtkCommunicator.h:245
vtkCommunicator::Broadcast
int Broadcast(vtkDataArray *data, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes.
vtkCommunicator::GatherV
int GatherV(const float *sendBuffer, float *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
Definition: vtkCommunicator.h:543
vtkCommunicator::AllGatherV
int AllGatherV(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Same as GatherV except that the result is placed in all processes.
Definition: vtkCommunicator.h:904
vtkCommunicator::GatherVoidArray
virtual int GatherVoidArray(const void *sendBuffer, void *recvBuffer, vtkIdType length, int type, int destProcessId)
Subclasses should reimplement these if they have a more efficient implementation.
vtkCommunicator::Reduce
int Reduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
Definition: vtkCommunicator.h:992
vtkCommunicator::Broadcast
int Broadcast(double *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes.
Definition: vtkCommunicator.h:359
vtkCommunicator::Broadcast
int Broadcast(unsigned short *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes.
Definition: vtkCommunicator.h:331
vtkCommunicator::Receive
int Receive(double *data, vtkIdType maxlength, int remoteHandle, int tag)
Convenience methods for receiving data arrays.
Definition: vtkCommunicator.h:277
vtkCommunicator::GetLeftChildProcessor
static int GetLeftChildProcessor(int pid)
Some helper functions when dealing with heap tree - based algorithms - we don't need a function for g...
vtkCommunicator::AllGatherVVoidArray
virtual int AllGatherVVoidArray(const void *sendBuffer, void *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int type)
Subclasses should reimplement these if they have a more efficient implementation.
vtkCommunicator::AllReduce
int AllReduce(const long *sendBuffer, long *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
Definition: vtkCommunicator.h:1109
vtkCommunicator::GatherV
int GatherV(const short *sendBuffer, short *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
Definition: vtkCommunicator.h:501
vtkCommunicator::AllGatherVoidArray
virtual int AllGatherVoidArray(const void *sendBuffer, void *recvBuffer, vtkIdType length, int type)
Subclasses should reimplement these if they have a more efficient implementation.
vtkCommunicator::AllGather
int AllGather(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
Definition: vtkCommunicator.h:790
vtkCommunicator::Receive
int Receive(unsigned long *data, vtkIdType maxlength, int remoteHandle, int tag)
Convenience methods for receiving data arrays.
Definition: vtkCommunicator.h:257
vtkCommunicator::GatherV
int GatherV(const long long *sendBuffer, long long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
Definition: vtkCommunicator.h:555
vtkCommunicator::AllReduce
int AllReduce(const unsigned int *sendBuffer, unsigned int *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
Definition: vtkCommunicator.h:1095
vtkCommunicator::Reduce
int Reduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
Reduce an array to the given destination process.
Definition: vtkCommunicator.h:1077
vtkCommunicator::GatherV
int GatherV(const unsigned long *sendBuffer, unsigned long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId)
GatherV is the vector variant of Gather.
Definition: vtkCommunicator.h:519
vtkCommunicator::AllGather
int AllGather(const vtkMultiProcessStream &sendBuffer, std::vector< vtkMultiProcessStream > &recvBuffer)
Same as gather except that the result ends up on all processes.
vtkCommunicator::AllGather
int AllGather(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer)
Same as gather except that the result ends up on all processes.
vtkCommunicator::AllReduce
int AllReduce(const unsigned long long *sendBuffer, unsigned long long *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
Definition: vtkCommunicator.h:1144
vtkCommunicator::Send
int Send(const signed char *data, vtkIdType length, int remoteHandle, int tag)
Convenience methods for sending data arrays.
Definition: vtkCommunicator.h:178
vtkCommunicator::AllGather
int AllGather(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
Definition: vtkCommunicator.h:770
vtkCommunicator::AllGather
int AllGather(const int *sendBuffer, int *recvBuffer, vtkIdType length)
Same as gather except that the result ends up on all processes.
Definition: vtkCommunicator.h:758
vtkCommunicator::Send
int Send(const unsigned int *data, vtkIdType length, int remoteHandle, int tag)
Convenience methods for sending data arrays.
Definition: vtkCommunicator.h:150
vtkCommunicator::BroadcastVoidArray
virtual int BroadcastVoidArray(void *data, vtkIdType length, int type, int srcProcessId)
Subclasses should reimplement these if they have a more efficient implementation.
vtkCommunicator::Receive
int Receive(unsigned short *data, vtkIdType maxlength, int remoteHandle, int tag)
Convenience methods for receiving data arrays.
Definition: vtkCommunicator.h:249
vtkCommunicator::Reduce
int Reduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, int operation, int destProcessId)
Reduce an array to the given destination process.
vtkCommunicator::Broadcast
int Broadcast(unsigned int *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes.
Definition: vtkCommunicator.h:323
vtkCommunicator::Broadcast
int Broadcast(vtkDataObject *data, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes.
vtkCommunicator::LocalProcessId
int LocalProcessId
Definition: vtkCommunicator.h:1351
vtkCommunicator::Reduce
int Reduce(const short *sendBuffer, short *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
Reduce an array to the given destination process.
Definition: vtkCommunicator.h:1017
vtkCommunicator::Reduce
int Reduce(const unsigned char *sendBuffer, unsigned char *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
Reduce an array to the given destination process.
Definition: vtkCommunicator.h:1041
vtkCommunicator::MarshalDataObject
static int MarshalDataObject(vtkDataObject *object, vtkCharArray *buffer)
Convert a data object into a string that can be transmitted and vice versa.
vtkCommunicator::Reduce
int Reduce(const unsigned short *sendBuffer, unsigned short *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
Reduce an array to the given destination process.
Definition: vtkCommunicator.h:1023
vtkCommunicator::Scatter
int Scatter(const float *sendBuffer, float *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
Definition: vtkCommunicator.h:644
vtkCommunicator::Send
int Send(const float *data, vtkIdType length, int remoteHandle, int tag)
Convenience methods for sending data arrays.
Definition: vtkCommunicator.h:182
vtkCommunicator::Send
int Send(const vtkMultiProcessStream &stream, int remoteId, int tag)
vtkCommunicator::AllReduce
int AllReduce(const float *sendBuffer, float *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
Definition: vtkCommunicator.h:1132
vtkCommunicator::CanProbe
virtual bool CanProbe()
Check if this communicator implements a probe operation.
Definition: vtkCommunicator.h:1251
vtkCommunicator::Reduce
int Reduce(const float *sendBuffer, float *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
Definition: vtkCommunicator.h:974
vtkCommunicator::AllGatherV
int AllGatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, vtkIdTypeArray *recvLengthsArray, vtkIdTypeArray *offsetsArray)
vtkCommunicator::AllGatherV
int AllGatherV(const float *sendBuffer, float *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Same as GatherV except that the result is placed in all processes.
Definition: vtkCommunicator.h:886
vtkCommunicator::NumberOfProcesses
int NumberOfProcesses
Definition: vtkCommunicator.h:1349
vtkCommunicator::AllReduce
int AllReduce(const short *sendBuffer, short *recvBuffer, vtkIdType length, int operation)
Same as Reduce except that the result is placed in all of the processes.
Definition: vtkCommunicator.h:1100
vtkCommunicator::AllGatherV
int AllGatherV(const long long *sendBuffer, long long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Same as GatherV except that the result is placed in all processes.
Definition: vtkCommunicator.h:898
vtkCommunicator::ReceiveDataObject
vtkDataObject * ReceiveDataObject(int remoteHandle, int tag)
The caller does not have to know the data type before this call is made.
vtkCommunicator::Scatter
int Scatter(const signed char *sendBuffer, signed char *recvBuffer, vtkIdType length, int srcProcessId)
Scatter takes an array in the process with id srcProcessId and distributes it.
Definition: vtkCommunicator.h:639
vtkCommunicator::Reduce
int Reduce(const int *sendBuffer, int *recvBuffer, vtkIdType length, Operation *operation, int destProcessId)
Reduce an array to the given destination process.
Definition: vtkCommunicator.h:1006
vtkCommunicator::AllGatherV
int AllGatherV(const short *sendBuffer, short *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Same as GatherV except that the result is placed in all processes.
Definition: vtkCommunicator.h:844
vtkCommunicator::Send
int Send(const unsigned short *data, vtkIdType length, int remoteHandle, int tag)
Convenience methods for sending data arrays.
Definition: vtkCommunicator.h:158
vtkCommunicator::AllReduce
int AllReduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer, int operation)
Same as Reduce except that the result is placed in all of the processes.
vtkCommunicator::AllGatherV
int AllGatherV(const long *sendBuffer, long *recvBuffer, vtkIdType sendLength, vtkIdType *recvLengths, vtkIdType *offsets)
Same as GatherV except that the result is placed in all processes.
Definition: vtkCommunicator.h:856
vtkCommunicator::Reduce
int Reduce(const short *sendBuffer, short *recvBuffer, vtkIdType length, int operation, int destProcessId)
Reduce an array to the given destination process.
Definition: vtkCommunicator.h:932
vtkCommunicator::ScatterV
int ScatterV(const char *sendBuffer, char *recvBuffer, vtkIdType *sendLengths, vtkIdType *offsets, vtkIdType recvLength, int srcProcessId)
ScatterV is the vector variant of Scatter.
Definition: vtkCommunicator.h:716
vtkCommunicator::Receive
int Receive(unsigned int *data, vtkIdType maxlength, int remoteHandle, int tag)
Convenience methods for receiving data arrays.
Definition: vtkCommunicator.h:241
vtkCommunicator::Broadcast
int Broadcast(float *data, vtkIdType length, int srcProcessId)
Broadcast sends the array in the process with id srcProcessId to all of the other processes.
Definition: vtkCommunicator.h:355
vtkDataArray
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:54
vtkDataObject
general representation of visualization data
Definition: vtkDataObject.h:64
vtkDataSet
abstract class to specify dataset behavior
Definition: vtkDataSet.h:62
vtkIdTypeArray
dynamic, self-adjusting array of vtkIdType
Definition: vtkIdTypeArray.h:37
vtkImageData
topologically and geometrically regular array of data
Definition: vtkImageData.h:52
vtkIndent
a simple class to control print indentation
Definition: vtkIndent.h:38
vtkMultiBlockDataSet
Composite dataset that organizes datasets into blocks.
Definition: vtkMultiBlockDataSet.h:50
vtkMultiProcessStream
stream used to pass data across processes using vtkMultiProcessController.
Definition: vtkMultiProcessStream.h:30
vtkObject
abstract base class for most VTK objects
Definition: vtkObject.h:61
vtkSmartPointer< vtkDataObject >
vtkX3D::vector
@ vector
Definition: vtkX3D.h:237
vtkX3D::length
@ length
Definition: vtkX3D.h:393
vtkX3D::type
@ type
Definition: vtkX3D.h:516
vtkX3D::data
@ data
Definition: vtkX3D.h:315
source
boost::graph_traits< vtkGraph * >::vertex_descriptor source(boost::graph_traits< vtkGraph * >::edge_descriptor e, vtkGraph *)
Definition: vtkBoostGraphAdapter.h:964
vtkObject.h
vtkSmartPointer.h
VTK_SHORT
#define VTK_SHORT
Definition: vtkType.h:36
vtkIdType
int vtkIdType
Definition: vtkType.h:315
VTK_UNSIGNED_INT
#define VTK_UNSIGNED_INT
Definition: vtkType.h:39
VTK_LONG_LONG
#define VTK_LONG_LONG
Definition: vtkType.h:51
VTK_DOUBLE
#define VTK_DOUBLE
Definition: vtkType.h:43
VTK_UNSIGNED_CHAR
#define VTK_UNSIGNED_CHAR
Definition: vtkType.h:35
VTK_UNSIGNED_SHORT
#define VTK_UNSIGNED_SHORT
Definition: vtkType.h:37
VTK_INT
#define VTK_INT
Definition: vtkType.h:38
VTK_SIGNED_CHAR
#define VTK_SIGNED_CHAR
Definition: vtkType.h:34
VTK_FLOAT
#define VTK_FLOAT
Definition: vtkType.h:42
VTK_CHAR
#define VTK_CHAR
Definition: vtkType.h:33
VTK_UNSIGNED_LONG
#define VTK_UNSIGNED_LONG
Definition: vtkType.h:41
VTK_UNSIGNED_LONG_LONG
#define VTK_UNSIGNED_LONG_LONG
Definition: vtkType.h:52
VTK_LONG
#define VTK_LONG
Definition: vtkType.h:40