Merge pull request #1147 from arcaneframework/dev/gg-add-read-compare-hash

Save and restore comparison hash in 'BasicReader' and 'BasicWriter'

Author: grospelliergilles

arcane/src/arcane/std/BasicGenericReader.cc

@@ -121,11 +121,9 @@ initialize(const String& path, Int32 rank)
   if (!hash_algorithm_name.null())
     hash_algorithm = BasicReaderWriterCommon::_createHashAlgorithm(m_application, hash_algorithm_name);
 
-  for (Integer i = 0, is = variables_elem.size(); i < is; ++i) {
-    XmlNode n = variables_elem[i];
+  for (const XmlNode& n : variables_elem) {
     String var_full_name = n.attrValue("full-name");
-    Ref<VariableDataInfo> vdi = makeRef(new VariableDataInfo(var_full_name, n));
-    m_variables_data_info.insert(std::make_pair(var_full_name, vdi));
+    m_variables_data_info.add(var_full_name, n);
   }
 
   if (!m_text_reader.get()) {
@@ -148,11 +146,10 @@ initialize(const String& path, Int32 rank)
 Ref<VariableDataInfo> BasicGenericReader::
 _getVarInfo(const String& full_name)
 {
-  VariableDataInfoMap::const_iterator ivar = m_variables_data_info.find(full_name);
-  if (ivar == m_variables_data_info.end())
+  Ref<VariableDataInfo> vdi = m_variables_data_info.find(full_name);
+  if (!vdi.get())
     ARCANE_THROW(ReaderWriterException,
                  "Can not find own metadata infos for data var={0} rank={1}", full_name, m_rank);
-  Ref<VariableDataInfo> vdi = ivar->second;
   return vdi;
 }
 
@@ -241,6 +238,18 @@ readItemGroup(const String& group_full_name, Int64Array& written_unique_ids,
 /*---------------------------------------------------------------------------*/
 /*---------------------------------------------------------------------------*/
 
+String BasicGenericReader::
+comparisonHashValue(const String& var_full_name) const
+{
+  Ref<VariableDataInfo> vdi = m_variables_data_info.find(var_full_name);
+  if (vdi.get())
+    return vdi->comparisonHashValue();
+  return {};
+}
+
+/*---------------------------------------------------------------------------*/
+/*---------------------------------------------------------------------------*/
+
 } // namespace Arcane::impl
 
 /*---------------------------------------------------------------------------*/

arcane/src/arcane/std/BasicGenericWriter.cc

@@ -61,13 +61,14 @@ initialize(const String& path, Int32 rank)
 /*---------------------------------------------------------------------------*/
 
 void BasicGenericWriter::
-writeData(const String& var_full_name, const ISerializedData* sdata)
+writeData(const String& var_full_name, const ISerializedData* sdata,
+          const String& comparison_hash)
 {
   //TODO: Verifier que initialize() a bien été appelé.
-  auto var_data_info = makeRef(new VariableDataInfo(var_full_name, sdata));
+  auto var_data_info = m_variables_data_info.add(var_full_name, sdata);
   KeyValueTextWriter* writer = m_text_writer.get();
   var_data_info->setFileOffset(writer->fileOffset());
-  m_variables_data_info.insert(std::make_pair(var_full_name, var_data_info));
+  var_data_info->setComparisonHashValue(comparison_hash);
   info(4) << " SDATA name=" << var_full_name << " nb_element=" << sdata->nbElement()
           << " dim=" << sdata->nbDimension() << " datatype=" << sdata->baseDataType()
           << " nb_basic_element=" << sdata->nbBaseElement()

arcane/src/arcane/std/BasicReader.cc

@@ -71,6 +71,7 @@ initialize()
   }
   String data_compressor_name;
   String hash_algorithm_name;
+  String comparison_hash_algorithm_name;
   if (has_db_file) {
     UniqueArray<Byte> bytes;
     pm->ioMng()->collectiveRead(db_filename, bytes, false);
@@ -82,10 +83,12 @@ initialize()
     m_nb_written_part = jv_arcane_db.expectedChild("NbPart").valueAsInt32();
     data_compressor_name = jv_arcane_db.child("DataCompressor").value();
     hash_algorithm_name = jv_arcane_db.child("HashAlgorithm").value();
+    comparison_hash_algorithm_name = jv_arcane_db.child("ComparisonHashAlgorithm").value();
     info() << "**--** Begin read using database version=" << m_version
            << " nb_part=" << m_nb_written_part
            << " compressor=" << data_compressor_name
-           << " hash_algorithm=" << hash_algorithm_name;
+           << " hash_algorithm=" << hash_algorithm_name
+           << " comparison_hash_algorithm=" << comparison_hash_algorithm_name;
   }
   else {
     // Ancien format
@@ -120,6 +123,10 @@ initialize()
       Ref<IHashAlgorithm> v = _createHashAlgorithm(m_application, hash_algorithm_name);
       m_forced_rank_to_read_text_reader->setHashAlgorithm(v);
     }
+    if (!comparison_hash_algorithm_name.empty()) {
+      Ref<IHashAlgorithm> v = _createHashAlgorithm(m_application, comparison_hash_algorithm_name);
+      m_comparison_hash_algorithm = v;
+    }
   }
 }
 
