Branch data     Line data    Source code

       1                 :            : // *****************************************************************************
       2                 :            : /*!
       3                 :            :   \file      src/Inciter/IntegralReducer.cpp
       4                 :            :   \copyright 2012-2015 J. Bakosi,
       5                 :            :              2016-2018 Los Alamos National Security, LLC.,
       6                 :            :              2019-2021 Triad National Security, LLC.,
       7                 :            :              2022-2024 J. Bakosi
       8                 :            :              All rights reserved. See the LICENSE file for details.
       9                 :            :   \brief     Custom Charm++ reducer for merging integrals across PEs
      10                 :            :   \details   Custom Charm++ reducer for merging integrals across PEs.
      11                 :            : */
      12                 :            : // *****************************************************************************
      13                 :            : 
      14                 :            : #include <memory>
      15                 :            : 
      16                 :            : #include "Integrals.hpp"
      17                 :            : #include "IntegralReducer.hpp"
      18                 :            : #include "Exception.hpp"
      19                 :            : 
      20                 :            : namespace inciter {
      21                 :            : namespace integrals {
      22                 :            : 
      23                 :            : std::pair< int, std::unique_ptr<char[]> >
      24                 :        310 : serialize( std::size_t meshid, const std::vector< std::map<int,tk::real> >& d )
      25                 :            : // *****************************************************************************
      26                 :            : // Serialize integrals to raw memory stream
      27                 :            : //! \param[in] meshid Mesh ID
      28                 :            : //! \param[in] d Integral contributions
      29                 :            : //! \return Pair of the length and the raw stream containing the serialized
      30                 :            : //!   vectors
      31                 :            : // *****************************************************************************
      32                 :            : {
      33                 :            :   // Prepare for serializing integrals to a raw binary stream, compute size
      34                 :        310 :   PUP::sizer sizer;
      35                 :            :   // cppcheck-suppress uninitvar
      36         [ +  - ]:        310 :   sizer | meshid;
      37         [ +  - ]:        310 :   sizer | const_cast< std::vector< std::map< int, tk::real > >& >( d );
      38                 :            : 
      39                 :            :   // Create raw character stream to store the serialized vectors
      40         [ +  - ]:        310 :   std::unique_ptr<char[]> flatData = std::make_unique<char[]>( sizer.size() );
      41                 :            : 
      42                 :            :   // Serialize integrals
      43                 :        310 :   PUP::toMem packer( flatData.get() );
      44                 :            :   // cppcheck-suppress uninitvar
      45         [ +  - ]:        310 :   packer | meshid;
      46         [ +  - ]:        310 :   packer | const_cast< std::vector< std::map< int, tk::real > >& >( d );
      47                 :            : 
      48                 :            :   // Return size of and raw stream
      49                 :        620 :   return { sizer.size(), std::move(flatData) };
      50                 :        310 : }
      51                 :            : 
      52                 :            : CkReductionMsg*
      53                 :         82 : mergeIntegrals( int nmsg, CkReductionMsg **msgs )
      54                 :            : // *****************************************************************************
      55                 :            : // Charm++ custom reducer for merging integrals during reduction across PEs
      56                 :            : //! \param[in] nmsg Number of messages in msgs
      57                 :            : //! \param[in] msgs Charm++ reduction message containing the serialized
      58                 :            : //!   integrals
      59                 :            : //! \return Aggregated integrals built for further aggregation if needed
      60                 :            : // *****************************************************************************
      61                 :            : {
      62                 :            :   // Will store deserialized integrals
      63                 :            :   std::size_t meshid;
      64                 :         82 :   std::vector< std::map< int, tk::real > > v;
      65                 :            : 
      66                 :            :   // Create PUP deserializer based on message passed in
      67                 :         82 :   PUP::fromMem creator( msgs[0]->getData() );
      68                 :            : 
      69                 :            :   // Deserialize vector from raw stream
      70                 :            :   // cppcheck-suppress uninitvar
      71         [ +  - ]:         82 :   creator | meshid;
      72         [ +  - ]:         82 :   creator | v;
      73                 :            : 
      74         [ +  + ]:        236 :   for (int m=1; m<nmsg; ++m) {
      75                 :            :     // Unpack vector
      76                 :            :     std::size_t mid;
      77                 :        154 :     std::vector< std::map< int, tk::real > > w;
      78                 :        154 :     PUP::fromMem curCreator( msgs[m]->getData() );
      79                 :            :     // cppcheck-suppress uninitvar
      80         [ +  - ]:        154 :     curCreator | mid;
      81         [ +  - ]:        154 :     curCreator | w;
      82                 :            :     // Aggregate integrals
      83                 :            :     // cppcheck-suppress uninitvar
      84                 :            :     // cppcheck-suppress unreadVariable
      85                 :        154 :     meshid = mid;
      86 [ -  + ][ -  - ]:        154 :     Assert( v.size() == w.size(), "Size mismatch during integrals aggregation");
         [ -  - ][ -  - ]
      87 [ -  + ][ -  - ]:        154 :     Assert( v.size() == NUMINT, "Size mismatch during integrals aggregation" );
         [ -  - ][ -  - ]
      88                 :            :     // Aggregate applying integrals aggregation policy
      89                 :            :     // Copy ITER, TIME, DT
      90                 :            :     // cppcheck-suppress containerOutOfBounds
      91         [ +  - ]:        154 :     v[ITER] = w[ITER];
      92                 :            :     // cppcheck-suppress containerOutOfBounds
      93         [ +  - ]:        154 :     v[TIME] = w[TIME];
      94                 :            :     // cppcheck-suppress containerOutOfBounds
      95         [ +  - ]:        154 :     v[DT] = w[DT];
      96                 :            :     // Sum integrals
      97                 :            :     // cppcheck-suppress containerOutOfBounds
      98 [ +  - ][ +  + ]:        237 :     for (const auto& [s,d] : w[MASS_FLOW_RATE]) v[MASS_FLOW_RATE][s] += d;
      99                 :        154 :   }
     100                 :            : 
     101                 :            :   // Serialize concatenated diagnostics vector to raw stream
     102                 :            :   // cppcheck-suppress uninitvar
     103         [ +  - ]:         82 :   auto stream = serialize( meshid, v );
     104                 :            : 
     105                 :            :   // Forward serialized diagnostics
     106         [ +  - ]:        164 :   return CkReductionMsg::buildNew( stream.first, stream.second.get() );
     107                 :         82 : }
     108                 :            : 
     109                 :            : } // integrals::
     110                 :            : } // inciter::