[arcane,std] Sauve le hash de comparaison dans les données de la variable.

Author: grospelliergilles

arcane/src/arcane/std/BasicGenericWriter.cc

@@ -61,12 +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& compare_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);
   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/BasicWriter.cc

@@ -183,10 +183,10 @@ _directWriteVal(IVariable* var, IData* data)
   }
 
   Ref<ISerializedData> sdata(write_data->createSerializedDataRef(false));
-  m_global_writer->writeData(var->fullName(), sdata.get());
-
+  String compare_hash;
   if (is_mesh_variable)
-    _computeCompareHash(var, write_data);
+    compare_hash = _computeCompareHash(var, write_data);
+  m_global_writer->writeData(var->fullName(), sdata.get(), compare_hash);
 }
 
 /*---------------------------------------------------------------------------*/
@@ -199,13 +199,16 @@ _directWriteVal(IVariable* var, IData* data)
  *
  * Comme ce tableau est trié suivant les uniqueId(), il peut servir à
  * comparer directement la valeur de la variable.
+ *
+ * \return le hash sous-forme de chaîne de caratères si un algorithme de hash
+ * est spécifié.
  */
-void BasicWriter::
+String BasicWriter::
 _computeCompareHash(IVariable* var, IData* write_data)
 {
   IHashAlgorithm* hash_algo = m_compare_hash_algorithm.get();
   if (!hash_algo)
-    return;
+    return {};
 
   INumericDataInternal* num_data = write_data->_commonInternal()->numericData();
   if (!num_data)
@@ -224,12 +227,14 @@ _computeCompareHash(IVariable* var, IData* write_data)
 
   pm->gatherVariable(Arccore::asSpan<Byte>(memory_view.bytes()).smallView(), bytes, master_rank);
 
+  String hash_string;
   if (my_rank == master_rank) {
     HashAlgorithmValue hash_value;
     hash_algo->computeHash(asBytes(bytes), hash_value);
-    info() << "VAR_HASH=" << Convert::toHexaString(asBytes(hash_value.bytes()))
-           << " name=" << var->fullName();
+    hash_string = Convert::toHexaString(asBytes(hash_value.bytes()));
+    info() << "VAR_HASH=" << hash_string << " name=" << var->fullName();
   }
+  return hash_string;
 }
 
 /*---------------------------------------------------------------------------*/

arcane/src/arcane/std/VariableDataInfo.cc

@@ -77,6 +77,12 @@ VariableDataInfo(const String& full_name, const XmlNode& element)
       m_shape.setDimensions(values);
     }
   }
+  {
+    // 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();
+  }
 }
 
 /*---------------------------------------------------------------------------*/
@@ -96,6 +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);
   {
     String s;
     if (builtInPutValue(m_shape.dimensions().smallView(), s))

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

@@ -149,7 +149,8 @@ class IGenericWriter
  public:
 
   virtual void initialize(const String& path, Int32 rank) = 0;
-  virtual void writeData(const String& var_full_name, const ISerializedData* sdata) = 0;
+  virtual void writeData(const String& var_full_name, const ISerializedData* sdata,
+                         const String& compare_hash) = 0;
   virtual void writeItemGroup(const String& group_full_name,
                               SmallSpan<const Int64> written_unique_ids,
                               SmallSpan<const Int64> wanted_unique_ids) = 0;
@@ -171,7 +172,7 @@ class BasicGenericWriter
  public:
 
   void initialize(const String& path, Int32 rank) override;
-  void writeData(const String& var_full_name, const ISerializedData* sdata) override;
+  void writeData(const String& var_full_name, const ISerializedData* sdata, const String& compare_hash) override;
   void writeItemGroup(const String& group_full_name, SmallSpan<const Int64> written_unique_ids,
                       SmallSpan<const Int64> wanted_unique_ids) override;
   void endWrite() override;

arcane/src/arcane/std/internal/BasicWriter.h

@@ -85,7 +85,7 @@ class BasicWriter
  private:
 
   void _directWriteVal(IVariable* v, IData* data);
-  void _computeCompareHash(IVariable* var, IData* write_data);
+  String _computeCompareHash(IVariable* var, IData* write_data);
   Ref<ParallelDataWriter> _getWriter(IVariable* var);
   void _endWriteV3();
   void _checkNoInit();

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

@@ -56,6 +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; }
 
  public:
 
@@ -107,6 +109,7 @@ class VariableDataInfo
   Int64 m_memory_size = 0;
   Int64 m_file_offset = 0;
   ArrayShape m_shape;
+  String m_compare_hash_value;
 };
 
 /*---------------------------------------------------------------------------*/