Arcane  v3.16.0.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
ItemGroupsSynchronize.cc
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2025 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
4// See the top-level COPYRIGHT file for details.
5// SPDX-License-Identifier: Apache-2.0
6//-----------------------------------------------------------------------------
7/*---------------------------------------------------------------------------*/
8/* ItemGroupsSynchronize.cc (C) 2000-2025 */
9/* */
10/* Synchronisations des groupes. */
11/*---------------------------------------------------------------------------*/
12/*---------------------------------------------------------------------------*/
13
14#include "arcane/mesh/ItemGroupsSynchronize.h"
15
16#include "arcane/utils/ITraceMng.h"
17#include "arcane/utils/Math.h"
18
20#include "arcane/core/IMesh.h"
21#include "arcane/core/IItemFamily.h"
22#include "arcane/core/VariableBuildInfo.h"
23#include "arcane/core/ItemPrinter.h"
24
25#include "arcane/mesh/CommonItemGroupFilterer.h"
26
27/*---------------------------------------------------------------------------*/
28/*---------------------------------------------------------------------------*/
29
30namespace Arcane::mesh
31{
32
33/*---------------------------------------------------------------------------*/
34/*---------------------------------------------------------------------------*/
35
38: TraceAccessor(item_family->traceMng())
39, m_item_family(item_family)
40, m_var(VariableBuildInfo(item_family,"MeshItemGroupSynchronize",
41 IVariable::PNoDump|IVariable::PNoRestore),
42 item_family->itemKind())
43{
44 _setGroups();
45}
46
47/*---------------------------------------------------------------------------*/
48/*---------------------------------------------------------------------------*/
49
52: TraceAccessor(item_family->traceMng())
53, m_item_family(item_family)
54, m_var(VariableBuildInfo(item_family,"MeshItemGroupSynchronize",
55 IVariable::PNoDump|IVariable::PNoRestore),
56 item_family->itemKind())
57, m_groups(groups)
58{
59}
60
61/*---------------------------------------------------------------------------*/
62/*---------------------------------------------------------------------------*/
63
64ItemGroupsSynchronize::
65~ItemGroupsSynchronize()
66{
67}
68
69/*---------------------------------------------------------------------------*/
70/*---------------------------------------------------------------------------*/
71
72void ItemGroupsSynchronize::
73_setGroups()
74{
75 m_groups.clear();
76 for( const ItemGroup& group : m_item_family->groups() ){
77 if (!group.internal()->needSynchronization())
78 continue;
79 m_groups.add(group);
80 }
81}
82
83/*---------------------------------------------------------------------------*/
84/*---------------------------------------------------------------------------*/
85
88{
89 ItemGroup all_items = m_item_family->allItems();
90
91 // Construction de la liste des groupes
93 CommonItemGroupFilterer group_filterer(m_item_family);
94 for( ItemGroup group : m_groups ){
95 ARCANE_ASSERT((!group.null()),("Null group in ItemGroupsSynchronize"));
96 groups.add(group);
97 group_filterer.addGroupToFilter(group);
98 }
99 // TODO: regarder s'il ne faudrait pas le faire à chaque fois
100 // Comme cela on serait certains que les groupes sont bien triés
101 if (arcaneIsCheck())
102 group_filterer.applyFiltering();
103
104 Int32UniqueArray group_items; // Tableau stockant les listes d'items en évolution
105 group_items.reserve(m_item_family->maxLocalId());
106
107 const Integer max_aggregate_size =
108 sizeof(IntAggregator)*8-1; // Pour rester dans l'espace des entiers positifs
109 const Integer aggregate_count =
110 (groups.size() / max_aggregate_size) +
111 ((groups.size() % max_aggregate_size)?1:0);
112
113 for(Integer i_aggregate=0; i_aggregate < aggregate_count; ++i_aggregate) {
114 const Integer first_group = i_aggregate * max_aggregate_size;
115 const Integer current_aggregate_size = math::min(max_aggregate_size,
116 groups.size()-first_group);
117 m_var.fill(0); // Initialisation du tableau parallèle
118 for(Integer i_group=0;i_group<current_aggregate_size;++i_group) {
119 const IntAggregator current_mask = static_cast<IntAggregator>(1)<<i_group;
120 ItemGroup group = groups[first_group+i_group];
121 ENUMERATE_ITEM(iitem,group){
122 m_var[iitem] |= current_mask;
123 }
124 }
125
126 // Partage des infos de contenu des groupes sur l'aggrégat
127 m_var.synchronize();
128
129 for(Integer i_group=0;i_group<current_aggregate_size;++i_group) {
130 const IntAggregator current_mask = static_cast<IntAggregator>(1)<<i_group;
131 ItemGroup group = groups[first_group+i_group];
132 const Integer current_size = group.size();
133 if (group.internal()->hasInfoObserver()) {
134 // Passage en mode incrémental
135 // Recherche des items disparus
136 group_items.clear();
137 ENUMERATE_ITEM(iitem, group) {
138 if ((m_var[iitem] & current_mask) == 0) {
139 group_items.add(iitem.itemLocalId());
140 } else {
141 m_var[iitem] &= ~current_mask; // marque comme déjà existant dans le groupe
142 }
143 }
144 Integer removed_size = group_items.size();
145 group.removeItems(group_items);
146 // Recherche des nouveaux items
147 group_items.clear();
148 ENUMERATE_ITEM(iitem, all_items) {
149 if ((m_var[iitem] & current_mask) != 0) {
150 group_items.add(iitem.itemLocalId());
151 }
152 }
153 group.addItems(group_items);
154 debug() << "Incremental synchronization for the group <" << group.name() << ">"
155 << " old=" << current_size << " new=" << group.size()
156 << " added=" << group_items.size() << " removed=" << removed_size;
157 }
158 else {
159 // On utilise le mode d'affectation direct des groupes
160 group_items.clear();
161 ENUMERATE_ITEM(iitem,all_items){
162 if ((m_var[iitem] & current_mask) != 0) {
163 group_items.add(iitem.itemLocalId());
164 }
165 }
166 // Préservation du précédent comportement : utilise createGroup et non findGroup + setItems
167 group.setItems(group_items);
168 debug() << "Direct synchronization for the group <" << group.name() << ">"
169 << " old=" << current_size << " new=" << group.size();
170 }
171 }
172 }
173}
174
175/*---------------------------------------------------------------------------*/
176/*---------------------------------------------------------------------------*/
177
180{
181 // TODO: vérifier que tous les sous-domaines ont les mêmes groupes.
182 Integer nb_diff = 0;
183 for( const ItemGroup& group : m_item_family->groups() ){
184 m_var.fill(0);
185 ENUMERATE_ITEM(i_item,group){
186 m_var[*i_item] = 1;
187 }
188 Integer diff = m_var.checkIfSync(10);
189 if (diff!=0){
190 error() << "Group is not in sync (name=" << group.name()
191 << ", nb_diff=" << nb_diff << ")";
192 }
193 nb_diff += diff;
194 }
195 return nb_diff;
196}
197
198/*---------------------------------------------------------------------------*/
199/*---------------------------------------------------------------------------*/
200
201} // End namespace Arcane::mesh
202
203/*---------------------------------------------------------------------------*/
204/*---------------------------------------------------------------------------*/
Types et macros pour itérer sur les entités du maillage.
#define ENUMERATE_ITEM(name, group)
Enumérateur générique d'un groupe de noeuds.
Integer size() const
Nombre d'éléments du vecteur.
void clear()
Supprime les éléments du tableau.
void reserve(Int64 new_capacity)
Réserve le mémoire pour new_capacity éléments.
void add(ConstReferenceType val)
Ajoute l'élément val à la fin du tableau.
void clear()
Supprime tous les éléments de la collection.
Definition Collection.h:68
Interface d'une famille d'entités.
Definition IItemFamily.h:84
virtual ItemGroupCollection groups() const =0
Liste des groupes de cette famille.
Interface d'une variable.
Definition IVariable.h:56
bool hasInfoObserver() const
Indique si le contenu de ce groupe est observé.
Groupe d'entités de maillage.
Definition ItemGroup.h:49
ItemGroupImpl * internal() const
Retourne l'implémentation du groupe.
Definition ItemGroup.h:120
const String & name() const
Nom du groupe.
Definition ItemGroup.h:76
void removeItems(Int32ConstArrayView items_local_id, bool check_if_present=true)
Supprime des entités.
Definition ItemGroup.cc:467
Integer size() const
Nombre d'éléments du groupe.
Definition ItemGroup.h:88
void setItems(Int32ConstArrayView items_local_id)
Positionne les entités du groupe.
Definition ItemGroup.cc:488
void addItems(Int32ConstArrayView items_local_id, bool check_if_present=true)
Ajoute des entités.
Definition ItemGroup.cc:445
Integer checkSynchronize()
Vérifie si les groupes sont synchronisé.
ItemGroupsSynchronize(IItemFamily *item_family)
Créé une instance pour synchroniser tous les groupes de la famille item_family.
Int32 IntAggregator
Type employé pour l'aggrégation des communications de groupes.
void synchronize()
Synchronise les groupes.
TraceAccessor(ITraceMng *m)
Construit un accesseur via le gestionnaire de trace m.
TraceMessageDbg debug(Trace::eDebugLevel=Trace::Medium) const
Flot pour un message de debug.
TraceMessage error() const
Flot pour un message d'erreur.
ITraceMng * traceMng() const
Gestionnaire de trace.
Vecteur 1D de données avec sémantique par valeur (style STL).
Paramètres nécessaires à la construction d'une variable.
__host__ __device__ Real2 min(Real2 a, Real2 b)
Retourne le minimum de deux Real2.
Definition MathUtils.h:336
bool arcaneIsCheck()
Vrai si on est en mode vérification.
Definition Misc.cc:68
Collection< ItemGroup > ItemGroupCollection
Collection de groupes d'éléments du maillage.
Int32 Integer
Type représentant un entier.
UniqueArray< Int32 > Int32UniqueArray
Tableau dynamique à une dimension d'entiers 32 bits.
Definition UtilsTypes.h:428