src/foam/db/IOstreams/Pstreams/gatherScatterList.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | foam-extend: Open Source CFD
   4    \\    /   O peration     | Version:     3.2
   5     \\  /    A nd           | Web:         http://www.foam-extend.org
   6      \\/     M anipulation  | For copyright notice see file Copyright
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of foam-extend.
  10
  11     foam-extend is free software: you can redistribute it and/or modify it
  12     under the terms of the GNU General Public License as published by the
  13     Free Software Foundation, either version 3 of the License, or (at your
  14     option) any later version.
  15
  16     foam-extend is distributed in the hope that it will be useful, but
  17     WITHOUT ANY WARRANTY; without even the implied warranty of
  18     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19     General Public License for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 Description
  25     Gather data from all processors onto single processor according to some
  26     communication schedule (usually linear-to-master or tree-to-master).
  27     The gathered data will be a list with element procID the data from
  28      processor procID. Before calling every processor should insert
  29     its value into Values[Pstream::myProcNo()].
  30
  31     Note: after gather every processor only knows its own data and that of the
  32     processors below it. Only the 'master' of the communication schedule holds
  33     a fully filled List. Use scatter to distribute the data.
  34
  35 \*---------------------------------------------------------------------------*/
  36
  37 #include "IPstream.H"
  38 #include "OPstream.H"
  39 #include "contiguous.H"
  40
  41 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  42
  43 namespace Foam
  44 {
  45
  46 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
  47
  48 template <class T>
  49 void Pstream::gatherList
  50 (
  51     const List<Pstream::commsStruct>& comms,
  52     List<T>& Values
  53 )
  54 {
  55     if (Pstream::parRun())
  56     {
  57         if (Values.size() != Pstream::nProcs())
  58         {
  59             FatalErrorIn
  60             (
  61                 "Pstream::gatherList(const List<Pstream::commsStruct>&"
  62                 ", List<T>)"
  63             )   << "Size of list:" << Values.size()
  64                 << " does not equal the number of processors:"
  65                 << Pstream::nProcs()
  66                 << Foam::abort(FatalError);
  67         }
  68
  69         // Get my communication order
  70         const commsStruct& myComm = comms[Pstream::myProcNo()];
  71
  72         // Receive from my downstairs neighbours
  73         forAll(myComm.below(), belowI)
  74         {
  75             label belowID = myComm.below()[belowI];
  76             const labelList& belowLeaves = comms[belowID].allBelow();
  77
  78             if (contiguous<T>())
  79             {
  80                 List<T> receivedValues(belowLeaves.size() + 1);
  81
  82                 IPstream::read
  83                 (
  84                     Pstream::scheduled,
  85                     belowID,
  86                     reinterpret_cast<char*>(receivedValues.begin()),
  87                     receivedValues.byteSize()
  88                 );
  89
  90                 Values[belowID] = receivedValues[0];
  91
  92                 forAll(belowLeaves, leafI)
  93                 {
  94                     Values[belowLeaves[leafI]] = receivedValues[leafI + 1];
  95                 }
  96             }
  97             else
  98             {
  99                 IPstream fromBelow(Pstream::scheduled, belowID);
 100                 fromBelow >> Values[belowID];
 101
 102                 if (debug > 1)
 103                 {
 104                     Pout<< " received through "
 105                         << belowID << " data from:" << belowID
 106                         << " data:" << Values[belowID] << endl;
 107                 }
 108
 109                 // Receive from all other processors below belowID
 110                 forAll(belowLeaves, leafI)
 111                 {
 112                     label leafID = belowLeaves[leafI];
 113                     fromBelow >> Values[leafID];
 114
 115                     if (debug > 1)
 116                     {
 117                         Pout<< " received through "
 118                             << belowID << " data from:" << leafID
 119                             << " data:" << Values[leafID] << endl;
 120                     }
 121                 }
 122             }
 123         }
 124
 125         // Send up from Values:
 126         // - my own value first
 127         // - all belowLeaves next
 128         if (myComm.above() != -1)
 129         {
 130             const labelList& belowLeaves = myComm.allBelow();
 131
 132             if (debug > 1)
 133             {
 134                 Pout<< " sending to " << myComm.above()
 135                     << " data from: " << Pstream::myProcNo()
 136                     << " data: " << Values[Pstream::myProcNo()] << endl;
 137             }
 138
 139             if (contiguous<T>())
 140             {
 141                 List<T> sendingValues(belowLeaves.size() + 1);
 142                 sendingValues[0] = Values[Pstream::myProcNo()];
 143
 144                 forAll(belowLeaves, leafI)
 145                 {
 146                     sendingValues[leafI + 1] = Values[belowLeaves[leafI]];
 147                 }
 148
 149                 OPstream::write
 150                 (
 151                     Pstream::scheduled,
 152                     myComm.above(),
 153                     reinterpret_cast<const char*>(sendingValues.begin()),
 154                     sendingValues.byteSize()
 155                 );
 156             }
 157             else
 158             {
 159                 OPstream toAbove(Pstream::scheduled, myComm.above());
 160                 toAbove << Values[Pstream::myProcNo()];
 161
 162                 forAll(belowLeaves, leafI)
 163                 {
 164                     label leafID = belowLeaves[leafI];
 165
 166                     if (debug > 1)
 167                     {
 168                         Pout<< " sending to "
 169                             << myComm.above() << " data from: " << leafID
 170                             << " data: " << Values[leafID] << endl;
 171                     }
 172                     toAbove << Values[leafID];
 173                 }
 174             }
 175         }
 176     }
 177 }
 178
 179
 180 template <class T>
 181 void Pstream::gatherList(List<T>& Values)
 182 {
 183     if (Pstream::nProcs() < Pstream::nProcsSimpleSum())
 184     {
 185         gatherList(Pstream::linearCommunication(), Values);
 186     }
 187     else
 188     {
 189         gatherList(Pstream::treeCommunication(), Values);
 190     }
 191 }
 192
 193
 194 template <class T>
 195 void Pstream::scatterList
 196 (
 197     const List<Pstream::commsStruct>& comms,
 198     List<T>& Values
 199 )
 200 {
 201     if (Pstream::parRun())
 202     {
 203         if (Values.size() != Pstream::nProcs())
 204         {
 205             FatalErrorIn
 206             (
 207                 "Pstream::scatterList(const List<Pstream::commsStruct>&"
 208                 ", List<T>)"
 209             )   << "Size of list:" << Values.size()
 210                 << " does not equal the number of processors:"
 211                 << Pstream::nProcs()
 212                 << Foam::abort(FatalError);
 213         }
 214
 215         // Get my communication order
 216         const commsStruct& myComm = comms[Pstream::myProcNo()];
 217
 218         // Receive from up
 219         if (myComm.above() != -1)
 220         {
 221             const labelList& notBelowLeaves = myComm.allNotBelow();
 222
 223             if (contiguous<T>())
 224             {
 225                 List<T> receivedValues(notBelowLeaves.size());
 226
 227                 IPstream::read
 228                 (
 229                     Pstream::scheduled,
 230                     myComm.above(),
 231                     reinterpret_cast<char*>(receivedValues.begin()),
 232                     receivedValues.byteSize()
 233                 );
 234
 235                 forAll(notBelowLeaves, leafI)
 236                 {
 237                     Values[notBelowLeaves[leafI]] = receivedValues[leafI];
 238                 }
 239             }
 240             else
 241             {
 242                 IPstream fromAbove(Pstream::scheduled, myComm.above());
 243
 244                 forAll(notBelowLeaves, leafI)
 245                 {
 246                     label leafID = notBelowLeaves[leafI];
 247                     fromAbove >> Values[leafID];
 248
 249                     if (debug)
 250                     {
 251                         Pout<< " received through "
 252                             << myComm.above() << " data for:" << leafID
 253                             << " data:" << Values[leafID] << endl;
 254                     }
 255                 }
 256             }
 257         }
 258
 259         // Send to my downstairs neighbours
 260         forAll(myComm.below(), belowI)
 261         {
 262             label belowID = myComm.below()[belowI];
 263             const labelList& notBelowLeaves = comms[belowID].allNotBelow();
 264
 265             if (contiguous<T>())
 266             {
 267                 List<T> sendingValues(notBelowLeaves.size());
 268
 269                 forAll(notBelowLeaves, leafI)
 270                 {
 271                     sendingValues[leafI] = Values[notBelowLeaves[leafI]];
 272                 }
 273
 274                 OPstream::write
 275                 (
 276                     Pstream::scheduled,
 277                     belowID,
 278                     reinterpret_cast<const char*>(sendingValues.begin()),
 279                     sendingValues.byteSize()
 280                 );
 281             }
 282             else
 283             {
 284                 OPstream toBelow(Pstream::scheduled, belowID);
 285
 286                 // Send data destined for all other processors below belowID
 287                 forAll(notBelowLeaves, leafI)
 288                 {
 289                     label leafID = notBelowLeaves[leafI];
 290                     toBelow << Values[leafID];
 291
 292                     if (debug)
 293                     {
 294                         Pout<< " sent through "
 295                             << belowID << " data for:" << leafID
 296                             << " data:" << Values[leafID] << endl;
 297                     }
 298                 }
 299             }
 300         }
 301     }
 302 }
 303
 304
 305 template <class T>
 306 void Pstream::scatterList(List<T>& Values)
 307 {
 308     if (Pstream::nProcs() < Pstream::nProcsSimpleSum())
 309     {
 310         scatterList(Pstream::linearCommunication(), Values);
 311     }
 312     else
 313     {
 314         scatterList(Pstream::treeCommunication(), Values);
 315     }
 316 }
 317
 318
 319 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 320
 321 } // End namespace Foam
 322
 323 // ************************************************************************* //