Arcane  v3.16.0.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
HybridParallelMng.h
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/* HybridParallelMng.h (C) 2000-2024 */
9/* */
10/* Implémentation des messages hybrides MPI/Mémoire partagée. */
11/*---------------------------------------------------------------------------*/
12#ifndef ARCANE_PARALLEL_THREAD_HYBRIDPARALLELMNG_H
13#define ARCANE_PARALLEL_THREAD_HYBRIDPARALLELMNG_H
14/*---------------------------------------------------------------------------*/
15/*---------------------------------------------------------------------------*/
16
17#include "arcane/utils/NotImplementedException.h"
18#include "arcane/utils/Array.h"
19#include "arcane/utils/Ref.h"
20
21#include "arcane/ParallelMngDispatcher.h"
22
23/*---------------------------------------------------------------------------*/
24/*---------------------------------------------------------------------------*/
25
26namespace Arcane
27{
28class SerializeBuffer;
29class MpiParallelMng;
30}
31
33{
39
40/*---------------------------------------------------------------------------*/
41/*---------------------------------------------------------------------------*/
46{
47 public:
48 Int32 local_rank = -1;
49 Int32 local_nb_rank = -1;
50 MpiParallelMng* mpi_parallel_mng = nullptr;
51 ITraceMng* trace_mng = nullptr;
52 IThreadMng* thread_mng = nullptr;
53 IParallelMng* world_parallel_mng = nullptr;
54 ISharedMemoryMessageQueue* message_queue = nullptr;
55 IThreadBarrier* thread_barrier = nullptr;
56 Array<HybridParallelMng*>* parallel_mng_list = nullptr;
57 MpiThreadAllDispatcher* all_dispatchers = nullptr;
58 IParallelMngContainerFactory* sub_builder_factory = nullptr;
60};
61
62/*---------------------------------------------------------------------------*/
63/*---------------------------------------------------------------------------*/
67class HybridParallelMng
68: public ParallelMngDispatcher
69{
70 friend HybridSerializeMessageList;
71 class RequestList;
72
73 public:
74
75 explicit HybridParallelMng(const HybridParallelMngBuildInfo& bi);
76 ~HybridParallelMng() override;
77
78 bool isParallel() const override { return m_is_parallel; }
79 Int32 commRank() const override { return m_global_rank; }
80 Int32 commSize() const override { return m_global_nb_rank; }
81 void* getMPICommunicator() override;
82 MP::Communicator communicator() const override;
83 bool isThreadImplementation() const override { return true; }
84 bool isHybridImplementation() const override { return true; }
85 ITraceMng* traceMng() const override { return m_trace; }
86 IThreadMng* threadMng() const override { return m_thread_mng; }
87 IParallelMng* worldParallelMng() const override { return m_world_parallel_mng; }
88 IIOMng* ioMng() const override { return m_io_mng; }
89
90 void initialize() override;
91 bool isMasterIO() const override { return commRank()==0; }
92 Int32 masterIORank() const override { return 0; }
93
94 ITimerMng* timerMng() const override { return m_timer_mng; }
95
97 Ref<IParallelMng> sequentialParallelMngRef() override;
98 void sendSerializer(ISerializer* values,Int32 rank) override;
99 Request sendSerializer(ISerializer* values,Int32 rank,ByteArray& bytes) override;
101
102 void recvSerializer(ISerializer* values,Int32 rank) override;
104
105 void freeRequests(ArrayView<Request> requests) override;
106
107 void broadcastSerializer(ISerializer* values,Int32 rank) override;
108 MessageId probe(const PointToPointMessageInfo& message) override;
110 Request sendSerializer(const ISerializer* values,const PointToPointMessageInfo& message) override;
111 Request receiveSerializer(ISerializer* values,const PointToPointMessageInfo& message) override;
112
113 void printStats() override;
114 void barrier() override;
115 void waitAllRequests(ArrayView<Request> requests) override;
116
117 IParallelNonBlockingCollective* nonBlockingCollective() const override { return nullptr; }
118
119 void build() override;
120
121 public:
122
123 Int32 localRank() const { return m_local_rank; }
124 Int32 localNbRank() const { return m_local_nb_rank; }
125 MpiParallelMng* mpiParallelMng() { return m_mpi_parallel_mng; }
127 PointToPointMessageInfo buildMessage(Int32 dest,MP::eBlockingType is_blocking);
129
130 protected:
131
137 IVariableSynchronizer* createSynchronizer(const ItemGroup& group) override;
138 Parallel::IStat* stat() override { return m_stat; }
139 IParallelReplication* replication() const override;
140 void setReplication(IParallelReplication* v) override;
142 ISerializeMessageList* _createSerializeMessageList() override;
143 IParallelMng* _createSubParallelMng(Int32ConstArrayView kept_ranks) override;
146 bool _isAcceleratorAware() const override;
147
148 public:
149
150 IThreadBarrier* getThreadBarrier()
151 {
152 return m_thread_barrier;
153 }
154
155 private:
156
157 ITraceMng* m_trace;
158 IThreadMng* m_thread_mng;
159 IParallelMng* m_world_parallel_mng;
160 IIOMng* m_io_mng;
161 Ref<IParallelMng> m_sequential_parallel_mng;
162 ITimerMng* m_timer_mng;
163 IParallelReplication* m_replication;
164 HybridMessageQueue* m_message_queue;
165 bool m_is_parallel;
171 Parallel::IStat* m_stat = nullptr;
172 IThreadBarrier* m_thread_barrier = nullptr;
173 MpiParallelMng* m_mpi_parallel_mng = nullptr;
174 MpiThreadAllDispatcher* m_all_dispatchers = nullptr;
175 Array<HybridParallelMng*>* m_parallel_mng_list = nullptr;
176 IParallelMngContainerFactory* m_sub_builder_factory = nullptr;
177 Ref<IParallelMngContainer> m_parent_container_ref;
178 Ref<IParallelMngUtilsFactory> m_utils_factory;
179
180 private:
181
182 SerializeBuffer* _castSerializer(ISerializer* serializer);
183};
184
185/*---------------------------------------------------------------------------*/
186/*---------------------------------------------------------------------------*/
187
188} // End namespace Arcane::MessagePassing
189
190/*---------------------------------------------------------------------------*/
191/*---------------------------------------------------------------------------*/
192
193#endif
Vue modifiable d'un tableau d'un type T.
Tableau d'items de types quelconques.
Opérations pour accéder aux valeurs de variables d'un autre sous-domaine.
Interface du gestionnaire des entrées sorties.
Definition IIOMng.h:42
Interface d'une famille d'entités.
Definition IItemFamily.h:84
Echange d'informations entre processeurs.
Interface d'une fabrique de conteneur de 'IParallelMng'.
Interface du gestionnaire de parallélisme pour un sous-domaine.
Interface des opérations parallèles collectives non bloquantes.
Informations sur la réplication des sous-domaines en parallèle.
Informations sur la topologie d'allocation des coeurs de calcul.
Interface d'un gestionnaire de thread.
Definition IThreadMng.h:30
Interface d'un gestionnaire de timer.
Definition ITimerMng.h:53
Interface du gestionnaire de traces.
Envoie de valeurs sur différents processeurs.
Interface d'un service de synchronisation de variable.
Groupe d'entités de maillage.
Definition ItemGroup.h:49
Interface d'une file de messages avec les threads.
Implémentation de IRequestList pour HybridParallelMng.
Gestionnaire du parallélisme utilisant les threads.
bool isMasterIO() const override
true si l'instance est un gestionnaire maître des entrées/sorties.
IParallelMng * worldParallelMng() const override
Gestionnaire de parallélisme sur l'ensemble des ressources allouées.
bool isThreadImplementation() const override
Indique si l'implémentation utilise les threads.
Parallel::IStat * stat() override
Gestionnaire des statistiques.
void freeRequests(ArrayView< Request > requests) override
Libère les requêtes.
IParallelNonBlockingCollective * nonBlockingCollective() const override
Interface des opérations collectives non blocantes.
void printStats() override
Affiche des statistiques liées à ce gestionnaire du parallélisme.
IParallelExchanger * createExchanger() override
Retourne une interface pour transférer des messages entre processeurs.
void barrier() override
Effectue une barière.
MP::Communicator communicator() const override
Communicateur MPI associé à ce gestionnaire.
bool m_is_initialized
true si déjà initialisé
ISerializeMessage * createReceiveSerializer(Int32 rank) override
Créé un message non bloquant pour recevoir des données sérialisées du rang rank.
Ref< Parallel::IRequestList > createRequestListRef() override
Créé une liste de requêtes pour ce gestionnaire.
bool isParallel() const override
Retourne true si l'exécution est parallèle.
ITimerMng * timerMng() const override
Gestionnaire de timers.
void build() override
Construit l'instance.
void waitAllRequests(ArrayView< Request > requests) override
Bloque en attendant que les requêtes rvalues soient terminées.
void initialize() override
Initialise le gestionnaire du parallélisme.
IThreadMng * threadMng() const override
Gestionnaire de threads.
Int32 m_global_nb_rank
Nombre de rangs globaux.
MessageSourceInfo legacyProbe(const PointToPointMessageInfo &message) override
Sonde si des messages sont disponibles.
Int32 m_local_rank
Rang local du processeur actuel.
ITraceMng * traceMng() const override
Gestionnaire de traces.
IGetVariablesValuesParallelOperation * createGetVariablesValuesOperation() override
Retourne une opération pour récupérer les valeurs d'une variable sur les entités d'un autre sous-doma...
void * getMPICommunicator() override
Adresse du communicateur MPI associé à ce gestionnaire.
IParallelReplication * replication() const override
Informations sur la réplication.
Ref< IParallelMngUtilsFactory > _internalUtilsFactory() const override
Fabrique des fonctions utilitaires.
Int32 masterIORank() const override
Rang de l'instance gérant les entrées/sorties (pour laquelle isMasterIO() est vrai)
Ref< IParallelMng > createSubParallelMngRef(Int32ConstArrayView kept_ranks) override
Créé un nouveau gestionnaire de parallélisme pour un sous-ensemble des rangs.
IIOMng * ioMng() const override
Gestionnaire des entrées/sorties.
ITransferValuesParallelOperation * createTransferValuesOperation() override
Retourne une opération pour transférer des valeurs entre sous-domaine.
IParallelTopology * createTopology() override
Créé une instance contenant les infos sur la topologie des rangs de ce gestionnnaire.
void setReplication(IParallelReplication *v) override
Positionne les Informations sur la réplication.
IParallelMng * sequentialParallelMng() override
Retourne un gestionnaire de parallélisme séquentiel.
Int32 commSize() const override
Nombre d'instance dans le communicateur.
bool isHybridImplementation() const override
Indique si l'implémentation utilise le mode hybride.
IVariableSynchronizer * createSynchronizer(IItemFamily *family) override
Retourne une interface pour synchroniser des variables sur le groupe de la famille family.
Int32 m_local_nb_rank
Nombre de rang locaux.
MessageId probe(const PointToPointMessageInfo &message) override
Sonde si des messages sont disponibles.
ISerializeMessage * createSendSerializer(Int32 rank) override
Créé un message non bloquant pour envoyer des données sérialisées au rang rank.
Int32 commRank() const override
Rang de cette instance dans le communicateur.
Int32 m_global_rank
Numéro du processeur actuel.
PointToPointMessageInfo buildMessage(Int32 dest, MP::eBlockingType is_blocking)
Construit un message avec pour destinataire dest.
Interface d'un message de sérialisation entre IMessagePassingMng.
Interface d'une file de messages avec les threads.
Informations sur la source d'un message.
Informations pour envoyer/recevoir un message point à point.
Requête d'un message.
Definition Request.h:77
Gestionnaire du parallélisme utilisant MPI.
Statistiques sur le parallélisme.
Référence à une instance.
Implémentation d'un tampon pour la sérialisation.
Déclarations des types et méthodes utilisés par les mécanismes d'échange de messages.
Definition Parallel.h:50
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
Array< Byte > ByteArray
Tableau dynamique à une dimension de caractères.
Definition UtilsTypes.h:208
ConstArrayView< Int32 > Int32ConstArrayView
Equivalent C d'un tableau à une dimension d'entiers 32 bits.
Definition UtilsTypes.h:569
std::int32_t Int32
Type entier signé sur 32 bits.
Infos pour construire un HybridParallelMng.