BasicIndexManager.h

#pragma once
 
#include <map>
#include <memory>
#include <vector>
 
#include <alien/index_manager/IIndexManager.h>
#include <alien/utils/Precomp.h>
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Alien
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

class ALIEN_EXPORT BasicIndexManager : public IIndexManager
{
 public:
 public:
  explicit BasicIndexManager(Alien::IMessagePassingMng* parallelMng);
  ~BasicIndexManager() override;

  void init() override;

  [[nodiscard]] bool isPrepared() const override { return m_state == Prepared; }

  void setTraceMng(Alien::ITraceMng* traceMng) override;

  void prepare() override;


  void stats(Arccore::Integer& globalSize, Arccore::Integer& minLocalIndex,
             Arccore::Integer& localSize) const override;


  [[nodiscard]] Arccore::Integer globalSize() const override;


  [[nodiscard]] Arccore::Integer minLocalIndex() const override;


  [[nodiscard]] Arccore::Integer localSize() const override;

  [[nodiscard]] EntryEnumerator enumerateEntry() const override;

  ScalarIndexSet buildScalarIndexSet(const Arccore::String& name,
                                     Arccore::IntegerConstArrayView localIds,
                                     const IIndexManager::IAbstractFamily& family) override;

  ScalarIndexSet buildScalarIndexSet(
  const Arccore::String& name, const IIndexManager::IAbstractFamily& family) override;


  VectorIndexSet buildVectorIndexSet(const Arccore::String& name,
                                     Arccore::IntegerConstArrayView localIds,
                                     const IIndexManager::IAbstractFamily& family,
                                     Arccore::Integer n) override;


  VectorIndexSet buildVectorIndexSet(const Arccore::String& name,
                                     const IIndexManager::IAbstractFamily& family, Arccore::Integer n) override;

  [[nodiscard]] Arccore::UniqueArray<Arccore::Integer> getIndexes(
  const ScalarIndexSet& entry) const override;

  [[nodiscard]] Arccore::UniqueArray2<Arccore::Integer> getIndexes(
  const VectorIndexSet& entries) const override;

 
  [[nodiscard]] Arccore::MessagePassing::IMessagePassingMng* parallelMng() const override
  {
    return m_parallel_mng;
  }

  void setMaxNullIndexOpt(bool flag) override { m_max_null_index_opt = flag; }
 
  [[nodiscard]] Arccore::Integer nullIndex() const override
  {
    ALIEN_ASSERT((m_state == Prepared), ("nullIndex is valid only in Prepared state"));
    if (m_max_null_index_opt)
      return m_global_entry_offset + m_local_entry_count;
    else
      return -1;
  }
 
 public:
  void keepAlive(const IAbstractFamily* family) override;
 
 private:
  Arccore::MessagePassing::IMessagePassingMng* m_parallel_mng = nullptr;
  Arccore::Integer m_local_owner = 0; 
 
  enum State
  {
    Undef,
    Initialized,
    Prepared
  } m_state;
 
  Arccore::ITraceMng* m_trace = nullptr;
 
  Arccore::Integer m_local_entry_count = 0;
  Arccore::Integer m_global_entry_count = 0;
  Arccore::Integer m_global_entry_offset = 0;
  Arccore::Integer m_local_removed_entry_count = 0;
  Arccore::Integer m_global_removed_entry_count = 0;
 
  bool m_max_null_index_opt = false;
 
  class MyEntryImpl;
  class MyEntryEnumeratorImpl;
 
  struct InternalEntryIndex
  {
    InternalEntryIndex(MyEntryImpl* e, Arccore::Integer lid, Arccore::Integer kind,
                       Arccore::Int64 uid, Arccore::Integer index,
                       [[maybe_unused]] Arccore::Integer creation_index, Arccore::Integer owner)
    : m_entry(e)
    , m_uid(uid)
    , m_localid(lid)
    , m_kind(kind)
    , m_index(index)
    // , m_creation_index(creation_index)
    , m_owner(owner)
    {}
    MyEntryImpl* m_entry;
    Arccore::Int64 m_uid;
    Arccore::Integer m_localid, m_kind, m_index;
    // Integer m_creation_index;
    Arccore::Integer m_owner;
    bool operator==(const InternalEntryIndex& m) const
    {
      return m.m_entry == m_entry && m.m_localid == m_localid;
    }
  };
 
  typedef std::vector<InternalEntryIndex> EntryIndexMap;
 
  struct EntryIndexComparator
  {
    inline bool operator()(
    const InternalEntryIndex& a, const InternalEntryIndex& b) const;
  };

  typedef std::map<Arccore::String, MyEntryImpl*> EntrySet;
  EntrySet m_entry_set;

  Arccore::Integer m_creation_index = 0;

 
  Arccore::Integer m_abstract_family_base_kind = 0;
 
  // TODO: why a shared_ptr here ?
  std::map<Arccore::Integer, std::shared_ptr<IAbstractFamily>>
  m_abstract_families; 
  std::map<const IAbstractFamily*, Arccore::Integer>
  m_abstract_family_to_kind_map; 

 
  [[nodiscard]] Entry getEntry(const Arccore::String& name) const override;
 
 protected:
  struct EntrySendRequest;
  struct EntryRecvRequest;
 
 protected: // Méthodes protègés en attendant une explicitation du besoin
 private:
  Entry buildEntry(const Arccore::String& name, const IAbstractFamily* itemFamily,
                   Arccore::Integer kind);
  void defineIndex(const Entry& entry, Arccore::IntegerConstArrayView localIds);
  void parallel_prepare(EntryIndexMap& entry_index);
  void sequential_prepare(EntryIndexMap& entry_index);
  [[nodiscard]] inline bool isOwn(const IAbstractFamily::Item& item) const
  {
    return item.owner() == m_local_owner;
  }
  [[nodiscard]] inline bool isOwn(const InternalEntryIndex& i) const
  {
    return i.m_owner == m_local_owner;
  }
  void reserveEntries(const EntryIndexMap& entry_index);
  Arccore::Integer addNewAbstractFamily(const IAbstractFamily* family);

  void init_mine();
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
} // namespace Alien
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/