[arcane,std] Ajoute récupération du hash de comparaison en relecture.

Renomme aussi 'compare_hash' en 'comparison_hash'.

Author: grospelliergilles

arcane/src/arcane/std/BasicGenericReader.cc

@@ -121,8 +121,7 @@ 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");
     m_variables_data_info.add(var_full_name, n);
   }
@@ -239,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

@@ -62,13 +62,13 @@ initialize(const String& path, Int32 rank)
 
 void BasicGenericWriter::
 writeData(const String& var_full_name, const ISerializedData* sdata,
-          const String& compare_hash)
+          const String& comparison_hash)
 {
   //TODO: Verifier que initialize() a bien été appelé.
   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());
-  var_data_info->setCompareHashValue(compare_hash);
+  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/BasicWriter.cc

@@ -325,7 +325,7 @@ _endWriteV3()
         String name;
         if (m_compare_hash_algorithm.get())
           name = m_compare_hash_algorithm->name();
-        jsw.write("CompareHashAlgorithm", name);
+        jsw.write("ComparisonHashAlgorithm", name);
       }
     }
   }

arcane/src/arcane/std/VariableDataInfo.cc

@@ -81,7 +81,7 @@ VariableDataInfo(const String& full_name, const XmlNode& element)
     // L'attribut 'compare-hash' est nul si on repart d'une veille protection (avant Arcane 3.12)
     XmlNode hash_attr = element.attr("compare-hash");
     if (!hash_attr.null())
-      m_compare_hash_value = hash_attr.value();
+      m_comparison_hash_value = hash_attr.value();
   }
 }
 
@@ -102,7 +102,7 @@ write(XmlNode element) const
   _addAttribute(element, "memory-size", m_memory_size);
   _addAttribute(element, "file-offset", m_file_offset);
   _addAttribute(element, "shape-size", m_shape.dimensions().size());
-  _addAttribute(element, "compare-hash", m_compare_hash_value);
+  _addAttribute(element, "comparison-hash", m_comparison_hash_value);
   {
     String s;
     if (builtInPutValue(m_shape.dimensions().smallView(), s))

arcane/src/arcane/std/internal/BasicReader.h

@@ -88,6 +88,7 @@ class BasicReader
   IItemGroupFinder* m_item_group_finder;
   Ref<KeyValueTextReader> m_forced_rank_to_read_text_reader; //!< Lecteur pour le premier rang à lire.
   Ref<IDataCompressor> m_data_compressor;
+  Ref<IHashAlgorithm> m_comparison_hash_algorithm;
 
  private:
 

arcane/src/arcane/std/internal/BasicReaderWriter.h

@@ -98,11 +98,14 @@ class IGenericReader
   virtual void readData(const String& var_full_name, IData* data) = 0;
   virtual void readItemGroup(const String& group_name, Int64Array& written_unique_ids,
                              Int64Array& wanted_unique_ids) = 0;
+  virtual String comparisonHashValue(const String& var_full_name) const = 0;
 };
 
 /*---------------------------------------------------------------------------*/
 /*---------------------------------------------------------------------------*/
-
+/*!
+ * \brief Implémentation basique de \a IGenericReader
+ */
 class BasicGenericReader
 : public TraceAccessor
 , public IGenericReader
@@ -119,6 +122,7 @@ class BasicGenericReader
   void readData(const String& var_full_name, IData* data) override;
   void readItemGroup(const String& group_name, Int64Array& written_unique_ids,
                      Int64Array& wanted_unique_ids) override;
+  String comparisonHashValue(const String& var_full_name) const override;
 
  private:
 

arcane/src/arcane/std/internal/VariableDataInfo.h

@@ -56,8 +56,8 @@ class VariableDataInfo
   const ArrayShape& shape() const { return m_shape; }
   void setFileOffset(Int64 v) { m_file_offset = v; }
   Int64 fileOffset() const { return m_file_offset; }
-  void setCompareHashValue(const String& v) { m_compare_hash_value = v; }
-  const String& compareHashValue() const { return m_compare_hash_value; }
+  void setComparisonHashValue(const String& v) { m_comparison_hash_value = v; }
+  const String& comparisonHashValue() const { return m_comparison_hash_value; }
 
  public:
 
@@ -109,7 +109,7 @@ class VariableDataInfo
   Int64 m_memory_size = 0;
   Int64 m_file_offset = 0;
   ArrayShape m_shape;
-  String m_compare_hash_value;
+  String m_comparison_hash_value;
 };
 
 /*---------------------------------------------------------------------------*/