VTK: dox/Parallel/vtkCommunicator.h Source File

00001 /*=========================================================================
00002 
00003   Program:   Visualization Toolkit
00004   Module:    vtkCommunicator.h
00005 
00006   Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
00007   All rights reserved.
00008   See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
00009 
00010      This software is distributed WITHOUT ANY WARRANTY; without even
00011      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
00012      PURPOSE.  See the above copyright notice for more information.
00013 
00014 =========================================================================*/
00034 #ifndef __vtkCommunicator_h
00035 #define __vtkCommunicator_h
00036 
00037 #include "vtkObject.h"
00038 
00039 class vtkBoundingBox;
00040 class vtkCharArray;
00041 class vtkDataArray;
00042 class vtkDataObject;
00043 class vtkDataSet;
00044 class vtkImageData;
00045 class vtkMultiBlockDataSet;
00046 class vtkMultiProcessStream;
00047 class vtkTemporalDataSet;
00048 
00049 class VTK_PARALLEL_EXPORT vtkCommunicator : public vtkObject
00050 {
00051 
00052 public:
00053 
00054   vtkTypeMacro(vtkCommunicator, vtkObject);
00055   void PrintSelf(ostream& os, vtkIndent indent);
00056 
00058 
00061   virtual void SetNumberOfProcesses(int num);
00062   vtkGetMacro(NumberOfProcesses, int);
00064 
00066 
00067   vtkGetMacro(LocalProcessId, int);
00069 
00070 //BTX
00071 
00072   enum Tags
00073   {
00074     BROADCAST_TAG       = 10,
00075     GATHER_TAG          = 11,
00076     GATHERV_TAG         = 12,
00077     SCATTER_TAG         = 13,
00078     SCATTERV_TAG        = 14,
00079     REDUCE_TAG          = 15,
00080     BARRIER_TAG         = 16
00081   };
00082 
00083   enum StandardOperations
00084   {
00085     MAX_OP,
00086     MIN_OP,
00087     SUM_OP,
00088     PRODUCT_OP,
00089     LOGICAL_AND_OP,
00090     BITWISE_AND_OP,
00091     LOGICAL_OR_OP,
00092     BITWISE_OR_OP,
00093     LOGICAL_XOR_OP,
00094     BITWISE_XOR_OP
00095   };
00096 
00098 
00100   class Operation
00101   {
00102   public:
00103     // Description:
00104     // Subclasses must overload this method, which performs the actual
00105     // operations.  The methods should first do a reintepret cast of the arrays
00106     // to the type suggestsed by \c datatype (which will be one of the VTK type
00107     // identifiers like VTK_INT, etc.).  Both arrays are considered top be
00108     // length entries.  The method should perform the operation A*B (where * is
00109     // a placeholder for whatever operation is actually performed) and store the
00110     // result in B.  The operation is assumed to be associative.  Commutativity
00111     // is specified by the Commutative method.
00112     virtual void Function(const void *A, void *B, vtkIdType length,
00113                           int datatype) = 0;
00115 
00118     virtual int Commutative() = 0;
00119 
00120     virtual ~Operation() {}
00121   };
00122 
00123 //ETX
00124 
00127   int Send(vtkDataObject* data, int remoteHandle, int tag);
00128 
00131   int Send(vtkDataArray* data, int remoteHandle, int tag);
00132 
00134 
00138   virtual int SendVoidArray(const void *data, vtkIdType length, int type,
00139                             int remoteHandle, int tag) = 0;
00141 
00143 
00144   int Send(const int* data, vtkIdType length, int remoteHandle, int tag) {
00145     return this->SendVoidArray(data, length, VTK_INT, remoteHandle, tag);
00146   }
00147   int Send(const unsigned int* data, vtkIdType length, int remoteHandle, int tag) {
00148     return this->SendVoidArray(data, length, VTK_INT, remoteHandle, tag);
00149   }
00150   int Send(const unsigned long* data, vtkIdType length,
00151            int remoteHandle, int tag) {
00152     return this->SendVoidArray(data, length,VTK_UNSIGNED_LONG,remoteHandle,tag);
00153   }
00154   int Send(const unsigned char* data, vtkIdType length,
00155            int remoteHandle, int tag) {
00156     return this->SendVoidArray(data, length,VTK_UNSIGNED_CHAR,remoteHandle,tag);
00157   }
00158   int Send(const char* data, vtkIdType length, int remoteHandle, int tag) {
00159     return this->SendVoidArray(data, length, VTK_CHAR, remoteHandle, tag);
00160   }
00161   int Send(const float* data, vtkIdType length, int remoteHandle, int tag) {
00162     return this->SendVoidArray(data, length, VTK_FLOAT, remoteHandle, tag);
00163   }
00164   int Send(const double* data, vtkIdType length, int remoteHandle, int tag) {
00165     return this->SendVoidArray(data, length, VTK_DOUBLE, remoteHandle, tag);
00166   }
00167 #ifdef VTK_USE_64BIT_IDS
00168   int Send(const vtkIdType* data, vtkIdType length, int remoteHandle, int tag) {
00169     return this->SendVoidArray(data, length, VTK_ID_TYPE, remoteHandle, tag);
00170   }
00171 #endif
00172 //BTX
00173   int Send(const vtkMultiProcessStream& stream, int remoteId, int tag);
00174 //ETX
00176 
00177 
00180   int Receive(vtkDataObject* data, int remoteHandle, int tag);
00181 
00184   vtkDataObject *ReceiveDataObject(int remoteHandle, int tag);
00185 
00188   int Receive(vtkDataArray* data, int remoteHandle, int tag);
00189 
00191 
00199   virtual int ReceiveVoidArray(void *data, vtkIdType maxlength, int type,
00200                                int remoteHandle, int tag) = 0;
00202 
00204 
00205   int Receive(int* data, vtkIdType maxlength, int remoteHandle, int tag) {
00206     return this->ReceiveVoidArray(data, maxlength, VTK_INT, remoteHandle, tag);
00207   }
00208   int Receive(unsigned int* data, vtkIdType maxlength, int remoteHandle, int tag) {
00209     return this->ReceiveVoidArray(data, maxlength, VTK_INT, remoteHandle, tag);
00210   }
00211   int Receive(unsigned long* data, vtkIdType maxlength, int remoteHandle, int tag){
00212     return this->ReceiveVoidArray(data, maxlength, VTK_UNSIGNED_LONG, remoteHandle,
00213                                   tag);
00214   }
00215   int Receive(unsigned char* data, vtkIdType maxlength, int remoteHandle, int tag){
00216     return this->ReceiveVoidArray(data, maxlength, VTK_UNSIGNED_CHAR, remoteHandle,
00217                                   tag);
00218   }
00219   int Receive(char* data, vtkIdType maxlength, int remoteHandle, int tag) {
00220     return this->ReceiveVoidArray(data, maxlength, VTK_CHAR, remoteHandle, tag);
00221   }
00222   int Receive(float* data, vtkIdType maxlength, int remoteHandle, int tag) {
00223     return this->ReceiveVoidArray(data, maxlength, VTK_FLOAT, remoteHandle, tag);
00224   }
00225   int Receive(double* data, vtkIdType maxlength, int remoteHandle, int tag) {
00226     return this->ReceiveVoidArray(data, maxlength, VTK_DOUBLE, remoteHandle, tag);
00227   }
00228 #ifdef VTK_USE_64BIT_IDS
00229   int Receive(vtkIdType* data, vtkIdType maxlength, int remoteHandle, int tag) {
00230     return this->ReceiveVoidArray(data, maxlength, VTK_ID_TYPE, remoteHandle, tag);
00231   }
00232 #endif
00233 //BTX
00234   int Receive(vtkMultiProcessStream& stream, int remoteId, int tag);
00235 //ETX
00237 
00239 
00246   vtkGetMacro(Count, vtkIdType);
00248 
00249   //---------------------- Collective Operations ----------------------
00250 
00253   virtual void Barrier();
00254 
00256 
00259   int Broadcast(int *data, vtkIdType length, int srcProcessId) {
00260     return this->BroadcastVoidArray(data, length, VTK_INT, srcProcessId);
00261   }
00262   int Broadcast(unsigned int *data, vtkIdType length, int srcProcessId) {
00263     return this->BroadcastVoidArray(data, length, VTK_UNSIGNED_INT, srcProcessId);
00264   }
00265   int Broadcast(unsigned long *data, vtkIdType length, int srcProcessId) {
00266     return this->BroadcastVoidArray(data,length,VTK_UNSIGNED_LONG,srcProcessId);
00267   }
00268   int Broadcast(unsigned char *data, vtkIdType length, int srcProcessId) {
00269     return this->BroadcastVoidArray(data,length,VTK_UNSIGNED_CHAR,srcProcessId);
00270   }
00271   int Broadcast(char *data, vtkIdType length, int srcProcessId) {
00272     return this->BroadcastVoidArray(data, length, VTK_CHAR, srcProcessId);
00273   }
00274   int Broadcast(float *data, vtkIdType length, int srcProcessId) {
00275     return this->BroadcastVoidArray(data, length, VTK_FLOAT, srcProcessId);
00276   }
00277   int Broadcast(double *data, vtkIdType length, int srcProcessId) {
00278     return this->BroadcastVoidArray(data, length, VTK_DOUBLE, srcProcessId);
00279   }
00280 #ifdef VTK_USE_64BIT_IDS
00281   int Broadcast(vtkIdType *data, vtkIdType length, int srcProcessId) {
00282     return this->BroadcastVoidArray(data, length, VTK_ID_TYPE, srcProcessId);
00283   }
00284 #endif
00285   int Broadcast(vtkDataObject *data, int srcProcessId);
00286   int Broadcast(vtkDataArray *data, int srcProcessId);
00287 //BTX
00288   int Broadcast(vtkMultiProcessStream& stream, int srcProcessId);
00289 //ETX
00291 
00293 
00301   int Gather(const int *sendBuffer, int *recvBuffer,
00302              vtkIdType length, int destProcessId) {
00303     return this->GatherVoidArray(sendBuffer, recvBuffer, length,
00304                                  VTK_INT, destProcessId);
00305   }
00306   int Gather(const unsigned long *sendBuffer, unsigned long *recvBuffer,
00307              vtkIdType length, int destProcessId) {
00308     return this->GatherVoidArray(sendBuffer, recvBuffer, length,
00309                                  VTK_UNSIGNED_LONG, destProcessId);
00310   }
00311   int Gather(const unsigned char *sendBuffer, unsigned char *recvBuffer,
00312              vtkIdType length, int destProcessId) {
00313     return this->GatherVoidArray(sendBuffer, recvBuffer, length,
00314                                  VTK_UNSIGNED_CHAR, destProcessId);
00315   }
00316   int Gather(const char *sendBuffer, char *recvBuffer,
00317              vtkIdType length, int destProcessId) {
00318     return this->GatherVoidArray(sendBuffer, recvBuffer, length,
00319                                  VTK_CHAR, destProcessId);
00320   }
00321   int Gather(const float *sendBuffer, float *recvBuffer,
00322              vtkIdType length, int destProcessId) {
00323     return this->GatherVoidArray(sendBuffer, recvBuffer, length,
00324                                  VTK_FLOAT, destProcessId);
00325   }
00326   int Gather(const double *sendBuffer, double *recvBuffer,
00327              vtkIdType length, int destProcessId) {
00328     return this->GatherVoidArray(sendBuffer, recvBuffer, length,
00329                                  VTK_DOUBLE, destProcessId);
00330   }
00331 #ifdef VTK_USE_64BIT_IDS
00332   int Gather(const vtkIdType *sendBuffer, vtkIdType *recvBuffer,
00333              vtkIdType length, int destProcessId) {
00334     return this->GatherVoidArray(sendBuffer, recvBuffer, length,
00335                                  VTK_ID_TYPE, destProcessId);
00336   }
00337 #endif
00338   int Gather(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
00339              int destProcessId);
00341 
00343 
00353   int GatherV(const int* sendBuffer, int* recvBuffer,
00354               vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
00355               int destProcessId) {
00356     return this->GatherVVoidArray(sendBuffer, recvBuffer,
00357                                   sendLength, recvLengths,
00358                                   offsets, VTK_INT, destProcessId);
00359   }
00360   int GatherV(const unsigned long* sendBuffer, unsigned long* recvBuffer,
00361               vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
00362               int destProcessId) {
00363     return this->GatherVVoidArray(sendBuffer, recvBuffer,
00364                                   sendLength, recvLengths,
00365                                   offsets, VTK_UNSIGNED_LONG, destProcessId);
00366   }
00367   int GatherV(const unsigned char* sendBuffer, unsigned char* recvBuffer,
00368               vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
00369               int destProcessId) {
00370     return this->GatherVVoidArray(sendBuffer, recvBuffer,
00371                                   sendLength, recvLengths,
00372                                   offsets, VTK_UNSIGNED_CHAR, destProcessId);
00373   }
00374   int GatherV(const char* sendBuffer, char* recvBuffer,
00375               vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
00376               int destProcessId) {
00377     return this->GatherVVoidArray(sendBuffer, recvBuffer,
00378                                   sendLength, recvLengths,
00379                                   offsets, VTK_CHAR, destProcessId);
00380   }
00381   int GatherV(const float* sendBuffer, float* recvBuffer,
00382               vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
00383               int destProcessId) {
00384     return this->GatherVVoidArray(sendBuffer, recvBuffer,
00385                                   sendLength, recvLengths,
00386                                   offsets, VTK_FLOAT, destProcessId);
00387   }
00388   int GatherV(const double* sendBuffer, double* recvBuffer,
00389               vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
00390               int destProcessId) {
00391     return this->GatherVVoidArray(sendBuffer, recvBuffer,
00392                                   sendLength, recvLengths,
00393                                   offsets, VTK_DOUBLE, destProcessId);
00394   }
00395 #ifdef VTK_USE_64BIT_IDS
00396   int GatherV(const vtkIdType* sendBuffer, vtkIdType* recvBuffer,
00397               vtkIdType sendLength, vtkIdType* recvLengths, vtkIdType* offsets,
00398               int destProcessId) {
00399     return this->GatherVVoidArray(sendBuffer, recvBuffer,
00400                                   sendLength, recvLengths,
00401                                   offsets, VTK_ID_TYPE, destProcessId);
00402   }
00403 #endif
00404   int GatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
00405               vtkIdType *recvLengths, vtkIdType *offsets, int destProcessId);
00406   int GatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
00407               int destProcessId);
00409 
00411 
00416   int Scatter(const int *sendBuffer, int *recvBuffer,
00417              vtkIdType length, int srcProcessId) {
00418     return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
00419                                   VTK_INT, srcProcessId);
00420   }
00421   int Scatter(const unsigned long *sendBuffer, unsigned long *recvBuffer,
00422              vtkIdType length, int srcProcessId) {
00423     return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
00424                                   VTK_UNSIGNED_LONG, srcProcessId);
00425   }
00426   int Scatter(const unsigned char *sendBuffer, unsigned char *recvBuffer,
00427              vtkIdType length, int srcProcessId) {
00428     return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
00429                                   VTK_UNSIGNED_CHAR, srcProcessId);
00430   }
00431   int Scatter(const char *sendBuffer, char *recvBuffer,
00432              vtkIdType length, int srcProcessId) {
00433     return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
00434                                   VTK_CHAR, srcProcessId);
00435   }
00436   int Scatter(const float *sendBuffer, float *recvBuffer,
00437              vtkIdType length, int srcProcessId) {
00438     return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
00439                                   VTK_FLOAT, srcProcessId);
00440   }
00441   int Scatter(const double *sendBuffer, double *recvBuffer,
00442              vtkIdType length, int srcProcessId) {
00443     return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
00444                                   VTK_DOUBLE, srcProcessId);
00445   }
00446 #ifdef VTK_USE_64BIT_IDS
00447   int Scatter(const vtkIdType *sendBuffer, vtkIdType *recvBuffer,
00448              vtkIdType length, int srcProcessId) {
00449     return this->ScatterVoidArray(sendBuffer, recvBuffer, length,
00450                                   VTK_ID_TYPE, srcProcessId);
00451   }
00452 #endif
00453   int Scatter(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
00454              int srcProcessId);
00456 
00458 
00464   int ScatterV(const int *sendBuffer, int *recvBuffer,
00465                vtkIdType *sendLengths, vtkIdType *offsets,
00466                vtkIdType recvLength, int srcProcessId) {
00467     return this->ScatterVVoidArray(sendBuffer, recvBuffer,
00468                                    sendLengths, offsets, recvLength,
00469                                    VTK_INT, srcProcessId);
00470   }
00471   int ScatterV(const unsigned long *sendBuffer, unsigned long *recvBuffer,
00472                vtkIdType *sendLengths, vtkIdType *offsets,
00473                vtkIdType recvLength, int srcProcessId) {
00474     return this->ScatterVVoidArray(sendBuffer, recvBuffer,
00475                                    sendLengths, offsets, recvLength,
00476                                    VTK_UNSIGNED_LONG, srcProcessId);
00477   }
00478   int ScatterV(const unsigned char *sendBuffer, unsigned char *recvBuffer,
00479                vtkIdType *sendLengths, vtkIdType *offsets,
00480                vtkIdType recvLength, int srcProcessId) {
00481     return this->ScatterVVoidArray(sendBuffer, recvBuffer,
00482                                    sendLengths, offsets, recvLength,
00483                                    VTK_UNSIGNED_CHAR, srcProcessId);
00484   }
00485   int ScatterV(const char *sendBuffer, char *recvBuffer,
00486                vtkIdType *sendLengths, vtkIdType *offsets,
00487                vtkIdType recvLength, int srcProcessId) {
00488     return this->ScatterVVoidArray(sendBuffer, recvBuffer,
00489                                    sendLengths, offsets, recvLength,
00490                                    VTK_CHAR, srcProcessId);
00491   }
00492   int ScatterV(const float *sendBuffer, float *recvBuffer,
00493                vtkIdType *sendLengths, vtkIdType *offsets,
00494                vtkIdType recvLength, int srcProcessId) {
00495     return this->ScatterVVoidArray(sendBuffer, recvBuffer,
00496                                    sendLengths, offsets, recvLength,
00497                                    VTK_FLOAT, srcProcessId);
00498   }
00499   int ScatterV(const double *sendBuffer, double *recvBuffer,
00500                vtkIdType *sendLengths, vtkIdType *offsets,
00501                vtkIdType recvLength, int srcProcessId) {
00502     return this->ScatterVVoidArray(sendBuffer, recvBuffer,
00503                                    sendLengths, offsets, recvLength,
00504                                    VTK_DOUBLE, srcProcessId);
00505   }
00506 #ifdef VTK_USE_64BIT_IDS
00507   int ScatterV(const vtkIdType *sendBuffer, vtkIdType *recvBuffer,
00508                vtkIdType *sendLengths, vtkIdType *offsets,
00509                vtkIdType recvLength, int srcProcessId) {
00510     return this->ScatterVVoidArray(sendBuffer, recvBuffer,
00511                                    sendLengths, offsets, recvLength,
00512                                    VTK_ID_TYPE, srcProcessId);
00513   }
00514 #endif
00515 
00516 
00518 
00519   int AllGather(const int *sendBuffer, int *recvBuffer, vtkIdType length) {
00520     return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_INT);
00521   }
00522   int AllGather(const unsigned long *sendBuffer,
00523                 unsigned long *recvBuffer, vtkIdType length) {
00524     return this->AllGatherVoidArray(sendBuffer, recvBuffer, length,
00525                                     VTK_UNSIGNED_LONG);
00526   }
00527   int AllGather(const unsigned char *sendBuffer,
00528                 unsigned char *recvBuffer, vtkIdType length) {
00529     return this->AllGatherVoidArray(sendBuffer, recvBuffer, length,
00530                                     VTK_UNSIGNED_CHAR);
00531   }
00532   int AllGather(const char *sendBuffer, char *recvBuffer, vtkIdType length) {
00533     return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_CHAR);
00534   }
00535   int AllGather(const float *sendBuffer, float *recvBuffer, vtkIdType length) {
00536     return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_FLOAT);
00537   }
00538   int AllGather(const double *sendBuffer,
00539                 double *recvBuffer, vtkIdType length) {
00540     return this->AllGatherVoidArray(sendBuffer, recvBuffer, length, VTK_DOUBLE);
00541   }
00542 #ifdef VTK_USE_64BIT_IDS
00543   int AllGather(const vtkIdType *sendBuffer, vtkIdType *recvBuffer,
00544                 vtkIdType length) {
00545     return this->AllGatherVoidArray(sendBuffer, recvBuffer, length,
00546                                     VTK_ID_TYPE);
00547   }
00548 #endif
00549   int AllGather(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer);
00551 
00553 
00554   int AllGatherV(const int* sendBuffer, int* recvBuffer,
00555                  vtkIdType sendLength, vtkIdType* recvLengths,
00556                  vtkIdType* offsets) {
00557     return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
00558                                      sendLength, recvLengths,
00559                                      offsets, VTK_INT);
00560   }
00561   int AllGatherV(const unsigned long* sendBuffer, unsigned long* recvBuffer,
00562                  vtkIdType sendLength, vtkIdType* recvLengths,
00563                  vtkIdType* offsets) {
00564     return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
00565                                      sendLength, recvLengths,
00566                                      offsets, VTK_UNSIGNED_LONG);
00567   }
00568   int AllGatherV(const unsigned char* sendBuffer, unsigned char* recvBuffer,
00569                  vtkIdType sendLength, vtkIdType* recvLengths,
00570                  vtkIdType* offsets) {
00571     return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
00572                                      sendLength, recvLengths,
00573                                      offsets, VTK_UNSIGNED_CHAR);
00574   }
00575   int AllGatherV(const char* sendBuffer, char* recvBuffer,
00576                  vtkIdType sendLength, vtkIdType* recvLengths,
00577                  vtkIdType* offsets) {
00578     return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
00579                                      sendLength, recvLengths,
00580                                      offsets, VTK_CHAR);
00581   }
00582   int AllGatherV(const float* sendBuffer, float* recvBuffer,
00583                  vtkIdType sendLength, vtkIdType* recvLengths,
00584                  vtkIdType* offsets) {
00585     return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
00586                                      sendLength, recvLengths,
00587                                      offsets, VTK_FLOAT);
00588   }
00589   int AllGatherV(const double* sendBuffer, double* recvBuffer,
00590                  vtkIdType sendLength, vtkIdType* recvLengths,
00591                  vtkIdType* offsets) {
00592     return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
00593                                      sendLength, recvLengths,
00594                                      offsets, VTK_DOUBLE);
00595   }
00596 #ifdef VTK_USE_64BIT_IDS
00597   int AllGatherV(const vtkIdType* sendBuffer, vtkIdType* recvBuffer,
00598                  vtkIdType sendLength, vtkIdType* recvLengths,
00599                  vtkIdType* offsets) {
00600     return this->AllGatherVVoidArray(sendBuffer, recvBuffer,
00601                                      sendLength, recvLengths,
00602                                      offsets, VTK_ID_TYPE);
00603   }
00604 #endif
00605   int AllGatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
00606                  vtkIdType *recvLengths, vtkIdType *offsets);
00607   int AllGatherV(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer);
00609 
00611 
00614   int Reduce(const int *sendBuffer, int *recvBuffer,
00615              vtkIdType length, int operation, int destProcessId) {
00616     return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
00617                                  VTK_INT, operation, destProcessId);
00618   }
00619   int Reduce(const unsigned int *sendBuffer, unsigned int *recvBuffer,
00620              vtkIdType length, int operation, int destProcessId) {
00621     return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
00622                                  VTK_UNSIGNED_INT, operation, destProcessId);
00623   }
00624   int Reduce(const unsigned long *sendBuffer, unsigned long *recvBuffer,
00625              vtkIdType length, int operation, int destProcessId) {
00626     return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
00627                                  VTK_UNSIGNED_LONG, operation, destProcessId);
00628   }
00629   int Reduce(const unsigned char *sendBuffer, unsigned char *recvBuffer,
00630              vtkIdType length, int operation, int destProcessId) {
00631     return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
00632                                  VTK_UNSIGNED_CHAR, operation, destProcessId);
00633   }
00634   int Reduce(const char *sendBuffer, char *recvBuffer,
00635              vtkIdType length, int operation, int destProcessId) {
00636     return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
00637                                  VTK_CHAR, operation, destProcessId);
00638   }
00639   int Reduce(const float *sendBuffer, float *recvBuffer,
00640              vtkIdType length, int operation, int destProcessId) {
00641     return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
00642                                  VTK_FLOAT, operation, destProcessId);
00643   }
00644   int Reduce(const double *sendBuffer, double *recvBuffer,
00645              vtkIdType length, int operation, int destProcessId) {
00646     return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
00647                                  VTK_DOUBLE, operation, destProcessId);
00648   }
00649 #ifdef VTK_USE_64BIT_IDS
00650   int Reduce(const vtkIdType *sendBuffer, vtkIdType *recvBuffer,
00651              vtkIdType length, int operation, int destProcessId) {
00652     return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
00653                                  VTK_ID_TYPE, operation, destProcessId);
00654   }
00655 #endif
00656   int Reduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
00657              int operation, int destProcessId);
00659 
00661 
00664   int Reduce(const int *sendBuffer, int *recvBuffer,
00665              vtkIdType length, Operation *operation, int destProcessId) {
00666     return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
00667                                  VTK_INT, operation, destProcessId);
00668   }
00669   int Reduce(const unsigned long *sendBuffer, unsigned long *recvBuffer,
00670              vtkIdType length, Operation *operation, int destProcessId) {
00671     return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
00672                                  VTK_UNSIGNED_LONG, operation, destProcessId);
00673   }
00674   int Reduce(const unsigned char *sendBuffer, unsigned char *recvBuffer,
00675              vtkIdType length, Operation *operation, int destProcessId) {
00676     return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
00677                                  VTK_UNSIGNED_CHAR, operation, destProcessId);
00678   }
00679   int Reduce(const char *sendBuffer, char *recvBuffer,
00680              vtkIdType length, Operation *operation, int destProcessId) {
00681     return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
00682                                  VTK_CHAR, operation, destProcessId);
00683   }
00684   int Reduce(const float *sendBuffer, float *recvBuffer,
00685              vtkIdType length, Operation *operation, int destProcessId) {
00686     return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
00687                                  VTK_FLOAT, operation, destProcessId);
00688   }
00689   int Reduce(const double *sendBuffer, double *recvBuffer,
00690              vtkIdType length, Operation *operation, int destProcessId) {
00691     return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
00692                                  VTK_DOUBLE, operation, destProcessId);
00693   }
00694 #ifdef VTK_USE_64BIT_IDS
00695   int Reduce(const vtkIdType *sendBuffer, vtkIdType *recvBuffer,
00696              vtkIdType length, Operation *operation, int destProcessId) {
00697     return this->ReduceVoidArray(sendBuffer, recvBuffer, length,
00698                                  VTK_ID_TYPE, operation, destProcessId);
00699   }
00700 #endif
00701   int Reduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
00702              Operation *operation, int destProcessId);
00704 
00706 
00708   int AllReduce(const int *sendBuffer, int *recvBuffer,
00709                 vtkIdType length, int operation) {
00710     return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
00711                                     VTK_INT, operation);
00712   }
00713   int AllReduce(const unsigned long *sendBuffer, unsigned long *recvBuffer,
00714                 vtkIdType length, int operation) {
00715     return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
00716                                     VTK_UNSIGNED_LONG, operation);
00717   }
00718   int AllReduce(const unsigned char *sendBuffer, unsigned char *recvBuffer,
00719                 vtkIdType length, int operation) {
00720     return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
00721                                     VTK_UNSIGNED_CHAR, operation);
00722   }
00723   int AllReduce(const char *sendBuffer, char *recvBuffer,
00724                 vtkIdType length, int operation) {
00725     return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
00726                                     VTK_CHAR, operation);
00727   }
00728   int AllReduce(const float *sendBuffer, float *recvBuffer,
00729                 vtkIdType length, int operation) {
00730     return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
00731                                     VTK_FLOAT, operation);
00732   }
00733   int AllReduce(const double *sendBuffer, double *recvBuffer,
00734                 vtkIdType length, int operation) {
00735     return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
00736                                     VTK_DOUBLE, operation);
00737   }
00738 #ifdef VTK_USE_64BIT_IDS
00739   int AllReduce(const vtkIdType *sendBuffer, vtkIdType *recvBuffer,
00740                 vtkIdType length, int operation) {
00741     return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
00742                                     VTK_ID_TYPE, operation);
00743   }
00744 #endif
00745   int AllReduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
00746                 int operation);
00747   int AllReduce(const int *sendBuffer, int *recvBuffer,
00748                 vtkIdType length, Operation *operation) {
00749     return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
00750                                     VTK_INT, operation);
00751   }
00752   int AllReduce(const unsigned long *sendBuffer, unsigned long *recvBuffer,
00753                 vtkIdType length, Operation *operation) {
00754     return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
00755                                     VTK_UNSIGNED_LONG, operation);
00756   }
00757   int AllReduce(const unsigned char *sendBuffer, unsigned char *recvBuffer,
00758                 vtkIdType length, Operation *operation) {
00759     return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
00760                                     VTK_UNSIGNED_CHAR, operation);
00761   }
00762   int AllReduce(const char *sendBuffer, char *recvBuffer,
00763                 vtkIdType length, Operation *operation) {
00764     return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
00765                                     VTK_CHAR, operation);
00766   }
00767   int AllReduce(const float *sendBuffer, float *recvBuffer,
00768                 vtkIdType length, Operation *operation) {
00769     return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
00770                                     VTK_FLOAT, operation);
00771   }
00772   int AllReduce(const double *sendBuffer, double *recvBuffer,
00773                 vtkIdType length, Operation *operation) {
00774     return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
00775                                     VTK_DOUBLE, operation);
00776   }
00777 #ifdef VTK_USE_64BIT_IDS
00778   int AllReduce(const vtkIdType *sendBuffer, vtkIdType *recvBuffer,
00779                 vtkIdType length, Operation *operation) {
00780     return this->AllReduceVoidArray(sendBuffer, recvBuffer, length,
00781                                     VTK_ID_TYPE, operation);
00782   }
00783 #endif
00784   int AllReduce(vtkDataArray *sendBuffer, vtkDataArray *recvBuffer,
00785                 Operation *operation);
00787 
00789 
00791   virtual int BroadcastVoidArray(void *data, vtkIdType length, int type,
00792                                  int srcProcessId);
00793   virtual int GatherVoidArray(const void *sendBuffer, void *recvBuffer,
00794                               vtkIdType length, int type, int destProcessId);
00795   virtual int GatherVVoidArray(const void *sendBuffer, void *recvBuffer,
00796                                vtkIdType sendLength, vtkIdType *recvLengths,
00797                                vtkIdType *offsets, int type, int destProcessId);
00798   virtual int ScatterVoidArray(const void *sendBuffer, void *recvBuffer,
00799                                vtkIdType length, int type, int srcProcessId);
00800   virtual int ScatterVVoidArray(const void *sendBuffer, void *recvBuffer,
00801                                 vtkIdType *sendLengths, vtkIdType *offsets,
00802                                 vtkIdType recvLength, int type,
00803                                 int srcProcessId);
00804   virtual int AllGatherVoidArray(const void *sendBuffer, void *recvBuffer,
00805                                  vtkIdType length, int type);
00806   virtual int AllGatherVVoidArray(const void *sendBuffer, void *recvBuffer,
00807                                   vtkIdType sendLength, vtkIdType *recvLengths,
00808                                   vtkIdType *offsets, int type);
00809   virtual int ReduceVoidArray(const void *sendBuffer, void *recvBuffer,
00810                               vtkIdType length, int type,
00811                               int operation, int destProcessId);
00812   virtual int ReduceVoidArray(const void *sendBuffer, void *recvBuffer,
00813                               vtkIdType length, int type,
00814                               Operation *operation, int destProcessId);
00815   virtual int AllReduceVoidArray(const void *sendBuffer, void *recvBuffer,
00816                                  vtkIdType length, int type,
00817                                  int operation);
00818   virtual int AllReduceVoidArray(const void *sendBuffer, void *recvBuffer,
00819                                  vtkIdType length, int type,
00820                                  Operation *operation);
00822 
00823   static void SetUseCopy(int useCopy);
00824 
00825 //BTX
00827 
00835   virtual int ComputeGlobalBounds(int processorId, int numProcesses,
00836                                   vtkBoundingBox *bounds,
00837                                   int *rightHasBounds = 0,
00838                                   int *leftHasBounds = 0,
00839                                   int hasBoundsTag = 288402,
00840                                   int localBoundsTag = 288403,
00841                                   int globalBoundsTag = 288404);
00842 //ETX
00844 
00846 
00849   static int GetParentProcessor(int pid);
00850   static int GetLeftChildProcessor(int pid);
00852 
00854 
00857   static int MarshalDataObject(vtkDataObject *object, vtkCharArray *buffer);
00858   static int UnMarshalDataObject(vtkCharArray *buffer, vtkDataObject *object);
00860 
00861 protected:
00862 
00863   int WriteDataArray(vtkDataArray *object);
00864   int ReadDataArray(vtkDataArray *object);
00865 
00866   vtkCommunicator();
00867   ~vtkCommunicator();
00868 
00869   // Internal methods called by Send/Receive(vtkDataObject *... ) above.
00870   int SendElementalDataObject(vtkDataObject* data, int remoteHandle, int tag);
00871   int SendMultiBlockDataSet(vtkMultiBlockDataSet* data, int remoteHandle, int tag);
00872   int SendTemporalDataSet(vtkTemporalDataSet* data, int remoteHandle, int tag);
00873   int ReceiveDataObject(vtkDataObject* data,
00874                         int remoteHandle, int tag, int type=-1);
00875   int ReceiveElementalDataObject(vtkDataObject* data,
00876                                  int remoteHandle, int tag);
00877   int ReceiveMultiBlockDataSet(
00878     vtkMultiBlockDataSet* data, int remoteHandle, int tag);
00879   int ReceiveTemporalDataSet(
00880     vtkTemporalDataSet* data, int remoteHandle, int tag);
00881 
00882   int MaximumNumberOfProcesses;
00883   int NumberOfProcesses;
00884 
00885   int LocalProcessId;
00886 
00887   static int UseCopy;
00888 
00889   vtkIdType Count;
00890 
00891 private:
00892   vtkCommunicator(const vtkCommunicator&);  // Not implemented.
00893   void operator=(const vtkCommunicator&);  // Not implemented.
00894 };
00895 
00896 #endif // __vtkCommunicator_h
00897 
00898