14#include "arcane/utils/PlatformUtils.h"
15#include "arcane/utils/ScopedPtr.h"
16#include "arcane/utils/ITraceMng.h"
17#include "arcane/utils/OStringStream.h"
19#include "arcane/mesh/DynamicMesh.h"
20#include "arcane/mesh/EdgeUniqueIdBuilder.h"
21#include "arcane/mesh/GhostLayerBuilder.h"
22#include "arcane/mesh/OneMeshItemAdder.h"
23#include "arcane/mesh/ItemsOwnerBuilder.h"
25#include "arcane/core/IParallelExchanger.h"
26#include "arcane/core/IParallelMng.h"
27#include "arcane/core/ISerializeMessage.h"
28#include "arcane/core/ISerializer.h"
29#include "arcane/core/ParallelMngUtils.h"
30#include "arcane/core/IMeshUniqueIdMng.h"
46, m_mesh(mesh_builder->
mesh())
47, m_mesh_builder(mesh_builder)
57void EdgeUniqueIdBuilder::
58computeEdgesUniqueIds()
64 info() <<
"Using version=" << edge_version <<
" to compute edges unique ids"
65 <<
" mesh=" << m_mesh->
name();
66 bool has_renumbering =
true;
67 if (edge_version == 1)
68 _computeEdgesUniqueIdsParallel3();
69 else if (edge_version == 2)
70 _computeEdgesUniqueIdsParallelV2();
71 else if (edge_version == 3)
72 _computeEdgesUniqueIdsParallel64bit();
73 else if (edge_version == 0) {
74 has_renumbering =
false;
75 info() <<
"No renumbering for edges";
78 ARCANE_FATAL(
"Invalid valid version '{0}'. Valid values are 0, 1, 2 or 3");
81 Real diff =
static_cast<Real>(end_time - begin_time);
82 info() <<
"TIME to compute edge unique ids=" << diff;
84 ItemInternalMap& edges_map = m_mesh->edgesMap();
91 if (m_mesh_builder->isVerbose()) {
92 info() <<
"NEW EDGES_MAP after re-indexing";
93 edges_map.eachItem([&](
Item edge) {
100 if (!has_renumbering) {
101 ItemsOwnerBuilder owner_builder(m_mesh);
102 owner_builder.computeEdgesOwner();
122 , m_nb_back_edge(nb_back_edge)
123 , m_nb_true_boundary_edge(nb_true_boundary_edge)
128 : m_unique_id(NULL_ITEM_ID)
130 , m_nb_true_boundary_edge(0)
136 bool operator<(
const T_CellEdgeInfo& ci)
const
138 return m_unique_id < ci.m_unique_id;
144 Int64 m_nb_back_edge;
145 Int64 m_nb_true_boundary_edge;
148template <
typename DataType>
149class ItemInfoMultiList
158 MyInfo(
const DataType& d,
Integer n)
172 : m_last_index(5000, true)
177 void add(
Int64 node_uid,
const DataType& data)
179 Integer current_index = m_values.size();
184 m_values.add(MyInfo(data, d->value()));
185 d->value() = current_index;
197class Parallel3EdgeUniqueIdBuilder
200 using BoundaryInfosMap = std::unordered_map<Int32, SharedArray<Int64>>;
216 const Int32 m_my_rank = A_NULL_RANK;
217 const Int32 m_nb_rank = A_NULL_RANK;
218 BoundaryInfosMap m_boundary_infos_to_send;
220 std::unordered_map<Int64, SharedArray<Int64>> m_nodes_info;
222 bool m_is_verbose =
false;
227 void _addEdgeBoundaryInfo(
Edge edge);
228 void _computeEdgesUniqueId();
229 void _sendInfosToOtherRanks();
235Parallel3EdgeUniqueIdBuilder::
238, m_mesh(mesh_builder->
mesh())
239, m_mesh_builder(mesh_builder)
240, m_parallel_mng(m_mesh->parallelMng())
241, m_my_rank(m_parallel_mng->commRank())
242, m_nb_rank(m_parallel_mng->commSize())
243, m_uid_to_subdomain_converter(max_node_uid, m_nb_rank)
244, m_is_verbose(m_mesh_builder->isVerbose())
257 for (
const auto& [key, value] : m_boundary_infos_to_send) {
268 s->
setMode(ISerializer::ModeReserve);
279 debug() <<
"END EXCHANGE";
285void Parallel3EdgeUniqueIdBuilder::
286_addEdgeBoundaryInfo(
Edge edge)
291 Int32 dest_rank = -1;
292 if (!m_is_boundary_nodes[first_node.
localId()]) {
293 v = m_nodes_info[first_node_uid];
296 dest_rank = m_uid_to_subdomain_converter.uidToRank(first_node_uid);
297 v = m_boundary_infos_to_send[dest_rank];
299 v.
add(first_node_uid);
303 v.
add(NULL_ITEM_UNIQUE_ID);
304 v.
add(NULL_ITEM_UNIQUE_ID);
307 <<
" n0=" << ItemPrinter(edge.
node(0)) <<
" n1=" << ItemPrinter(edge.
node(1)) <<
" dest_rank=" << dest_rank;
308 for (Node edge_node : edge.
nodes())
309 v.
add(edge_node.uniqueId());
333 Integer nb_local_edge = m_mesh_builder->oneMeshItemAdder()->nbEdge();
334 info() <<
"ComputeEdgesUniqueIdsParallel3 nb_edge=" << nb_local_edge;
337 edges_opposite_cell_uid.
fill(NULL_ITEM_ID);
345 edges_new_uid.
fill(NULL_ITEM_UNIQUE_ID);
370 m_is_boundary_nodes.resize(node_family->
maxLocalId(),
false);
377 if (face_nb_cell == 1) {
379 m_is_boundary_nodes[ilid] =
true;
392 const bool is_new_item_map_impl = ItemInternalMap::UseNewImpl;
393 if (is_new_item_map_impl) {
394 info() <<
"Edge: ItemInternalMap is using new implementation";
400 _addEdgeBoundaryInfo(edge);
405 _addEdgeBoundaryInfo(edge);
409 _computeEdgesUniqueId();
410 _sendInfosToOtherRanks();
414 info() <<
"END OF TEST NEW EDGE COMPUTE";
420void Parallel3EdgeUniqueIdBuilder::
421_computeEdgesUniqueId()
428 Integer nb_receiver = exchanger->nbReceiver();
429 debug() <<
"NB RECEIVER=" << nb_receiver;
431 for (
Integer i = 0; i < nb_receiver; ++i) {
438 received_infos.
resize(nb_info);
443 while (z < nb_info) {
444 Int64 node_uid = received_infos[z + 0];
447 Int32 edge_type = (
Int32)received_infos[z + 3];
465 for (
const auto& [key, value] : m_nodes_info) {
472 while (z < nb_info) {
480 ItemTypeInfo* itt = itm->
typeFromId(edge_type);
489 my_max_edge_node =
math::max(node_nb_edge, my_max_edge_node);
492 debug() <<
"GLOBAL MAX EDGE NODE=" << global_max_edge_node;
495 m_boundary_infos_to_send.
clear();
497 for (
const auto& [key, value] : m_nodes_info) {
503 while (z < nb_info) {
504 Int64 node_uid = a[z + 0];
506 Int64 edge_uid = a[z + 2];
510 ItemTypeInfo* itt = itm->
typeFromId(edge_type);
514 Integer edge_index = node_nb_edge;
515 Int32 edge_new_owner = sender_rank;
516 for (
Integer y = 0; y < node_nb_edge; ++y) {
517 if (memcmp(&a[indexes[y] + 6], &a[z + 6],
sizeof(
Int64) * edge_nb_node) == 0) {
519 edge_new_owner = (
Int32)a[indexes[y] + 1];
522 Int64 edge_new_uid = (node_uid * global_max_edge_node) + edge_index;
523 Int64Array& v = m_boundary_infos_to_send[sender_rank];
527 v.add(edge_new_owner);
537 my_max_edge_node =
math::max(node_nb_edge, my_max_edge_node);
544void Parallel3EdgeUniqueIdBuilder::
545_sendInfosToOtherRanks()
547 const bool is_verbose = m_mesh_builder->isVerbose();
548 IParallelMng* pm = m_parallel_mng;
553 ItemInternalMap& edges_map = m_mesh->edgesMap();
554 Integer nb_receiver = exchanger->nbReceiver();
555 debug() <<
"NB RECEIVER=" << nb_receiver;
557 for (
Integer i = 0; i < nb_receiver; ++i) {
558 ISerializeMessage* sm = exchanger->messageToReceive(i);
560 ISerializer* s = sm->serializer();
562 Int64 nb_info = s->getInt64();
564 info() <<
"RECEIVE NB_INFO=" << nb_info <<
" from=" << orig_rank;
565 received_infos.resize(nb_info);
566 s->getSpan(received_infos);
567 if ((nb_info % 3) != 0)
568 ARCANE_FATAL(
"info size can not be divided by 3 x={0}", nb_info);
569 Int64 nb_item = nb_info / 3;
570 for (
Int64 z = 0; z < nb_item; ++z) {
571 Int64 old_uid = received_infos[(z * 3)];
572 Int64 new_uid = received_infos[(z * 3) + 1];
573 Int32 new_owner =
static_cast<Int32>(received_infos[(z * 3) + 2]);
575 impl::MutableItemBase iedge(edges_map.tryFind(old_uid));
578 iedge.setUniqueId(new_uid);
579 iedge.setOwner(new_owner, m_my_rank);
582 info() <<
"SetEdgeOwner uid=" << new_uid <<
" owner=" << new_owner
584 <<
" n0=" << ItemPrinter(edge.
node(0)) <<
" n1=" << ItemPrinter(edge.
node(1));
599 bool is_verbose = m_mesh_builder->isVerbose();
600 Integer nb_cell = m_mesh_builder->oneMeshItemAdder()->nbCell();
609 if (cell_uid>max_uid)
612 info() <<
"Max uid=" << max_uid;
620 Integer nb_true_boundary_edge = 0;
621 for(
Edge edge : cell.edges()){
624 else if (edge.
nbCell()==1){
625 ++nb_true_boundary_edge;
628 cell_nb_num_back_edge[cell_uid] = nb_num_back_edge;
629 cell_true_boundary_edge[cell_uid] = nb_true_boundary_edge;
633 for(
Integer i=0; i<nb_cell; ++i ){
634 cell_first_edge_uid[i] = current_edge_uid;
635 current_edge_uid += cell_nb_num_back_edge[i] + cell_true_boundary_edge[i];
639 for(
Integer i=0; i<nb_cell; ++i ){
640 info() <<
"Recv: Cell EdgeInfo celluid=" << i
641 <<
" firstedgeuid=" << cell_first_edge_uid[i]
642 <<
" nbback=" << cell_nb_num_back_edge[i]
643 <<
" nbbound=" << cell_true_boundary_edge[i];
650 Integer nb_true_boundary_edge = 0;
651 for(
Edge edge : cell.edges() ){
652 Int64 edge_new_uid = NULL_ITEM_UNIQUE_ID;
655 edge_new_uid = cell_first_edge_uid[cell_uid] + nb_num_back_edge;
658 else if (edge.
nbCell()==1){
659 edge_new_uid = cell_first_edge_uid[cell_uid] + cell_nb_num_back_edge[cell_uid] + nb_true_boundary_edge;
660 ++nb_true_boundary_edge;
662 if (edge_new_uid!=NULL_ITEM_UNIQUE_ID){
676 Int64 opposite_cell_uid = NULL_ITEM_UNIQUE_ID;
677 bool true_boundary =
false;
678 bool internal_other =
false;
681 else if (edge.
nbCell()==1){
682 true_boundary =
true;
685 internal_other =
true;
688 ostr() <<
"NEW LOCAL ID FOR CELLEDGE " << cell_uid <<
' '
689 << index <<
' ' << edge.
uniqueId() <<
" (";
691 ostr() <<
' ' << node.uniqueId();
695 ostr() <<
" internal-other";
697 ostr() <<
" true-boundary";
698 if (opposite_cell_uid!=NULL_ITEM_ID)
699 ostr() <<
" opposite " << opposite_cell_uid;
704 info() << ostr.str();
711void EdgeUniqueIdBuilder::
712_computeEdgesUniqueIdsParallelV2()
733 if (total_max_uid>INT32_MAX)
734 ARCANE_FATAL(
"Max uniqueId() for node is too big v={0} max_allowed={1}",total_max_uid,INT32_MAX);
738 Node node1{edge.
node(1)};
739 Int64 new_uid = (node0.uniqueId().asInt64() * total_max_uid) + node1.
uniqueId().asInt64();
747void EdgeUniqueIdBuilder::
748_computeEdgesUniqueIdsParallel3()
750 IParallelMng* pm = m_mesh->parallelMng();
751 ItemInternalMap& nodes_map = m_mesh->nodesMap();
754 Int64 my_max_node_uid = NULL_ITEM_UNIQUE_ID;
756 Int64 node_uid = item.uniqueId();
757 if (node_uid > my_max_node_uid)
758 my_max_node_uid = node_uid;
761 debug() <<
"NODE_UID_INFO: MY_MAX_UID=" << my_max_node_uid
762 <<
" GLOBAL=" << global_max_node_uid;
764 Parallel3EdgeUniqueIdBuilder builder(
traceMng(), m_mesh_builder, global_max_node_uid);
771void EdgeUniqueIdBuilder::
772_computeEdgesUniqueIdsParallel64bit()
776 ItemInternalMap& edges_map = m_mesh->edgesMap();
778 std::hash<Int64> hasher;
781 Node node0{edge.node(0)};
782 Node node1{edge.node(1)};
783 size_t hash0 = hasher(node0.uniqueId().asInt64());
784 size_t hash1 = hasher(node1.uniqueId().asInt64());
785 hash0 ^= hash1 + 0x9e3779b9 + (hash0 << 6) + (hash0 >> 2);
786 Int64 new_uid = hash0 & 0x7fffffff;
787 edge.mutableItemBase().setUniqueId(new_uid);
#define ARCANE_FATAL(...)
Macro envoyant une exception FatalErrorException.
void fill(const DataType &data)
Remplissage du tableau.
void clear()
Supprime les éléments du tableau.
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.
EdgeConnectedListViewType edges() const
Liste des arêtes de la maille.
Vue constante d'un tableau de type T.
constexpr Integer size() const noexcept
Nombre d'éléments du tableau.
Int32 nbCell() const
Nombre de mailles connectées à l'arête.
Int32 nbCell() const
Nombre de mailles de la face (1 ou 2)
Table de hachage pour tableaux associatifs.
Data * lookupAdd(KeyTypeConstRef id, const ValueType &value, bool &is_add)
Recherche ou ajoute la valeur correspondant à la clé id.
bool add(KeyTypeConstRef id, const ValueType &value)
Ajoute la valeur value correspondant à la clé id.
void eachValue(const Lambda &lambda)
Applique le fonctor f à tous les éléments de la collection et utilise x->value() (de type ValueType) ...
Interface d'une famille d'entités.
virtual Int32 maxLocalId() const =0
virtual Integer edgeBuilderVersion() const =0
Version de la numérotation des arêtes.
Echange d'informations entre processeurs.
virtual void addSender(Int32 rank)=0
Ajoute un processeur à envoyer.
virtual Integer nbSender() const =0
Nombre de processeurs auquel on envoie.
virtual bool initializeCommunicationsMessages()=0
Calcule les communications.
virtual ISerializeMessage * messageToSend(Integer i)=0
Message destiné au ième processeur.
virtual void processExchange()=0
Effectue l'échange avec les options par défaut de ParallelExchangerOptions.
Interface du gestionnaire de parallélisme pour un sous-domaine.
virtual char reduce(eReduceType rt, char v)=0
Effectue la réduction de type rt sur le réel v et retourne la valeur.
virtual void barrier()=0
Effectue une barière.
Interface d'un sérialiseur.
void reserveInt64(Int64 n)
Réserve pour n Int64.
@ ModePut
Le sérialiseur attend des reserve()
@ ModeGet
Le sérialiseur attend des get()
virtual Int64 getInt64()=0
Récupère une taille.
virtual void allocateBuffer()=0
Alloue la mémoire du sérialiseur.
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.
Interface du gestionnaire de traces.
virtual void flush()=0
Flush tous les flots.
ItemUniqueId uniqueId() const
Numéro unique de l'entité
ItemBase backCell() const
Maille derrière l'entité (nullItem() si aucune)
Infos sur un type d'entité du maillage.
Integer nbLocalNode() const
Nombre de noeuds de l'entité
Gestionnaire des types d'entités d'un maillage.
ItemTypeInfo * typeFromId(Integer id) const
Type correspondant au numéro id.
Node node(Int32 i) const
i-ème noeud de l'entité
NodeConnectedListViewType nodes() const
Liste des noeuds de l'entité
NodeLocalIdView nodeIds() const
Liste des noeuds de l'entité
Classe de base d'un élément de maillage.
impl::MutableItemBase mutableItemBase() const
Partie interne modifiable de l'entité.
constexpr Int32 localId() const
Identifiant local de l'entité dans le sous-domaine du processeur.
ItemUniqueId uniqueId() const
Identifiant unique sur tous les domaines.
impl::ItemBase itemBase() const
Partie interne de l'entité.
Int16 type() const
Type de l'entité
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.
Flot de sortie lié à une String.
Référence à une instance.
Vecteur 1D de données avec sémantique par référence.
Classe d'accès aux traces.
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 info() const
Flot pour un message d'information.
ITraceMng * traceMng() const
Gestionnaire de trace.
Vecteur 1D de données avec sémantique par valeur (style STL).
Construction d'un maillage de manière incrémentale.
Implémentation d'un maillage.
IParallelMng * parallelMng() override
Gestionnaire de parallèlisme.
String name() const override
Nom du maillage.
ItemTypeMng * itemTypeMng() const override
Gestionnaire de types d'entités associé
IMeshUniqueIdMng * meshUniqueIdMng() const override
Gestionnare de la numérotation des identifiants uniques.
EdgeUniqueIdBuilder(DynamicMeshIncrementalBuilder *mesh_builder)
Construit une instance pour le maillage mesh.
void _computeEdgesUniqueIdsSequential()
Calcul les numéros uniques de chaque edge en séquentiel.
Tableau associatif de ItemInternal.
void notifyUniqueIdsChanged()
Notifie que les numéros uniques des entités ont changés.
void eachItem(const Lambda &lambda)
Fonction template pour itérer sur les entités de l'instance.
void _exchangeData(IParallelExchanger *exchanger)
void compute()
Calcule les numéros uniques de chaque edge en parallèle.
T max(const T &a, const T &b, const T &c)
Retourne le maximum de trois éléments.
@ ReduceMax
Maximum des valeurs.
Ref< IParallelExchanger > createExchangerRef(IParallelMng *pm)
Retourne une interface pour transférer des messages entre rangs.
Array< Int64 > Int64Array
Tableau dynamique à une dimension d'entiers 64 bits.
UniqueArray< Int64 > Int64UniqueArray
Tableau dynamique à une dimension d'entiers 64 bits.
std::int64_t Int64
Type entier signé sur 64 bits.
Int32 Integer
Type représentant un entier.
@ Int64
Donnée de type entier 64 bits.
ConstArrayView< Int64 > Int64ConstArrayView
Equivalent C d'un tableau à une dimension d'entiers 64 bits.
UniqueArray< Int32 > Int32UniqueArray
Tableau dynamique à une dimension d'entiers 32 bits.
double Real
Type représentant un réel.
UniqueArray< Integer > IntegerUniqueArray
Tableau dynamique à une dimension d'entiers.
std::int32_t Int32
Type entier signé sur 32 bits.