14#include "arccore/base/ReferenceCounter.h"
16#include "arccore/message_passing/PointToPointMessageInfo.h"
18#include "arcane/utils/Collection.h"
19#include "arcane/utils/ITraceMng.h"
20#include "arcane/utils/NotImplementedException.h"
21#include "arcane/utils/Real2.h"
22#include "arcane/utils/Real2x2.h"
23#include "arcane/utils/Real3.h"
24#include "arcane/utils/Real3x3.h"
25#include "arcane/utils/HPReal.h"
26#include "arcane/utils/NullThreadMng.h"
27#include "arcane/utils/ArgumentException.h"
29#include "arcane/core/IIOMng.h"
30#include "arcane/core/ISubDomain.h"
31#include "arcane/core/IApplication.h"
32#include "arcane/core/IParallelDispatch.h"
33#include "arcane/core/ParallelMngDispatcher.h"
34#include "arcane/core/ItemGroup.h"
35#include "arcane/core/IMesh.h"
36#include "arcane/core/IItemFamily.h"
37#include "arcane/core/MeshVariable.h"
38#include "arcane/core/Timer.h"
39#include "arcane/core/FactoryService.h"
40#include "arcane/core/AbstractService.h"
41#include "arcane/core/ISerializer.h"
42#include "arcane/core/internal/SerializeMessage.h"
44#include "arcane/parallel/IStat.h"
46#include "arcane/impl/TimerMng.h"
47#include "arcane/impl/GetVariablesValuesParallelOperation.h"
48#include "arcane/impl/ParallelExchanger.h"
49#include "arcane/impl/ParallelTopology.h"
50#include "arcane/impl/ParallelReplication.h"
51#include "arcane/impl/SequentialParallelSuperMng.h"
52#include "arcane/impl/SequentialParallelMng.h"
53#include "arcane/impl/internal/ParallelMngUtilsFactoryBase.h"
54#include "arcane/impl/internal/VariableSynchronizer.h"
56#include "arccore/message_passing/RequestListBase.h"
57#include "arccore/message_passing/SerializeMessageList.h"
78:
public RequestListBase
83 ARCANE_UNUSED(wait_mode);
93class SequentialParallelDispatchT
102 SequentialParallelDispatchT(
ITraceMng* tm)
104 void finalize()
override {}
108 ARCANE_UNUSED(send_buf);
113 ARCANE_UNUSED(send_buf);
118 recv_buf.
copy(send_buf);
122 recv_buf.
copy(send_buf);
127 recv_buf.
copy(send_buf);
132 recv_buf.
copy(send_buf);
137 recv_buf.
copy(send_buf);
142 recv_buf.
copy(send_buf);
146 gatherVariable(send_buf,recv_buf,0);
150 gatherVariable(send_buf,recv_buf,0);
155 recv_buf.resize(send_buf.
size());
162 recv_buf.resize(send_buf.
size());
168 ARCANE_UNUSED(count);
169 recv_buf.
copy(send_buf);
173 ARCANE_UNUSED(count);
174 recv_buf.
copy(send_buf);
183 ARCANE_UNUSED(send_count);
184 ARCANE_UNUSED(recv_count);
185 ARCANE_UNUSED(send_index);
186 ARCANE_UNUSED(recv_index);
187 recv_buf.
copy(send_buf);
196 ARCANE_UNUSED(send_count);
197 ARCANE_UNUSED(recv_count);
198 ARCANE_UNUSED(send_index);
199 ARCANE_UNUSED(recv_index);
200 recv_buf.
copy(send_buf);
208 ARCANE_UNUSED(send_buffer);
214 Request send(
Span<const Type> send_buffer,
const PointToPointMessageInfo& message)
override
216 ARCANE_UNUSED(send_buffer);
223 return receive(
Span<Type>(recv_buffer),rank,is_blocked);
227 ARCANE_UNUSED(send_buffer);
233 ARCANE_UNUSED(recv_buffer);
237 Request receive(
Span<Type> recv_buffer,
Int32 rank,
bool is_blocked)
override
239 ARCANE_UNUSED(recv_buffer);
245 Request receive(
Span<Type> recv_buffer,
const PointToPointMessageInfo& message)
override
247 ARCANE_UNUSED(recv_buffer);
255 recv_buffer.
copy(send_buffer);
257 Type allReduce(eReduceType op,
Type v)
override
265 ARCANE_UNUSED(send_buf);
267 void allReduce(eReduceType op,
Span<Type> send_buf)
override
270 ARCANE_UNUSED(send_buf);
275 ARCANE_UNUSED(send_buf);
276 ARCANE_UNUSED(recv_buf);
281 recv_buf.
copy(send_buf);
286 ARCANE_UNUSED(send_buf);
293 recv_buf.
copy(send_buf);
298 ARCANE_UNUSED(count);
299 recv_buf.
copy(send_buf);
306 ARCANE_UNUSED(send_count);
307 ARCANE_UNUSED(recv_count);
308 ARCANE_UNUSED(send_index);
309 ARCANE_UNUSED(recv_index);
310 recv_buf.
copy(send_buf);
313 Type scan(eReduceType op,
Type v)
override
321 ARCANE_UNUSED(send_buf);
325 Int32& max_rank)
override
327 min_val = max_val = sum_val = val;
328 min_rank = max_rank = 0;
339 min_values[i] = max_values[i] = sum_values[i] = values[i];
340 min_ranks[i] = max_ranks[i] = 0;
363 return makeRef(createNullVariableSynchronizer(pm,group));
375class SequentialParallelMng
376:
public ParallelMngDispatcher
382 ~SequentialParallelMng();
391 void setBaseObject(
IBase* m);
406 recv_serializer->
copy(send_serializer);
410 ARCANE_UNUSED(values);
415 ARCANE_UNUSED(values);
417 ARCANE_UNUSED(bytes);
427 ARCANE_UNUSED(values);
436 void broadcastString(
String& str,
Int32 rank)
override
443 ARCANE_UNUSED(bytes);
448 ARCANE_UNUSED(values);
453 ARCANE_UNUSED(message);
458 ARCANE_UNUSED(message);
463 ARCANE_UNUSED(values);
464 ARCANE_UNUSED(message);
469 ARCANE_UNUSED(values);
470 ARCANE_UNUSED(message);
476 ARCANE_UNUSED(messages);
480 ARCANE_UNUSED(requests);
491 ARCANE_UNUSED(requests);
497 ARCANE_UNUSED(requests);
530 return createNullVariableSynchronizer(
this,family->
allItems());
534 return createNullVariableSynchronizer(
this,group);
545 return m_replication;
550 delete m_replication;
562 return m_utils_factory;
570 void build()
override;
595 ARCANE_UNUSED(kept_ranks);
596 SequentialParallelMngBuildInfo bi(m_timer_mng,m_world_parallel_mng);
597 bi.setThreadMng(m_thread_mng);
598 bi.setTraceMng(m_trace.get());
599 bi.setCommunicator(m_communicator);
605 ReferenceCounter<ITraceMng> m_trace;
606 IThreadMng* m_thread_mng =
nullptr;
607 ITimerMng* m_timer_mng =
nullptr;
608 IParallelMng* m_world_parallel_mng =
nullptr;
610 Parallel::IStat* m_stat;
611 IParallelReplication* m_replication;
612 MP::Communicator m_communicator;
613 Ref<IParallelMngUtilsFactory> m_utils_factory;
631 return SequentialParallelMng::create(bi);
636 return SequentialParallelMng::createRef(bi);
642SequentialParallelMng::
645, m_trace(bi.traceMng())
646, m_thread_mng(bi.threadMng())
647, m_timer_mng(bi.m_timer_mng)
648, m_world_parallel_mng(bi.m_world_parallel_mng)
652, m_communicator(bi.communicator())
655 ARCANE_CHECK_PTR(m_trace);
656 ARCANE_CHECK_PTR(m_thread_mng);
657 if (!m_world_parallel_mng)
658 m_world_parallel_mng =
this;
660 _messagePassingMng()->setCommunicator(m_communicator);
666SequentialParallelMng::
667~SequentialParallelMng()
670 delete m_replication;
677void SequentialParallelMng::
678setBaseObject(
IBase* sd)
692 DispatchCreator(ITraceMng* tm) : m_tm(tm){}
694 template<
typename DataType> SequentialParallelDispatchT<DataType>*
697 return new SequentialParallelDispatchT<DataType>(m_tm);
706 m_io_mng = arcaneCreateIOMng(
this);
707 DispatchCreator creator(m_trace.get());
708 this->createDispatchers(creator);
727SequentialParallelSuperMng::
730, m_application(sbi.application())
732, m_timer_mng(nullptr)
740SequentialParallelSuperMng::
743, m_application(sbi.application())
745, m_timer_mng(nullptr)
746, m_communicator(comm)
754SequentialParallelSuperMng::
755~SequentialParallelSuperMng()
772 _setDispatchers(c,i32,i64,r);
783 m_timer_mng = m_owned_timer_mng.get();
800 return SequentialParallelMng::createRef(bi);
820class SequentialParallelMngBuilder
827 ~SequentialParallelMngBuilder()
override
856 bi.setThreadMng(m_thread_mng);
857 bi.setCommunicator(m_communicator);
858 return arcaneCreateSequentialParallelMngRef(bi);
864class SequentialParallelMngContainerFactory
875 ARCANE_UNUSED(nb_rank);
#define ARCANE_THROW(exception_class,...)
Macro pour envoyer une exception avec formattage.
#define ARCANE_SERVICE_INTERFACE(ainterface)
Macro pour déclarer une interface lors de l'enregistrement d'un service.
#define ARCANE_REGISTER_APPLICATION_FACTORY(aclass, ainterface, aname)
Enregistre un service de fabrique pour la classe aclass.
Classe de base d'un service.
AbstractService(const ServiceBuildInfo &)
Constructeur à partir d'un ServiceBuildInfo.
Exception lorsqu'un argument est invalide.
Vue modifiable d'un tableau d'un type T.
void copy(const U ©_array)
Recopie le tableau copy_array dans l'instance.
constexpr Integer size() const noexcept
Retourne la taille du tableau.
Tableau d'items de types quelconques.
Vue constante d'un tableau de type T.
constexpr Integer size() const noexcept
Nombre d'éléments du tableau.
Opérations pour accéder aux valeurs de variables d'un autre sous-domaine.
Interface de l'application.
Interface de la classe de base des objets principaux arcane.
virtual ITraceMng * traceMng() const =0
Gestionnaire de traces.
Opérations pour accéder aux valeurs de variables d'un autre sous-domaine.
Interface du gestionnaire des entrées sorties.
Interface d'une famille d'entités.
virtual ItemGroup allItems() const =0
Groupe de toutes les entités.
Gestion des messages parallèles pour le type Type.
Echange d'informations entre processeurs.
Interface d'une fabrique de conteneur de 'IParallelMng'.
Interface d'une fabrique pour les fonctions utilitaires de IParallelMng.
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.
Interface des opérations parallèles collectives non bloquantes.
Informations sur la réplication des sous-domaines en parallèle.
Classe abstraite du superviseur de parallélisme.
Informations sur la topologie d'allocation des coeurs de calcul.
Interface d'un sérialiseur.
virtual void copy(const ISerializer *from)=0
Copie les données de from dans cette instance.
Interface d'un gestionnaire de thread.
Interface d'un gestionnaire de timer.
Interface du gestionnaire de traces.
virtual TraceMessage info()=0
Flot pour un message d'information.
Envoie de valeurs sur différents processeurs.
Interface d'un service de synchronisation de variable.
Groupe d'entités de maillage.
Communicateur pour l'échange de message.
Liste de requête de messages.
Interface d'une liste de messages de sérialisation.
Interface d'un message de sérialisation entre IMessagePassingMng.
Gestion des messages parallèles pour le type Type.
Informations sur la source d'un message.
Informations pour envoyer/recevoir un message point à point.
bool isBlocking() const
Indique si le message est bloquant.
Classe de base d'une liste de requêtes.
Liste de messages de sérialisation.
Exception lorsqu'une fonction n'est pas implémentée.
Exception lorsqu'une opération n'est pas supportée.
Gestionnaire de thread en mode mono-thread.
Echange d'informations entre processeurs.
Redirige la gestion des messages des sous-domaines suivant le type de l'argument.
IMessagePassingMng * messagePassingMng() const override
Gestionnaire de message de Arccore associé
Classe de base d'une fabrique pour les fonctions utilitaires de IParallelMng.
Informations sur la réplication des sous-domaines en parallèle.
Informations sur la topologie d'allocation des coeurs de calcul.
virtual void initialize()
Initialise l'instance. Cette opération est collective.
Statistiques sur le parallélisme.
Référence à une instance.
Interface des messages pour le type Type.
Ref< IParallelMng > _createParallelMng(Int32 local_rank, ITraceMng *tm) override
Créé le IParallelMng pour le rang local local_rank.
Ref< IParallelMngContainer > _createParallelMngBuilder(Int32 nb_rank, Parallel::Communicator comm) override
Créé un conteneur pour nb_local_rank rangs locaux et avec comme communicateur communicator.
Ref< ITransferValuesParallelOperation > createTransferValuesOperation(IParallelMng *) override
Retourne une opération pour transférer des valeurs entre rangs.
Ref< IVariableSynchronizer > createSynchronizer(IParallelMng *pm, const ItemGroup &group) override
Retourne une interface pour synchroniser des variables sur le groupe group.
Ref< IVariableSynchronizer > createSynchronizer(IParallelMng *pm, IItemFamily *family) override
Retourne une interface pour synchroniser des variables sur le groupe de la famille family.
Gestionnaire du parallélisme en mode séquentiel.
Parallel::Communicator communicator() const override
Communicateur MPI associé à ce gestionnaire.
ISerializeMessage * createReceiveSerializer(Int32 rank) override
Créé un message non bloquant pour recevoir des données sérialisées du rang rank.
IParallelNonBlockingCollective * nonBlockingCollective() const override
Interface des opérations collectives non blocantes.
ITransferValuesParallelOperation * createTransferValuesOperation() override
Retourne une opération pour transférer des valeurs entre sous-domaine.
IThreadMng * threadMng() const override
Gestionnaire de threads.
UniqueArray< Integer > testSomeRequests(ArrayView< Request > requests) override
Test si une des requêtes rvalues est terminée.
Int32 commRank() const override
Rang de cette instance dans le communicateur.
ISerializeMessage * createSendSerializer(Int32 rank) override
Créé un message non bloquant pour envoyer des données sérialisées au rang rank.
Int32 commSize() const override
Nombre d'instance dans le communicateur.
IParallelMng * sequentialParallelMng() override
Retourne un gestionnaire de parallélisme séquentiel.
void build() override
Construit l'instance.
void barrier() override
Effectue une barière.
void allGather(ISerializer *send_serializer, ISerializer *recv_serializer) override
Redéfinit ici allGather pour éviter de cacher le symbole dans les classes dérivées.
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...
IParallelReplication * replication() const override
Informations sur la réplication.
ITimerMng * timerMng() const override
Gestionnaire de timers.
MessageId probe(const PointToPointMessageInfo &message) override
Sonde si des messages sont disponibles.
Ref< IParallelMngUtilsFactory > _internalUtilsFactory() const override
Fabrique des fonctions utilitaires.
MessageSourceInfo legacyProbe(const PointToPointMessageInfo &message) override
Sonde si des messages sont disponibles.
void processMessages(ConstArrayView< ISerializeMessage * > messages) override
Exécute les opérations des messages messages.
bool isMasterIO() const override
true si l'instance est un gestionnaire maître des entrées/sorties.
bool isThreadImplementation() const override
Indique si l'implémentation utilise les threads.
Ref< IRequestList > createRequestListRef() override
Créé une liste de requêtes pour ce gestionnaire.
Parallel::IStat * stat() override
Gestionnaire des statistiques.
void printStats() override
Affiche des statistiques liées à ce gestionnaire du parallélisme.
ITraceMng * traceMng() const override
Gestionnaire de traces.
void initialize() override
Initialise le gestionnaire du parallélisme.
IParallelMng * worldParallelMng() const override
Gestionnaire de parallélisme sur l'ensemble des ressources allouées.
bool isHybridImplementation() const override
Indique si l'implémentation utilise le mode hybride.
IParallelTopology * createTopology() override
Créé une instance contenant les infos sur la topologie des rangs de ce gestionnnaire.
bool isParallel() const override
Retourne true si l'exécution est parallèle.
void setReplication(IParallelReplication *v) override
Positionne les Informations sur la réplication.
void freeRequests(ArrayView< Parallel::Request > requests) override
Libère les requêtes.
void waitAllRequests(ArrayView< Request > requests) override
Bloque en attendant que les requêtes rvalues soient terminées.
UniqueArray< Integer > waitSomeRequests(ArrayView< Request > requests) override
Bloque en attendant qu'une des requêtes rvalues soit terminée.
void broadcastMemoryBuffer(ByteArray &bytes, Int32 rank) override
Effectue un broadcast d'une zone mémoire.
IVariableSynchronizer * createSynchronizer(const ItemGroup &group) override
Retourne une interface pour synchroniser des variables sur le groupe group.
IIOMng * ioMng() const override
Gestionnaire des entrées/sorties.
Int32 masterIORank() const override
Rang de l'instance gérant les entrées/sorties (pour laquelle isMasterIO() est vrai)
IVariableSynchronizer * createSynchronizer(IItemFamily *family) override
Retourne une interface pour synchroniser des variables sur le groupe de la famille family.
IParallelExchanger * createExchanger() override
Retourne une interface pour transférer des messages entre processeurs.
Request sendSerializer(ISerializer *values, Int32 rank, ByteArray &bytes) override
void * getMPICommunicator() override
Adresse du communicateur MPI associé à ce gestionnaire.
Superviseur du parallélisme en mode séquentiel.
void initialize() override
Initialise l'instance.
Ref< IParallelMng > internalCreateWorldParallelMng(Int32 local_rank) override
Créé un gestionnaire de parallélisme pour l'ensemble des coeurs alloués.
MP::Communicator communicator() const override
Communicateur MPI associé à ce gestionnaire.
void tryAbort() override
Tente de faire un abort.
void build() override
Construction de niveau build du service.
IApplication * m_application
Superviseur associé
IThreadMng * threadMng() const override
Gestionnaire de thread.
void _wait(Parallel::eWaitType wait_mode)
Effectue l'attente ou le test.
Message utilisant un SerializeBuffer.
IApplication * application() const
Accès à l'application IApplication associé.
Structure contenant les informations pour créer un service.
Propriétés de création d'un service.
__host__ __device__ void copy(const U ©_array)
Recopie le tableau copy_array dans l'instance.
Vue d'un tableau d'éléments de type T.
Chaîne de caractères unicode.
TraceAccessor(ITraceMng *m)
Construit un accesseur via le gestionnaire de trace m.
ITraceMng * traceMng() const
Gestionnaire de trace.
Vecteur 1D de données avec sémantique par valeur (style STL).
#define ARCANE_REGISTER_SERVICE(aclass, a_service_property,...)
Macro pour enregistrer un service.
Déclarations des types et méthodes utilisés par les mécanismes d'échange de messages.
eReduceType
Types des réductions supportées.
IStat * createDefaultStat()
Créé une instance par défaut.
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
Ref< TrueType > createRef(Args &&... args)
Créé une instance de type TrueType avec les arguments Args et retourne une référence dessus.
Int32 Integer
Type représentant un entier.
Array< Byte > ByteArray
Tableau dynamique à une dimension de caractères.
ConstArrayView< Int32 > Int32ConstArrayView
Equivalent C d'un tableau à une dimension d'entiers 32 bits.
@ ST_Application
Le service s'utilise au niveau de l'application.
auto makeRef(InstanceType *t) -> Ref< InstanceType >
Créé une référence sur un pointeur.
std::int32_t Int32
Type entier signé sur 32 bits.
Infos pour construire un SequentialParallelMng.