Arcane  4.1.12.0
Developer documentation
Loading...
Searching...
No Matches
ParallelMngDispatcher.h
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2026 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/* ParallelMngDispatcher.h (C) 2000-2025 */
9/* */
10/* Interface of the parallelism manager on a domain. */
11/*---------------------------------------------------------------------------*/
12#ifndef ARCANE_PARALLELMNGDISPATCHER_H
13#define ARCANE_PARALLELMNGDISPATCHER_H
14/*---------------------------------------------------------------------------*/
15/*---------------------------------------------------------------------------*/
16
17#include "arcane/core/IParallelMng.h"
18#include "arccore/base/ReferenceCounterImpl.h"
19#include "arccore/message_passing/MessagePassingMng.h"
20
21#include <atomic>
22
23/*---------------------------------------------------------------------------*/
24/*---------------------------------------------------------------------------*/
25
26namespace Arcane
27{
28
29/*---------------------------------------------------------------------------*/
30/*---------------------------------------------------------------------------*/
31
32template <typename T>
33class IParallelDispatchT;
34class ITimeStats;
35namespace MP = ::Arccore::MessagePassing;
36
37/*---------------------------------------------------------------------------*/
38/*---------------------------------------------------------------------------*/
39
40class ARCANE_CORE_EXPORT ParallelMngDispatcherBuildInfo
41{
42 public:
43
44 ARCANE_DEPRECATED_REASON("Y2022: Use overload with Ref<MP::MessagePassingMng> and Ref<MP::Dispatchers> instead")
45 ParallelMngDispatcherBuildInfo(MP::Dispatchers* dispatchers,
46 MP::MessagePassingMng* mpm);
47 ParallelMngDispatcherBuildInfo(Ref<MP::Dispatchers> dispatchers,
48 Ref<MP::MessagePassingMng> mpm);
49 ParallelMngDispatcherBuildInfo(Int32 comm_rank, Int32 comm_size);
50
51 public:
52
53 Int32 commRank() const { return m_comm_rank; }
54 Int32 commSize() const { return m_comm_size; }
55 Ref<MP::Dispatchers> dispatchersRef() const { return m_dispatchers_ref; }
56 Ref<MP::MessagePassingMng> messagePassingMngRef() const { return m_message_passing_mng_ref; }
57
58 ARCANE_DEPRECATED_REASON("Y2022: Use messagePassingMngRef() instead")
59 MP::MessagePassingMng* messagePassingMng() const { return m_message_passing_mng; }
60 ARCANE_DEPRECATED_REASON("Y2022: Use dispatchersRef() instead")
61 MP::Dispatchers* dispatchers() const { return m_dispatchers; }
62
63 private:
64
65 Int32 m_comm_rank;
66 Int32 m_comm_size;
67 MP::Dispatchers* m_dispatchers;
68 Ref<MP::Dispatchers> m_dispatchers_ref;
69 MP::MessagePassingMng* m_message_passing_mng;
70 Ref<MP::MessagePassingMng> m_message_passing_mng_ref;
71
72 private:
73
74 void _init();
75};
76
77/*---------------------------------------------------------------------------*/
78/*---------------------------------------------------------------------------*/
79
85class ARCANE_CORE_EXPORT ParallelMngDispatcher
86: public ReferenceCounterImpl
87, public IParallelMng
88{
89 public:
90
92 class ARCANE_CORE_EXPORT DefaultControlDispatcher
93 : public MP::IControlDispatcher
94 {
95 public:
96
97 explicit DefaultControlDispatcher(IParallelMng* pm);
98
99 public:
100
101 void waitAllRequests(ArrayView<Request> requests) override;
102 void waitSomeRequests(ArrayView<Request> requests,
103 ArrayView<bool> indexes, bool is_non_blocking) override;
104 IMessagePassingMng* commSplit(bool keep) override;
105 void barrier() override;
106 Request nonBlockingBarrier() override;
107 MessageId probe(const PointToPointMessageInfo& message) override;
108 MP::MessageSourceInfo legacyProbe(const PointToPointMessageInfo& message) override;
109 Ref<Parallel::IRequestList> createRequestListRef() override;
110 MP::IProfiler* profiler() const override { return nullptr; }
111 void setProfiler(MP::IProfiler* p) override;
112
113 private:
114
115 IParallelMng* m_parallel_mng;
116 };
117
119 class SerializeDispatcher;
120
121 friend class ParallelMngInternal;
122
123 public:
124
125 ARCCORE_DEFINE_REFERENCE_COUNTED_INCLASS_METHODS();
126
127 public:
128
129 explicit ParallelMngDispatcher(const ParallelMngDispatcherBuildInfo& bi);
130 ~ParallelMngDispatcher() override;
131
132 public:
133
134 ParallelMngDispatcher(const ParallelMngDispatcher&) = delete;
135 ParallelMngDispatcher(ParallelMngDispatcher&&) = delete;
136 ParallelMngDispatcher& operator=(ParallelMngDispatcher&&) = delete;
137 ParallelMngDispatcher& operator=(const ParallelMngDispatcher&) = delete;
138
139 private:
140
141 void _setArccoreDispatchers();
142
143 public:
144
145 IMessagePassingMng* messagePassingMng() const override;
146 void broadcastString(String& str, Int32 rank) override;
147 void broadcastMemoryBuffer(ByteArray& bytes, Int32 rank) override;
148
150 void allGather(ISerializer* send_serializer, ISerializer* recv_serializer) override;
151
152 public:
153
154#define ARCANE_PARALLEL_MANAGER_DISPATCH_PROTOTYPE(field, type) \
155 public: \
156\
157 void allGather(ConstArrayView<type> send_buf, ArrayView<type> recv_buf) override; \
158 void gather(ConstArrayView<type> send_buf, ArrayView<type> recv_buf, Integer rank) override; \
159 void allGatherVariable(ConstArrayView<type> send_buf, Array<type>& recv_buf) override; \
160 void gatherVariable(ConstArrayView<type> send_buf, Array<type>& recv_buf, Integer rank) override; \
161 void scatterVariable(ConstArrayView<type> send_buf, ArrayView<type> recv_buf, Integer root) override; \
162 type reduce(eReduceType rt, type v) override; \
163 void reduce(eReduceType rt, ArrayView<type> v) override; \
164 void broadcast(ArrayView<type> send_buf, Integer id) override; \
165 void send(ConstArrayView<type> values, Integer id) override; \
166 void recv(ArrayView<type> values, Integer id) override; \
167 Request send(ConstArrayView<type> values, Int32 rank, bool is_blocked) override; \
168 Request send(Span<const type> values, const PointToPointMessageInfo& message) override; \
169 Request recv(ArrayView<type> values, Int32 rank, bool is_blocked) override; \
170 Request receive(Span<type> values, const PointToPointMessageInfo& message) override; \
171 void sendRecv(ConstArrayView<type> send_buf, ArrayView<type> recv_buf, Integer id) override; \
172 void allToAll(ConstArrayView<type> send_buf, ArrayView<type> recv_buf, Integer count) override; \
173 void allToAllVariable(ConstArrayView<type> send_buf, Int32ConstArrayView send_count, \
174 Int32ConstArrayView send_index, ArrayView<type> recv_buf, \
175 Int32ConstArrayView recv_count, Int32ConstArrayView recv_index) override; \
176 type scan(eReduceType rt, type v); \
177 void computeMinMaxSum(type val, type& min_val, type& max_val, type& sum_val, Int32& min_proc, Int32& max_proc) override; \
178 void computeMinMaxSum(ConstArrayView<type> values, \
179 ArrayView<type> min_values, \
180 ArrayView<type> max_values, \
181 ArrayView<type> sum_values, \
182 ArrayView<Int32> min_ranks, \
183 ArrayView<Int32> max_ranks) override; \
184 void scan(eReduceType rt, ArrayView<type> v) override; \
185\
186 protected: \
187\
188 IParallelDispatchT<type>* field;
189
190 ARCANE_PARALLEL_MANAGER_DISPATCH_PROTOTYPE(m_char, char)
191 ARCANE_PARALLEL_MANAGER_DISPATCH_PROTOTYPE(m_unsigned_char, unsigned char)
192 ARCANE_PARALLEL_MANAGER_DISPATCH_PROTOTYPE(m_signed_char, signed char)
193 ARCANE_PARALLEL_MANAGER_DISPATCH_PROTOTYPE(m_short, short)
194 ARCANE_PARALLEL_MANAGER_DISPATCH_PROTOTYPE(m_unsigned_short, unsigned short)
195 ARCANE_PARALLEL_MANAGER_DISPATCH_PROTOTYPE(m_int, int)
196 ARCANE_PARALLEL_MANAGER_DISPATCH_PROTOTYPE(m_unsigned_int, unsigned int)
197 ARCANE_PARALLEL_MANAGER_DISPATCH_PROTOTYPE(m_long, long)
198 ARCANE_PARALLEL_MANAGER_DISPATCH_PROTOTYPE(m_unsigned_long, unsigned long)
199 ARCANE_PARALLEL_MANAGER_DISPATCH_PROTOTYPE(m_long_long, long long)
200 ARCANE_PARALLEL_MANAGER_DISPATCH_PROTOTYPE(m_unsigned_long_long, unsigned long long)
201 ARCANE_PARALLEL_MANAGER_DISPATCH_PROTOTYPE(m_float, float)
202 ARCANE_PARALLEL_MANAGER_DISPATCH_PROTOTYPE(m_double, double)
203 ARCANE_PARALLEL_MANAGER_DISPATCH_PROTOTYPE(m_long_double, long double)
204 ARCANE_PARALLEL_MANAGER_DISPATCH_PROTOTYPE(m_apreal, APReal)
205 ARCANE_PARALLEL_MANAGER_DISPATCH_PROTOTYPE(m_real2, Real2)
206 ARCANE_PARALLEL_MANAGER_DISPATCH_PROTOTYPE(m_real3, Real3)
207 ARCANE_PARALLEL_MANAGER_DISPATCH_PROTOTYPE(m_real2x2, Real2x2)
208 ARCANE_PARALLEL_MANAGER_DISPATCH_PROTOTYPE(m_real3x3, Real3x3)
209 ARCANE_PARALLEL_MANAGER_DISPATCH_PROTOTYPE(m_hpreal, HPReal)
210
211#undef ARCANE_PARALLEL_MANAGER_DISPATCH_PROTOTYPE
212
213 public:
214
215 virtual IParallelDispatchT<char>* dispatcher(char*);
216 virtual IParallelDispatchT<signed char>* dispatcher(signed char*);
217 virtual IParallelDispatchT<unsigned char>* dispatcher(unsigned char*);
218 virtual IParallelDispatchT<short>* dispatcher(short*);
219 virtual IParallelDispatchT<unsigned short>* dispatcher(unsigned short*);
220 virtual IParallelDispatchT<int>* dispatcher(int*);
221 virtual IParallelDispatchT<unsigned int>* dispatcher(unsigned int*);
222 virtual IParallelDispatchT<long>* dispatcher(long*);
223 virtual IParallelDispatchT<unsigned long>* dispatcher(unsigned long*);
224 virtual IParallelDispatchT<long long>* dispatcher(long long*);
225 virtual IParallelDispatchT<unsigned long long>* dispatcher(unsigned long long*);
226 virtual IParallelDispatchT<APReal>* dispatcher(APReal*);
227 virtual IParallelDispatchT<float>* dispatcher(float*);
228 virtual IParallelDispatchT<double>* dispatcher(double*);
229 virtual IParallelDispatchT<long double>* dispatcher(long double*);
230 virtual IParallelDispatchT<Real2>* dispatcher(Real2*);
231 virtual IParallelDispatchT<Real3>* dispatcher(Real3*);
232 virtual IParallelDispatchT<Real2x2>* dispatcher(Real2x2*);
233 virtual IParallelDispatchT<Real3x3>* dispatcher(Real3x3*);
234 virtual IParallelDispatchT<HPReal>* dispatcher(HPReal*);
235
236 public:
237
238 template <class CreatorType> void
239 createDispatchers(CreatorType& ct)
240 {
241 m_char = ct.template create<char>();
242 m_signed_char = ct.template create<signed char>();
243 m_unsigned_char = ct.template create<unsigned char>();
244 m_short = ct.template create<short>();
245 m_unsigned_short = ct.template create<unsigned short>();
246 m_int = ct.template create<int>();
247 m_unsigned_int = ct.template create<unsigned int>();
248 m_long = ct.template create<long>();
249 m_unsigned_long = ct.template create<unsigned long>();
250 m_long_long = ct.template create<long long>();
251 m_unsigned_long_long = ct.template create<unsigned long long>();
252
253 m_float = ct.template create<float>();
254 m_double = ct.template create<double>();
255 m_long_double = ct.template create<long double>();
256
257 m_apreal = ct.template create<APReal>();
258 m_real2 = ct.template create<Real2>();
259 m_real3 = ct.template create<Real3>();
260 m_real2x2 = ct.template create<Real2x2>();
261 m_real3x3 = ct.template create<Real3x3>();
262 m_hpreal = ct.template create<HPReal>();
263
264 _setArccoreDispatchers();
265 }
266
267 public:
268
269 ITimeStats* timeStats() const override { return m_time_stats; }
270 void setTimeStats(ITimeStats* ts) override;
271 ITimeMetricCollector* timeMetricCollector() const override;
272
273 UniqueArray<Integer> waitSomeRequests(ArrayView<Request> requests) override;
274 UniqueArray<Integer> testSomeRequests(ArrayView<Request> requests) override;
275 void processMessages(ConstArrayView<ISerializeMessage*> messages) override;
276 void processMessages(ConstArrayView<Ref<ISerializeMessage>> messages) override;
277 ISerializeMessageList* createSerializeMessageList() final;
278 Ref<ISerializeMessageList> createSerializeMessageListRef() final;
279 IParallelMng* createSubParallelMng(Int32ConstArrayView kept_ranks) final;
280 Ref<IParallelMng> createSubParallelMngRef(Int32ConstArrayView kept_ranks) override;
281
282 public:
283
284 IParallelMngInternal* _internalApi() override { return m_parallel_mng_internal; }
285
286 protected:
287
288 MP::MessagePassingMng* _messagePassingMng() const { return m_message_passing_mng_ref.get(); }
289 UniqueArray<Integer> _doWaitRequests(ArrayView<Request> requests, Parallel::eWaitType wait_type);
290 virtual ISerializeMessageList* _createSerializeMessageList() = 0;
291 virtual IParallelMng* _createSubParallelMng(Int32ConstArrayView kept_ranks) = 0;
292 virtual bool _isAcceleratorAware() const { return false; }
293 virtual Ref<IParallelMng> _createSubParallelMngRef(Int32 color, Int32 key);
294
295 protected:
296
297 TimeMetricAction _communicationTimeMetricAction() const;
298 void _setControlDispatcher(MP::IControlDispatcher* d);
299 void _setSerializeDispatcher(MP::ISerializeDispatcher* d);
300
301 private:
302
303 ITimeStats* m_time_stats = nullptr;
304 Ref<MP::Dispatchers> m_mp_dispatchers_ref;
305 Ref<MP::MessagePassingMng> m_message_passing_mng_ref;
306 MP::IControlDispatcher* m_control_dispatcher = nullptr;
307 MP::ISerializeDispatcher* m_serialize_dispatcher = nullptr;
308 IParallelMngInternal* m_parallel_mng_internal = nullptr;
309};
310
311/*---------------------------------------------------------------------------*/
312/*---------------------------------------------------------------------------*/
313
320
321/*---------------------------------------------------------------------------*/
322/*---------------------------------------------------------------------------*/
323
324} // End namespace Arcane
325
326/*---------------------------------------------------------------------------*/
327/*---------------------------------------------------------------------------*/
328
329#endif
ARCCORE_DEFINE_REFERENCE_COUNTED_INCLASS_METHODS
#define ARCCORE_DEFINE_REFERENCE_COUNTED_INCLASS_METHODS()
Macro to define methods managing counters of references.
Definition ReferenceCounterImpl.h:228
Arcane::APReal
Emulation of real number in arbitrary precision.
Definition ArccoreGlobal.h:279
Arcane::ArrayView
Modifiable view of an array of type T.
Definition arccore/src/base/arccore/base/ArrayView.h:96
Arcane::ConstArrayView
Constant view of an array of type T.
Definition arccore/src/base/arccore/base/ArrayView.h:550
Arcane::HPReal
Class implementing a High-Precision real number.
Definition HPReal.h:159
Arcane::IParallelDispatchT
Parallel message handling for the type Type.
Definition IParallelDispatch.h:36
Arcane::IParallelMngContainer
Interface for an 'IParallelMng' container.
Definition IParallelMng.h:1258
Arcane::IParallelMngInternal
Internal part of IParallelMng.
Definition IParallelMngInternal.h:42
Arcane::IParallelMng
Interface of the parallelism manager for a subdomain.
Definition IParallelMng.h:53
Arcane::ITimeMetricCollector
Interface managing statistics on execution.
Definition ITimeMetricCollector.h:37
Arcane::ITimeStats
Interface managing execution time statistics.
Definition ITimeStats.h:44
Arcane::MessagePassing::IMessagePassingMng
Interface of the message passing manager.
Definition IMessagePassingMng.h:49
Arcane::ParallelMngDispatcher::DefaultControlDispatcher::createRequestListRef
Ref< Parallel::IRequestList > createRequestListRef() override
Creation of a request list associated with this manager.
Definition ParallelMngDispatcher.cc:173
Arcane::ParallelMngDispatcher::allGather
void allGather(ISerializer *send_serializer, ISerializer *recv_serializer) override
Redefines allGather here to avoid hiding the symbol in derived classes.
Definition ParallelMngDispatcher.cc:429
Arcane::ParallelMngDispatcher::_internalApi
IParallelMngInternal * _internalApi() override
Internal Arcane API.
Definition ParallelMngDispatcher.h:284
Arcane::ParallelMngDispatcher::messagePassingMng
IMessagePassingMng * messagePassingMng() const override
Associated Arccore message passing manager.
Definition ParallelMngDispatcher.cc:342
Arcane::ParallelMngDispatcher::timeStats
ITimeStats * timeStats() const override
Associated statistics manager (can be null).
Definition ParallelMngDispatcher.h:269
Arcane::ParallelMngDispatcher::broadcastMemoryBuffer
void broadcastMemoryBuffer(ByteArray &bytes, Int32 rank) override
Performs a broadcast of a memory region.
Definition ParallelMngDispatcher.cc:409
Arcane::Real2
Class managing a 2-dimensional real vector.
Definition Real2.h:122
Arcane::Real2x2
Class managing a 2x2 matrix of reals.
Definition Real2x2.h:55
Arcane::Real3
Class managing a 3-dimensional real vector.
Definition Real3.h:132
Arcane::Real3x3
Class managing a 3x3 real matrix.
Definition Real3x3.h:67
Arcane::Ref
Reference to an instance.
Definition arccore/src/base/arccore/base/Ref.h:325
Arcane::ReferenceCounterImpl
Thread-safe implementation of a reference counter.
Definition ReferenceCounterImpl.h:95
Arcane::UniqueArray
1D data vector with value semantics (STL style).
Definition arccore/src/common/arccore/common/Array.h:890
Arcane
-- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature --
Definition arcane/src/arcane/accelerator/AcceleratorGlobal.h:37
Arcane::ByteArray
Array< Byte > ByteArray
Dynamic one-dimensional array of characters.
Definition UtilsTypes.h:121
Arcane::Int32ConstArrayView
ConstArrayView< Int32 > Int32ConstArrayView
C equivalent of a 1D array of 32-bit integers.
Definition UtilsTypes.h:482
Arcane::Int32
std::int32_t Int32
Signed integer type of 32 bits.
Definition ArccoreGlobal.h:233
Arccore::MessagePassing
Namespace containing the types and declarations that manage the message-passing parallelism mechanism...
Definition MessagePassingGlobal.cc:46