feat: Additional information on the table log perforation

src/coreComponents/common/MpiWrapper.cpp

@@ -463,6 +463,26 @@ int MpiWrapper::nodeCommSize()
   return nodeCommSize;
 }
 
+void MpiWrapper::gatherStringOnRank0( string_view rankStr, std::function< void(string_view) > && func )
+{
+  std::vector< buffer_unit_type > localbuffer;
+  localbuffer.reserve( rankStr.size());
+  localbuffer.insert( localbuffer.end(), rankStr.begin(), rankStr.end());
+  auto [globalLogRecords, counts, offsets] =
+    MpiWrapper::gatherBufferRank0< std::vector< buffer_unit_type > >( localbuffer );
+  if( MpiWrapper::commRank() == 0 )
+  {
+    for( integer rankId = 0; rankId < MpiWrapper::commSize(); ++rankId )
+    {
+      if( counts[rankId] > 0 )
+      {
+        func( string( globalLogRecords.begin() + offsets[rankId],
+                      globalLogRecords.begin() + offsets[rankId]+ counts[rankId] ) );
+      }
+    }
+  }
+}
+
 namespace internal
 {
 

src/coreComponents/common/MpiWrapper.hpp

@@ -331,6 +331,53 @@ struct MpiWrapper
    */
   static int nodeCommSize();
 
+  /**
+   * @brief Structure holding the result from all the gather operation
+   * @tparam CONTAINER The container type holding the data.
+   * The underlying storage in CONTAINER must be contiguous
+   */
+  template< typename CONTAINER >
+  struct GatherResult
+  {
+    // Collected data which must be trivially copyable
+    CONTAINER data;
+    // Number of elements per rank
+    stdVector< integer > counts;
+    // Starting index for each rank in 'data'
+    stdVector< integer > offsets;
+  };
+
+  /**
+   * @brief Gather buffers of varying sizes from all ranks to rank 0.
+   * @tparam CONTAINER The container type holding the data.
+   * @tparam VALUE_T The trivially copyable underlying data type (deduced automatically).
+   * @param localBuffer The local buffer to be gathered on rank 0.
+   * @return A struct containing:
+   * - 'data': all the gathered data on rank 0
+   * - 'counts': number of elements for each rank
+   * - 'offsets': starting index for each rank in 'data'
+   */
+  template<
+    typename CONTAINER,
+    typename VALUE_T = typename CONTAINER::value_type,
+    typename = std::enable_if_t<
+      std::is_trivially_copyable_v< VALUE_T > &&
+      std::is_same_v< decltype(std::declval< CONTAINER >().data()), VALUE_T * > &&
+      std::is_same_v< decltype(std::declval< CONTAINER >().size()), std::size_t >
+      >
+    >
+  static GatherResult< CONTAINER >
+  gatherBufferRank0( CONTAINER const & localBuffer );
+
+  /**
+   * @brief Gather srting from all ranks to rank 0
+   * @tparam FUNC Callable type invoked as void(string_view) for each non-empty rank string.
+   * @param str The local string to send from the calling rank.
+   * @param func Callback invoked on rank 0 for each non-empty received string.
+   */
+  static void gatherStringOnRank0( string_view str,
+                                   std::function< void(string_view) > && func );
+
   /**
    * @brief Strongly typed wrapper around MPI_Allgather.
    * @tparam T_SEND The pointer type for \p sendbuf
@@ -978,6 +1025,45 @@ inline MPI_Op MpiWrapper::getMpiOp( Reduction const op )
   }
 }
 
+template< typename CONTAINER, typename VALUE_T, typename >
+MpiWrapper::GatherResult< CONTAINER >
+MpiWrapper::gatherBufferRank0( CONTAINER const & localBuffer )
+{
+  integer const numRanks = MpiWrapper::commSize();
+  integer const numLocalValues  = static_cast< integer >(localBuffer.size());
+
+  GatherResult< CONTAINER > gatherResult;
+
+  if( MpiWrapper::commRank() == 0 )
+  {
+    gatherResult.counts.resize( numRanks );
+    gatherResult.offsets.resize( numRanks );
+  }
+
+
+  MpiWrapper::gather( &numLocalValues, 1, gatherResult.counts.data(), 1, 0 );
+
+  if( MpiWrapper::commRank() == 0 )
+  {
+    integer totalSize = 0;
+    for( integer i = 0; i < numRanks; ++i )
+    {
+      gatherResult.offsets[i] = totalSize;
+      totalSize += gatherResult.counts[i];
+    }
+    gatherResult.data.resize( totalSize );
+  }
+
+  MpiWrapper::gatherv( localBuffer.data(),
+                       numLocalValues,
+                       gatherResult.data.data(),
+                       gatherResult.counts.data(),
+                       gatherResult.offsets.data(),
+                       0 );
+
+  return gatherResult;
+}
+
 template< typename T_SEND, typename T_RECV >
 int MpiWrapper::allgather( T_SEND const * const sendbuf,
                            int sendcount,

src/coreComponents/common/format/table/TableData.cpp

@@ -59,7 +59,81 @@ TableData & TableData::operator=( TableData const & other )
 
 bool TableData::operator<( TableData const & other ) const
 {
-  return m_rows < other.m_rows;
+  if( other.getCellsData().size()!= getCellsData().size())
+    return false;
+
+  for( size_t i = 0; i < getCellsData().size(); i++ )
+  {
+    if( getCellsData()[i].data()->value > other.getCellsData()[i].data()->value )
+      return false;
+  }
+  return true;
+}
+
+bool TableData::operator==( TableData const & comparingTable ) const
+{
+  if( comparingTable.getCellsData().size()!= getCellsData().size())
+    return false;
+  for( size_t i = 0; i < getCellsData().size(); i++ )
+  {
+    if( getCellsData()[i].data()->value  != comparingTable.getCellsData()[i].data()->value )
+      return false;
+  }
+  return true;
+}
+
+void TableData::CellData::serialize( stdVector< buffer_unit_type > & out ) const
+{
+  basicSerialization::serializePrimitive( type, out );
+  basicSerialization::serializeString( value, out );
+}
+
+
+size_t TableData::CellData::getSerializedSize() const
+{
+  return basicSerialization::sizeOfPrimitive( type ) + basicSerialization::sizeOfString( value );
+}
+
+size_t TableData::getSerializedSize() const
+{
+  size_t totalSize  =0;
+
+  if( m_rows.empty())
+    return totalSize;
+
+  for( auto & row : m_rows )
+  {
+    size_t rowSize = 0;
+    for( auto & cell : row )
+    {
+      rowSize += cell.getSerializedSize();
+    }
+    totalSize += sizeof(size_t) + rowSize;
+  }
+  return totalSize;
+}
+
+void TableData::serialize( stdVector< buffer_unit_type > & serializedTableData ) const
+{
+  if( m_rows.empty())
+    return;
+
+  for( auto & row : m_rows )
+  {
+    { // pack row size;
+      size_t rowSize = 0;
+      for( auto const & cell : row )
+        rowSize += cell.getSerializedSize();
+      basicSerialization::serializePrimitive( rowSize, serializedTableData );
+    }
+
+    { // pack cells
+      for( auto const & cell : row )
+      {
+        cell.serialize( serializedTableData );
+      }
+    }
+  }
 }
 
 
@@ -180,4 +254,63 @@ TableData2D::TableDataHolder TableData2D::buildTableData( string_view targetUnit
 
   return tableData1D;
 }
+
+void basicSerialization::serializeString ( string const & data, stdVector< buffer_unit_type > & out )
+{
+  basicSerialization::serializePrimitive( data.size(), out );
+  auto * begin = data.data();
+  auto * end = begin + data.size();
+  out.insert( out.end(), begin, end );
+}
+
+void basicSerialization::deserializeString( string & str, buffer_unit_type const * & ptr, buffer_unit_type const * end )
+{
+  string::size_type strSize = 0;
+  basicSerialization::deserializePrimitive( strSize, ptr, end );
+  if( static_cast< long >(strSize) > std::distance( ptr, end ) )
+  {
+    throw std::runtime_error( "buffer overflow reading string" );
+  }
+  str.assign( ptr, ptr + strSize );
+  ptr += str.size();
+}
+
+bool tableDataSorting::positiveNumberStringComp( string_view s1, string_view s2 )
+{
+  auto split = []( string_view s, string & intPart, string & decPart )
+  {
+    size_t dotPos = s.find( '.' );
+    if( dotPos == string::npos )
+    {
+      intPart = s;
+      decPart = "";
+    }
+    else
+    {
+      intPart = s.substr( 0, dotPos );
+      decPart = s.substr( dotPos + 1 );
+    }
+  };
+
+  string s1Int, s1Dec, s2Int, s2Dec;
+  split( s1, s1Int, s1Dec );
+  split( s2, s2Int, s2Dec );
+
+  if( s1Int.length() != s2Int.length())
+    return s1Int.length() < s2Int.length();
+
+  if( s1Int != s2Int )
+    return s1Int < s2Int;
+
+  size_t minLen = std::min( s1Dec.length(), s2Dec.length());
+  for( size_t i = 0; i < minLen; ++i )
+  {
+    if( s1Dec[i] != s2Dec[i] )
+      return s1Dec[i] < s2Dec[i];
+  }
+
+
+  return false;
+}
+
 }