Merge pull request #1142 from arcaneframework/dev/gg-use-refcounter-for-basic-reader-and-writer

Use reference counter for fields of 'BasicReader' and 'BasicWriter'

Author: grospelliergilles

Diff for: arcane/src/arcane/std/BasicReader.cc

@@ -1,11 +1,11 @@
 // -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
 //-----------------------------------------------------------------------------
-// Copyright 2000-2023 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
+// Copyright 2000-2024 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
 // See the top-level COPYRIGHT file for details.
 // SPDX-License-Identifier: Apache-2.0
 //-----------------------------------------------------------------------------
 /*---------------------------------------------------------------------------*/
-/* BasicReader.cc                                              (C) 2000-2023 */
+/* BasicReader.cc                                              (C) 2000-2024 */
 /*                                                                           */
 /* Lecture simple pour les protections/reprises.                             */
 /*---------------------------------------------------------------------------*/
@@ -19,6 +19,7 @@
 #include "arcane/utils/JSONReader.h"
 #include "arcane/utils/IDataCompressor.h"
 #include "arcane/utils/IHashAlgorithm.h"
+#include "arcane/utils/Ref.h"
 
 #include "arcane/core/IApplication.h"
 #include "arcane/core/IXmlDocumentHolder.h"
@@ -50,24 +51,13 @@ BasicGenericReader(IApplication* app, Int32 version, Ref<KeyValueTextReader> tex
 : TraceAccessor(app->traceMng())
 , m_application(app)
 , m_text_reader(text_reader)
-, m_rank(A_NULL_RANK)
 , m_version(version)
 {
 }
 
 /*---------------------------------------------------------------------------*/
 /*---------------------------------------------------------------------------*/
 
-BasicGenericReader::
-~BasicGenericReader()
-{
-  for (const auto& x : m_variables_data_info)
-    delete x.second;
-}
-
-/*---------------------------------------------------------------------------*/
-/*---------------------------------------------------------------------------*/
-
 void BasicGenericReader::
 initialize(const String& path, Int32 rank)
 {
@@ -143,7 +133,7 @@ initialize(const String& path, Int32 rank)
   for (Integer i = 0, is = variables_elem.size(); i < is; ++i) {
     XmlNode n = variables_elem[i];
     String var_full_name = n.attrValue("full-name");
-    auto vdi = new VariableDataInfo(var_full_name, n);
+    Ref<VariableDataInfo> vdi = makeRef(new VariableDataInfo(var_full_name, n));
     m_variables_data_info.insert(std::make_pair(var_full_name, vdi));
   }
 
@@ -164,14 +154,14 @@ initialize(const String& path, Int32 rank)
 /*---------------------------------------------------------------------------*/
 /*---------------------------------------------------------------------------*/
 
-VariableDataInfo* BasicGenericReader::
+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())
     ARCANE_THROW(ReaderWriterException,
                  "Can not find own metadata infos for data var={0} rank={1}", full_name, m_rank);
-  VariableDataInfo* vdi = ivar->second;
+  Ref<VariableDataInfo> vdi = ivar->second;
   return vdi;
 }
 
