src/OpenFOAM/db/IOstreams/Pstreams/Pstream.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
   6      \\/     M anipulation  |
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of OpenFOAM.
  10
  11     OpenFOAM is free software: you can redistribute it and/or modify it
  12     under the terms of the GNU General Public License as published by
  13     the Free Software Foundation, either version 3 of the License, or
  14     (at your option) any later version.
  15
  16     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
  17     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  19     for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 Class
  25     Foam::Pstream
  26
  27 Description
  28     Inter-processor communications stream
  29
  30 SourceFiles
  31     Pstream.C
  32     gatherScatter.C
  33     combineGatherScatter.C
  34     gatherScatterList.C
  35     exchange.C
  36
  37 \*---------------------------------------------------------------------------*/
  38
  39 #ifndef Pstream_H
  40 #define Pstream_H
  41
  42 #include "UPstream.H"
  43 #include "DynamicList.H"
  44
  45 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  46
  47 namespace Foam
  48 {
  49
  50 /*---------------------------------------------------------------------------*\
  51                            Class Pstream Declaration
  52 \*---------------------------------------------------------------------------*/
  53
  54 class Pstream
  55 :
  56     public UPstream
  57 {
  58
  59 protected:
  60
  61     // Protected data
  62
  63         //- Transfer buffer
  64         DynamicList<char> buf_;
  65
  66 public:
  67
  68     // Declare name of the class and its debug switch
  69     ClassName("Pstream");
  70
  71
  72     // Constructors
  73
  74         //- Construct given optional buffer size
  75         Pstream
  76         (
  77             const commsTypes commsType,
  78             const label bufSize = 0
  79         )
  80         :
  81             UPstream(commsType),
  82             buf_(0)
  83         {
  84             if (bufSize)
  85             {
  86                 buf_.setCapacity(bufSize + 2*sizeof(scalar) + 1);
  87             }
  88         }
  89
  90
  91         // Gather and scatter
  92
  93             //- Gather data. Apply bop to combine Value
  94             //  from different processors
  95             template <class T, class BinaryOp>
  96             static void gather
  97             (
  98                 const List<commsStruct>& comms,
  99                 T& Value,
 100                 const BinaryOp& bop
 101             );
 102
 103             //- Like above but switches between linear/tree communication
 104             template <class T, class BinaryOp>
 105             static void gather(T& Value, const BinaryOp& bop);
 106
 107             //- Scatter data. Distribute without modification. Reverse of gather
 108             template <class T>
 109             static void scatter(const List<commsStruct>& comms, T& Value);
 110
 111             //- Like above but switches between linear/tree communication
 112             template <class T>
 113             static void scatter(T& Value);
 114
 115
 116         // Combine variants. Inplace combine values from processors.
 117         // (Uses construct from Istream instead of <<)
 118
 119             template <class T, class CombineOp>
 120             static void combineGather
 121             (
 122                 const List<commsStruct>& comms,
 123                 T& Value,
 124                 const CombineOp& cop
 125             );
 126
 127             //- Like above but switches between linear/tree communication
 128             template <class T, class CombineOp>
 129             static void combineGather(T& Value, const CombineOp& cop);
 130
 131             //- Scatter data. Reverse of combineGather
 132             template <class T>
 133             static void combineScatter
 134             (
 135                 const List<commsStruct>& comms,
 136                 T& Value
 137             );
 138
 139             //- Like above but switches between linear/tree communication
 140             template <class T>
 141             static void combineScatter(T& Value);
 142
 143         // Combine variants working on whole List at a time.
 144
 145             template <class T, class CombineOp>
 146             static void listCombineGather
 147             (
 148                 const List<commsStruct>& comms,
 149                 List<T>& Value,
 150                 const CombineOp& cop
 151             );
 152
 153             //- Like above but switches between linear/tree communication
 154             template <class T, class CombineOp>
 155             static void listCombineGather(List<T>& Value, const CombineOp& cop);
 156
 157             //- Scatter data. Reverse of combineGather
 158             template <class T>
 159             static void listCombineScatter
 160             (
 161                 const List<commsStruct>& comms,
 162                 List<T>& Value
 163             );
 164
 165             //- Like above but switches between linear/tree communication
 166             template <class T>
 167             static void listCombineScatter(List<T>& Value);
 168
 169         // Combine variants working on whole map at a time. Container needs to
 170         // have iterators and find() defined.
 171
 172             template <class Container, class CombineOp>
 173             static void mapCombineGather
 174             (
 175                 const List<commsStruct>& comms,
 176                 Container& Values,
 177                 const CombineOp& cop
 178             );
 179
 180             //- Like above but switches between linear/tree communication
 181             template <class Container, class CombineOp>
 182             static void mapCombineGather
 183             (
 184                 Container& Values,
 185                 const CombineOp& cop
 186             );
 187
 188             //- Scatter data. Reverse of combineGather
 189             template <class Container>
 190             static void mapCombineScatter
 191             (
 192                 const List<commsStruct>& comms,
 193                 Container& Values
 194             );
 195
 196             //- Like above but switches between linear/tree communication
 197             template <class Container>
 198             static void mapCombineScatter(Container& Values);
 199
 200
 201
 202         // Gather/scatter keeping the individual processor data separate.
 203         // Values is a List of size UPstream::nProcs() where
 204         // Values[UPstream::myProcNo()] is the data for the current processor.
 205
 206             //- Gather data but keep individual values separate
 207             template <class T>
 208             static void gatherList
 209             (
 210                 const List<commsStruct>& comms,
 211                 List<T>& Values
 212             );
 213
 214             //- Like above but switches between linear/tree communication
 215             template <class T>
 216             static void gatherList(List<T>& Values);
 217
 218             //- Scatter data. Reverse of gatherList
 219             template <class T>
 220             static void scatterList
 221             (
 222                 const List<commsStruct>& comms,
 223                 List<T>& Values
 224             );
 225
 226             //- Like above but switches between linear/tree communication
 227             template <class T>
 228             static void scatterList(List<T>& Values);
 229
 230
 231         // Exchange
 232
 233             //- Exchange data. Sends sendData, receives into recvData, sets
 234             //  sizes (not bytes). sizes[p0][p1] is what processor p0 has
 235             //  sent to p1. Continuous data only.
 236             //  If block=true will wait for all transfers to finish.
 237             template <class Container, class T>
 238             static void exchange
 239             (
 240                 const List<Container >&,
 241                 List<Container >&,
 242                 labelListList& sizes,
 243                 const int tag = UPstream::msgType(),
 244                 const bool block = true
 245             );
 246
 247 };
 248
 249
 250 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 251
 252 } // End namespace Foam
 253
 254 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 255
 256 #ifdef NoRepository
 257 #   include "gatherScatter.C"
 258 #   include "combineGatherScatter.C"
 259 #   include "gatherScatterList.C"
 260 #   include "exchange.C"
 261 #endif
 262
 263 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 264
 265 #endif
 266
 267 // ************************************************************************* //