src/Pstream/gamma/OPwrite.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2004-2011 OpenCFD Ltd.
   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 Description
  25     Write primitive and binary block from OPstream gamma-mpi
  26
  27 \*---------------------------------------------------------------------------*/
  28
  29 #include "OPstream.H"
  30 #include "long.H"
  31 #include "PstreamGlobals.H"
  32
  33 extern "C" {
  34
  35 #include <linux/gamma/libgamma.h>
  36
  37 }
  38
  39 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  40
  41 namespace Foam
  42 {
  43
  44 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  45
  46 // Largest message sent so far. This tracks the size of the receive
  47 // buffer on the receiving end. Done so we only send out resize messages
  48 // if necessary
  49 //! \cond fileScope
  50 labelList maxSendSize;
  51 //! \endcond
  52
  53
  54 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
  55
  56 OPstream::~OPstream()
  57 {
  58     if (Pstream::debug)
  59     {
  60         Pout<< "OPstream::~OPstream() to processor " << toProcNo_
  61             << Foam::endl;
  62     }
  63
  64     if
  65     (
  66        !write
  67         (
  68             commsType_,
  69             toProcNo_,
  70             buf_.begin(),
  71             bufPosition_
  72         )
  73     )
  74     {
  75         FatalErrorIn("OPstream::~OPstream()")
  76             << "GAMMA cannot send outgoing message"
  77             << Foam::abort(FatalError);
  78     }
  79 }
  80
  81
  82 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
  83
  84 bool OPstream::write
  85 (
  86     const commsTypes commsType,
  87     const int toProcNo,
  88     const char* buf,
  89     const std::streamsize bufSize
  90 )
  91 {
  92     if (PstreamGlobals::getSizeFromHeader(buf, bufSize) != -1)
  93     {
  94         FatalErrorIn("OPstream::write")
  95             << "Problem: Trying to send message of size " << bufSize
  96             << " that corresponds to the special resizeMessage."
  97             << Foam::abort(FatalError);
  98     }
  99
 100     if (maxSendSize.empty())
 101     {
 102         // Intialize maxSendSize to the initial size of the receive buffers.
 103         maxSendSize.setSize(Pstream::nProcs());
 104         maxSendSize = PstreamGlobals::initialBufferLen;
 105         maxSendSize[Pstream::myProcNo()] = 0;
 106
 107         if (Pstream::debug)
 108         {
 109             forAll(maxSendSize, procNo)
 110             {
 111                 Pout<< "OPstream::write() : for toProcNo:" << procNo
 112                     << " set maxSendSize to " << maxSendSize[procNo]
 113                     << Foam::endl;
 114             }
 115         }
 116     }
 117
 118     if (Pstream::debug)
 119     {
 120         Pout<< "OPstream::write() : proc:" << toProcNo
 121             << " maxSendSize:" << maxSendSize[toProcNo]
 122             << Foam::endl;
 123     }
 124
 125     if (bufSize > maxSendSize[toProcNo])
 126     {
 127         // Send resize message.
 128         if (Pstream::debug)
 129         {
 130             Pout<< "OPstream::write() : Sending resize message to proc "
 131             << toProcNo
 132             << " for size:" << bufSize
 133             << Foam::endl;
 134         }
 135
 136         PstreamGlobals::setResizeMessage(bufSize);
 137         gamma_send_flowctl
 138         (
 139             toProcNo,
 140             reinterpret_cast<char*>(PstreamGlobals::resizeMessage),
 141             PstreamGlobals::resizeMessageLen*sizeof(uint64_t)
 142         );
 143
 144         maxSendSize[toProcNo] = bufSize;
 145     }
 146
 147
 148     // Do normal send
 149     // ~~~~~~~~~~~~~~
 150
 151     // Note: could be put into allocation of buf.
 152     //gamma_mlock(const_cast<char*>(buf), bufSize);
 153
 154     if (Pstream::debug)
 155     {
 156         Pout<< "OPstream::write() : Sending to proc " << toProcNo
 157             << " bytes:" << bufSize << Foam::endl;
 158     }
 159
 160     gamma_send_flowctl
 161     (
 162         toProcNo,
 163         const_cast<char*>(buf),
 164         bufSize
 165     );
 166
 167     //gamma_munlock(const_cast<char*>(buf), bufSize);
 168
 169     if (Pstream::debug)
 170     {
 171         Pout<< "OPstream::write() : Sent " << bufSize
 172             << " to proc " << toProcNo
 173             << Foam::endl;
 174     }
 175
 176
 177     return true;
 178 }
 179
 180
 181 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 182
 183 } // End namespace Foam
 184
 185 // ************************************************************************* //