@@ -183,7 +173,7 @@ readData(const String& var_full_name, IData* data)
 {
   KeyValueTextReader* reader = m_text_reader.get();
   String vname = var_full_name;
-  VariableDataInfo* vdi = _getVarInfo(vname);
+  Ref<VariableDataInfo> vdi = _getVarInfo(vname);
   if (m_version < 3)
     reader->setFileOffset(vdi->fileOffset());
 
@@ -354,18 +344,6 @@ initialize()
 /*---------------------------------------------------------------------------*/
 /*---------------------------------------------------------------------------*/
 
-BasicReader::
-~BasicReader()
-{
-  for (const auto& i : m_parallel_data_readers)
-    delete i.second;
-  for (const auto& r : m_global_readers)
-    delete r;
-}
-
-/*---------------------------------------------------------------------------*/
-/*---------------------------------------------------------------------------*/
-
 void BasicReader::
 _directReadVal(VariableMetaData* varmd, IData* data)
 {
@@ -396,7 +374,7 @@ _directReadVal(VariableMetaData* varmd, IData* data)
   }
 
   if (is_item_variable) {
-    ParallelDataReader* parallel_data_reader = _getReader(varmd);
+    Ref<ParallelDataReader> parallel_data_reader = _getReader(varmd);
 
     Int64UniqueArray full_written_unique_ids;
     IData* full_written_data = nullptr;
@@ -439,7 +417,7 @@ _directReadVal(VariableMetaData* varmd, IData* data)
 /*---------------------------------------------------------------------------*/
 /*---------------------------------------------------------------------------*/
 
-ParallelDataReader* BasicReader::
+Ref<ParallelDataReader> BasicReader::
 _getReader(VariableMetaData* varmd)
 {
   Int32 nb_to_read = m_nb_rank_to_read;
@@ -454,7 +432,7 @@ _getReader(VariableMetaData* varmd)
     return ix->second;
 
   IParallelMng* pm = m_parallel_mng;
-  auto reader = new ParallelDataReader(pm);
+  Ref<ParallelDataReader> reader = makeRef(new ParallelDataReader(pm));
   {
     UniqueArray<SharedArray<Int64>> written_unique_ids(nb_to_read);
     Int64Array& wanted_unique_ids = reader->wantedUniqueIds();
@@ -609,7 +587,7 @@ _setRanksToRead()
 /*---------------------------------------------------------------------------*/
 /*---------------------------------------------------------------------------*/
 
-IGenericReader* BasicReader::
+Ref<IGenericReader> BasicReader::
 _readOwnMetaDataAndCreateReader(Int32 rank)
 {
   String main_filename = _getBasicVariableFile(m_version, m_path, rank);
@@ -628,7 +606,7 @@ _readOwnMetaDataAndCreateReader(Int32 rank)
     }
   }
 
-  auto r = new BasicGenericReader(m_application, m_version, text_reader);
+  auto r = makeRef<IGenericReader>(new BasicGenericReader(m_application, m_version, text_reader));
   r->initialize(m_path, rank);
   return r;
 }

Diff for: arcane/src/arcane/std/BasicWriter.cc

@@ -1,11 +1,11 @@
 // -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
 //-----------------------------------------------------------------------------
-// Copyright 2000-2023 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
+// Copyright 2000-2024 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
 // See the top-level COPYRIGHT file for details.
 // SPDX-License-Identifier: Apache-2.0
 //-----------------------------------------------------------------------------
 /*---------------------------------------------------------------------------*/
-/* BasicWriter.cc                                              (C) 2000-2023 */
+/* BasicWriter.cc                                              (C) 2000-2024 */
 /*                                                                           */
 /* Ecriture simple pour les protections/reprises.                            */
 /*---------------------------------------------------------------------------*/
@@ -201,24 +201,13 @@ BasicWriter(IApplication* app, IParallelMng* pm, const String& path,
             eOpenMode open_mode, Integer version, bool want_parallel)
 : BasicReaderWriterCommon(app, pm, path, open_mode)
 , m_want_parallel(want_parallel)
-, m_is_gather(false)
 , m_version(version)
 {
 }
 
 /*---------------------------------------------------------------------------*/
 /*---------------------------------------------------------------------------*/
 
-BasicWriter::
-~BasicWriter()
-{
-  for (const auto& i : m_parallel_data_writers)
-    delete i.second;
-}
-
-/*---------------------------------------------------------------------------*/
-/*---------------------------------------------------------------------------*/
-
 void BasicWriter::
 initialize()
 {
@@ -264,14 +253,14 @@ initialize()
 /*---------------------------------------------------------------------------*/
 /*---------------------------------------------------------------------------*/
 
-ParallelDataWriter* BasicWriter::
+Ref<ParallelDataWriter> BasicWriter::
 _getWriter(IVariable* var)
 {
   ItemGroup group = var->itemGroup();
   auto i = m_parallel_data_writers.find(group);
   if (i != m_parallel_data_writers.end())
     return i->second;
-  ParallelDataWriter* writer = new ParallelDataWriter(m_parallel_mng);
+  Ref<ParallelDataWriter> writer = makeRef<ParallelDataWriter>(new ParallelDataWriter(m_parallel_mng));
   writer->setGatherAll(m_is_gather);
   {
     Int64UniqueArray items_uid;
@@ -300,7 +289,7 @@ _directWriteVal(IVariable* var, IData* data)
   if (var->itemKind() != IK_Unknown) {
     ItemGroup group = var->itemGroup();
     if (m_want_parallel) {
-      ParallelDataWriter* writer = _getWriter(var);
+      Ref<ParallelDataWriter> writer = _getWriter(var);
       written_unique_ids = writer->sortedUniqueIds();
       allocated_write_data = writer->getSortedValues(data);
       write_data = allocated_write_data.get();
@@ -314,7 +303,7 @@ _directWriteVal(IVariable* var, IData* data)
     if (m_written_groups.find(group) == m_written_groups.end()) {
       info(5) << "WRITE GROUP " << group.name();
       IItemFamily* item_family = group.itemFamily();
-      String gname = group.name();
+      const String& gname = group.name();
       String group_full_name = item_family->fullName() + "_" + gname;
       m_global_writer->writeItemGroup(group_full_name, written_unique_ids, wanted_unique_ids.view());
       m_written_groups.insert(group);

Diff for: arcane/src/arcane/std/internal/BasicReaderWriter.h

@@ -1,11 +1,11 @@
 // -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
 //-----------------------------------------------------------------------------
-// Copyright 2000-2023 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
+// Copyright 2000-2024 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
 // See the top-level COPYRIGHT file for details.
 // SPDX-License-Identifier: Apache-2.0
 //-----------------------------------------------------------------------------
 /*---------------------------------------------------------------------------*/
-/* BasicReaderWriter.h                                         (C) 2000-2023 */
+/* BasicReaderWriter.h                                         (C) 2000-2024 */
 /*                                                                           */
 /* Lecture/Ecriture simple.                                                  */
 /*---------------------------------------------------------------------------*/
@@ -193,7 +193,6 @@ class BasicGenericReader
   // Si 'version==-1', alors cela sera déterminé lors de
   // l'initialisation.
   BasicGenericReader(IApplication* app, Int32 version, Ref<KeyValueTextReader> text_reader);
-  ~BasicGenericReader() override;
 
  public:
 
@@ -204,18 +203,18 @@ class BasicGenericReader
 
  private:
 
-  using VariableDataInfoMap = std::map<String, VariableDataInfo*>;
+  using VariableDataInfoMap = std::map<String, Ref<VariableDataInfo>>;
 
-  IApplication* m_application;
+  IApplication* m_application = nullptr;
   Ref<KeyValueTextReader> m_text_reader;
   String m_path;
-  Int32 m_rank;
-  Int32 m_version;
+  Int32 m_rank = A_NULL_RANK;
+  Int32 m_version = -1;
   VariableDataInfoMap m_variables_data_info;
 
  private:
 
-  VariableDataInfo* _getVarInfo(const String& full_name);
+  Ref<VariableDataInfo> _getVarInfo(const String& full_name);
 };
 
 /*---------------------------------------------------------------------------*/
@@ -228,7 +227,7 @@ class IGenericWriter
 {
  public:
 
-  virtual ~IGenericWriter() {}
+  virtual ~IGenericWriter() = default;
 
  public:
 
@@ -335,7 +334,6 @@ class BasicWriter
 
   BasicWriter(IApplication* app, IParallelMng* pm, const String& path,
               eOpenMode open_mode, Integer version, bool want_parallel);
-  ~BasicWriter() override;
 
  public:
 
@@ -355,26 +353,24 @@ class BasicWriter
 
  private:
 
-  bool m_want_parallel;
-  bool m_is_gather;
-  Int32 m_version;
+  bool m_want_parallel = false;
+  bool m_is_gather = false;
+  Int32 m_version = -1;
 
   Ref<IDataCompressor> m_data_compressor;
   Ref<IHashAlgorithm> m_hash_algorithm;
   Ref<KeyValueTextWriter> m_text_writer;
 
-  std::map<ItemGroup, ParallelDataWriter*> m_parallel_data_writers;
+  std::map<ItemGroup, Ref<ParallelDataWriter>> m_parallel_data_writers;
   std::set<ItemGroup> m_written_groups;
 
   ScopedPtrT<IGenericWriter> m_global_writer;
 
  private:
 
   void _directWriteVal(IVariable* v, IData* data);
-  void _writeVal(TextWriter* writer, VariableDataInfo* data_info,
-                 const ISerializedData* sdata);
 
-  ParallelDataWriter* _getWriter(IVariable* var);
+  Ref<ParallelDataWriter> _getWriter(IVariable* var);
 };
 
 /*---------------------------------------------------------------------------*/
@@ -405,7 +401,6 @@ class BasicReader
 
   BasicReader(IApplication* app, IParallelMng* pm, Int32 forced_rank_to_read,
               const String& path, bool want_parallel);
-  ~BasicReader() override;
 
  public:
 
@@ -428,16 +423,16 @@ class BasicReader
 
  private:
 
-  bool m_want_parallel;
-  Integer m_nb_written_part;
-  Int32 m_version;
+  bool m_want_parallel = false;
+  Integer m_nb_written_part = 0;
+  Int32 m_version = -1;
 
-  Int32 m_first_rank_to_read;
-  Int32 m_nb_rank_to_read;
-  Int32 m_forced_rank_to_read;
+  Int32 m_first_rank_to_read = -1;
+  Int32 m_nb_rank_to_read = -1;
+  Int32 m_forced_rank_to_read = -1;
 
-  std::map<String, ParallelDataReader*> m_parallel_data_readers;
-  UniqueArray<IGenericReader*> m_global_readers;
+  std::map<String, Ref<ParallelDataReader>> m_parallel_data_readers;
+  UniqueArray<Ref<IGenericReader>> m_global_readers;
   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;
@@ -446,9 +441,9 @@ class BasicReader
 
   void _directReadVal(VariableMetaData* varmd, IData* data);
 
-  ParallelDataReader* _getReader(VariableMetaData* varmd);
+  Ref<ParallelDataReader> _getReader(VariableMetaData* varmd);
   void _setRanksToRead();
-  IGenericReader* _readOwnMetaDataAndCreateReader(Int32 rank);
+  Ref<IGenericReader> _readOwnMetaDataAndCreateReader(Int32 rank);
 };
 
 /*---------------------------------------------------------------------------*/