@@ -130,7 +137,7 @@ void BasicReader::
 _directReadVal(VariableMetaData* varmd, IData* data)
 {
   info(4) << "DIRECT READ VAL v=" << varmd->fullName();
-
+    
   bool is_item_variable = !varmd->itemFamilyName().null();
   Int32 nb_rank_to_read = m_nb_rank_to_read;
   // S'il s'agit d'une variable qui n'est pas sur le maillage,
@@ -153,6 +160,8 @@ _directReadVal(VariableMetaData* varmd, IData* data)
     String vname = varmd->fullName();
     info(4) << " TRY TO READ var_full_name=" << vname;
     m_global_readers[i]->readData(vname, written_data[i]);
+    if (i==0 && m_comparison_hash_algorithm.get() )
+      info(5) << "COMPARISON_HASH =" << m_global_readers[i]->comparisonHashValue(vname);
   }
 
   if (is_item_variable) {

arcane/src/arcane/std/BasicReaderWriter.cc

@@ -31,84 +31,6 @@ namespace Arcane::impl
 /*---------------------------------------------------------------------------*/
 /*---------------------------------------------------------------------------*/
 
-VariableDataInfo::
-VariableDataInfo(const String& full_name, const ISerializedData* sdata)
-: m_full_name(full_name)
-, m_nb_dimension(sdata->nbDimension())
-, m_nb_element(sdata->nbElement())
-, m_nb_base_element(sdata->nbBaseElement())
-, m_is_multi_size(sdata->isMultiSize())
-{
-  Int64ConstArrayView extents = sdata->extents();
-
-  if (m_nb_dimension == 2 && !m_is_multi_size) {
-    m_dim1_size = extents[0];
-    m_dim2_size = extents[1];
-  }
-  m_dimension_array_size = extents.size();
-  m_base_data_type = sdata->baseDataType();
-  m_memory_size = sdata->memorySize();
-  m_shape = sdata->shape();
-}
-
-/*---------------------------------------------------------------------------*/
-/*---------------------------------------------------------------------------*/
-
-VariableDataInfo::
-VariableDataInfo(const String& full_name, const XmlNode& element)
-: m_full_name(full_name)
-{
-  m_nb_dimension = _readInteger(element, "nb-dimension");
-  m_dim1_size = _readInt64(element, "dim1-size");
-  m_dim2_size = _readInt64(element, "dim2-size");
-  m_nb_element = _readInt64(element, "nb-element");
-  m_nb_base_element = _readInt64(element, "nb-base-element");
-  m_dimension_array_size = _readInteger(element, "dimension-array-size");
-  m_is_multi_size = _readBool(element, "is-multi-size");
-  m_base_data_type = (eDataType)_readInteger(element, "base-data-type");
-  m_memory_size = _readInt64(element, "memory-size");
-  m_file_offset = _readInt64(element, "file-offset");
-  // L'élément est nul si on repart d'une veille protection (avant Arcane 3.7)
-  XmlNode shape_attr = element.attr("shape");
-  if (!shape_attr.null()) {
-    String shape_str = shape_attr.value();
-    if (!shape_str.empty()) {
-      UniqueArray<Int32> values;
-      if (builtInGetValue(values, shape_str))
-        ARCANE_FATAL("Can not read values '{0}' for attribute 'shape'", shape_str);
-      m_shape.setDimensions(values);
-    }
-  }
-}
-
-/*---------------------------------------------------------------------------*/
-/*---------------------------------------------------------------------------*/
-
-void VariableDataInfo::
-write(XmlNode element) const
-{
-  _addAttribute(element, "nb-dimension", m_nb_dimension);
-  _addAttribute(element, "dim1-size", m_dim1_size);
-  _addAttribute(element, "dim2-size", m_dim2_size);
-  _addAttribute(element, "nb-element", m_nb_element);
-  _addAttribute(element, "nb-base-element", m_nb_base_element);
-  _addAttribute(element, "dimension-array-size", m_dimension_array_size);
-  _addAttribute(element, "is-multi-size", (m_is_multi_size) ? 1 : 0);
-  _addAttribute(element, "base-data-type", (Integer)m_base_data_type);
-  _addAttribute(element, "memory-size", m_memory_size);
-  _addAttribute(element, "file-offset", m_file_offset);
-  _addAttribute(element, "shape-size", m_shape.dimensions().size());
-  {
-    String s;
-    if (builtInPutValue(m_shape.dimensions().smallView(), s))
-      ARCANE_FATAL("Can not write '{0}'", m_shape.dimensions());
-    _addAttribute(element, "shape", s);
-  }
-}
-
-/*---------------------------------------------------------------------------*/
-/*---------------------------------------------------------------------------*/
-
 String BasicReaderWriterCommon::
 _getArcaneDBTag()
 {