ItemGroupInternal.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2025 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* ItemGroupInternal.h                                         (C) 2000-2025 */
/*                                                                           */
/* Partie interne à Arcane de ItemGroup.                                     */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_CORE_INTERNAL_ITEMGROUPINTERNAL_H
#define ARCANE_CORE_INTERNAL_ITEMGROUPINTERNAL_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/MemoryUtils.h"
 
#include "arcane/core/ArcaneTypes.h"
#include "arcane/core/VariableTypes.h"
#include "arcane/core/internal/ItemGroupImplInternal.h"
 
#include <map>
#include <mutex>
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
class ItemGroupImpl;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ItemGroupInternal
{
  friend class ItemGroupImplInternal;
 
 public:

  class CheckNeedUpdateMutex
  {
   public:
 
    class ScopedLock
    {
     public:
 
      explicit ScopedLock(const CheckNeedUpdateMutex& mutex)
      : m_update_mutex(mutex)
      {
        m_update_mutex._lock();
      }
      ~ScopedLock()
      {
        m_update_mutex._unlock();
      }
 
     private:
 
      const CheckNeedUpdateMutex& m_update_mutex;
    };
 
   public:
 
    ~CheckNeedUpdateMutex()
    {
      delete m_mutex;
    }
    void create()
    {
      m_mutex = new std::mutex();
    }
 
   private:
 
    std::mutex* m_mutex = nullptr;
 
   private:
 
    void _lock() const
    {
      if (m_mutex)
        m_mutex->lock();
    }
    void _unlock() const
    {
      if (m_mutex)
        m_mutex->unlock();
    }
  };
 
 public:
 
  ItemGroupInternal();
  ItemGroupInternal(IItemFamily* family, const String& name);
  ItemGroupInternal(IItemFamily* family, ItemGroupImpl* parent, const String& name);
  ~ItemGroupInternal();
 
 public:
 
  const String& name() const { return m_name; }
  const String& fullName() const { return m_full_name; }
  bool null() const { return m_is_null; }
  IMesh* mesh() const { return m_mesh; }
  eItemKind kind() const { return m_kind; }
  Integer maxLocalId() const;
  ItemInternalList items() const;
  ItemInfoListView itemInfoListView() const;
 
  Int32ArrayView itemsLocalId() { return *m_items_local_id; }
  Int32ConstArrayView itemsLocalId() const { return *m_items_local_id; }
  Int32Array& mutableItemsLocalId() { return *m_items_local_id; }
  VariableArrayInt32* variableItemsLocalid() { return m_variable_items_local_id; }
 
  Int64 timestamp() const { return m_timestamp; }
  bool isContiguous() const { return m_is_contiguous; }
  void checkIsContiguous();
 
  void updateTimestamp()
  {
    ++m_timestamp;
    m_is_contiguous = false;
  }
 
  void setNeedRecompute()
  {
    // NOTE: normalement il ne faudrait mettre cette valeur à 'true' que pour
    // les groupes recalculés (qui ont un parent ou pour lequel 'm_compute_functor' n'est
    // pas nul). Cependant, cette méthode est aussi appelé sur le groupe de toutes les entités
    // et peut-être d'autres groupes.
    // Changer ce comportement risque d'impacter pas mal de code donc il faudrait bien vérifier
    // que tout est OK avant de faire cette modification.
    m_need_recompute = true;
  }

  void applySimdPadding();
 
  void checkUpdateSimdPadding();
  bool isAllItems() const { return m_is_all_items; }
  bool isOwn() const { return m_is_own; }
  Int32 nbItem() const { return itemsLocalId().size(); }
  void checkValid();
 
 public:
 
  void _removeItems(SmallSpan<const Int32> items_local_id);
 
 private:
 
  void _notifyDirectRemoveItems(SmallSpan<const Int32> removed_ids, Int32 nb_remaining);
 
 public:
 
