Arcane  v3.16.0.0
Documentation développeur
Tout Classes Espaces de nommage Fichiers Fonctions Variables Définitions de type Énumérations Valeurs énumérées Amis Macros Groupes Pages Concepts
ItemsExchangeInfo2.cc
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2024 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/* ItemsExchangeInfo2.cc (C) 2000-2024 */
9/* */
10/* Echange des entités et leurs variables. */
11/*---------------------------------------------------------------------------*/
12/*---------------------------------------------------------------------------*/
13
14#include "arcane/mesh/ItemsExchangeInfo2.h"
15
16#include "arcane/utils/NotSupportedException.h"
17#include "arcane/utils/PlatformUtils.h"
18#include "arcane/utils/ValueConvert.h"
19
20#include "arcane/core/IMesh.h"
21#include "arcane/core/VariableTypes.h"
23
24#include "arcane/core/ISubDomain.h"
25#include "arcane/core/IParticleFamily.h"
26#include "arcane/core/IParallelMng.h"
27#include "arcane/core/ItemPrinter.h"
28#include "arcane/core/IParallelExchanger.h"
29#include "arcane/core/ISerializer.h"
30#include "arcane/core/ISerializeMessage.h"
31#include "arcane/core/SerializeBuffer.h"
32#include "arcane/core/MeshToMeshTransposer.h"
33#include "arcane/core/IItemFamilyPolicyMng.h"
34#include "arcane/core/IItemFamilySerializer.h"
35#include "arcane/core/ItemFamilySerializeArgs.h"
36#include "arcane/core/ParallelMngUtils.h"
37#include "arcane/core/internal/IItemFamilyInternal.h"
38
39#include "arcane/mesh/ItemGroupsSerializer2.h"
40#include "arcane/mesh/TiedInterfaceExchanger.h"
41#include "arcane/mesh/ItemFamilyVariableSerializer.h"
42
43// TODO: a supprimer
44#include "arcane/mesh/DynamicMesh.h"
45#include "arcane/mesh/DynamicMeshIncrementalBuilder.h"
46
47#include "arcane/IVariableAccessor.h"
48
49/*---------------------------------------------------------------------------*/
50/*---------------------------------------------------------------------------*/
51
52namespace Arcane
53{
54class ItemFamilyExchange;
55}
56
57/*---------------------------------------------------------------------------*/
58/*---------------------------------------------------------------------------*/
59
60namespace Arcane::mesh
61{
62namespace
63{
64const Integer GROUPS_MAGIC_NUMBER = 0x3a9e4325;
65}
66/*---------------------------------------------------------------------------*/
67/*---------------------------------------------------------------------------*/
68
69ItemsExchangeInfo2::
70ItemsExchangeInfo2(IItemFamily* item_family)
71: TraceAccessor(item_family->traceMng())
72, m_item_family(item_family)
73, m_groups_serializers()
74, m_exchanger(ParallelMngUtils::createExchangerRef(item_family->parallelMng()))
75, m_family_serializer(nullptr)
76{
77 m_family_serializer = item_family->policyMng()->createSerializer();
78
79 // Positionne infos pour l'affichage listing
80 m_exchanger->setName(item_family->name());
81
82 // Celui ci doit toujours être le premier de la phase de sérialisation des variables.
83 addSerializeStep(new ItemFamilyVariableSerializer(item_family));
84}
85
86/*---------------------------------------------------------------------------*/
87/*---------------------------------------------------------------------------*/
88
89ItemsExchangeInfo2::
90~ItemsExchangeInfo2()
91{
92 for( IItemFamilySerializeStep* step : m_serialize_steps )
93 delete step;
94 delete m_family_serializer;
95 for(Integer i=0;i<m_groups_serializers.size(); ++i)
96 delete m_groups_serializers[i];
97}
98
99/*---------------------------------------------------------------------------*/
100/*---------------------------------------------------------------------------*/
101
102inline void ItemsExchangeInfo2::
103_addItemToSend(Int32 sub_domain_id,Item item)
104{
105 if (m_send_local_ids[sub_domain_id].empty())
106 // Si premier élément, ajoute le sous-domaine à la liste des
107 // sous-domaines communicants
108 m_exchanger->addSender(sub_domain_id);
109 m_send_local_ids[sub_domain_id].add(item.localId());
110}
111
112/*---------------------------------------------------------------------------*/
113/*---------------------------------------------------------------------------*/
114
115bool ItemsExchangeInfo2::
116computeExchangeInfos()
117{
118 // Détermine la liste des variables a échanger
119 // On y intégre aussi les variables issues des familles enfants
120 {
121 m_families_to_exchange.add(itemFamily()); // La famille courante
122 IItemFamilyCollection child_families = itemFamily()->childFamilies();
123 for( IItemFamily* child_family : child_families )
124 m_families_to_exchange.add(child_family);
125
126 for( IItemFamily* current_family : m_families_to_exchange ){
127 // Si la famille n'a pas de table de uniqueId, il ne faut pas
128 // transferer les groupes car il n'est pas possible de convertir
129 // les uniqueId en localId et le serialiseur en a besoin.
130 // TODO: supprimer ce besoin dans le serialiseur
131 if (current_family->hasUniqueIdMap())
132 m_groups_serializers.add(new ItemGroupsSerializer2(current_family,m_exchanger.get()));
133 }
134 }
135
136 for( IItemFamilySerializeStep* step : m_serialize_steps ){
137 step->initialize();
138 }
139
140 bool r = m_exchanger->initializeCommunicationsMessages();
141 m_receive_local_ids.resize(m_exchanger->nbReceiver());
142 return r;
143}
144
145/*---------------------------------------------------------------------------*/
146/*---------------------------------------------------------------------------*/
147
148void ItemsExchangeInfo2::
149setExchangeItems(ConstArrayView< std::set<Int32> > items_to_send)
150{
151 Int32 nb_part = m_item_family->mesh()->meshPartInfo().nbPart();
152 m_send_local_ids.resize(nb_part);
153
154 for( Integer i=0, is=items_to_send.size(); i<is; ++i ){
155 Int64 n = items_to_send[i].size();
156 if (n!=0){
157 m_exchanger->addSender(i);
158 //ItemInternalList items = m_item_family->itemsInternal();
159 std::set<Int32>::const_iterator iids = items_to_send[i].begin();
160 std::set<Int32>::const_iterator ids_end = items_to_send[i].end();
161 //info() << "SEND kind=" << itemKindName(itemKind()) << " dest=" << i << " nb=" << n;
162 for( ; iids!=ids_end; ++iids ){
163 m_send_local_ids[i].add(*iids);
164 }
165 }
166 }
167}
168
169/*---------------------------------------------------------------------------*/
170/*---------------------------------------------------------------------------*/
184void ItemsExchangeInfo2::
185computeExchangeItems()
186{
187 if (m_item_family->itemKind()!=IK_Particle)
188 ARCANE_FATAL("This call is only valid for ParticleFamily. family={0}",
189 itemFamily()->name());
190
191 Int32 nb_part = m_item_family->mesh()->meshPartInfo().nbPart();
192 // Contient pour chaque sous-domaine la liste des entités à envoyer
193 m_send_local_ids.resize(nb_part);
194 // Liste des sous-domaines avec lesquels je dois communiquer.
195 VariableItemInt32& items_owner(itemFamily()->itemsNewOwner());
196
197 // Pour déterminer la liste des entités à envoyer, il suffit de comparer
198 // le champs owner() de l'entité qui contient le propriétaire de l'entité courante
199 // avec la variable itemsNewOwner() qui contient le nouveau propriétaire.
200 // Si ces deux valeurs sont différentes, l'entité doit être envoyée.
201 // ATTENTION: surtout, ne pas utiliser les ownItems(), car ceux ci sont calculés à la volée
202 // (lazy evaluation)
203 ENUMERATE_ITEM(i_item,itemFamily()->allItems()){
204 Item item = *i_item;
205 Int32 new_owner = items_owner[item];
206 Int32 current_owner = item.owner();
207 if (item.isOwn() && new_owner!=current_owner){
208 _addItemToSend(new_owner,item);
209 }
210 }
211}
212
213/*---------------------------------------------------------------------------*/
214/*---------------------------------------------------------------------------*/
215
216void ItemsExchangeInfo2::
217prepareToSend()
218{
219 info(4) << "ItemsExchangeInfo2::prepareToSend() for " << itemFamily()->name();
220 info(4) << "Number of groups to serialize: " << m_groups_serializers.size();
221
222 // Préparation des sérialiseurs de groupes
223 for(Integer i_serializer=0;i_serializer<m_groups_serializers.size(); ++i_serializer){
224 ItemGroupsSerializer2 * groups_serializer = m_groups_serializers[i_serializer];
225 if (groups_serializer->itemFamily() == itemFamily()){
226 // C'est la famille originale, donc sans transformation
227 groups_serializer->prepareData(m_send_local_ids);
228 }
229 else{
230 // C'est une sous-famille
231 UniqueArray< SharedArray<Int32> > subitems_to_send(m_send_local_ids.size());
232 for(Integer i_dest=0; i_dest<m_send_local_ids.size(); ++i_dest) {
233 ItemVector subitems = MeshToMeshTransposer::transpose(itemFamily(), groups_serializer->itemFamily(), itemFamily()->view(m_send_local_ids[i_dest]));
234 Int32Array & current_subitem_lids = subitems_to_send[i_dest];
235 ENUMERATE_ITEM(iitem, subitems)
236 if (iitem.localId() != NULL_ITEM_LOCAL_ID)
237 current_subitem_lids.add(iitem.localId());
238 }
239 groups_serializer->prepareData(subitems_to_send);
240 }
241 }
242
243 // Génère les infos pour chaque processeur à qui on va envoyer des entités
244 ItemInfoListView items_internal(itemFamily());
245 IItemFamilyCollection child_families = itemFamily()->childFamilies();
246
247 const Integer nb_send = m_exchanger->nbSender();
248 {
250 for( IItemFamilySerializeStep* step : m_serialize_steps )
251 step->notifyAction(IItemFamilySerializeStep::NotifyActionArgs(action,nb_send));
252 }
253
254 for( Integer i=0; i<nb_send; ++i ){
255 ISerializeMessage* comm = m_exchanger->messageToSend(i);
256 Int32 dest_sub_domain = comm->destination().value();
257 // Liste des localId() des entités à envoyer
258 Int32ConstArrayView dest_items_local_id = m_send_local_ids[dest_sub_domain];
259 info(5) << "Processing message to " << dest_sub_domain
260 << " for family " << itemFamily()->fullName();
261
262 ISerializer* sbuf = comm->serializer();
263
264 ItemFamilySerializeArgs serialize_args(sbuf,dest_sub_domain,dest_items_local_id,i);
265
266 // Réserve la mémoire pour la sérialisation
267 sbuf->setMode(ISerializer::ModeReserve);
268
269 // Réserve pour les items et les uids des sous-items
270 m_family_serializer->serializeItems(sbuf,dest_items_local_id);
271 m_family_serializer->serializeItemRelations(sbuf,dest_items_local_id);
272
273 // Réserve pour les uids des sous-items (calcul en doublon de MeshToMeshTransposer::transpose avec les put)
274 for( IItemFamily* child_family : child_families ) {
275 ItemVectorView dest_items(items_internal, dest_items_local_id);
276 ItemVector sub_dest_items = MeshToMeshTransposer::transpose(itemFamily(), child_family, dest_items);
277 Integer sub_dest_item_count = 0;
278 ENUMERATE_ITEM(iitem, sub_dest_items) {
279 Int32 lid = iitem.localId();
280 if (lid != NULL_ITEM_LOCAL_ID)
281 ++sub_dest_item_count;
282 }
283 sbuf->reserveInt64(1);
284 sbuf->reserveSpan(eBasicDataType::Int64,sub_dest_item_count);
285 }
286
287 _applySerializeStep(IItemFamilySerializeStep::PH_Item,serialize_args);
288
289 sbuf->reserveInteger(1); // Pour nombre magique pour serialisation des groupes
290
291 // Réserve pour les groupes
292 for(Integer i_serializer=0; i_serializer<m_groups_serializers.size(); ++i_serializer)
293 m_groups_serializers[i_serializer]->serialize(serialize_args);
294
295 _applySerializeStep(IItemFamilySerializeStep::PH_Group,serialize_args);
296
297 // Les objets suivants sont désérialisés dans readVariables()
298
299 // Réserve pour la sérialisation des variables
300 _applySerializeStep(IItemFamilySerializeStep::PH_Variable,serialize_args);
301
302 sbuf->allocateBuffer();
303
304 // Sérialise les infos
306
307 m_family_serializer->serializeItems(sbuf,dest_items_local_id);
308 m_family_serializer->serializeItemRelations(sbuf,dest_items_local_id);
309
310 // Sérialisation uids des sous-items (calcul en doublon de MeshToMeshTransposer::transpose avec les réserve)
311 for( IItemFamily* child_family : child_families ) {
312 ItemVectorView dest_items(items_internal, dest_items_local_id);
313 ItemVector sub_dest_items = MeshToMeshTransposer::transpose(itemFamily(), child_family, dest_items);
314 Int64UniqueArray sub_dest_uids;
315 sub_dest_uids.reserve(sub_dest_items.size());
316 ENUMERATE_ITEM(iitem, sub_dest_items) {
317 Int32 lid = iitem.localId();
318 if (lid != NULL_ITEM_LOCAL_ID)
319 sub_dest_uids.add(iitem->uniqueId());
320 }
321 sbuf->putInt64(sub_dest_uids.size());
322 sbuf->putSpan(sub_dest_uids);
323 }
324
325 _applySerializeStep(IItemFamilySerializeStep::PH_Item,serialize_args);
326
327 sbuf->put(GROUPS_MAGIC_NUMBER);
328
329 // Sérialise la liste des groupes
330 for(Integer i_serializer=0; i_serializer<m_groups_serializers.size(); ++i_serializer)
331 m_groups_serializers[i_serializer]->serialize(serialize_args);
332
333 _applySerializeStep(IItemFamilySerializeStep::PH_Group,serialize_args);
334
335 // Sérialise les infos pour les variables
336 _applySerializeStep(IItemFamilySerializeStep::PH_Variable,serialize_args);
337 }
338
339 {
341 for( IItemFamilySerializeStep* step : m_serialize_steps )
342 step->notifyAction(IItemFamilySerializeStep::NotifyActionArgs(action,nb_send));
343 }
344}
345
346void ItemsExchangeInfo2::
347releaseBuffer()
348{
349 for( Integer i=0, is=m_exchanger->senderRanks().size(); i<is; ++i ) {
350 ISerializeMessage* comm = m_exchanger->messageToSend(i);
351
352 ISerializer* isbuf = comm->serializer();
353 SerializeBuffer* sbuf = dynamic_cast<SerializeBuffer*>(isbuf);
354
355 if(sbuf)
356 sbuf->releaseBuffer();
357 }
358}
359
360/*---------------------------------------------------------------------------*/
361/*---------------------------------------------------------------------------*/
362
363void ItemsExchangeInfo2::
364readAndAllocItems()
365{
366 info(4) << "ItemsExchangeInfo2::readAndAllocItems() " << itemFamily()->name();
367
368 // L'organisation des boucles et du switch n'est pas ici identiques à prepareToSend,
369 // pour la lisibilité, il faudrait les rendre similaires
370
371 // Récupère les infos des mailles de chaque receveur et créé les entités.
372 for( Integer i=0, is=m_exchanger->nbReceiver(); i<is; ++i ){
373 ISerializeMessage* comm = m_exchanger->messageToReceive(i);
374 ISerializer* sbuf = comm->serializer();
375 info(5) << "Processing item message from " << comm->destination()
376 << " for family " << itemFamily()->fullName();
377 m_family_serializer->deserializeItems(sbuf,&m_receive_local_ids[i]);
378 }
379}
380
381/*---------------------------------------------------------------------------*/
382/*---------------------------------------------------------------------------*/
383
384void ItemsExchangeInfo2::
385readAndAllocSubMeshItems()
386{
387 IItemFamilyCollection child_families = itemFamily()->childFamilies();
388 for( Integer i=0, is=m_exchanger->nbReceiver(); i<is; ++i ){
389 ISerializeMessage* comm = m_exchanger->messageToReceive(i);
390 ISerializer* sbuf = comm->serializer();
391
392 for( IItemFamily* child_family : child_families ) {
393 Int64 sub_dest_item_count = sbuf->getInt64();
394 Int64UniqueArray sub_dest_uids;
395 sub_dest_uids.resize(sub_dest_item_count);
396 sbuf->getSpan(sub_dest_uids);
397 IntegerUniqueArray parent_sub_dest_lids(sub_dest_item_count);
398 itemFamily()->itemsUniqueIdToLocalId(parent_sub_dest_lids,sub_dest_uids,true);
399 ItemVectorView parent_sub_dest_items(itemFamily()->view(parent_sub_dest_lids));
400 // Hack temporaire pour trouver le sous-maillage associé
401 DynamicMesh* dn = dynamic_cast<DynamicMesh*>(child_family->mesh());
403 dn->incrementalBuilder()->addParentItems(parent_sub_dest_items, child_family->itemKind());
404 }
405 }
406
407 _applyDeserializePhase(IItemFamilySerializeStep::PH_Item);
408
409}
410
411/*---------------------------------------------------------------------------*/
412/*---------------------------------------------------------------------------*/
413
414void ItemsExchangeInfo2::
415readAndAllocItemRelations()
416{
417 info(4) << "ItemsExchangeInfo2::readAndAllocItemRelations() " << itemFamily()->name();
418
419 // L'organisation des boucles et du switch n'est pas ici identiques à prepareToSend,
420 // pour la lisibilité, il faudrait les rendre similaires
421
422 // Récupère les infos des mailles de chaque receveur et créé les entités.
423 for( Integer i=0, is=m_exchanger->nbReceiver(); i<is; ++i ){
424 ISerializeMessage* comm = m_exchanger->messageToReceive(i);
425 ISerializer* sbuf = comm->serializer();
426 info(5) << "Processing item message from " << comm->destination()
427 << " for family " << itemFamily()->fullName();
428 m_family_serializer->deserializeItemRelations(sbuf,&m_receive_local_ids[i]);
429 }
430}
431
432/*---------------------------------------------------------------------------*/
433/*---------------------------------------------------------------------------*/
434
435void ItemsExchangeInfo2::
436readGroups()
437{
438 info(4) << "ItemsExchangeInfo2::readGroups() for "
439 << m_item_family->name();
440
441 Int64UniqueArray items_in_groups_uid;
442
443 // Récupère les infos pour les groupes
444 for( Integer i=0, is=m_exchanger->nbReceiver(); i<is; ++i ){
445 ISerializeMessage* comm = m_exchanger->messageToReceive(i);
446 ISerializer* sbuf = comm->serializer();
447
448 info(4) << "Processing group message from " << comm->destination()
449 << " for family " << itemFamily()->fullName();
450
451 // Vérifie pas d'erreurs de sérialisation.
452 Integer magic_number = sbuf->getInteger();
453 if (magic_number!=GROUPS_MAGIC_NUMBER)
454 ARCANE_FATAL("Internal error: bad magic number expected={0} found={1}",
455 GROUPS_MAGIC_NUMBER,magic_number);
456
457 // Désérialise les groupes
458 for(Integer i_serializer=0; i_serializer<m_groups_serializers.size(); ++i_serializer)
459 m_groups_serializers[i_serializer]->get(sbuf,items_in_groups_uid);
460 }
461
462 _applyDeserializePhase(IItemFamilySerializeStep::PH_Group);
463}
464
465/*---------------------------------------------------------------------------*/
466/*---------------------------------------------------------------------------*/
467
468void ItemsExchangeInfo2::
469readVariables()
470{
471 info(4) << "ItemsExchangeInfo2::readVariables() for " << m_item_family->name();
472
473 // Redimensionne éventuellement les données associées aux variables.
474 // NOTE GG: normalement il me semble que c'est déjà fait lors
475 // de l'appel à DynamicMesh::_internalEndUpdateInit() dans _exchangeItemsNew()
476 // pour toutes les familles.
477 for( IItemFamily* family : m_families_to_exchange )
478 family->_internalApi()->resizeVariables(true);
479
480 _applyDeserializePhase(IItemFamilySerializeStep::PH_Variable);
481}
482
483/*---------------------------------------------------------------------------*/
484/*---------------------------------------------------------------------------*/
485
486void ItemsExchangeInfo2::
487removeSentItems()
488{
489 // NOTE: Cette méthode n'est appelée que pour les familles de particules
490 // sans fantômes.
491 IItemFamily* family = itemFamily();
492 IParticleFamily* pfamily = family->toParticleFamily();
493 if (!pfamily)
494 ARCANE_FATAL("This call is only valid for ParticleFamily. family={0}",
495 itemFamily()->name());
496 if (pfamily->getEnableGhostItems())
497 ARCANE_FATAL("This call is only valid for ParticleFamily without ghost",
498 itemFamily()->name());
499
500 info(4) << "ItemsExchangeInfo2::removeSentItems(): " << family->name();
501
502 for( Integer i=0, is=m_exchanger->nbSender(); i<is; ++i ){
503 ISerializeMessage* comm = m_exchanger->messageToSend(i);
504 Int32 dest_rank = comm->destination().value();
505 Int32ConstArrayView dest_items_local_id = m_send_local_ids[dest_rank];
506
507 ItemVectorView dest_items = family->view(dest_items_local_id);
508
509 //NOTE: (HP) Jamais testé sur des sous-maillages avec particules
510 IItemFamilyCollection child_families = itemFamily()->childFamilies();
511 for( IItemFamily* child_family : child_families){
512 ItemVector sub_dest_items = MeshToMeshTransposer::transpose(family, child_family, dest_items);
513 IParticleFamily* child_pfamily = child_family->toParticleFamily();
514 ARCANE_CHECK_POINTER(child_pfamily);
515 child_pfamily->removeParticles(sub_dest_items.view().localIds());
516 child_family->endUpdate();
517 }
518 pfamily->removeParticles(dest_items_local_id);
519 }
520 family->endUpdate(); // N'est ce pas trop fort car ca resize aussi les variables (mais ca fait aussi les groupes vs partialEndUpdate) ?
521}
522
523/*---------------------------------------------------------------------------*/
524/*---------------------------------------------------------------------------*/
525
526void ItemsExchangeInfo2::
527processExchange()
528{
529 m_exchanger->processExchange(m_exchanger_option);
530}
531
532/*---------------------------------------------------------------------------*/
533/*---------------------------------------------------------------------------*/
534
535void ItemsExchangeInfo2::
536finalizeExchange()
537{
538 for( IItemFamilySerializeStep* step : m_serialize_steps ){
539 step->finalize();
540 }
541}
542
543/*---------------------------------------------------------------------------*/
544/*---------------------------------------------------------------------------*/
545
546void ItemsExchangeInfo2::
547addSerializeStep(IItemFamilySerializeStep* step)
548{
549 m_serialize_steps.add(step);
550}
551
552/*---------------------------------------------------------------------------*/
553/*---------------------------------------------------------------------------*/
554
555void ItemsExchangeInfo2::
556_applySerializeStep(IItemFamilySerializeStep::ePhase phase,const ItemFamilySerializeArgs& args)
557{
558 for( IItemFamilySerializeStep* step : m_serialize_steps ){
559 if (step->phase()==phase)
560 step->serialize(args);
561 }
562}
563
564/*---------------------------------------------------------------------------*/
565/*---------------------------------------------------------------------------*/
566
567void ItemsExchangeInfo2::
568_applyDeserializePhase(IItemFamilySerializeStep::ePhase phase)
569{
570 for( IItemFamilySerializeStep* step : m_serialize_steps ){
571 if (step->phase()!=phase)
572 continue;
573
574 Integer nb_receive = m_exchanger->nbReceiver();
575 {
576 auto action = IItemFamilySerializeStep::eAction::AC_BeginReceive;
577 step->notifyAction(IItemFamilySerializeStep::NotifyActionArgs(action,nb_receive));
578 }
579 for( Integer i=0; i<nb_receive; ++i ){
580 ISerializeMessage* comm = m_exchanger->messageToReceive(i);
581 ISerializer* sbuf = comm->serializer();
582 Int32ConstArrayView local_ids = m_receive_local_ids[i].view();
583 ItemFamilySerializeArgs serialize_args(sbuf,comm->destination().value(),local_ids,i);
584 step->serialize(serialize_args);
585 }
586 {
587 auto action = IItemFamilySerializeStep::eAction::AC_EndReceive;
588 step->notifyAction(IItemFamilySerializeStep::NotifyActionArgs(action,nb_receive));
589 }
590 }
591}
592
593/*---------------------------------------------------------------------------*/
594/*---------------------------------------------------------------------------*/
595
596void ItemsExchangeInfo2::
597setParallelExchangerOption(const ParallelExchangerOptions& option)
598{
599 m_exchanger_option = option;
600 m_exchanger->setVerbosityLevel(option.verbosityLevel());
601}
602
603/*---------------------------------------------------------------------------*/
604/*---------------------------------------------------------------------------*/
605
606} // End namespace Arcane::mesh
607
608/*---------------------------------------------------------------------------*/
609/*---------------------------------------------------------------------------*/
610
#define ARCANE_CHECK_POINTER(ptr)
Macro retournant le pointeur ptr s'il est non nul ou lancant une exception s'il est nul.
#define ARCANE_FATAL(...)
Macro envoyant une exception FatalErrorException.
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 resize(Int64 s)
Change le nombre d'éléments du tableau à s.
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.
Vue constante d'un tableau de type T.
Interface d'une étape de la sérialisation des familles d'entités.
virtual void notifyAction(const NotifyActionArgs &args)=0
Notifie l'instance qu'on entre dans une certaine phase de l'échange.
virtual ePhase phase() const =0
Phase de la sérialisation où cette instance intervient.
@ AC_EndPrepareSend
Fin de la préparation de l'envoie.
@ AC_BeginPrepareSend
Début de la préparation de l'envoie.
virtual void serialize(const ItemFamilySerializeArgs &args)=0
Sérialise dans/depuis buf.
Interface d'une famille d'entités.
Definition IItemFamily.h:84
virtual IParticleFamily * toParticleFamily()=0
Retourne l'interface de la famille de particule de cette famille.
virtual String name() const =0
Nom de la famille.
virtual ItemVectorView view(Int32ConstArrayView local_ids)=0
Vue sur les entités.
virtual void endUpdate()=0
Notifie la fin de modification de la liste des entités.
Interface d'une famille de particules.
virtual bool getEnableGhostItems() const =0
récupère le flag pour gérer les particules ghost de la famille
virtual Integer getInteger()=0
Récupère une taille.
@ ModePut
Le sérialiseur attend des reserve()
virtual Int64 getInt64()=0
Récupère une taille.
virtual void allocateBuffer()=0
Alloue la mémoire du sérialiseur.
virtual void put(Span< const Real > values)=0
Ajoute le tableau values.
virtual void putSpan(Span< const Real > values)
Ajoute le tableau values.
virtual void getSpan(Span< Real > values)
Récupère le tableau values.
virtual void reserveSpan(eBasicDataType dt, Int64 n)=0
Réserve de la mémoire pour n valeurs de dt.
virtual void setMode(eMode new_mode)=0
Positionne le fonctionnement actuel.
virtual void putInt64(Int64 value)=0
Ajoute l'entier value.
Arguments des callbacks de sérialisation des familles d'entités.
Sérialise les entités des groupes.
Vue sur une liste pour obtenir des informations sur les entités.
Vue sur un vecteur d'entités.
Int32ConstArrayView localIds() const
Tableau des numéros locaux des entités.
Vecteur d'entités.
Definition ItemVector.h:59
ItemVectorView view() const
Vue sur le vecteur.
Definition ItemVector.h:114
Int32 size() const
Nombre d'éléments du vecteur.
Definition ItemVector.h:105
Classe de base d'un élément de maillage.
Definition Item.h:83
bool isOwn() const
true si l'entité est appartient au sous-domaine
Definition Item.h:253
Int32 owner() const
Numéro du sous-domaine propriétaire de l'entité
Definition Item.h:238
static ItemVector transpose(IMesh *meshA, IMesh *meshB, ItemVectorView itemsA, bool do_fatal=false)
Transpose itemsA from meshB to items on meshB.
Interface d'un message de sérialisation entre IMessagePassingMng.
virtual MessageRank destination() const =0
Rang du destinataire (si isSend() est vrai) ou de l'envoyeur.
virtual ISerializer * serializer()=0
Sérialiseur.
Int32 value() const
Valeur du rang.
Definition MessageRank.h:72
Options pour IParallelMng::processExchange().
Int32 verbosityLevel() const
Niveau de verbosité
void setVerbosityLevel(Int32 v)
Positionne le niveau de verbosité
Implémentation d'un tampon pour la sérialisation.
TraceMessage info() const
Flot pour un message d'information.
Vecteur 1D de données avec sémantique par valeur (style STL).
void addParentItems(const ItemVectorView &items, const eItemKind submesh_kind)
Ajout au maillage courant d'item venant d'un maillage parent.
Implémentation d'un maillage.
Definition DynamicMesh.h:97
UniqueArray< ItemGroupsSerializer2 * > m_groups_serializers
Sérialiseur des groupes.
UniqueArray< IItemFamily * > m_families_to_exchange
Liste des familles intégrées à l'échange.
UniqueArray< SharedArray< Int32 > > m_receive_local_ids
Liste des numéros locaux des entités reçues.
UniqueArray< SharedArray< Int32 > > m_send_local_ids
Liste des entités à envoyer à chaque processeur.
IItemFamily * itemFamily() override
Famille associée.
ItemVariableScalarRefT< Int32 > VariableItemInt32
Grandeur de type entier 32 bits.
Ref< IParallelExchanger > createExchangerRef(IParallelMng *pm)
Retourne une interface pour transférer des messages entre rangs.
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
UniqueArray< Int64 > Int64UniqueArray
Tableau dynamique à une dimension d'entiers 64 bits.
Definition UtilsTypes.h:426
std::int64_t Int64
Type entier signé sur 64 bits.
Int32 Integer
Type représentant un entier.
ConstArrayView< Int32 > Int32ConstArrayView
Equivalent C d'un tableau à une dimension d'entiers 32 bits.
Definition UtilsTypes.h:569
Collection< IItemFamily * > IItemFamilyCollection
Collection de familles d'entités.
@ IK_Particle
Entité de maillage de genre particule.
ARCCORE_SERIALIZE_EXPORT Ref< ISerializer > createSerializer()
Créé une instance de ISerializer.
Array< Int32 > Int32Array
Tableau dynamique à une dimension d'entiers 32 bits.
Definition UtilsTypes.h:214
UniqueArray< Integer > IntegerUniqueArray
Tableau dynamique à une dimension d'entiers.
Definition UtilsTypes.h:434
std::int32_t Int32
Type entier signé sur 32 bits.