Arcane  v3.16.7.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/ParallelMngInternal.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
221/*---------------------------------------------------------------------------*/
222/*---------------------------------------------------------------------------*/
223
224ParallelMngDispatcher::
225ParallelMngDispatcher(const ParallelMngDispatcherBuildInfo& bi)
226: m_char(nullptr)
227, m_unsigned_char(nullptr)
228, m_signed_char(nullptr)
229, m_short(nullptr)
230, m_unsigned_short(nullptr)
231, m_int(nullptr)
232, m_unsigned_int(nullptr)
233, m_long(nullptr)
234, m_unsigned_long(nullptr)
235, m_long_long(nullptr)
236, m_unsigned_long_long(nullptr)
237, m_float(nullptr)
238, m_double(nullptr)
239, m_long_double(nullptr)
240, m_apreal(nullptr)
241, m_real2(nullptr)
242, m_real3(nullptr)
243, m_real2x2(nullptr)
244, m_real3x3(nullptr)
245, m_hpreal(nullptr)
246, m_time_stats(nullptr)
247, m_mp_dispatchers_ref(bi.dispatchersRef())
248, m_message_passing_mng_ref(bi.messagePassingMngRef())
249, m_control_dispatcher(new DefaultControlDispatcher(this))
250, m_serialize_dispatcher(new SerializeDispatcher(this))
251, m_parallel_mng_internal(new ParallelMngInternal(this))
252{
253}
254
255/*---------------------------------------------------------------------------*/
256/*---------------------------------------------------------------------------*/
257
258ParallelMngDispatcher::
259~ParallelMngDispatcher()
260{
261 m_mp_dispatchers_ref.reset();
262
263 delete m_parallel_mng_internal;
264
265 delete m_serialize_dispatcher;
266 delete m_control_dispatcher;
267 delete m_char;
268 delete m_signed_char;
269 delete m_unsigned_char;
270 delete m_short;
271 delete m_unsigned_short;
272 delete m_int;
273 delete m_unsigned_int;
274 delete m_long;
275 delete m_unsigned_long;
276 delete m_long_long;
277 delete m_unsigned_long_long;
278 delete m_apreal;
279 delete m_float;
280 delete m_double;
281 delete m_long_double;
282 delete m_real2;
283 delete m_real3;
284 delete m_real2x2;
285 delete m_real3x3;
286 delete m_hpreal;
287}
288
289/*---------------------------------------------------------------------------*/
290/*---------------------------------------------------------------------------*/
291
292void ParallelMngDispatcher::
293_setControlDispatcher(MP::IControlDispatcher* d)
294{
295 delete m_control_dispatcher;
296 m_control_dispatcher = d;
297}
298
299/*---------------------------------------------------------------------------*/
300/*---------------------------------------------------------------------------*/
301
302void ParallelMngDispatcher::
303_setSerializeDispatcher(MP::ISerializeDispatcher* d)
304{
305 delete m_serialize_dispatcher;
306 m_serialize_dispatcher = d;
307}
308
309/*---------------------------------------------------------------------------*/
310/*---------------------------------------------------------------------------*/
311
312void ParallelMngDispatcher::
313_setArccoreDispatchers()
314{
315 m_mp_dispatchers_ref->setDispatcher(m_char->toArccoreDispatcher());
316 m_mp_dispatchers_ref->setDispatcher(m_signed_char->toArccoreDispatcher());
317 m_mp_dispatchers_ref->setDispatcher(m_unsigned_char->toArccoreDispatcher());
318 m_mp_dispatchers_ref->setDispatcher(m_short->toArccoreDispatcher());
319 m_mp_dispatchers_ref->setDispatcher(m_unsigned_short->toArccoreDispatcher());
320 m_mp_dispatchers_ref->setDispatcher(m_int->toArccoreDispatcher());
321 m_mp_dispatchers_ref->setDispatcher(m_unsigned_int->toArccoreDispatcher());
322 m_mp_dispatchers_ref->setDispatcher(m_long->toArccoreDispatcher());
323 m_mp_dispatchers_ref->setDispatcher(m_unsigned_long->toArccoreDispatcher());
324 m_mp_dispatchers_ref->setDispatcher(m_long_long->toArccoreDispatcher());
325 m_mp_dispatchers_ref->setDispatcher(m_unsigned_long_long->toArccoreDispatcher());
326 m_mp_dispatchers_ref->setDispatcher(m_float->toArccoreDispatcher());
327 m_mp_dispatchers_ref->setDispatcher(m_double->toArccoreDispatcher());
328 m_mp_dispatchers_ref->setDispatcher(m_long_double->toArccoreDispatcher());
329
330 ARCANE_CHECK_POINTER(m_control_dispatcher);
331 m_mp_dispatchers_ref->setDispatcher(m_control_dispatcher);
332 ARCANE_CHECK_POINTER(m_serialize_dispatcher);
333 m_mp_dispatchers_ref->setDispatcher(m_serialize_dispatcher);
334}
335
336/*---------------------------------------------------------------------------*/
337/*---------------------------------------------------------------------------*/
338
339IMessagePassingMng* ParallelMngDispatcher::
340messagePassingMng() const
341{
342 return m_message_passing_mng_ref.get();
343}
344
345/*---------------------------------------------------------------------------*/
346/*---------------------------------------------------------------------------*/
347
348ITimeMetricCollector* ParallelMngDispatcher::
349timeMetricCollector() const
350{
351 ITimeMetricCollector* c = nullptr;
352 ITimeStats* s = m_time_stats;
353 if (s)
354 c = s->metricCollector();
355 return c;
356}
357
358/*---------------------------------------------------------------------------*/
359/*---------------------------------------------------------------------------*/
360
361void ParallelMngDispatcher::
362setTimeStats(ITimeStats* ts)
363{
364 m_time_stats = ts;
365 if (ts){
366 ITimeMetricCollector* c = ts->metricCollector();
367 _messagePassingMng()->setTimeMetricCollector(c);
368 }
369}
370
371/*---------------------------------------------------------------------------*/
372/*---------------------------------------------------------------------------*/
373
374TimeMetricAction ParallelMngDispatcher::
375_communicationTimeMetricAction() const
376{
377 return Timer::phaseAction(timeStats(),TP_Communication);
378}
379
380/*---------------------------------------------------------------------------*/
381/*---------------------------------------------------------------------------*/
382
383void ParallelMngDispatcher::
384broadcastString(String& str,Int32 rank)
385{
386 Int64 len_info[1];
387 Int32 my_rank = commRank();
388 Span<const Byte> bytes = str.bytes();
389 if (rank==my_rank){
390 len_info[0] = bytes.size();
391 broadcast(Int64ArrayView(1,len_info),rank);
392 ByteUniqueArray utf8_array(bytes);
393 broadcast(utf8_array,rank);
394 }
395 else{
396 broadcast(Int64ArrayView(1,len_info),rank);
397 ByteUniqueArray utf8_array(len_info[0]);
398 broadcast(utf8_array,rank);
399 str = String::fromUtf8(utf8_array);
400 }
401}
402
403/*---------------------------------------------------------------------------*/
404/*---------------------------------------------------------------------------*/
405
406void ParallelMngDispatcher::
407broadcastMemoryBuffer(ByteArray& bytes,Int32 rank)
408{
409 Int64 size = 0;
410 if (commRank()==rank){
411 size = bytes.largeSize();
412 }
413 {
414 Int64ArrayView bs(1,&size);
415 broadcast(bs,rank);
416 }
417 if (commRank()!=rank)
418 bytes.resize(size);
419 if (size!=0)
420 broadcast(bytes,rank);
421}
422
423/*---------------------------------------------------------------------------*/
424/*---------------------------------------------------------------------------*/
425
426void ParallelMngDispatcher::
427allGather(ISerializer* send_serializer, ISerializer* recv_serializer)
428{
429 Timer::Phase tphase(timeStats(), TP_Communication);
430 mpAllGather(_messagePassingMng(), send_serializer, recv_serializer);
431}
432
433/*---------------------------------------------------------------------------*/
434/*---------------------------------------------------------------------------*/
435
436void ParallelMngDispatcher::
437processMessages(ConstArrayView<ISerializeMessage*> messages)
438{
439 TimeMetricSentry tphase(Timer::phaseAction(timeStats(),TP_Communication));
440 Ref<ISerializeMessageList> message_list(createSerializeMessageListRef());
441
442 for (ISerializeMessage* m : messages)
443 message_list->addMessage(m);
444
445 message_list->waitMessages(Parallel::WaitAll);
446}
447
448/*---------------------------------------------------------------------------*/
449/*---------------------------------------------------------------------------*/
450
451void ParallelMngDispatcher::
452processMessages(ConstArrayView<Ref<ISerializeMessage>> messages)
453{
454 TimeMetricSentry tphase(Timer::phaseAction(timeStats(), TP_Communication));
455 Ref<ISerializeMessageList> message_list(createSerializeMessageListRef());
456
457 for (const Ref<ISerializeMessage>& v : messages)
458 message_list->addMessage(v.get());
459
460 message_list->waitMessages(Parallel::WaitAll);
461}
462
463/*---------------------------------------------------------------------------*/
464/*---------------------------------------------------------------------------*/
465
466Ref<ISerializeMessageList> ParallelMngDispatcher::
467createSerializeMessageListRef()
468{
469 return makeRef(_createSerializeMessageList());
470}
471
472/*---------------------------------------------------------------------------*/
473/*---------------------------------------------------------------------------*/
474
475ISerializeMessageList* ParallelMngDispatcher::
476createSerializeMessageList()
477{
478 return _createSerializeMessageList();
479}
480
481/*---------------------------------------------------------------------------*/
482/*---------------------------------------------------------------------------*/
483
484IParallelMng* ParallelMngDispatcher::
485createSubParallelMng(Int32ConstArrayView kept_ranks)
486{
487 return _createSubParallelMng(kept_ranks);
488}
489
490/*---------------------------------------------------------------------------*/
491/*---------------------------------------------------------------------------*/
492
493Ref<IParallelMng> ParallelMngDispatcher::
494createSubParallelMngRef(Int32ConstArrayView kept_ranks)
495{
496 return makeRef(_createSubParallelMng(kept_ranks));
497}
498
499/*---------------------------------------------------------------------------*/
500/*---------------------------------------------------------------------------*/
501
502Ref<IParallelMng> ParallelMngDispatcher::
503_createSubParallelMngRef([[maybe_unused]] Int32 color, [[maybe_unused]] Int32 key)
504{
505 ARCANE_THROW(NotImplementedException, "Create sub-parallelmng with split semantic");
506}
507
508/*---------------------------------------------------------------------------*/
509/*---------------------------------------------------------------------------*/
510
511UniqueArray<Integer> ParallelMngDispatcher::
512_doWaitRequests(ArrayView<Request> requests,eWaitType wait_type)
513{
514 Timer::Phase tphase(timeStats(),TP_Communication);
515 Ref<IRequestList> request_list(createRequestListRef());
516 Integer nb_request = requests.size();
517 request_list->add(requests);
518 request_list->wait(wait_type);
519 // Ne pas oublier de recopier les requêtes car elles ont pu être modifiées
520 for (Integer i=0; i<nb_request; ++i )
521 requests[i] = request_list->request(i);
522 return request_list->doneRequestIndexes();
523}
524
525/*---------------------------------------------------------------------------*/
526/*---------------------------------------------------------------------------*/
527
528UniqueArray<Integer> ParallelMngDispatcher::
529waitSomeRequests(ArrayView<Request> requests)
530{
531 return _doWaitRequests(requests,Parallel::WaitSome);
532}
533
534/*---------------------------------------------------------------------------*/
535/*---------------------------------------------------------------------------*/
536
542
543/*---------------------------------------------------------------------------*/
544/*---------------------------------------------------------------------------*/
545
546#define ARCANE_PARALLEL_MANAGER_DISPATCH(field,type)\
547void ParallelMngDispatcher::\
548allGather(ConstArrayView<type> send_buf,ArrayView<type> recv_buf)\
549{\
550 Timer::Phase tphase(timeStats(),TP_Communication);\
551 field->allGather(send_buf,recv_buf);\
552}\
553void ParallelMngDispatcher::\
554gather(ConstArrayView<type> send_buf,ArrayView<type> recv_buf,Integer rank) \
555{\
556 Timer::Phase tphase(timeStats(),TP_Communication);\
557 field->gather(send_buf,recv_buf,rank); \
558}\
559void ParallelMngDispatcher::\
560allGatherVariable(ConstArrayView<type> send_buf,Array<type>& recv_buf)\
561{\
562 Timer::Phase tphase(timeStats(),TP_Communication);\
563 field->allGatherVariable(send_buf,recv_buf);\
564}\
565void ParallelMngDispatcher::\
566gatherVariable(ConstArrayView<type> send_buf,Array<type>& recv_buf,Integer rank) \
567{\
568 Timer::Phase tphase(timeStats(),TP_Communication);\
569 field->gatherVariable(send_buf,recv_buf,rank); \
570}\
571void ParallelMngDispatcher::\
572scatterVariable(ConstArrayView<type> send_buf,ArrayView<type> recv_buf,Integer root)\
573{\
574 Timer::Phase tphase(timeStats(),TP_Communication);\
575 field->scatterVariable(send_buf,recv_buf,root);\
576}\
577type ParallelMngDispatcher::\
578reduce(eReduceType rt,type v)\
579{\
580 Timer::Phase tphase(timeStats(),TP_Communication);\
581 return field->allReduce(rt,v);\
582}\
583void ParallelMngDispatcher::\
584reduce(eReduceType rt,ArrayView<type> v)\
585{\
586 Timer::Phase tphase(timeStats(),TP_Communication);\
587 field->allReduce(rt,v);\
588}\
589void ParallelMngDispatcher::\
590broadcast(ArrayView<type> send_buf,Integer id)\
591{ \
592 Timer::Phase tphase(timeStats(),TP_Communication);\
593 field->broadcast(send_buf,id);\
594}\
595void ParallelMngDispatcher::\
596send(ConstArrayView<type> values,Integer id)\
597{\
598 Timer::Phase tphase(timeStats(),TP_Communication);\
599 field->send(values,id);\
600}\
601void ParallelMngDispatcher::\
602recv(ArrayView<type> values,Integer id)\
603{\
604 Timer::Phase tphase(timeStats(),TP_Communication);\
605 field->recv(values,id);\
606}\
607Parallel::Request ParallelMngDispatcher::\
608send(ConstArrayView<type> values,Integer id,bool is_blocked)\
609{\
610 Timer::Phase tphase(timeStats(),TP_Communication);\
611 return field->send(values,id,is_blocked);\
612}\
613Request ParallelMngDispatcher::\
614send(Span<const type> values,const PointToPointMessageInfo& message) \
615{\
616 Timer::Phase tphase(timeStats(),TP_Communication);\
617 return field->send(values,message);\
618}\
619Parallel::Request ParallelMngDispatcher::\
620recv(ArrayView<type> values,Integer id,bool is_blocked)\
621{\
622 Timer::Phase tphase(timeStats(),TP_Communication);\
623 return field->recv(values,id,is_blocked);\
624}\
625Request ParallelMngDispatcher::\
626receive(Span<type> values,const PointToPointMessageInfo& message) \
627{\
628 Timer::Phase tphase(timeStats(),TP_Communication);\
629 return field->receive(values,message);\
630}\
631void ParallelMngDispatcher::\
632sendRecv(ConstArrayView<type> send_buf,ArrayView<type> recv_buf,Integer id)\
633{\
634 Timer::Phase tphase(timeStats(),TP_Communication);\
635 field->sendRecv(send_buf,recv_buf,id);\
636}\
637void ParallelMngDispatcher::\
638allToAll(ConstArrayView<type> send_buf,ArrayView<type> recv_buf,Integer count)\
639{\
640 Timer::Phase tphase(timeStats(),TP_Communication);\
641 field->allToAll(send_buf,recv_buf,count);\
642}\
643void ParallelMngDispatcher::\
644allToAllVariable(ConstArrayView<type> send_buf,Int32ConstArrayView send_count,\
645 Int32ConstArrayView send_index,ArrayView<type> recv_buf,\
646 Int32ConstArrayView recv_count,Int32ConstArrayView recv_index)\
647{\
648 Timer::Phase tphase(timeStats(),TP_Communication);\
649 field->allToAllVariable(send_buf,send_count,send_index,recv_buf,recv_count,recv_index);\
650}\
651type ParallelMngDispatcher::\
652scan(eReduceType rt,type v)\
653{\
654 Timer::Phase tphase(timeStats(),TP_Communication);\
655 return field->scan(rt,v);\
656}\
657void ParallelMngDispatcher::\
658computeMinMaxSum(type val,type& min_val,type& max_val,type& sum_val,Int32& min_proc,Int32& max_proc)\
659{\
660 Timer::Phase tphase(timeStats(),TP_Communication);\
661 field->computeMinMaxSum(val,min_val,max_val,sum_val,min_proc,max_proc);\
662}\
663IParallelDispatchT<type>* ParallelMngDispatcher::\
664dispatcher(type*)\
665{\
666 return field;\
667}\
668void ParallelMngDispatcher::\
669computeMinMaxSum(ConstArrayView<type> values, \
670 ArrayView<type> min_values, \
671 ArrayView<type> max_values, \
672 ArrayView<type> sum_values, \
673 ArrayView<Int32> min_ranks, \
674 ArrayView<Int32> max_ranks) \
675{\
676 Timer::Phase tphase(timeStats(),TP_Communication);\
677 field->computeMinMaxSum(values,min_values,max_values,sum_values,min_ranks,max_ranks);\
678}\
679void ParallelMngDispatcher::\
680scan(eReduceType rt,ArrayView<type> v)\
681{\
682 Timer::Phase tphase(timeStats(),TP_Communication);\
683 field->scan(rt,v);\
684}
685
686ARCANE_PARALLEL_MANAGER_DISPATCH(m_char,char)
687ARCANE_PARALLEL_MANAGER_DISPATCH(m_unsigned_char,unsigned char)
688ARCANE_PARALLEL_MANAGER_DISPATCH(m_signed_char,signed char)
689ARCANE_PARALLEL_MANAGER_DISPATCH(m_short,short)
690ARCANE_PARALLEL_MANAGER_DISPATCH(m_unsigned_short,unsigned short)
691ARCANE_PARALLEL_MANAGER_DISPATCH(m_int,int)
692ARCANE_PARALLEL_MANAGER_DISPATCH(m_unsigned_int,unsigned int)
693ARCANE_PARALLEL_MANAGER_DISPATCH(m_long,long)
694ARCANE_PARALLEL_MANAGER_DISPATCH(m_unsigned_long,unsigned long)
695ARCANE_PARALLEL_MANAGER_DISPATCH(m_long_long,long long)
696ARCANE_PARALLEL_MANAGER_DISPATCH(m_unsigned_long_long,unsigned long long)
697ARCANE_PARALLEL_MANAGER_DISPATCH(m_float,float)
698ARCANE_PARALLEL_MANAGER_DISPATCH(m_double,double)
699ARCANE_PARALLEL_MANAGER_DISPATCH(m_long_double,long double)
700ARCANE_PARALLEL_MANAGER_DISPATCH(m_apreal,APReal)
701ARCANE_PARALLEL_MANAGER_DISPATCH(m_real2,Real2)
702ARCANE_PARALLEL_MANAGER_DISPATCH(m_real3,Real3)
703ARCANE_PARALLEL_MANAGER_DISPATCH(m_real2x2,Real2x2)
704ARCANE_PARALLEL_MANAGER_DISPATCH(m_real3x3,Real3x3)
705ARCANE_PARALLEL_MANAGER_DISPATCH(m_hpreal,HPReal)
706
707/*---------------------------------------------------------------------------*/
708/*---------------------------------------------------------------------------*/
709
710} // End namespace Arcane
711
712/*---------------------------------------------------------------------------*/
713/*---------------------------------------------------------------------------*/
714
715namespace Arccore
716{
717ARCCORE_DEFINE_REFERENCE_COUNTED_CLASS(Arcane::IParallelMng);
718ARCCORE_DEFINE_REFERENCE_COUNTED_CLASS(Arcane::IParallelMngContainer);
719}
720
721/*---------------------------------------------------------------------------*/
722/*---------------------------------------------------------------------------*/
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:827
ARCANE_THROW
#define ARCANE_THROW(exception_class,...)
Macro pour envoyer une exception avec formattage.
Definition ArcaneGlobal.h:757
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::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::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::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:476
Arcane::ParallelMngDispatcher::setTimeStats
void setTimeStats(ITimeStats *ts) override
Positionne le gestionnaire de statistiques.
Definition ParallelMngDispatcher.cc:362
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:427
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:494
Arcane::ParallelMngDispatcher::processMessages
void processMessages(ConstArrayView< ISerializeMessage * > messages) override
Exécute les opérations des messages messages.
Definition ParallelMngDispatcher.cc:437
Arcane::ParallelMngDispatcher::messagePassingMng
IMessagePassingMng * messagePassingMng() const override
Gestionnaire de message de Arccore associé
Definition ParallelMngDispatcher.cc:340
Arcane::ParallelMngDispatcher::timeMetricCollector
ITimeMetricCollector * timeMetricCollector() const override
Collecteur Arccore des statistiques temporelles (peut être nul)
Definition ParallelMngDispatcher.cc:349
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:485
Arcane::ParallelMngDispatcher::testSomeRequests
UniqueArray< Integer > testSomeRequests(ArrayView< Request > requests) override
Test si une des requêtes rvalues est terminée.
Definition ParallelMngDispatcher.cc:538
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:467
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:529
Arcane::ParallelMngDispatcher::broadcastMemoryBuffer
void broadcastMemoryBuffer(ByteArray &bytes, Int32 rank) override
Effectue un broadcast d'une zone mémoire.
Definition ParallelMngDispatcher.cc:407
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::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:292
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::MessagePassing::WaitSome
@ WaitSome
Attend que tous les messages de la liste soient traités.
Definition MessagePassingGlobal.h:112
Arcane::MessagePassing::mpAllGather
void mpAllGather(IMessagePassingMng *pm, const ISerializer *send_serializer, ISerializer *receive_serialize)
Message allGather() pour une sérialisation.
Definition Messages.cc:308
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