  ItemGroupImplInternal m_internal_api;
  IMesh* m_mesh = nullptr; 
  IItemFamily* m_item_family = nullptr; 
  ItemGroupImpl* m_parent = nullptr; 
  String m_variable_name; 
  String m_full_name; 
  bool m_is_null = true; 
  eItemKind m_kind = IK_Unknown; 
  String m_name; 
  bool m_is_own = false; 
 
 private:
 
  Int64 m_timestamp = -1; 
 
 public:
 
  Int64 m_simd_timestamp = -1; 
  ItemGroupImpl* m_own_group = nullptr; 
  ItemGroupImpl* m_ghost_group = nullptr; 
  ItemGroupImpl* m_interface_group = nullptr; 
  ItemGroupImpl* m_node_group = nullptr; 
  ItemGroupImpl* m_edge_group = nullptr; 
  ItemGroupImpl* m_face_group = nullptr; 
  ItemGroupImpl* m_cell_group = nullptr; 
  ItemGroupImpl* m_inner_face_group = nullptr; 
  ItemGroupImpl* m_outer_face_group = nullptr; 
  // FIXME on peut éviter de stocker ces groupes en introduisant des predicats
  // sur les groupes parents
  ItemGroupImpl* m_active_cell_group = nullptr; 
  ItemGroupImpl* m_own_active_cell_group = nullptr; 
  ItemGroupImpl* m_active_face_group = nullptr; 
  ItemGroupImpl* m_own_active_face_group = nullptr; 
  ItemGroupImpl* m_inner_active_face_group = nullptr; 
  ItemGroupImpl* m_outer_active_face_group = nullptr; 
  std::map<Integer, ItemGroupImpl*> m_level_cell_group; 
  std::map<Integer, ItemGroupImpl*> m_own_level_cell_group; 
 
  UniqueArray<ItemGroupImpl*> m_children_by_type; 
  std::map<String, AutoRefT<ItemGroupImpl>> m_sub_groups; 
  bool m_need_recompute = false; 
  bool m_need_invalidate_on_recompute = false; 
  bool m_transaction_mode = false; 
  bool m_is_local_to_sub_domain = false; 
  IFunctor* m_compute_functor = nullptr; 
  bool m_is_all_items = false; 
  bool m_is_constituent_group = false; 
  SharedPtrT<GroupIndexTable> m_group_index_table; 
  Ref<IVariableSynchronizer> m_synchronizer; 
 
  // Anciennement dans DynamicMeshKindInfo
  Int32UniqueArray m_items_index_in_all_group; 
 
  std::map<const void*, IItemGroupObserver*> m_observers; 
  bool m_observer_need_info = false; 
  void notifyExtendObservers(const Int32ConstArrayView* info);
  void notifyReduceObservers(const Int32ConstArrayView* info);
  void notifyCompactObservers(const Int32ConstArrayView* info);
  void notifyInvalidateObservers();
 
  void resetSubGroups();
 
 public:
 
  bool isUseV2ForApplyOperation() const { return m_use_v2_for_apply_operation; }
 
 private:
 
  UniqueArray<Int32> m_local_buffer{ MemoryUtils::getAllocatorForMostlyReadOnlyData() };
  Array<Int32>* m_items_local_id = &m_local_buffer; 
  VariableArrayInt32* m_variable_items_local_id = nullptr;
  bool m_is_contiguous = false; 
  bool m_is_check_simd_padding = true;
  bool m_is_print_check_simd_padding = false;
  bool m_is_print_apply_simd_padding = false;
  bool m_is_print_stack_apply_simd_padding = false;
 
 private:
 
  // TODO: Mettre cela dans une classe spécifique ce qui permettra
  // de l'utiliser par exemple pour ItemVector


  bool m_use_v2_for_apply_operation = true;
 
 public:

  UniqueArray<UniqueArray<Int32>> m_children_by_type_ids;

  ItemTypeId m_unique_children_type{ IT_NullType };

  Int64 m_children_by_type_ids_computed_timestamp = -1;
 
  bool m_is_debug_apply_operation = false;

  CheckNeedUpdateMutex m_check_need_update_mutex;
 
 private:
 
  void _init();
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif