Arcane  v3.16.0.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
SharedMemoryParallelMng.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/* SharedMemoryParallelMng.h (C) 2000-2024 */
9/* */
10/* Implémentation des messages en mode mémoire partagé. */
11/*---------------------------------------------------------------------------*/
12#ifndef ARCANE_PARALLEL_THREAD_SHAREDMEMORYPARALLELMNG_H
13#define ARCANE_PARALLEL_THREAD_SHAREDMEMORYPARALLELMNG_H
14/*---------------------------------------------------------------------------*/
15/*---------------------------------------------------------------------------*/
16
17#include "arcane/ParallelMngDispatcher.h"
18
19#include "arcane/utils/TraceInfo.h"
20#include "arcane/utils/NotImplementedException.h"
21#include "arcane/utils/Ref.h"
22#include "arccore/base/ReferenceCounter.h"
23
24/*---------------------------------------------------------------------------*/
25/*---------------------------------------------------------------------------*/
26
27namespace Arcane
28{
29class SerializeBuffer;
31}
32
34{
37
38/*---------------------------------------------------------------------------*/
39/*---------------------------------------------------------------------------*/
43struct ARCANE_THREAD_EXPORT SharedMemoryParallelMngBuildInfo
44{
45 public:
46 SharedMemoryParallelMngBuildInfo()
47 : rank(-1), nb_rank(0), trace_mng(nullptr), thread_mng(nullptr)
48 , message_queue(nullptr), thread_barrier(nullptr), all_dispatchers(nullptr){}
49 public:
50 Int32 rank;
51 Int32 nb_rank;
52 ITraceMng* trace_mng;
53 IThreadMng* thread_mng;
54 Ref<IParallelMng> sequential_parallel_mng;
55 IParallelMng* world_parallel_mng = nullptr;
56 ISharedMemoryMessageQueue* message_queue = nullptr;
57 IThreadBarrier* thread_barrier = nullptr;
58 SharedMemoryAllDispatcher* all_dispatchers = nullptr;
59 IParallelMngContainerFactory* sub_builder_factory = nullptr;
61 MP::Communicator communicator;
62};
63
64/*---------------------------------------------------------------------------*/
65/*---------------------------------------------------------------------------*/
69class ARCANE_THREAD_EXPORT SharedMemoryParallelMng
70: public ParallelMngDispatcher
71{
72 public:
73 class RequestList;
74 public:
75
76 explicit SharedMemoryParallelMng(const SharedMemoryParallelMngBuildInfo& build_info);
77 ~SharedMemoryParallelMng() override;
78
79 bool isParallel() const override { return m_is_parallel; }
80 Int32 commRank() const override { return m_rank; }
81 Int32 commSize() const override { return m_nb_rank; }
82 void* getMPICommunicator() override { return m_mpi_communicator.communicatorAddress(); }
83 MP::Communicator communicator() const override { return m_mpi_communicator; }
84 bool isThreadImplementation() const override { return true; }
85 bool isHybridImplementation() const override { return false; }
86 ITraceMng* traceMng() const override { return m_trace.get(); }
87 IThreadMng* threadMng() const override { return m_thread_mng; }
88 void initialize() override;
89 bool isMasterIO() const override { return commRank()==0; }
90 Integer masterIORank() const override { return 0; }
91 IIOMng* ioMng() const override { return m_io_mng; }
92 IParallelMng* worldParallelMng() const override { return m_world_parallel_mng; }
93 ITimerMng* timerMng() const override { return m_timer_mng; }
94
95 IParallelMng* sequentialParallelMng() override;
96 Ref<IParallelMng> sequentialParallelMngRef() override;
97 void sendSerializer(ISerializer* values,Int32 rank) override;
98 Request sendSerializer(ISerializer* values,Int32 rank,ByteArray& bytes) override;
99 ISerializeMessage* createSendSerializer(Int32 rank) override;
100
101 void recvSerializer(ISerializer* values,Int32 rank) override;
102 ISerializeMessage* createReceiveSerializer(Int32 rank) override;
103
104 void freeRequests(ArrayView<Parallel::Request> requests) override;
105
106 void broadcastSerializer(ISerializer* values,Int32 rank) override;
107 MessageId probe(const PointToPointMessageInfo& message) override;
108 MessageSourceInfo legacyProbe(const PointToPointMessageInfo& message) override;
109 Request sendSerializer(const ISerializer* values,const PointToPointMessageInfo& message) override;
110 Request receiveSerializer(ISerializer* values,const PointToPointMessageInfo& message) override;
111
112 void printStats() override;
113 void barrier() override;
114 void waitAllRequests(ArrayView<Request> requests) override;
115
116 ARCANE_DEPRECATED_260 Real reduceRank(eReduceType rt,Real v,Int32* rank)
117 {
118 Real rv = reduce(rt,v);
119 if (rank)
120 *rank = 0;
121 return rv;
122 }
123
125
126 void build() override;
127
128 public:
129
130 IThreadBarrier* getThreadBarrier()
131 {
132 return m_thread_barrier;
133 }
134
135 public:
136
138 PointToPointMessageInfo buildMessage(Int32 dest,MP::eBlockingType is_blocking);
140
141 protected:
142
148 IVariableSynchronizer* createSynchronizer(const ItemGroup& group) override;
149 Parallel::IStat* stat() override { return m_stat; }
150 IParallelReplication* replication() const override;
151 void setReplication(IParallelReplication* v) override;
152 Ref<Parallel::IRequestList> createRequestListRef() override;
153 Ref<IParallelMng> createSubParallelMngRef(Int32ConstArrayView kept_ranks) override;
154 Ref<IParallelMngUtilsFactory> _internalUtilsFactory() const override;
155
156 protected:
157
158 ISerializeMessageList* _createSerializeMessageList() override;
159 IParallelMng* _createSubParallelMng(Int32ConstArrayView kept_ranks) override;
160 bool _isAcceleratorAware() const override { return true; }
161
162 private:
163
165 IThreadMng* m_thread_mng;
166 Ref<IParallelMng> m_sequential_parallel_mng;
167 ITimerMng* m_timer_mng;
168 IParallelReplication* m_replication;
169 IParallelMng* m_world_parallel_mng;
170 IIOMng* m_io_mng;
171 ISharedMemoryMessageQueue* m_message_queue;
172 bool m_is_parallel;
176 Parallel::IStat* m_stat;
177 IThreadBarrier* m_thread_barrier;
178 SharedMemoryAllDispatcher* m_all_dispatchers;
179 IParallelMngContainerFactory* m_sub_builder_factory;
180 Ref<IParallelMngContainer> m_parent_container_ref;
181 MP::Communicator m_mpi_communicator;
182 Ref<IParallelMngUtilsFactory> m_utils_factory;
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.
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'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
Implémentation de IRequestList pour SharedMemoryParallelMng.
IParallelTopology * createTopology() override
Créé une instance contenant les infos sur la topologie des rangs de ce gestionnnaire.
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...
bool isThreadImplementation() const override
Indique si l'implémentation utilise les threads.
bool isMasterIO() const override
true si l'instance est un gestionnaire maître des entrées/sorties.
Integer masterIORank() const override
Rang de l'instance gérant les entrées/sorties (pour laquelle isMasterIO() est vrai)
IParallelNonBlockingCollective * nonBlockingCollective() const override
Interface des opérations collectives non blocantes.
PointToPointMessageInfo buildMessage(Int32 dest, MP::eBlockingType is_blocking)
Construit un message avec pour destinataire dest.
IParallelMng * worldParallelMng() const override
Gestionnaire de parallélisme sur l'ensemble des ressources allouées.
Parallel::IStat * stat() override
Gestionnaire des statistiques.
IVariableSynchronizer * createSynchronizer(IItemFamily *family) override
Retourne une interface pour synchroniser des variables sur le groupe de la famille family.
MP::Communicator communicator() const override
Communicateur MPI associé à ce gestionnaire.
IIOMng * ioMng() const override
Gestionnaire des entrées/sorties.
ITraceMng * traceMng() const override
Gestionnaire de traces.
bool isParallel() const override
Retourne true si l'exécution est parallèle.
bool isHybridImplementation() const override
Indique si l'implémentation utilise le mode hybride.
Int32 commSize() const override
Nombre d'instance dans le communicateur.
Int32 commRank() const override
Rang de cette instance dans le communicateur.
IParallelExchanger * createExchanger() override
Retourne une interface pour transférer des messages entre processeurs.
IThreadMng * threadMng() const override
Gestionnaire de threads.
void * getMPICommunicator() override
Adresse du communicateur MPI associé à ce gestionnaire.
ITransferValuesParallelOperation * createTransferValuesOperation() override
Retourne une opération pour transférer des valeurs entre sous-domaine.
ITimerMng * timerMng() const override
Gestionnaire de timers.
Statistiques sur le parallélisme.
Référence à une instance.
Encapsulation d'un pointeur avec compteur de référence.
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
eReduceType
Types des réductions supportées.
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
Int32 Integer
Type représentant un entier.
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
double Real
Type représentant un réel.
std::int32_t Int32
Type entier signé sur 32 bits.
Infos pour construire un SharedMemoryParallelMng.