Arcane  v3.14.10.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-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/* ParallelMngDispatcher.cc (C) 2000-2024 */
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/Real2.h"
16#include "arcane/utils/Real3.h"
17#include "arcane/utils/Real2x2.h"
18#include "arcane/utils/Real3x3.h"
19#include "arcane/utils/HPReal.h"
20#include "arcane/utils/NotImplementedException.h"
21#include "arcane/utils/ScopedPtr.h"
22#include "arcane/utils/ITraceMng.h"
23#include "arcane/utils/ValueConvert.h"
24
25#include "arcane/core/ParallelMngDispatcher.h"
26#include "arcane/core/IParallelDispatch.h"
27#include "arcane/core/Timer.h"
28#include "arcane/core/ITimeStats.h"
29#include "arcane/core/IParallelNonBlockingCollective.h"
30#include "arcane/core/internal/IParallelMngInternal.h"
31
32#include "arcane/accelerator/core/Runner.h"
33#include "arcane/accelerator/core/RunQueueBuildInfo.h"
34
35#include "arccore/message_passing/Dispatchers.h"
36#include "arccore/message_passing/Messages.h"
37#include "arccore/message_passing/MessagePassingMng.h"
38#include "arccore/message_passing/IControlDispatcher.h"
39#include "arccore/message_passing/ISerializeDispatcher.h"
40#include "arccore/message_passing/PointToPointMessageInfo.h"
41#include "arccore/message_passing/IRequestList.h"
42#include "arccore/message_passing/ISerializeMessageList.h"
43#include "arccore/trace/TimeMetric.h"
44
45/*---------------------------------------------------------------------------*/
46/*---------------------------------------------------------------------------*/
47
48namespace Arcane
49{
50using namespace Arccore::MessagePassing;
51
52/*---------------------------------------------------------------------------*/
53/*---------------------------------------------------------------------------*/
54
55ParallelMngDispatcherBuildInfo::
56ParallelMngDispatcherBuildInfo(MP::Dispatchers* dispatchers,
57 MP::MessagePassingMng* mpm)
58: m_comm_rank(mpm->commRank())
59, m_comm_size(mpm->commSize())
60, m_dispatchers(dispatchers)
61, m_message_passing_mng(mpm)
62{
63 _init();
64}
65
66/*---------------------------------------------------------------------------*/
67/*---------------------------------------------------------------------------*/
68
69ParallelMngDispatcherBuildInfo::
70ParallelMngDispatcherBuildInfo(Ref<MP::Dispatchers> dispatchers,
71 Ref<MP::MessagePassingMng> mpm_ref)
72: m_comm_rank(mpm_ref->commRank())
73, m_comm_size(mpm_ref->commSize())
74, m_dispatchers(dispatchers.get())
75, m_dispatchers_ref(dispatchers)
76, m_message_passing_mng(mpm_ref.get())
77, m_message_passing_mng_ref(mpm_ref)
78{
79 _init();
80}
81
82/*---------------------------------------------------------------------------*/
83/*---------------------------------------------------------------------------*/
84
85ParallelMngDispatcherBuildInfo::
86ParallelMngDispatcherBuildInfo(Int32 comm_rank,Int32 comm_size)
87: m_comm_rank(comm_rank)
88, m_comm_size(comm_size)
89, m_dispatchers(nullptr)
90, m_message_passing_mng(nullptr)
91{
92 _init();
93}
94
95/*---------------------------------------------------------------------------*/
96/*---------------------------------------------------------------------------*/
97
98void ParallelMngDispatcherBuildInfo::
99_init()
100{
101 if (!m_dispatchers){
102 m_dispatchers_ref = createRef<MP::Dispatchers>();
103 m_dispatchers = m_dispatchers_ref.get();
104 }
105 if (!m_message_passing_mng){
106 auto* x = new MP::MessagePassingMng(m_comm_rank,m_comm_size,m_dispatchers);
107 m_message_passing_mng = x;
108 m_message_passing_mng_ref = makeRef(x);
109 }
110 if (!m_message_passing_mng_ref.get())
111 m_message_passing_mng_ref = makeRef(m_message_passing_mng);
112}
113
114/*---------------------------------------------------------------------------*/
115/*---------------------------------------------------------------------------*/
116
117ParallelMngDispatcher::DefaultControlDispatcher::
118DefaultControlDispatcher(IParallelMng* pm)
119: m_parallel_mng(pm)
120{
121}
122
123
124void ParallelMngDispatcher::DefaultControlDispatcher::
125waitAllRequests(ArrayView<Request> requests)
126{
127 m_parallel_mng->waitAllRequests(requests);
128}
129
130void ParallelMngDispatcher::DefaultControlDispatcher::
131waitSomeRequests(ArrayView<Request> requests,ArrayView<bool> indexes,
132 bool is_non_blocking)
133{
134 UniqueArray<Integer> done_requests;
135 if (is_non_blocking)
136 done_requests = m_parallel_mng->testSomeRequests(requests);
137 else
138 done_requests = m_parallel_mng->waitSomeRequests(requests);
139 indexes.fill(false);
140 for( int x : done_requests )
141 indexes[x] = true;
142}
143
144IMessagePassingMng* ParallelMngDispatcher::DefaultControlDispatcher::
145commSplit(bool keep)
146{
147 ARCANE_UNUSED(keep);
148 ARCANE_THROW(NotImplementedException,"split from MessagePassing::IControlDispatcher");
149}
150
151void ParallelMngDispatcher::DefaultControlDispatcher::
152barrier()
153{
154 m_parallel_mng->barrier();
155}
156
157Request ParallelMngDispatcher::DefaultControlDispatcher::
158nonBlockingBarrier()
159{
160 return m_parallel_mng->nonBlockingCollective()->barrier();
161}
162
163MessageId ParallelMngDispatcher::DefaultControlDispatcher::
164probe(const PointToPointMessageInfo& message)
165{
166 return m_parallel_mng->probe(message);
167}
168
169MessageSourceInfo ParallelMngDispatcher::DefaultControlDispatcher::
170legacyProbe(const PointToPointMessageInfo& message)
171{
172 return m_parallel_mng->legacyProbe(message);
173}
174
175Ref<Parallel::IRequestList> ParallelMngDispatcher::DefaultControlDispatcher::
176createRequestListRef()
177{
178 return m_parallel_mng->createRequestListRef();
179}
180
181/*---------------------------------------------------------------------------*/
182/*---------------------------------------------------------------------------*/
183
184void ParallelMngDispatcher::DefaultControlDispatcher::
185setProfiler(MP::IProfiler* p)
186{
187 ARCANE_UNUSED(p);
188 ARCANE_THROW(NotImplementedException,"setProfiler() from MessagePassing::IControlDispatcher");
189}
190
191/*---------------------------------------------------------------------------*/
192/*---------------------------------------------------------------------------*/
193
194class ParallelMngDispatcher::SerializeDispatcher
195: public MP::ISerializeDispatcher
196{
197 public:
198
199 explicit SerializeDispatcher(IParallelMng* pm)
200 : m_parallel_mng(pm)
201 {}
202
203 public:
204 Ref<ISerializeMessageList> createSerializeMessageListRef() override
205 {
206 return m_parallel_mng->createSerializeMessageListRef();
207 }
208 Request sendSerializer(const ISerializer* s,const PointToPointMessageInfo& message) override
209 {
210 return m_parallel_mng->sendSerializer(s,message);
211 }
212 Request receiveSerializer(ISerializer* s,const PointToPointMessageInfo& message) override
213 {
214 return m_parallel_mng->receiveSerializer(s,message);
215 }
216 private:
217 IParallelMng* m_parallel_mng;
218};
219
220/*---------------------------------------------------------------------------*/
221/*---------------------------------------------------------------------------*/
222
223class ParallelMngDispatcher::Impl
224: public IParallelMngInternal
225{
226 public:
227
228 explicit Impl(ParallelMngDispatcher* pm)
229 : m_parallel_mng(pm)
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 m_queue.reset();
237 }
238 public:
239
240 Runner* defaultRunner() const override { return m_runner; }
241 RunQueue* defaultQueue() const override { return m_queue.get(); }
242 bool isAcceleratorAware() const override
243 {
244 if (m_is_accelerator_aware_disabled)
245 return false;
246 if (!m_queue.get())
247 return false;
248 if (!m_queue->isAcceleratorPolicy())
249 return false;
250 return m_parallel_mng->_isAcceleratorAware();
251 }
252 void setDefaultRunner(Runner* runner) override
253 {
254 m_runner = runner;
255 // Conserve une référence sur le Runner pour éviter sa destruction
256 m_runner_ref = (runner) ? *runner : Runner();
257 if (m_runner){
258 Accelerator::RunQueueBuildInfo build_info(-5);
259 m_queue = makeQueueRef(*m_runner,build_info);
260 m_queue->setAsync(true);
261 }
262 else
263 m_queue.reset();
264 }
265 Ref<IParallelMng> createSubParallelMngRef(Int32 color, Int32 key) override
266 {
267 return m_parallel_mng->_createSubParallelMngRef(color, key);
268 }
269
270 private:
271
272 ParallelMngDispatcher* m_parallel_mng = nullptr;
273 Runner* m_runner = nullptr;
274 Ref<RunQueue> m_queue;
275 Runner m_runner_ref;
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
587UniqueArray<Integer> ParallelMngDispatcher::
588testSomeRequests(ArrayView<Request> requests)
589{
590 return _doWaitRequests(requests,Parallel::WaitSomeNonBlocking);
591}
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:868
ARCANE_THROW
#define ARCANE_THROW(exception_class,...)
Macro pour envoyer une exception avec formattage.
Definition ArcaneGlobal.h:798
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:233
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:53
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::ITimeStats::metricCollector
virtual ITimeMetricCollector * metricCollector()=0
Interface de collection associée.
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:208
Arcane::ParallelMngDispatcher::SerializeDispatcher::receiveSerializer
Request receiveSerializer(ISerializer *s, const PointToPointMessageInfo &message) override
Message de réception.
Definition ParallelMngDispatcher.cc:212
Arcane::ParallelMngDispatcher::SerializeDispatcher::createSerializeMessageListRef
Ref< ISerializeMessageList > createSerializeMessageListRef() override
Créé une liste de messages de sérialisation.
Definition ParallelMngDispatcher.cc:204
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::ScopedPtrT
Encapsulation d'un pointeur qui se détruit automatiquement.
Definition ScopedPtr.h:44
Arcane::Timer::Phase
Positionne la phase de l'action en cours d'exécution.
Definition Timer.h:128
Arccore::APReal
Emulation de réel en précision arbitraire.
Definition ArccoreGlobal.h:227
Arccore::AbstractArray::largeSize
Int64 largeSize() const
Nombre d'éléments du vecteur (en 64 bits)
Definition arccore/src/collections/arccore/collections/Array.h:427
Arccore::ArrayView
Vue modifiable d'un tableau d'un type T.
Definition arccore/src/base/arccore/base/ArrayView.h:94
Arccore::ArrayView::fill
void fill(const T &o) noexcept
Remplit le tableau avec la valeur o.
Definition arccore/src/base/arccore/base/ArrayView.h:301
Arccore::ArrayView::size
constexpr Integer size() const noexcept
Retourne la taille du tableau.
Definition arccore/src/base/arccore/base/ArrayView.h:235
Arccore::Array
Classe de base des vecteurs 1D de données.
Definition arccore/src/collections/arccore/collections/Array.h:988
Arccore::Array::resize
void resize(Int64 s)
Change le nombre d'éléments du tableau à s.
Definition arccore/src/collections/arccore/collections/Array.h:1194
Arccore::ConstArrayView
Vue constante d'un tableau de type T.
Definition arccore/src/base/arccore/base/ArrayView.h:533
Arccore::ConstArrayView::size
constexpr Integer size() const noexcept
Nombre d'éléments du tableau.
Definition arccore/src/base/arccore/base/ArrayView.h:713
Arccore::ITimeMetricCollector
Interface gérant les statistiques sur l'exécution.
Definition ITimeMetricCollector.h:35
Arccore::MessagePassing::Dispatchers
Interface du conteneur des dispatchers.
Definition Dispatchers.h:34
Arccore::MessagePassing::IMessagePassingMng
Interface du gestionnaire des échanges de messages.
Definition IMessagePassingMng.h:47
Arccore::MessagePassing::IProfiler
Interface d'un profiler pour les échanges de messages.
Definition IProfiler.h:31
Arccore::MessagePassing::ISerializeDispatcher
Interface des messages de sérialisation.
Definition ISerializeDispatcher.h:31
Arccore::MessagePassing::MessagePassingMng
Gestionnaire des échanges de messages.
Definition MessagePassingMng.h:39
Arccore::MessagePassing::MessageSourceInfo
Informations sur la source d'un message.
Definition MessageSourceInfo.h:36
Arccore::MessagePassing::PointToPointMessageInfo
Informations pour envoyer/recevoir un message point à point.
Definition PointToPointMessageInfo.h:52
Arccore::MessagePassing::Request
Requête d'un message.
Definition Request.h:77
Arccore::SpanImpl::size
constexpr __host__ __device__ SizeType size() const noexcept
Retourne la taille du tableau.
Definition Span.h:209
Arccore::Span
Vue d'un tableau d'éléments de type T.
Definition Span.h:510
Arccore::String
Chaîne de caractères unicode.
Definition arccore/src/base/arccore/base/String.h:70
Arccore::String::bytes
Span< const Byte > bytes() const
Retourne la conversion de l'instance dans l'encodage UTF-8.
Definition String.cc:291
Arccore::TimeMetricSentry
Sentinelle pour collecter les informations temporelles.
Definition TimeMetric.h:101
Arccore::UniqueArray
Vecteur 1D de données avec sémantique par valeur (style STL).
Definition arccore/src/collections/arccore/collections/Array.h:1807
Arcane::Accelerator::makeQueueRef
Ref< RunQueue > makeQueueRef(const Runner &runner)
Créé une référence sur file avec la politique d'exécution par défaut de runner.
Definition core/Runner.h:257
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:609
Arcane::ByteUniqueArray
UniqueArray< Byte > ByteUniqueArray
Tableau dynamique à une dimension de caractères.
Definition UtilsTypes.h:509
Arccore::MessagePassing
Espace de nommage contenant les types et déclarations qui gèrent le mécanisme de parallélisme par éch...
Definition BasicSerializeMessage.cc:22
Arccore::MessagePassing::mpAllGather
void mpAllGather(IMessagePassingMng *pm, const ISerializer *send_serializer, ISerializer *receive_serialize)
Message allGather() pour une sérialisation.
Definition Messages.cc:296
Arccore
Espace de nom de Arccore.
Definition ArcaneTypes.h:24
Arccore::Integer
Int32 Integer
Type représentant un entier.
Definition ArccoreGlobal.h:240
Arccore::Int64
std::int64_t Int64
Type entier signé sur 64 bits.
Definition ArccoreGlobal.h:186
Arccore::Int32
std::int32_t Int32
Type entier signé sur 32 bits.
Definition ArccoreGlobal.h:184