Arcane  v3.16.0.0
Documentation utilisateur
Chargement...
Recherche...
Aucune correspondance
ParallelMngDispatcher.cc
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2025 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.cc (C) 2000-2025 */
9/* */
10/* Redirection de la gestion des messages suivant le type des arguments. */
11/*---------------------------------------------------------------------------*/
12/*---------------------------------------------------------------------------*/
13
14#include "arcane/utils/Array.h"
15#include "arcane/utils/HPReal.h"
16#include "arcane/utils/NumericTypes.h"
17#include "arcane/utils/NotImplementedException.h"
18#include "arcane/utils/ScopedPtr.h"
19#include "arcane/utils/ITraceMng.h"
20#include "arcane/utils/ValueConvert.h"
21#include "arcane/utils/FatalErrorException.h"
22
23#include "arcane/core/ParallelMngDispatcher.h"
24#include "arcane/core/IParallelDispatch.h"
25#include "arcane/core/Timer.h"
26#include "arcane/core/ITimeStats.h"
27#include "arcane/core/IParallelNonBlockingCollective.h"
28#include "arcane/core/internal/IParallelMngInternal.h"
29
30#include "arcane/accelerator/core/Runner.h"
31#include "arcane/accelerator/core/RunQueueBuildInfo.h"
32
33#include "arccore/message_passing/Dispatchers.h"
34#include "arccore/message_passing/Messages.h"
35#include "arccore/message_passing/MessagePassingMng.h"
36#include "arccore/message_passing/IControlDispatcher.h"
37#include "arccore/message_passing/ISerializeDispatcher.h"
38#include "arccore/message_passing/PointToPointMessageInfo.h"
39#include "arccore/message_passing/IRequestList.h"
40#include "arccore/message_passing/ISerializeMessageList.h"
41#include "arccore/trace/TimeMetric.h"
42
43/*---------------------------------------------------------------------------*/
44/*---------------------------------------------------------------------------*/
45
46namespace Arcane
47{
48using namespace Arccore::MessagePassing;
49
50/*---------------------------------------------------------------------------*/
51/*---------------------------------------------------------------------------*/
52
53ParallelMngDispatcherBuildInfo::
54ParallelMngDispatcherBuildInfo(MP::Dispatchers* dispatchers,
55 MP::MessagePassingMng* mpm)
56: m_comm_rank(mpm->commRank())
57, m_comm_size(mpm->commSize())
58, m_dispatchers(dispatchers)
59, m_message_passing_mng(mpm)
60{
61 _init();
62}
63
64/*---------------------------------------------------------------------------*/
65/*---------------------------------------------------------------------------*/
66
67ParallelMngDispatcherBuildInfo::
68ParallelMngDispatcherBuildInfo(Ref<MP::Dispatchers> dispatchers,
69 Ref<MP::MessagePassingMng> mpm_ref)
70: m_comm_rank(mpm_ref->commRank())
71, m_comm_size(mpm_ref->commSize())
72, m_dispatchers(dispatchers.get())
73, m_dispatchers_ref(dispatchers)
74, m_message_passing_mng(mpm_ref.get())
75, m_message_passing_mng_ref(mpm_ref)
76{
77 _init();
78}
79
80/*---------------------------------------------------------------------------*/
81/*---------------------------------------------------------------------------*/
82
83ParallelMngDispatcherBuildInfo::
84ParallelMngDispatcherBuildInfo(Int32 comm_rank,Int32 comm_size)
85: m_comm_rank(comm_rank)
86, m_comm_size(comm_size)
87, m_dispatchers(nullptr)
88, m_message_passing_mng(nullptr)
89{
90 _init();
91}
92
93/*---------------------------------------------------------------------------*/
94/*---------------------------------------------------------------------------*/
95
96void ParallelMngDispatcherBuildInfo::
97_init()
98{
99 if (!m_dispatchers){
100 m_dispatchers_ref = createRef<MP::Dispatchers>();
101 m_dispatchers = m_dispatchers_ref.get();
102 }
103 if (!m_message_passing_mng){
104 auto* x = new MP::MessagePassingMng(m_comm_rank,m_comm_size,m_dispatchers);
105 m_message_passing_mng = x;
106 m_message_passing_mng_ref = makeRef(x);
107 }
108 if (!m_message_passing_mng_ref.get())
109 m_message_passing_mng_ref = makeRef(m_message_passing_mng);
110}
111
112/*---------------------------------------------------------------------------*/
113/*---------------------------------------------------------------------------*/
114
115ParallelMngDispatcher::DefaultControlDispatcher::
116DefaultControlDispatcher(IParallelMng* pm)
117: m_parallel_mng(pm)
118{
119}
120
121
122void ParallelMngDispatcher::DefaultControlDispatcher::
123waitAllRequests(ArrayView<Request> requests)
124{
125 m_parallel_mng->waitAllRequests(requests);
126}
127
128void ParallelMngDispatcher::DefaultControlDispatcher::
129waitSomeRequests(ArrayView<Request> requests,ArrayView<bool> indexes,
130 bool is_non_blocking)
131{
132 UniqueArray<Integer> done_requests;
133 if (is_non_blocking)
134 done_requests = m_parallel_mng->testSomeRequests(requests);
135 else
136 done_requests = m_parallel_mng->waitSomeRequests(requests);
137 indexes.fill(false);
138 for( int x : done_requests )
139 indexes[x] = true;
140}
141
142IMessagePassingMng* ParallelMngDispatcher::DefaultControlDispatcher::
143commSplit(bool keep)
144{
145 ARCANE_UNUSED(keep);
146 ARCANE_THROW(NotImplementedException,"split from MessagePassing::IControlDispatcher");
147}
148
149void ParallelMngDispatcher::DefaultControlDispatcher::
150barrier()
151{
152 m_parallel_mng->barrier();
153}
154
155Request ParallelMngDispatcher::DefaultControlDispatcher::
156nonBlockingBarrier()
157{
158 return m_parallel_mng->nonBlockingCollective()->barrier();
159}
160
161MessageId ParallelMngDispatcher::DefaultControlDispatcher::
162probe(const PointToPointMessageInfo& message)
163{
164 return m_parallel_mng->probe(message);
165}
166
167MessageSourceInfo ParallelMngDispatcher::DefaultControlDispatcher::
168legacyProbe(const PointToPointMessageInfo& message)
169{
170 return m_parallel_mng->legacyProbe(message);
171}
172
173Ref<Parallel::IRequestList> ParallelMngDispatcher::DefaultControlDispatcher::
174createRequestListRef()
175{
176 return m_parallel_mng->createRequestListRef();
177}
178
179/*---------------------------------------------------------------------------*/
180/*---------------------------------------------------------------------------*/
181
182void ParallelMngDispatcher::DefaultControlDispatcher::
183setProfiler(MP::IProfiler* p)
184{
185 ARCANE_UNUSED(p);
186 ARCANE_THROW(NotImplementedException,"setProfiler() from MessagePassing::IControlDispatcher");
187}
188
189/*---------------------------------------------------------------------------*/
190/*---------------------------------------------------------------------------*/
191
192class ParallelMngDispatcher::SerializeDispatcher
193: public MP::ISerializeDispatcher
194{
195 public:
196
197 explicit SerializeDispatcher(IParallelMng* pm)
198 : m_parallel_mng(pm)
199 {}
200
201 public:
202 Ref<ISerializeMessageList> createSerializeMessageListRef() override
203 {
204 return m_parallel_mng->createSerializeMessageListRef();
205 }
206 Request sendSerializer(const ISerializer* s,const PointToPointMessageInfo& message) override
207 {
208 return m_parallel_mng->sendSerializer(s,message);
209 }
210 Request receiveSerializer(ISerializer* s,const PointToPointMessageInfo& message) override
211 {
212 return m_parallel_mng->receiveSerializer(s,message);
213 }
214 private:
215 IParallelMng* m_parallel_mng;
216};
217
218/*---------------------------------------------------------------------------*/
219/*---------------------------------------------------------------------------*/
220
221class ParallelMngDispatcher::Impl
222: public IParallelMngInternal
223{
224 public:
225
226 explicit Impl(ParallelMngDispatcher* pm)
227 : m_parallel_mng(pm)
228 , m_runner(Accelerator::eExecutionPolicy::Sequential)
229 , m_queue(makeQueue(m_runner))
230 {
231 if (auto v = Convert::Type<Int32>::tryParseFromEnvironment("ARCANE_DISABLE_ACCELERATOR_AWARE_MESSAGE_PASSING", true))
232 m_is_accelerator_aware_disabled = (v.value()!=0);
233 }
234 ~Impl()
235 {
236 }
237 public:
238
239 Runner runner() const override { return m_runner; }
240 RunQueue queue() const override { return m_queue; }
241 bool isAcceleratorAware() const override
242 {
243 if (m_is_accelerator_aware_disabled)
244 return false;
245 if (m_queue.isNull())
246 return false;
247 if (!m_queue.isAcceleratorPolicy())
248 return false;
249 return m_parallel_mng->_isAcceleratorAware();
250 }
251 void setDefaultRunner(const Runner& runner) override
252 {
253 if (!m_runner.isInitialized())
254 ARCANE_FATAL("Can not set an unitialized Runner");
255
256 // Attention à bien supprimer la référence sur la RunQueue
257 // avant de détruire le Runner car s'il n'y a pas d'autres
258 // références sur \a m_runner il sera détruit avec \a m_queue
259 // et ce dernier aura un \a m_runner détruit.
260 m_queue = RunQueue{};
261 m_runner = runner;
262 Accelerator::RunQueueBuildInfo build_info(-5);
263 m_queue = makeQueue(m_runner,build_info);
264 m_queue.setAsync(true);
265 }
266 Ref<IParallelMng> createSubParallelMngRef(Int32 color, Int32 key) override
267 {
268 return m_parallel_mng->_createSubParallelMngRef(color, key);
269 }
270
271 private:
272
273 ParallelMngDispatcher* m_parallel_mng = nullptr;
274 Runner m_runner;
275 RunQueue m_queue;
276 bool m_is_accelerator_aware_disabled = false;
277};
278
279/*---------------------------------------------------------------------------*/
280/*---------------------------------------------------------------------------*/
281
282/*---------------------------------------------------------------------------*/
283/*---------------------------------------------------------------------------*/
284
285ParallelMngDispatcher::
286ParallelMngDispatcher(const ParallelMngDispatcherBuildInfo& bi)
287: m_char(nullptr)
288, m_unsigned_char(nullptr)
289, m_signed_char(nullptr)
290, m_short(nullptr)
291, m_unsigned_short(nullptr)
292, m_int(nullptr)
293, m_unsigned_int(nullptr)
294, m_long(nullptr)
295, m_unsigned_long(nullptr)
296, m_long_long(nullptr)
297, m_unsigned_long_long(nullptr)
298, m_float(nullptr)
299, m_double(nullptr)
300, m_long_double(nullptr)
301, m_apreal(nullptr)
302, m_real2(nullptr)
303, m_real3(nullptr)
304, m_real2x2(nullptr)
305, m_real3x3(nullptr)
306, m_hpreal(nullptr)
307, m_time_stats(nullptr)
308, m_mp_dispatchers_ref(bi.dispatchersRef())
309, m_message_passing_mng_ref(bi.messagePassingMngRef())
310, m_control_dispatcher(new DefaultControlDispatcher(this))
311, m_serialize_dispatcher(new SerializeDispatcher(this))
312, m_parallel_mng_internal(new Impl(this))
313{
314}
315
316/*---------------------------------------------------------------------------*/
317/*---------------------------------------------------------------------------*/
318
319ParallelMngDispatcher::
320~ParallelMngDispatcher()
321{
322 m_mp_dispatchers_ref.reset();
323
324 delete m_parallel_mng_internal;
325
326 delete m_serialize_dispatcher;
327 delete m_control_dispatcher;
328 delete m_char;
329 delete m_signed_char;
330 delete m_unsigned_char;
331 delete m_short;
332 delete m_unsigned_short;
333 delete m_int;
334 delete m_unsigned_int;
335 delete m_long;
336 delete m_unsigned_long;
337 delete m_long_long;
338 delete m_unsigned_long_long;
339 delete m_apreal;
340 delete m_float;
341 delete m_double;
342 delete m_long_double;
343 delete m_real2;
344 delete m_real3;
345 delete m_real2x2;
346 delete m_real3x3;
347 delete m_hpreal;
348}
349
350/*---------------------------------------------------------------------------*/
351/*---------------------------------------------------------------------------*/
352
353void ParallelMngDispatcher::
354_setControlDispatcher(MP::IControlDispatcher* d)
355{
356 delete m_control_dispatcher;
357 m_control_dispatcher = d;
358}
359
360/*---------------------------------------------------------------------------*/
361/*---------------------------------------------------------------------------*/
362
363void ParallelMngDispatcher::
364_setSerializeDispatcher(MP::ISerializeDispatcher* d)
365{
366 delete m_serialize_dispatcher;
367 m_serialize_dispatcher = d;
368}
369
370/*---------------------------------------------------------------------------*/
371/*---------------------------------------------------------------------------*/
372
373void ParallelMngDispatcher::
374_setArccoreDispatchers()
375{
376 m_mp_dispatchers_ref->setDispatcher(m_char->toArccoreDispatcher());
377 m_mp_dispatchers_ref->setDispatcher(m_signed_char->toArccoreDispatcher());
378 m_mp_dispatchers_ref->setDispatcher(m_unsigned_char->toArccoreDispatcher());
379 m_mp_dispatchers_ref->setDispatcher(m_short->toArccoreDispatcher());
380 m_mp_dispatchers_ref->setDispatcher(m_unsigned_short->toArccoreDispatcher());
381 m_mp_dispatchers_ref->setDispatcher(m_int->toArccoreDispatcher());
382 m_mp_dispatchers_ref->setDispatcher(m_unsigned_int->toArccoreDispatcher());
383 m_mp_dispatchers_ref->setDispatcher(m_long->toArccoreDispatcher());
384 m_mp_dispatchers_ref->setDispatcher(m_unsigned_long->toArccoreDispatcher());
385 m_mp_dispatchers_ref->setDispatcher(m_long_long->toArccoreDispatcher());
386 m_mp_dispatchers_ref->setDispatcher(m_unsigned_long_long->toArccoreDispatcher());
387 m_mp_dispatchers_ref->setDispatcher(m_float->toArccoreDispatcher());
388 m_mp_dispatchers_ref->setDispatcher(m_double->toArccoreDispatcher());
389 m_mp_dispatchers_ref->setDispatcher(m_long_double->toArccoreDispatcher());
390
391 ARCANE_CHECK_POINTER(m_control_dispatcher);
392 m_mp_dispatchers_ref->setDispatcher(m_control_dispatcher);
393 ARCANE_CHECK_POINTER(m_serialize_dispatcher);
394 m_mp_dispatchers_ref->setDispatcher(m_serialize_dispatcher);
395}
396
397/*---------------------------------------------------------------------------*/
398/*---------------------------------------------------------------------------*/
399
400IMessagePassingMng* ParallelMngDispatcher::
401messagePassingMng() const
402{
403 return m_message_passing_mng_ref.get();
404}
405
406/*---------------------------------------------------------------------------*/
407/*---------------------------------------------------------------------------*/
408
409ITimeMetricCollector* ParallelMngDispatcher::
410timeMetricCollector() const
411{
412 ITimeMetricCollector* c = nullptr;
413 ITimeStats* s = m_time_stats;
414 if (s)
415 c = s->metricCollector();
416 return c;
417}
418
419/*---------------------------------------------------------------------------*/
420/*---------------------------------------------------------------------------*/
421
422void ParallelMngDispatcher::
423setTimeStats(ITimeStats* ts)
424{
425 m_time_stats = ts;
426 if (ts){
427 ITimeMetricCollector* c = ts->metricCollector();
428 _messagePassingMng()->setTimeMetricCollector(c);
429 }
430}
431
432/*---------------------------------------------------------------------------*/
433/*---------------------------------------------------------------------------*/
434
435TimeMetricAction ParallelMngDispatcher::
436_communicationTimeMetricAction() const
437{
438 return Timer::phaseAction(timeStats(),TP_Communication);
439}
440
441/*---------------------------------------------------------------------------*/
442/*---------------------------------------------------------------------------*/
443
444void ParallelMngDispatcher::
445broadcastString(String& str,Int32 rank)
446{
447 Int64 len_info[1];
448 Int32 my_rank = commRank();
449 Span<const Byte> bytes = str.bytes();
450 if (rank==my_rank){
451 len_info[0] = bytes.size();
452 broadcast(Int64ArrayView(1,len_info),rank);
453 ByteUniqueArray utf8_array(bytes);
454 broadcast(utf8_array,rank);
455 }
456 else{
457 broadcast(Int64ArrayView(1,len_info),rank);
458 ByteUniqueArray utf8_array(len_info[0]);
459 broadcast(utf8_array,rank);
460 str = String::fromUtf8(utf8_array);
461 }
462}
463
464/*---------------------------------------------------------------------------*/
465/*---------------------------------------------------------------------------*/
466
467void ParallelMngDispatcher::
468broadcastMemoryBuffer(ByteArray& bytes,Int32 rank)
469{
470 Int64 size = 0;
471 if (commRank()==rank){
472 size = bytes.largeSize();
473 }
474 {
475 Int64ArrayView bs(1,&size);
476 broadcast(bs,rank);
477 }
478 if (commRank()!=rank)
479 bytes.resize(size);
480 if (size!=0)
481 broadcast(bytes,rank);
482}
483
484/*---------------------------------------------------------------------------*/
485/*---------------------------------------------------------------------------*/
486
487void ParallelMngDispatcher::
488allGather(ISerializer* send_serializer, ISerializer* recv_serializer)
489{
490 Timer::Phase tphase(timeStats(), TP_Communication);
491 mpAllGather(_messagePassingMng(), send_serializer, recv_serializer);
492}
493
494/*---------------------------------------------------------------------------*/
495/*---------------------------------------------------------------------------*/
496
497void ParallelMngDispatcher::
498processMessages(ConstArrayView<ISerializeMessage*> messages)
499{
500 TimeMetricSentry tphase(Timer::phaseAction(timeStats(),TP_Communication));
501 ScopedPtrT<ISerializeMessageList> message_list(createSerializeMessageList());
502
503 Integer nb_message = messages.size();
504 for( Integer i=0; i<nb_message; ++i ){
505 ISerializeMessage* m = messages[i];
506 message_list->addMessage(m);
507 }
508 message_list->processPendingMessages();
509
510 message_list->waitMessages(Parallel::WaitAll);
511}
512
513/*---------------------------------------------------------------------------*/
514/*---------------------------------------------------------------------------*/
515
516Ref<ISerializeMessageList> ParallelMngDispatcher::
517createSerializeMessageListRef()
518{
519 return makeRef(_createSerializeMessageList());
520}
521
522/*---------------------------------------------------------------------------*/
523/*---------------------------------------------------------------------------*/
524
525ISerializeMessageList* ParallelMngDispatcher::
526createSerializeMessageList()
527{
528 return _createSerializeMessageList();
529}
530
531/*---------------------------------------------------------------------------*/
532/*---------------------------------------------------------------------------*/
533
534IParallelMng* ParallelMngDispatcher::
535createSubParallelMng(Int32ConstArrayView kept_ranks)
536{
537 return _createSubParallelMng(kept_ranks);
538}
539
540/*---------------------------------------------------------------------------*/
541/*---------------------------------------------------------------------------*/
542
543Ref<IParallelMng> ParallelMngDispatcher::
544createSubParallelMngRef(Int32ConstArrayView kept_ranks)
545{
546 return makeRef(_createSubParallelMng(kept_ranks));
547}
548
549/*---------------------------------------------------------------------------*/
550/*---------------------------------------------------------------------------*/
551
552Ref<IParallelMng> ParallelMngDispatcher::
553_createSubParallelMngRef([[maybe_unused]] Int32 color, [[maybe_unused]] Int32 key)
554{
555 ARCANE_THROW(NotImplementedException, "Create sub-parallelmng with split semantic");
556}
557
558/*---------------------------------------------------------------------------*/
559/*---------------------------------------------------------------------------*/
560
561UniqueArray<Integer> ParallelMngDispatcher::
562_doWaitRequests(ArrayView<Request> requests,eWaitType wait_type)
563{
564 Timer::Phase tphase(timeStats(),TP_Communication);
565 Ref<IRequestList> request_list(createRequestListRef());
566 Integer nb_request = requests.size();
567 request_list->add(requests);
568 request_list->wait(wait_type);
569 // Ne pas oublier de recopier les requêtes car elles ont pu être modifiées
570 for (Integer i=0; i<nb_request; ++i )
571 requests[i] = request_list->request(i);
572 return request_list->doneRequestIndexes();
573}
574
575/*---------------------------------------------------------------------------*/
576/*---------------------------------------------------------------------------*/
577
578UniqueArray<Integer> ParallelMngDispatcher::
579waitSomeRequests(ArrayView<Request> requests)
580{
581 return _doWaitRequests(requests,Parallel::WaitSome);
582}
583
584/*---------------------------------------------------------------------------*/
585/*---------------------------------------------------------------------------*/
586
592
593/*---------------------------------------------------------------------------*/
594/*---------------------------------------------------------------------------*/
595
596#define ARCANE_PARALLEL_MANAGER_DISPATCH(field,type)\
597void ParallelMngDispatcher::\
598allGather(ConstArrayView<type> send_buf,ArrayView<type> recv_buf)\
599{\
600 Timer::Phase tphase(timeStats(),TP_Communication);\
601 field->allGather(send_buf,recv_buf);\
602}\
603void ParallelMngDispatcher::\
604gather(ConstArrayView<type> send_buf,ArrayView<type> recv_buf,Integer rank) \
605{\
606 Timer::Phase tphase(timeStats(),TP_Communication);\
607 field->gather(send_buf,recv_buf,rank); \
608}\
609void ParallelMngDispatcher::\
610allGatherVariable(ConstArrayView<type> send_buf,Array<type>& recv_buf)\
611{\
612 Timer::Phase tphase(timeStats(),TP_Communication);\
613 field->allGatherVariable(send_buf,recv_buf);\
614}\
615void ParallelMngDispatcher::\
616gatherVariable(ConstArrayView<type> send_buf,Array<type>& recv_buf,Integer rank) \
617{\
618 Timer::Phase tphase(timeStats(),TP_Communication);\
619 field->gatherVariable(send_buf,recv_buf,rank); \
620}\
621void ParallelMngDispatcher::\
622scatterVariable(ConstArrayView<type> send_buf,ArrayView<type> recv_buf,Integer root)\
623{\
624 Timer::Phase tphase(timeStats(),TP_Communication);\
625 field->scatterVariable(send_buf,recv_buf,root);\
626}\
627type ParallelMngDispatcher::\
628reduce(eReduceType rt,type v)\
629{\
630 Timer::Phase tphase(timeStats(),TP_Communication);\
631 return field->allReduce(rt,v);\
632}\
633void ParallelMngDispatcher::\
634reduce(eReduceType rt,ArrayView<type> v)\
635{\
636 Timer::Phase tphase(timeStats(),TP_Communication);\
637 field->allReduce(rt,v);\
638}\
639void ParallelMngDispatcher::\
640broadcast(ArrayView<type> send_buf,Integer id)\
641{ \
642 Timer::Phase tphase(timeStats(),TP_Communication);\
643 field->broadcast(send_buf,id);\
644}\
645void ParallelMngDispatcher::\
646send(ConstArrayView<type> values,Integer id)\
647{\
648 Timer::Phase tphase(timeStats(),TP_Communication);\
649 field->send(values,id);\
650}\
651void ParallelMngDispatcher::\
652recv(ArrayView<type> values,Integer id)\
653{\
654 Timer::Phase tphase(timeStats(),TP_Communication);\
655 field->recv(values,id);\
656}\
657Parallel::Request ParallelMngDispatcher::\
658send(ConstArrayView<type> values,Integer id,bool is_blocked)\
659{\
660 Timer::Phase tphase(timeStats(),TP_Communication);\
661 return field->send(values,id,is_blocked);\
662}\
663Request ParallelMngDispatcher::\
664send(Span<const type> values,const PointToPointMessageInfo& message) \
665{\
666 Timer::Phase tphase(timeStats(),TP_Communication);\
667 return field->send(values,message);\
668}\
669Parallel::Request ParallelMngDispatcher::\
670recv(ArrayView<type> values,Integer id,bool is_blocked)\
671{\
672 Timer::Phase tphase(timeStats(),TP_Communication);\
673 return field->recv(values,id,is_blocked);\
674}\
675Request ParallelMngDispatcher::\
676receive(Span<type> values,const PointToPointMessageInfo& message) \
677{\
678 Timer::Phase tphase(timeStats(),TP_Communication);\
679 return field->receive(values,message);\
680}\
681void ParallelMngDispatcher::\
682sendRecv(ConstArrayView<type> send_buf,ArrayView<type> recv_buf,Integer id)\
683{\
684 Timer::Phase tphase(timeStats(),TP_Communication);\
685 field->sendRecv(send_buf,recv_buf,id);\
686}\
687void ParallelMngDispatcher::\
688allToAll(ConstArrayView<type> send_buf,ArrayView<type> recv_buf,Integer count)\
689{\
690 Timer::Phase tphase(timeStats(),TP_Communication);\
691 field->allToAll(send_buf,recv_buf,count);\
692}\
693void ParallelMngDispatcher::\
694allToAllVariable(ConstArrayView<type> send_buf,Int32ConstArrayView send_count,\
695 Int32ConstArrayView send_index,ArrayView<type> recv_buf,\
696 Int32ConstArrayView recv_count,Int32ConstArrayView recv_index)\
697{\
698 Timer::Phase tphase(timeStats(),TP_Communication);\
699 field->allToAllVariable(send_buf,send_count,send_index,recv_buf,recv_count,recv_index);\
700}\
701type ParallelMngDispatcher::\
702scan(eReduceType rt,type v)\
703{\
704 Timer::Phase tphase(timeStats(),TP_Communication);\
705 return field->scan(rt,v);\
706}\
707void ParallelMngDispatcher::\
708computeMinMaxSum(type val,type& min_val,type& max_val,type& sum_val,Int32& min_proc,Int32& max_proc)\
709{\
710 Timer::Phase tphase(timeStats(),TP_Communication);\
711 field->computeMinMaxSum(val,min_val,max_val,sum_val,min_proc,max_proc);\
712}\
713IParallelDispatchT<type>* ParallelMngDispatcher::\
714dispatcher(type*)\
715{\
716 return field;\
717}\
718void ParallelMngDispatcher::\
719computeMinMaxSum(ConstArrayView<type> values, \
720 ArrayView<type> min_values, \
721 ArrayView<type> max_values, \
722 ArrayView<type> sum_values, \
723 ArrayView<Int32> min_ranks, \
724 ArrayView<Int32> max_ranks) \
725{\
726 Timer::Phase tphase(timeStats(),TP_Communication);\
727 field->computeMinMaxSum(values,min_values,max_values,sum_values,min_ranks,max_ranks);\
728}\
729void ParallelMngDispatcher::\
730scan(eReduceType rt,ArrayView<type> v)\
731{\
732 Timer::Phase tphase(timeStats(),TP_Communication);\
733 field->scan(rt,v);\
734}
735
736ARCANE_PARALLEL_MANAGER_DISPATCH(m_char,char)
737ARCANE_PARALLEL_MANAGER_DISPATCH(m_unsigned_char,unsigned char)
738ARCANE_PARALLEL_MANAGER_DISPATCH(m_signed_char,signed char)
739ARCANE_PARALLEL_MANAGER_DISPATCH(m_short,short)
740ARCANE_PARALLEL_MANAGER_DISPATCH(m_unsigned_short,unsigned short)
741ARCANE_PARALLEL_MANAGER_DISPATCH(m_int,int)
742ARCANE_PARALLEL_MANAGER_DISPATCH(m_unsigned_int,unsigned int)
743ARCANE_PARALLEL_MANAGER_DISPATCH(m_long,long)
744ARCANE_PARALLEL_MANAGER_DISPATCH(m_unsigned_long,unsigned long)
745ARCANE_PARALLEL_MANAGER_DISPATCH(m_long_long,long long)
746ARCANE_PARALLEL_MANAGER_DISPATCH(m_unsigned_long_long,unsigned long long)
747ARCANE_PARALLEL_MANAGER_DISPATCH(m_float,float)
748ARCANE_PARALLEL_MANAGER_DISPATCH(m_double,double)
749ARCANE_PARALLEL_MANAGER_DISPATCH(m_long_double,long double)
750ARCANE_PARALLEL_MANAGER_DISPATCH(m_apreal,APReal)
751ARCANE_PARALLEL_MANAGER_DISPATCH(m_real2,Real2)
752ARCANE_PARALLEL_MANAGER_DISPATCH(m_real3,Real3)
753ARCANE_PARALLEL_MANAGER_DISPATCH(m_real2x2,Real2x2)
754ARCANE_PARALLEL_MANAGER_DISPATCH(m_real3x3,Real3x3)
755ARCANE_PARALLEL_MANAGER_DISPATCH(m_hpreal,HPReal)
756
757/*---------------------------------------------------------------------------*/
758/*---------------------------------------------------------------------------*/
759
760} // End namespace Arcane
761
762/*---------------------------------------------------------------------------*/
763/*---------------------------------------------------------------------------*/
764
765namespace Arccore
766{
767ARCCORE_DEFINE_REFERENCE_COUNTED_CLASS(Arcane::IParallelMng);
768ARCCORE_DEFINE_REFERENCE_COUNTED_CLASS(Arcane::IParallelMngContainer);
769}
770
771/*---------------------------------------------------------------------------*/
772/*---------------------------------------------------------------------------*/
ARCANE_CHECK_POINTER
#define ARCANE_CHECK_POINTER(ptr)
Macro retournant le pointeur ptr s'il est non nul ou lancant une exception s'il est nul.
Definition ArcaneGlobal.h:823
ARCANE_THROW
#define ARCANE_THROW(exception_class,...)
Macro pour envoyer une exception avec formattage.
Definition ArcaneGlobal.h:753
ARCANE_FATAL
#define ARCANE_FATAL(...)
Macro envoyant une exception FatalErrorException.
Definition ArcaneGlobal.h:764
Messages.h
Liste des fonctions d'échange de message.
ARCCORE_DEFINE_REFERENCE_COUNTED_CLASS
#define ARCCORE_DEFINE_REFERENCE_COUNTED_CLASS(class_name)
Macro pour définir les méthodes et types une classe qui utilise un compteur de référence.
Definition ReferenceCounterImpl.h:244
Arcane::APReal
Emulation de réel en précision arbitraire.
Definition ArccoreGlobal.h:227
Arcane::AbstractArray::largeSize
Int64 largeSize() const
Nombre d'éléments du vecteur (en 64 bits)
Definition arccore/src/collections/arccore/collections/Array.h:429
Arcane::Accelerator::RunQueueBuildInfo
Informations pour créer une RunQueue.
Definition RunQueueBuildInfo.h:31
Arcane::Accelerator::RunQueue
File d'exécution pour un accélérateur.
Definition core/RunQueue.h:52
Arcane::Accelerator::Runner
Gestionnaire d'exécution pour accélérateur.
Definition core/Runner.h:68
Arcane::ArrayView
Vue modifiable d'un tableau d'un type T.
Definition arccore/src/base/arccore/base/ArrayView.h:94
Arcane::ArrayView::fill
void fill(const T &o) noexcept
Remplit le tableau avec la valeur o.
Definition arccore/src/base/arccore/base/ArrayView.h:301
Arcane::ArrayView::size
constexpr Integer size() const noexcept
Retourne la taille du tableau.
Definition arccore/src/base/arccore/base/ArrayView.h:235
Arcane::Array::resize
void resize(Int64 s)
Change le nombre d'éléments du tableau à s.
Definition arccore/src/collections/arccore/collections/Array.h:1213
Arcane::ConstArrayView
Vue constante d'un tableau de type T.
Definition arccore/src/base/arccore/base/ArrayView.h:533
Arcane::ConstArrayView::size
constexpr Integer size() const noexcept
Nombre d'éléments du tableau.
Definition arccore/src/base/arccore/base/ArrayView.h:713
Arcane::HPReal
Classe implémentant un réel Haute Précision.
Definition HPReal.h:161
Arcane::IParallelMng
Interface du gestionnaire de parallélisme pour un sous-domaine.
Definition IParallelMng.h:52
Arcane::IParallelMng::commRank
virtual Int32 commRank() const =0
Rang de cette instance dans le communicateur.
Arcane::IParallelMng::createRequestListRef
virtual Ref< Parallel::IRequestList > createRequestListRef()=0
Créé une liste de requêtes pour ce gestionnaire.
Arcane::ITimeMetricCollector
Interface gérant les statistiques sur l'exécution.
Definition ITimeMetricCollector.h:35
Arcane::ITimeStats::metricCollector
virtual ITimeMetricCollector * metricCollector()=0
Interface de collection associée.
Arcane::MessagePassing::Dispatchers
Interface du conteneur des dispatchers.
Definition Dispatchers.h:34
Arcane::MessagePassing::IMessagePassingMng
Interface du gestionnaire des échanges de messages.
Definition IMessagePassingMng.h:47
Arcane::MessagePassing::MessagePassingMng
Gestionnaire des échanges de messages.
Definition MessagePassingMng.h:39
Arcane::MessagePassing::MessageSourceInfo
Informations sur la source d'un message.
Definition MessageSourceInfo.h:36
Arcane::MessagePassing::PointToPointMessageInfo
Informations pour envoyer/recevoir un message point à point.
Definition PointToPointMessageInfo.h:52
Arcane::MessagePassing::Request
Requête d'un message.
Definition Request.h:77
Arcane::ParallelMngDispatcher::DefaultControlDispatcher
Implémentation de Arccore::MessagePassing::IControlDispatcher.
Definition ParallelMngDispatcher.h:92
Arcane::ParallelMngDispatcher::SerializeDispatcher::sendSerializer
Request sendSerializer(const ISerializer *s, const PointToPointMessageInfo &message) override
Message d'envoi.
Definition ParallelMngDispatcher.cc:206
Arcane::ParallelMngDispatcher::SerializeDispatcher::receiveSerializer
Request receiveSerializer(ISerializer *s, const PointToPointMessageInfo &message) override
Message de réception.
Definition ParallelMngDispatcher.cc:210
Arcane::ParallelMngDispatcher::SerializeDispatcher::createSerializeMessageListRef
Ref< ISerializeMessageList > createSerializeMessageListRef() override
Créé une liste de messages de sérialisation.
Definition ParallelMngDispatcher.cc:202
Arcane::ParallelMngDispatcher::createSerializeMessageList
ISerializeMessageList * createSerializeMessageList() final
Créé une liste pour gérer les 'ISerializeMessage'.
Definition ParallelMngDispatcher.cc:526
Arcane::ParallelMngDispatcher::setTimeStats
void setTimeStats(ITimeStats *ts) override
Positionne le gestionnaire de statistiques.
Definition ParallelMngDispatcher.cc:423
Arcane::ParallelMngDispatcher::allGather
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.
Definition ParallelMngDispatcher.cc:488
Arcane::ParallelMngDispatcher::createSubParallelMngRef
Ref< IParallelMng > createSubParallelMngRef(Int32ConstArrayView kept_ranks) override
Créé un nouveau gestionnaire de parallélisme pour un sous-ensemble des rangs.
Definition ParallelMngDispatcher.cc:544
Arcane::ParallelMngDispatcher::processMessages
void processMessages(ConstArrayView< ISerializeMessage * > messages) override
Exécute les opérations des messages messages.
Definition ParallelMngDispatcher.cc:498
Arcane::ParallelMngDispatcher::messagePassingMng
IMessagePassingMng * messagePassingMng() const override
Gestionnaire de message de Arccore associé
Definition ParallelMngDispatcher.cc:401
Arcane::ParallelMngDispatcher::timeMetricCollector
ITimeMetricCollector * timeMetricCollector() const override
Collecteur Arccore des statistiques temporelles (peut être nul)
Definition ParallelMngDispatcher.cc:410
Arcane::ParallelMngDispatcher::createSubParallelMng
IParallelMng * createSubParallelMng(Int32ConstArrayView kept_ranks) final
Créé un nouveau gestionnaire de parallélisme pour un sous-ensemble des rangs.
Definition ParallelMngDispatcher.cc:535
Arcane::ParallelMngDispatcher::testSomeRequests
UniqueArray< Integer > testSomeRequests(ArrayView< Request > requests) override
Test si une des requêtes rvalues est terminée.
Definition ParallelMngDispatcher.cc:588
Arcane::ParallelMngDispatcher::timeStats
ITimeStats * timeStats() const override
Gestionnaire de statistiques associé (peut être nul)
Definition ParallelMngDispatcher.h:264
Arcane::ParallelMngDispatcher::createSerializeMessageListRef
Ref< ISerializeMessageList > createSerializeMessageListRef() final
Créé une liste pour gérer les 'ISerializeMessage'.
Definition ParallelMngDispatcher.cc:517
Arcane::ParallelMngDispatcher::waitSomeRequests
UniqueArray< Integer > waitSomeRequests(ArrayView< Request > requests) override
Bloque en attendant qu'une des requêtes rvalues soit terminée.
Definition ParallelMngDispatcher.cc:579
Arcane::ParallelMngDispatcher::broadcastMemoryBuffer
void broadcastMemoryBuffer(ByteArray &bytes, Int32 rank) override
Effectue un broadcast d'une zone mémoire.
Definition ParallelMngDispatcher.cc:468
Arcane::Real2
Classe gérant un vecteur de réel de dimension 2.
Definition Real2.h:121
Arcane::Real2x2
Classe gérant une matrice de réel de dimension 2x2.
Definition Real2x2.h:53
Arcane::Real3
Classe gérant un vecteur de réel de dimension 3.
Definition Real3.h:132
Arcane::Real3x3
Classe gérant une matrice de réel de dimension 3x3.
Definition Real3x3.h:66
Arcane::Ref
Référence à une instance.
Definition arccore/src/base/arccore/base/Ref.h:143
Arcane::ScopedPtrT
Encapsulation d'un pointeur qui se détruit automatiquement.
Definition ScopedPtr.h:44
Arcane::SpanImpl::size
constexpr __host__ __device__ SizeType size() const noexcept
Retourne la taille du tableau.
Definition Span.h:212
Arcane::Span
Vue d'un tableau d'éléments de type T.
Definition Span.h:513
Arcane::String
Chaîne de caractères unicode.
Definition arccore/src/base/arccore/base/String.h:70
Arcane::String::bytes
Span< const Byte > bytes() const
Retourne la conversion de l'instance dans l'encodage UTF-8.
Definition String.cc:291
Arcane::TimeMetricSentry
Sentinelle pour collecter les informations temporelles.
Definition TimeMetric.h:101
Arcane::Timer::Phase
Positionne la phase de l'action en cours d'exécution.
Definition Timer.h:128
Arcane::UniqueArray
Vecteur 1D de données avec sémantique par valeur (style STL).
Definition arccore/src/collections/arccore/collections/Array.h:1844
Arccore::Ref::reset
void reset()
Positionne l'instance au pointeur nul.
Definition arccore/src/base/arccore/base/Ref.h:298
Arcane::Accelerator::makeQueue
RunQueue makeQueue(const Runner &runner)
Créé une file associée à runner.
Definition core/Runner.h:222
Arcane::Accelerator::eExecutionPolicy::Sequential
@ Sequential
Politique d'exécution séquentielle.
Definition AcceleratorCoreGlobal.h:97
Arcane::MessagePassing::WaitSome
@ WaitSome
Attend que tous les messages de la liste soient traités.
Definition MessagePassingGlobal.h:111
Arcane::MessagePassing::mpAllGather
void mpAllGather(IMessagePassingMng *pm, const ISerializer *send_serializer, ISerializer *receive_serialize)
Message allGather() pour une sérialisation.
Definition Messages.cc:307
Arcane
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
Definition AbstractCaseDocumentVisitor.cc:20
Arcane::Int64ArrayView
ArrayView< Int64 > Int64ArrayView
Equivalent C d'un tableau à une dimension d'entiers 64 bits.
Definition UtilsTypes.h:538
Arcane::Int64
std::int64_t Int64
Type entier signé sur 64 bits.
Definition ArccoreGlobal.h:186
Arcane::Integer
Int32 Integer
Type représentant un entier.
Definition ArccoreGlobal.h:240
Arcane::ByteArray
Array< Byte > ByteArray
Tableau dynamique à une dimension de caractères.
Definition UtilsTypes.h:208
Arcane::Int32ConstArrayView
ConstArrayView< Int32 > Int32ConstArrayView
Equivalent C d'un tableau à une dimension d'entiers 32 bits.
Definition UtilsTypes.h:569
Arcane::ByteUniqueArray
UniqueArray< Byte > ByteUniqueArray
Tableau dynamique à une dimension de caractères.
Definition UtilsTypes.h:422
Arcane::makeRef
auto makeRef(InstanceType *t) -> Ref< InstanceType >
Créé une référence sur un pointeur.
Definition arccore/src/base/arccore/base/Ref.h:356
Arcane::Int32
std::int32_t Int32
Type entier signé sur 32 bits.
Definition ArccoreGlobal.h:184
Arccore
Espace de nom de Arccore.
Definition CaseOptionList.cc:764
Arccore::createRef
Ref< TrueType > createRef(Args &&... args)
Créé une instance de type TrueType avec les arguments Args et retourne une référence dessus.
Definition arccore/src/base/arccore/base/Ref.h:393
Arccore::makeRef
auto makeRef(InstanceType *t) -> Ref< InstanceType >
Créé une référence sur un pointeur.
Definition arccore/src/base/arccore/base/Ref.h:356