VariableMng.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2023 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* VariableMng.h                                               (C) 2000-2024 */
/*                                                                           */
/* Classe gérant la liste des maillages.                                     */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_IMPL_INTERNAL_VARIABLEMNG_H
#define ARCANE_IMPL_INTERNAL_VARIABLEMNG_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/TraceAccessor.h"
#include "arcane/utils/String.h"
#include "arcane/utils/HashTableMap.h"
#include "arcane/utils/List.h"
#include "arcane/utils/Ref.h"
 
#include "arcane/core/IVariableMng.h"
#include "arcane/core/IVariableFilter.h"
#include "arcane/core/VariableCollection.h"
#include "arcane/core/internal/IVariableMngInternal.h"
 
#include "arcane/accelerator/core/IAcceleratorMng.h"
 
#include <map>
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class VariableMetaDataList;
class VariableReaderMng;
class XmlNode;
class VariableIOWriterMng;
class VariableIOReaderMng;
class VariableSynchronizerMng;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class VariableMng
: public TraceAccessor
, public IVariableMng
{
  friend class VariableIOWriterMng;
  friend class VariableIOReaderMng;
 
  class VariableNameInfo
  {
   public:
 
    String m_local_name;
    String m_family_name;
    String m_mesh_name;
    bool operator==(const VariableNameInfo& vni) const
    {
      return m_local_name == vni.m_local_name && m_family_name == vni.m_family_name && m_mesh_name == vni.m_mesh_name;
    }
 
   public:
 
    Int32 hash() const
    {
      Int32 h = 0;
      if (!m_mesh_name.null()) {
        h = hash(h, m_mesh_name.localstr());
        h = hash(h, "_");
      }
      if (!m_family_name.null()) {
        h = hash(h, m_family_name.localstr());
        h = hash(h, "_");
      }
      h = hash(h, m_local_name.localstr());
      return h;
    }
 
   public:
 
    static Int32 hash(Int32 h, const char* p)
    {
      if (!p)
        return h;
      for (; *p != '\0'; ++p)
        h = (h << 5) - h + *p;
      return h;
    }
  };
 
  class VNIComparer
  {
   public:
 
    typedef const VariableNameInfo& KeyTypeConstRef;
    typedef VariableNameInfo& KeyTypeRef;
    typedef VariableNameInfo KeyTypeValue;
    typedef FalseType Printable;
    typedef Int32 HashValueType;
    static Int32 hashFunction(const VariableNameInfo& key)
    {
      // garantie que la valeur est positive
      return key.hash() & 0x7fffffff;
    }
  };
 
  class InternalApi
  : public IVariableMngInternal
  {
   public:
 
    explicit InternalApi(VariableMng* v)
    : m_variable_mng(v)
    {}
 
   public:
 
    void build() override { m_variable_mng->build(); }
    void initialize() override { m_variable_mng->initialize(); }
    void removeAllVariables() override { m_variable_mng->removeAllVariables(); }
    void detachMeshVariables(IMesh* mesh) override { m_variable_mng->detachMeshVariables(mesh); }
    void addVariableRef(VariableRef* var) override { m_variable_mng->addVariableRef(var); }
    void removeVariableRef(VariableRef* var) override { m_variable_mng->removeVariableRef(var); }
    void addVariable(IVariable* var) override { m_variable_mng->addVariable(var); }
    void removeVariable(IVariable* var) override { m_variable_mng->removeVariable(var); }
    void initializeVariables(bool is_continue) override { m_variable_mng->initializeVariables(is_continue); }
    ISubDomain* internalSubDomain() const override { return m_variable_mng->_internalSubDomain(); }
    IAcceleratorMng* acceleratorMng() const override { return m_variable_mng->m_accelerator_mng.get(); }
    void setAcceleratorMng(Ref<IAcceleratorMng> v) override { m_variable_mng->m_accelerator_mng = v; }
    void addAutoDestroyVariable(VariableRef* var) override { m_variable_mng->m_auto_create_variables.add(var); }
 
   private:
 
    VariableMng* m_variable_mng = nullptr;
  };
 
 public:
 
  using VNIMap = HashTableMapT<VariableNameInfo, IVariable*, VNIComparer>;
 
 public:
 
  explicit VariableMng(ISubDomain* sd);
  ~VariableMng() override;
 
 public:
 
  void build() override;
  void initialize() override;
  void removeAllVariables() override;
  void detachMeshVariables(IMesh* mesh) override;
 
 public:
 
  ISubDomain* subDomain() override { return m_sub_domain; }
  IParallelMng* parallelMng() const override { return m_parallel_mng; }
  ITraceMng* traceMng() override { return TraceAccessor::traceMng(); }
  IVariable* checkVariable(const VariableInfo& infos) override;
  void addVariableRef(VariableRef* ref) override;
  void addVariable(IVariable* var) override;
  void removeVariableRef(VariableRef*) override;
  void removeVariable(IVariable* var) override;
  void dumpList(std::ostream&, IModule*) override;
  void dumpList(std::ostream&) override;
  void initializeVariables(bool) override;
  String generateTemporaryVariableName() override;
  void variables(VariableRefCollection, IModule*) override;
  VariableCollection variables() override;
  VariableCollection usedVariables() override;
  void notifyUsedVariableChanged() override { m_used_variables_changed = true; }
  Real exportSize(const VariableCollection& vars) override;
  IObservable* writeObservable() override { return m_write_observable; }
  IObservable* readObservable() override { return m_read_observable; }
  void writeVariables(IDataWriter*, const VariableCollection& vars) override;
  void writeVariables(IDataWriter*, IVariableFilter*) override;
  void writeCheckpoint(ICheckpointWriter*) override;
  void writePostProcessing(IPostProcessorWriter* writer) override;
  void readVariables(IDataReader*, IVariableFilter*) override;
  void readCheckpoint(ICheckpointReader*) override;
  void readCheckpoint(const CheckpointReadInfo& infos) override;
  IVariable* findVariable(const String& name) override;
  IVariable* findMeshVariable(IMesh* mesh, const String& name) override;
  IVariable* findVariableFullyQualified(const String& name) override;
 
  void dumpStats(std::ostream& ostr, bool is_verbose) override;
  void dumpStatsJSON(JSONWriter& writer) override;
  IVariableUtilities* utilities() const override { return m_utilities; }
 
  EventObservable<const VariableStatusChangedEventArgs&>&
  onVariableAdded() override
  {
    return m_on_variable_added;
  }
 
  EventObservable<const VariableStatusChangedEventArgs&>&
  onVariableRemoved() override
  {
    return m_on_variable_removed;
  }
  IVariableSynchronizerMng* synchronizerMng() const override;
  ISubDomain* _internalSubDomain() const override { return m_sub_domain; }
  IVariableMngInternal* _internalApi() override { return &m_internal_api; }
 
 public:
 
  static bool isVariableToSave(IVariable& var);
 
 private:

  using FullNameVariableMap = std::map<String, IVariable*>;
  using FullNameVariablePair = FullNameVariableMap::value_type;

  using VariableFactoryMap = std::map<String, IVariableFactory*>;
  using VariableFactoryPair = VariableFactoryMap::value_type;

  ISubDomain* m_sub_domain = nullptr;
  IParallelMng* m_parallel_mng = nullptr;
  ITimeStats* m_time_stats = nullptr;
  InternalApi m_internal_api{ this };
  VariableRefList m_variables_ref; 
  VariableList m_variables;
  VariableList m_used_variables;
  bool m_variables_changed = true;
  bool m_used_variables_changed = true;
  FullNameVariableMap m_full_name_variable_map;
  VNIMap m_vni_map;
  IObservable* m_write_observable = nullptr;
  IObservable* m_read_observable = nullptr;
  EventObservable<const VariableStatusChangedEventArgs&> m_on_variable_added;
  EventObservable<const VariableStatusChangedEventArgs&> m_on_variable_removed;
  List<IVariableFactory*> m_variable_factories;
  List<VariableRef*> m_auto_create_variables;
  VariableFactoryMap m_variable_factory_map;
 
  Integer m_generate_name_id = 0; 
 
  Int64 m_nb_created_variable_reference = 0;
  Int64 m_nb_created_variable = 0;
  // Indique dans quel module une variable est créée
  std::map<IVariable*, IModule*> m_variable_creation_modules;
 
  IVariableUtilities* m_utilities = nullptr;
  VariableIOWriterMng* m_variable_io_writer_mng = nullptr;
  VariableIOReaderMng* m_variable_io_reader_mng = nullptr;
  VariableSynchronizerMng* m_variable_synchronizer_mng = nullptr;
 
  Ref<IAcceleratorMng> m_accelerator_mng;
 
 private:

  void _dumpVariable(const VariableRef& v, std::ostream& o);
 
  static const char* _msgClassName() { return "Variable"; }
  VariableRef* _createVariableFromType(const String& full_type,
                                       const VariableBuildInfo& vbi);
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class VariableIOWriterMng
: public TraceAccessor
{
 private:
 
  class CheckpointSaveFilter
  : public IVariableFilter
  {
   public:
 
    bool applyFilter(IVariable& var) override
    {
      return VariableMng::isVariableToSave(var);
    }
  };
 
 public:
 
  explicit VariableIOWriterMng(VariableMng* vm);
 
 public:
 
  void writeCheckpoint(ICheckpointWriter* service);
  void writePostProcessing(IPostProcessorWriter* post_processor);
  void writeVariables(IDataWriter* writer, const VariableCollection& vars, bool use_hash);
  void writeVariables(IDataWriter* writer, IVariableFilter* filter, bool use_hash);
 
 private:
 
  VariableMng* m_variable_mng = nullptr;
  bool m_use_hash_v2 = false;
 
 private:
 
  void _writeVariables(IDataWriter* writer, const VariableCollection& vars, bool use_hash);
  String _generateMetaData(const VariableCollection& vars, IHashAlgorithm* hash_algo);
  void _generateVariablesMetaData(JSONWriter& json_writer, XmlNode variables_node,
                                  const VariableCollection& vars, IHashAlgorithm* hash_algo);
  void _generateMeshesMetaData(JSONWriter& json_writer, XmlNode meshes_node);
  static const char* _msgClassName() { return "Variable"; }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class VariableIOReaderMng
: public TraceAccessor
{
 public:
 
  class IDataReaderWrapper;
  class OldDataReaderWrapper;
  class DataReaderWrapper;
  class VariableDataTypeInfo;
 
 public:
 
  explicit VariableIOReaderMng(VariableMng* vm);
 
 public:
 
  void readCheckpoint(ICheckpointReader* service);
  void readCheckpoint(const CheckpointReadInfo& infos);
  void readVariables(IDataReader* reader, IVariableFilter* filter);
 
 private:
 
  VariableMng* m_variable_mng = nullptr;
  bool m_is_use_json_metadata = true;
 
 private:
 
  void _readVariablesData(VariableReaderMng& var_read_mng, IDataReaderWrapper* reader);
  void _readMetaData(VariableMetaDataList& vmd_list, Span<const Byte> bytes);
  void _checkHashFunction(const VariableMetaDataList& vmd_list);
  void _createVariablesFromMetaData(const VariableMetaDataList& vmd_list);
  void _readVariablesMetaData(VariableMetaDataList& vmd_list, JSONValue variables_json, const XmlNode& variables_node);
  void _readMeshesMetaData(JSONValue meshes_json, const XmlNode& meshes_node);
  void _buildFilteredVariableList(VariableReaderMng& vars_read_mng, IVariableFilter* filter);
  void _finalizeReadVariables(const VariableList& vars_to_read);
  static const char* _msgClassName() { return "Variable"; }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif