Arcane  v3.16.0.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
SequentialParallelMng.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/* SequentialParallelMng.cc (C) 2000-2025 */
9/* */
10/* Gestion du parallélisme dans le cas séquentiel. */
11/*---------------------------------------------------------------------------*/
12/*---------------------------------------------------------------------------*/
13
14#include "arccore/base/ReferenceCounter.h"
15
16#include "arccore/message_passing/PointToPointMessageInfo.h"
17
18#include "arcane/utils/Collection.h"
19#include "arcane/utils/ITraceMng.h"
20#include "arcane/utils/NotImplementedException.h"
21#include "arcane/utils/Real2.h"
22#include "arcane/utils/Real2x2.h"
23#include "arcane/utils/Real3.h"
24#include "arcane/utils/Real3x3.h"
25#include "arcane/utils/HPReal.h"
26#include "arcane/utils/NullThreadMng.h"
27#include "arcane/utils/ArgumentException.h"
28
29#include "arcane/core/IIOMng.h"
30#include "arcane/core/ISubDomain.h"
31#include "arcane/core/IApplication.h"
32#include "arcane/core/IParallelDispatch.h"
33#include "arcane/core/ParallelMngDispatcher.h"
34#include "arcane/core/ItemGroup.h"
35#include "arcane/core/IMesh.h"
36#include "arcane/core/IItemFamily.h"
37#include "arcane/core/MeshVariable.h"
38#include "arcane/core/Timer.h"
39#include "arcane/core/FactoryService.h"
40#include "arcane/core/AbstractService.h"
41#include "arcane/core/ISerializer.h"
42#include "arcane/core/internal/SerializeMessage.h"
43
44#include "arcane/parallel/IStat.h"
45
46#include "arcane/impl/TimerMng.h"
47#include "arcane/impl/GetVariablesValuesParallelOperation.h"
48#include "arcane/impl/ParallelExchanger.h"
49#include "arcane/impl/ParallelTopology.h"
50#include "arcane/impl/ParallelReplication.h"
51#include "arcane/impl/SequentialParallelSuperMng.h"
52#include "arcane/impl/SequentialParallelMng.h"
53#include "arcane/impl/internal/ParallelMngUtilsFactoryBase.h"
54#include "arcane/impl/internal/VariableSynchronizer.h"
55
56#include "arccore/message_passing/RequestListBase.h"
57#include "arccore/message_passing/SerializeMessageList.h"
58
59/*---------------------------------------------------------------------------*/
60/*---------------------------------------------------------------------------*/
61
62namespace Arcane
63{
66using namespace Arcane::MessagePassing;
67
68/*---------------------------------------------------------------------------*/
69/*---------------------------------------------------------------------------*/
70
71extern "C++" IVariableSynchronizer*
72createNullVariableSynchronizer(IParallelMng* pm,const ItemGroup& group);
73
74/*---------------------------------------------------------------------------*/
75/*---------------------------------------------------------------------------*/
76
78: public RequestListBase
79{
80 public:
81 void _wait(Parallel::eWaitType wait_mode)
82 {
83 ARCANE_UNUSED(wait_mode);
84 }
85};
86
87/*---------------------------------------------------------------------------*/
88/*---------------------------------------------------------------------------*/
92template<class Type>
93class SequentialParallelDispatchT
94: public TraceAccessor
95, public IParallelDispatchT<Type>
96, public ITypeDispatcher<Type>
97{
98 public:
99 typedef Parallel::Request Request;
100 typedef Parallel::eReduceType eReduceType;
101 public:
102 SequentialParallelDispatchT(ITraceMng* tm)
103 : TraceAccessor(tm) {}
104 void finalize() override {}
105 public:
106 void broadcast(ArrayView<Type> send_buf,Int32 rank) override
107 {
108 ARCANE_UNUSED(send_buf);
109 ARCANE_UNUSED(rank);
110 }
111 void broadcast(Span<Type> send_buf,Int32 rank) override
112 {
113 ARCANE_UNUSED(send_buf);
114 ARCANE_UNUSED(rank);
115 }
116 void allGather(ConstArrayView<Type> send_buf,ArrayView<Type> recv_buf) override
117 {
118 recv_buf.copy(send_buf);
119 }
120 void allGather(Span<const Type> send_buf,Span<Type> recv_buf) override
121 {
122 recv_buf.copy(send_buf);
123 }
124 void gather(ConstArrayView<Type> send_buf,ArrayView<Type> recv_buf,Int32 rank) override
125 {
126 ARCANE_UNUSED(rank);
127 recv_buf.copy(send_buf);
128 }
129 void gather(Span<const Type> send_buf,Span<Type> recv_buf,Int32 rank) override
130 {
131 ARCANE_UNUSED(rank);
132 recv_buf.copy(send_buf);
133 }
134 void scatterVariable(ConstArrayView<Type> send_buf,ArrayView<Type> recv_buf,Int32 root) override
135 {
136 ARCANE_UNUSED(root);
137 recv_buf.copy(send_buf);
138 }
139 void scatterVariable(Span<const Type> send_buf,Span<Type> recv_buf,Int32 root) override
140 {
141 ARCANE_UNUSED(root);
142 recv_buf.copy(send_buf);
143 }
144 void allGatherVariable(ConstArrayView<Type> send_buf,Array<Type>& recv_buf) override
145 {
146 gatherVariable(send_buf,recv_buf,0);
147 }
148 void allGatherVariable(Span<const Type> send_buf,Array<Type>& recv_buf) override
149 {
150 gatherVariable(send_buf,recv_buf,0);
151 }
152 void gatherVariable(ConstArrayView<Type> send_buf,Array<Type>& recv_buf,Int32 rank) override
153 {
154 ARCANE_UNUSED(rank);
155 recv_buf.resize(send_buf.size());
156 ArrayView<Type> av(recv_buf);
157 av.copy(send_buf);
158 }
159 void gatherVariable(Span<const Type> send_buf,Array<Type>& recv_buf,Int32 rank) override
160 {
161 ARCANE_UNUSED(rank);
162 recv_buf.resize(send_buf.size());
163 Span<Type> av(recv_buf.span());
164 av.copy(send_buf);
165 }
166 void allToAll(ConstArrayView<Type> send_buf,ArrayView<Type> recv_buf,Integer count) override
167 {
168 ARCANE_UNUSED(count);
169 recv_buf.copy(send_buf);
170 }
171 void allToAll(Span<const Type> send_buf,Span<Type> recv_buf,Int32 count) override
172 {
173 ARCANE_UNUSED(count);
174 recv_buf.copy(send_buf);
175 }
176 void allToAllVariable(ConstArrayView<Type> send_buf,
177 Int32ConstArrayView send_count,
178 Int32ConstArrayView send_index,
179 ArrayView<Type> recv_buf,
180 Int32ConstArrayView recv_count,
181 Int32ConstArrayView recv_index) override
182 {
183 ARCANE_UNUSED(send_count);
184 ARCANE_UNUSED(recv_count);
185 ARCANE_UNUSED(send_index);
186 ARCANE_UNUSED(recv_index);
187 recv_buf.copy(send_buf);
188 }
189 void allToAllVariable(Span<const Type> send_buf,
190 ConstArrayView<Int32> send_count,
191 ConstArrayView<Int32> send_index,
192 Span<Type> recv_buf,
193 ConstArrayView<Int32> recv_count,
194 ConstArrayView<Int32> recv_index) override
195 {
196 ARCANE_UNUSED(send_count);
197 ARCANE_UNUSED(recv_count);
198 ARCANE_UNUSED(send_index);
199 ARCANE_UNUSED(recv_index);
200 recv_buf.copy(send_buf);
201 }
202 Request send(ConstArrayView<Type> send_buffer,Int32 rank,bool is_blocked) override
203 {
204 return send(Span<const Type>(send_buffer),rank,is_blocked);
205 }
206 Request send(Span<const Type> send_buffer,Int32 rank,bool is_blocked) override
207 {
208 ARCANE_UNUSED(send_buffer);
209 ARCANE_UNUSED(rank);
210 if (is_blocked)
211 throw NotSupportedException(A_FUNCINFO,"blocking send is not allowed in sequential");
212 return Request();
213 }
214 Request send(Span<const Type> send_buffer,const PointToPointMessageInfo& message) override
215 {
216 ARCANE_UNUSED(send_buffer);
217 if (message.isBlocking())
218 throw NotSupportedException(A_FUNCINFO,"blocking send is not allowed in sequential");
219 return Request();
220 }
221 Request recv(ArrayView<Type> recv_buffer,Int32 rank,bool is_blocked) override
222 {
223 return receive(Span<Type>(recv_buffer),rank,is_blocked);
224 }
225 void send(ConstArrayView<Type> send_buffer,Int32 rank) override
226 {
227 ARCANE_UNUSED(send_buffer);
228 ARCANE_UNUSED(rank);
229 throw NotSupportedException(A_FUNCINFO,"send is not allowed in sequential");
230 }
231 void recv(ArrayView<Type> recv_buffer,Int32 rank) override
232 {
233 ARCANE_UNUSED(recv_buffer);
234 ARCANE_UNUSED(rank);
235 throw NotSupportedException(A_FUNCINFO,"recv is not allowed in sequential");
236 }
237 Request receive(Span<Type> recv_buffer,Int32 rank,bool is_blocked) override
238 {
239 ARCANE_UNUSED(recv_buffer);
240 ARCANE_UNUSED(rank);
241 if (is_blocked)
242 throw NotSupportedException(A_FUNCINFO,"blocking receive is not allowed in sequential");
243 return Request();
244 }
245 Request receive(Span<Type> recv_buffer,const PointToPointMessageInfo& message) override
246 {
247 ARCANE_UNUSED(recv_buffer);
248 if (message.isBlocking())
249 throw NotSupportedException(A_FUNCINFO,"blocking receive is not allowed in sequential");
250 return Request();
251 }
252 void sendRecv(ConstArrayView<Type> send_buffer,ArrayView<Type> recv_buffer,Int32 rank) override
253 {
254 ARCANE_UNUSED(rank);
255 recv_buffer.copy(send_buffer);
256 }
257 Type allReduce(eReduceType op,Type v) override
258 {
259 ARCANE_UNUSED(op);
260 return v;
261 }
262 void allReduce(eReduceType op,ArrayView<Type> send_buf) override
263 {
264 ARCANE_UNUSED(op);
265 ARCANE_UNUSED(send_buf);
266 }
267 void allReduce(eReduceType op,Span<Type> send_buf) override
268 {
269 ARCANE_UNUSED(op);
270 ARCANE_UNUSED(send_buf);
271 }
272 Request nonBlockingAllReduce(eReduceType op,Span<const Type> send_buf,Span<Type> recv_buf) override
273 {
274 ARCANE_UNUSED(op);
275 ARCANE_UNUSED(send_buf);
276 ARCANE_UNUSED(recv_buf);
277 return Request();
278 }
279 Request nonBlockingAllGather(Span<const Type> send_buf, Span<Type> recv_buf) override
280 {
281 recv_buf.copy(send_buf);
282 return Request();
283 }
284 Request nonBlockingBroadcast(Span<Type> send_buf, Int32 rank) override
285 {
286 ARCANE_UNUSED(send_buf);
287 ARCANE_UNUSED(rank);
288 return Request();
289 }
290 Request nonBlockingGather(Span<const Type> send_buf, Span<Type> recv_buf, Int32 rank) override
291 {
292 ARCANE_UNUSED(rank);
293 recv_buf.copy(send_buf);
294 return Request();
295 }
296 Request nonBlockingAllToAll(Span<const Type> send_buf, Span<Type> recv_buf, Int32 count) override
297 {
298 ARCANE_UNUSED(count);
299 recv_buf.copy(send_buf);
300 return Request();
301 }
302 Request nonBlockingAllToAllVariable(Span<const Type> send_buf, ConstArrayView<Int32> send_count,
303 ConstArrayView<Int32> send_index, Span<Type> recv_buf,
304 ConstArrayView<Int32> recv_count, ConstArrayView<Int32> recv_index) override
305 {
306 ARCANE_UNUSED(send_count);
307 ARCANE_UNUSED(recv_count);
308 ARCANE_UNUSED(send_index);
309 ARCANE_UNUSED(recv_index);
310 recv_buf.copy(send_buf);
311 return Request();
312 }
313 Type scan(eReduceType op,Type v) override
314 {
315 ARCANE_UNUSED(op);
316 return v;
317 }
318 void scan(eReduceType op,ArrayView<Type> send_buf) override
319 {
320 ARCANE_UNUSED(op);
321 ARCANE_UNUSED(send_buf);
322 }
323 void computeMinMaxSum(Type val,Type& min_val,Type& max_val,Type& sum_val,
324 Int32& min_rank,
325 Int32& max_rank) override
326 {
327 min_val = max_val = sum_val = val;
328 min_rank = max_rank = 0;
329 }
330 void computeMinMaxSum(ConstArrayView<Type> values,
331 ArrayView<Type> min_values,
332 ArrayView<Type> max_values,
333 ArrayView<Type> sum_values,
334 ArrayView<Int32> min_ranks,
335 ArrayView<Int32> max_ranks) override
336 {
337 const Integer n = values.size();
338 for(Integer i=0;i<n;++i) {
339 min_values[i] = max_values[i] = sum_values[i] = values[i];
340 min_ranks[i] = max_ranks[i] = 0;
341 }
342 }
343 ITypeDispatcher<Type>* toArccoreDispatcher() override { return this; }
344};
345
346/*---------------------------------------------------------------------------*/
347/*---------------------------------------------------------------------------*/
348
351{
352 public:
358 {
359 return makeRef(createNullVariableSynchronizer(pm,family->allItems()));
360 }
362 {
363 return makeRef(createNullVariableSynchronizer(pm,group));
364 }
365};
366
367/*---------------------------------------------------------------------------*/
368/*---------------------------------------------------------------------------*/
375class SequentialParallelMng
376: public ParallelMngDispatcher
377{
378 private:
379 // Construit un gestionnaire séquentiel.
380 SequentialParallelMng(const SequentialParallelMngBuildInfo& bi);
381 public:
382 ~SequentialParallelMng();
383
384 bool isParallel() const override { return false; }
385 Int32 commRank() const override { return 0; }
386 Int32 commSize() const override { return 1; }
387 void* getMPICommunicator() override { return m_communicator.communicatorAddress(); }
388 Parallel::Communicator communicator() const override { return m_communicator; }
389 bool isThreadImplementation() const override { return false; }
390 bool isHybridImplementation() const override { return false; }
391 void setBaseObject(IBase* m);
392 ITraceMng* traceMng() const override { return m_trace.get(); }
393 IThreadMng* threadMng() const override { return m_thread_mng; }
394 ITimerMng* timerMng() const override { return m_timer_mng; }
395 IParallelMng* worldParallelMng() const override { return m_world_parallel_mng; }
396 IIOMng* ioMng() const override { return m_io_mng; }
397
398 void initialize() override ;
399 bool isMasterIO() const override { return true; }
400 Int32 masterIORank() const override { return 0; }
401
402 public:
403
404 void allGather(ISerializer* send_serializer, ISerializer* recv_serializer) override
405 {
406 recv_serializer->copy(send_serializer);
407 }
408 void sendSerializer(ISerializer* values,Int32 rank) override
409 {
410 ARCANE_UNUSED(values);
411 ARCANE_UNUSED(rank);
412 }
413 Request sendSerializer(ISerializer* values,Int32 rank,ByteArray& bytes) override
414 {
415 ARCANE_UNUSED(values);
416 ARCANE_UNUSED(rank);
417 ARCANE_UNUSED(bytes);
418 return Parallel::Request();
419 }
421 {
422 ARCANE_UNUSED(rank);
423 return new SerializeMessage(0,0,ISerializeMessage::MT_Send);
424 }
425 void recvSerializer(ISerializer* values,Int32 rank) override
426 {
427 ARCANE_UNUSED(values);
428 ARCANE_UNUSED(rank);
429 }
431 {
432 ARCANE_UNUSED(rank);
433 return new SerializeMessage(0,0,ISerializeMessage::MT_Recv);
434 }
435
436 void broadcastString(String& str,Int32 rank) override
437 {
438 ARCANE_UNUSED(str);
439 ARCANE_UNUSED(rank);
440 }
441 void broadcastMemoryBuffer(ByteArray& bytes,Int32 rank) override
442 {
443 ARCANE_UNUSED(bytes);
444 ARCANE_UNUSED(rank);
445 }
446 void broadcastSerializer(ISerializer* values,Int32 rank) override
447 {
448 ARCANE_UNUSED(values);
449 ARCANE_UNUSED(rank);
450 }
451 MessageId probe(const PointToPointMessageInfo& message) override
452 {
453 ARCANE_UNUSED(message);
454 return MessageId();
455 }
457 {
458 ARCANE_UNUSED(message);
459 return MessageSourceInfo();
460 }
461 Request sendSerializer(const ISerializer* values,const PointToPointMessageInfo& message) override
462 {
463 ARCANE_UNUSED(values);
464 ARCANE_UNUSED(message);
465 return Parallel::Request();
466 }
467 Request receiveSerializer(ISerializer* values,const PointToPointMessageInfo& message) override
468 {
469 ARCANE_UNUSED(values);
470 ARCANE_UNUSED(message);
471 return Parallel::Request();
472 }
473
475 {
476 ARCANE_UNUSED(messages);
477 }
479 {
480 ARCANE_UNUSED(requests);
481 }
482
483 void printStats() override {}
484 void barrier() override {}
485
486 IParallelMng* sequentialParallelMng() override { return this; }
487 Ref<IParallelMng> sequentialParallelMngRef() override { return makeRef<IParallelMng>(this); }
488
489 void waitAllRequests(ArrayView<Request> requests) override
490 {
491 ARCANE_UNUSED(requests);
492 }
493
494 // Les requetes sont forcement deja satisfaites.
496 {
497 ARCANE_UNUSED(requests);
498 return UniqueArray<Integer>();
499 }
501 {
502 return waitSomeRequests(requests);
503 }
504
505 ISerializeMessageList* _createSerializeMessageList() override
506 {
508 }
509 Real reduceRank(eReduceType rt,Real v,Int32* rank)
510 {
511 Real rv = reduce(rt,v);
512 if (rank)
513 *rank = 0;
514 return rv;
515 }
525 {
526 return new ParallelExchanger(this);
527 }
529 {
530 return createNullVariableSynchronizer(this,family->allItems());
531 }
533 {
534 return createNullVariableSynchronizer(this,group);
535 }
537 {
538 ParallelTopology* t = new ParallelTopology(this);
539 t->initialize();
540 return t;
541 }
542
544 {
545 return m_replication;
546 }
547
549 {
550 delete m_replication;
551 m_replication = v;
552 }
553
555 {
557 return makeRef(r);
558 }
559
561 {
562 return m_utils_factory;
563 }
564
566 {
567 return m_stat;
568 }
569
570 void build() override;
571
573
574 public:
575
576 static IParallelMng* create(const SequentialParallelMngBuildInfo& bi)
577 {
578 if (!bi.traceMng())
579 ARCANE_THROW(ArgumentException,"null traceMng()");
580 if (!bi.threadMng())
581 ARCANE_THROW(ArgumentException,"null threadMng()");
582 auto x = new SequentialParallelMng(bi);
583 x->build();
584 return x;
585 }
587 {
588 return makeRef(create(bi));
589 }
590
591 protected:
592
593 IParallelMng* _createSubParallelMng(Int32ConstArrayView kept_ranks) override
594 {
595 ARCANE_UNUSED(kept_ranks);
596 SequentialParallelMngBuildInfo bi(m_timer_mng,m_world_parallel_mng);
597 bi.setThreadMng(m_thread_mng);
598 bi.setTraceMng(m_trace.get());
599 bi.setCommunicator(m_communicator);
600 return create(bi);
601 }
602
603 private:
604
605 ReferenceCounter<ITraceMng> m_trace;
606 IThreadMng* m_thread_mng = nullptr;
607 ITimerMng* m_timer_mng = nullptr;
608 IParallelMng* m_world_parallel_mng = nullptr;
609 IIOMng* m_io_mng;
610 Parallel::IStat* m_stat;
611 IParallelReplication* m_replication;
612 MP::Communicator m_communicator;
613 Ref<IParallelMngUtilsFactory> m_utils_factory;
614
615 private:
616
617};
618
619/*---------------------------------------------------------------------------*/
620/*---------------------------------------------------------------------------*/
621
622extern "C++" IIOMng*
623arcaneCreateIOMng(IParallelMng* psm);
624
625/*---------------------------------------------------------------------------*/
626/*---------------------------------------------------------------------------*/
627
628extern "C++" IParallelMng*
629arcaneCreateSequentialParallelMng(const SequentialParallelMngBuildInfo& bi)
630{
631 return SequentialParallelMng::create(bi);
632}
633extern "C++" Ref<IParallelMng>
634arcaneCreateSequentialParallelMngRef(const SequentialParallelMngBuildInfo& bi)
635{
636 return SequentialParallelMng::createRef(bi);
637}
638
639/*---------------------------------------------------------------------------*/
640/*---------------------------------------------------------------------------*/
641
642SequentialParallelMng::
643SequentialParallelMng(const SequentialParallelMngBuildInfo& bi)
645, m_trace(bi.traceMng())
646, m_thread_mng(bi.threadMng())
647, m_timer_mng(bi.m_timer_mng)
648, m_world_parallel_mng(bi.m_world_parallel_mng)
649, m_io_mng(nullptr)
650, m_stat(nullptr)
651, m_replication(new ParallelReplication())
652, m_communicator(bi.communicator())
654{
655 ARCANE_CHECK_PTR(m_trace);
656 ARCANE_CHECK_PTR(m_thread_mng);
657 if (!m_world_parallel_mng)
658 m_world_parallel_mng = this;
660 _messagePassingMng()->setCommunicator(m_communicator);
661}
662
663/*---------------------------------------------------------------------------*/
664/*---------------------------------------------------------------------------*/
665
666SequentialParallelMng::
667~SequentialParallelMng()
668{
669 delete m_stat;
670 delete m_replication;
671 delete m_io_mng;
672}
673
674/*---------------------------------------------------------------------------*/
675/*---------------------------------------------------------------------------*/
676
677void SequentialParallelMng::
678setBaseObject(IBase* sd)
679{
680 ARCANE_UNUSED(sd);
681}
682
683/*---------------------------------------------------------------------------*/
684/*---------------------------------------------------------------------------*/
685
686namespace
687{
688// Classe pour créer les différents dispatchers
689class DispatchCreator
690{
691 public:
692 DispatchCreator(ITraceMng* tm) : m_tm(tm){}
693 public:
694 template<typename DataType> SequentialParallelDispatchT<DataType>*
695 create()
696 {
697 return new SequentialParallelDispatchT<DataType>(m_tm);
698 }
699 ITraceMng* m_tm;
700};
701}
702
704build()
705{
706 m_io_mng = arcaneCreateIOMng(this);
707 DispatchCreator creator(m_trace.get());
708 this->createDispatchers(creator);
709}
710
711/*---------------------------------------------------------------------------*/
712/*---------------------------------------------------------------------------*/
713
716{
717 traceMng()->info() << "** ** MPI Communicator = " << getMPICommunicator();
718}
719
720/*---------------------------------------------------------------------------*/
721/*---------------------------------------------------------------------------*/
722
723/*---------------------------------------------------------------------------*/
724/*---------------------------------------------------------------------------*/
725
726// Construit un superviseur séquentiel lié au superviseur \a sm
727SequentialParallelSuperMng::
728SequentialParallelSuperMng(const ServiceBuildInfo& sbi)
729: AbstractService(sbi)
730, m_application(sbi.application())
731, m_thread_mng(new NullThreadMng())
732, m_timer_mng(nullptr)
733{
734}
735
736/*---------------------------------------------------------------------------*/
737/*---------------------------------------------------------------------------*/
738
739// Construit un superviseur séquentiel lié au superviseur \a sm
740SequentialParallelSuperMng::
741SequentialParallelSuperMng(const ServiceBuildInfo& sbi,Parallel::Communicator comm)
742: AbstractService(sbi)
743, m_application(sbi.application())
744, m_thread_mng(new NullThreadMng())
745, m_timer_mng(nullptr)
746, m_communicator(comm)
747{
748}
749
750/*---------------------------------------------------------------------------*/
751/*---------------------------------------------------------------------------*/
752
753// Construit un superviseur séquentiel lié au superviseur \a sm
754SequentialParallelSuperMng::
755~SequentialParallelSuperMng()
756{
757 delete m_thread_mng;
758}
759
760/*---------------------------------------------------------------------------*/
761/*---------------------------------------------------------------------------*/
762
774
775/*---------------------------------------------------------------------------*/
776/*---------------------------------------------------------------------------*/
777
779build()
780{
781 if (!m_timer_mng){
782 m_owned_timer_mng = new TimerMng(traceMng());
783 m_timer_mng = m_owned_timer_mng.get();
784 }
785}
786
787/*---------------------------------------------------------------------------*/
788/*---------------------------------------------------------------------------*/
789
792{
793 if (local_rank!=0)
794 ARCANE_THROW(ArgumentException,"Bad local_rank '{0}' (should be 0)",local_rank);
795
796 SequentialParallelMngBuildInfo bi(m_timer_mng,nullptr);
797 bi.setThreadMng(threadMng());
798 bi.setTraceMng(traceMng());
799 bi.setCommunicator(communicator());
800 return SequentialParallelMng::createRef(bi);
801}
802
803/*---------------------------------------------------------------------------*/
804/*---------------------------------------------------------------------------*/
805
810
811/*---------------------------------------------------------------------------*/
812/*---------------------------------------------------------------------------*/
813
816
817/*---------------------------------------------------------------------------*/
818/*---------------------------------------------------------------------------*/
819
820class SequentialParallelMngBuilder
822{
823 public:
824 SequentialParallelMngBuilder(IApplication* app,Parallel::Communicator comm)
825 : m_application(app), m_thread_mng(new NullThreadMng()),
826 m_timer_mng(new TimerMng(app->traceMng())), m_communicator(comm){}
827 ~SequentialParallelMngBuilder() override
828 {
829 delete m_timer_mng;
830 delete m_thread_mng;
831 }
832
833 public:
834
835 void build() {}
836 Ref<IParallelMng> _createParallelMng(Int32 local_rank,ITraceMng* tm) override;
837
838 public:
839 IApplication* m_application;
840 IThreadMng* m_thread_mng;
841 ITimerMng* m_timer_mng;
842 Parallel::Communicator m_communicator;
843};
844
845/*---------------------------------------------------------------------------*/
846/*---------------------------------------------------------------------------*/
847
849_createParallelMng(Int32 local_rank,ITraceMng* tm)
850{
851 if (local_rank!=0)
852 ARCANE_THROW(ArgumentException,"Bad local_rank '{0}' (should be 0)",local_rank);
853
854 SequentialParallelMngBuildInfo bi(m_timer_mng,nullptr);
855 bi.setTraceMng(tm);
856 bi.setThreadMng(m_thread_mng);
857 bi.setCommunicator(m_communicator);
858 return arcaneCreateSequentialParallelMngRef(bi);
859}
860
861/*---------------------------------------------------------------------------*/
862/*---------------------------------------------------------------------------*/
863
864class SequentialParallelMngContainerFactory
865: public AbstractService
867{
868 public:
869 SequentialParallelMngContainerFactory(const ServiceBuildInfo& sbi)
870 : AbstractService(sbi), m_application(sbi.application()){}
871 public:
874 {
875 ARCANE_UNUSED(nb_rank);
876 auto x = new SequentialParallelMngBuilder(m_application,comm);
877 x->build();
879 }
880 private:
881 IApplication* m_application;
882};
883
884/*---------------------------------------------------------------------------*/
885/*---------------------------------------------------------------------------*/
886
888 ServiceProperty("SequentialParallelMngContainerFactory",ST_Application),
890
891/*---------------------------------------------------------------------------*/
892/*---------------------------------------------------------------------------*/
893
894} // End namespace Arcane
895
896/*---------------------------------------------------------------------------*/
897/*---------------------------------------------------------------------------*/
898
#define ARCANE_THROW(exception_class,...)
Macro pour envoyer une exception avec formattage.
#define ARCANE_SERVICE_INTERFACE(ainterface)
Macro pour déclarer une interface lors de l'enregistrement d'un service.
#define ARCANE_REGISTER_APPLICATION_FACTORY(aclass, ainterface, aname)
Enregistre un service de fabrique pour la classe aclass.
Classe de base d'un service.
AbstractService(const ServiceBuildInfo &)
Constructeur à partir d'un ServiceBuildInfo.
Exception lorsqu'un argument est invalide.
Vue modifiable d'un tableau d'un type T.
void copy(const U &copy_array)
Recopie le tableau copy_array dans l'instance.
constexpr Integer size() const noexcept
Retourne la taille du tableau.
Tableau d'items de types quelconques.
Vue constante d'un tableau de type T.
constexpr Integer size() const noexcept
Nombre d'éléments du tableau.
Opérations pour accéder aux valeurs de variables d'un autre sous-domaine.
Interface de l'application.
Interface de la classe de base des objets principaux arcane.
Definition IBase.h:38
virtual ITraceMng * traceMng() const =0
Gestionnaire de traces.
Opérations pour accéder aux valeurs de variables d'un autre sous-domaine.
Interface du gestionnaire des entrées sorties.
Definition IIOMng.h:42
Interface d'une famille d'entités.
Definition IItemFamily.h:84
virtual ItemGroup allItems() const =0
Groupe de toutes les entités.
Gestion des messages parallèles pour le type Type.
Echange d'informations entre processeurs.
Interface d'une fabrique de conteneur de 'IParallelMng'.
Interface d'une fabrique pour les fonctions utilitaires de IParallelMng.
Interface du gestionnaire de parallélisme pour un sous-domaine.
virtual char reduce(eReduceType rt, char v)=0
Effectue la réduction de type rt sur le réel v et retourne la valeur.
Interface des opérations parallèles collectives non bloquantes.
Informations sur la réplication des sous-domaines en parallèle.
Classe abstraite du superviseur de parallélisme.
Informations sur la topologie d'allocation des coeurs de calcul.
virtual void copy(const ISerializer *from)=0
Copie les données de from dans cette instance.
Interface d'un gestionnaire de thread.
Definition IThreadMng.h:30
Interface d'un gestionnaire de timer.
Definition ITimerMng.h:53
Interface du gestionnaire de traces.
virtual TraceMessage info()=0
Flot pour un message d'information.
Envoie de valeurs sur différents processeurs.
Interface d'un service de synchronisation de variable.
Groupe d'entités de maillage.
Definition ItemGroup.h:49
Communicateur pour l'échange de message.
Interface d'un message de sérialisation entre IMessagePassingMng.
Gestion des messages parallèles pour le type Type.
Informations sur la source d'un message.
Informations pour envoyer/recevoir un message point à point.
bool isBlocking() const
Indique si le message est bloquant.
Requête d'un message.
Definition Request.h:77
Classe de base d'une liste de requêtes.
Exception lorsqu'une fonction n'est pas implémentée.
Exception lorsqu'une opération n'est pas supportée.
Gestionnaire de thread en mode mono-thread.
Echange d'informations entre processeurs.
Redirige la gestion des messages des sous-domaines suivant le type de l'argument.
IMessagePassingMng * messagePassingMng() const override
Gestionnaire de message de Arccore associé
Classe de base d'une fabrique pour les fonctions utilitaires de IParallelMng.
Informations sur la réplication des sous-domaines en parallèle.
Informations sur la topologie d'allocation des coeurs de calcul.
virtual void initialize()
Initialise l'instance. Cette opération est collective.
Statistiques sur le parallélisme.
Référence à une instance.
Interface des messages pour le type Type.
Ref< IParallelMng > _createParallelMng(Int32 local_rank, ITraceMng *tm) override
Créé le IParallelMng pour le rang local local_rank.
Ref< IParallelMngContainer > _createParallelMngBuilder(Int32 nb_rank, Parallel::Communicator comm) override
Créé un conteneur pour nb_local_rank rangs locaux et avec comme communicateur communicator.
Ref< ITransferValuesParallelOperation > createTransferValuesOperation(IParallelMng *) override
Retourne une opération pour transférer des valeurs entre rangs.
Ref< IVariableSynchronizer > createSynchronizer(IParallelMng *pm, const ItemGroup &group) override
Retourne une interface pour synchroniser des variables sur le groupe group.
Ref< IVariableSynchronizer > createSynchronizer(IParallelMng *pm, IItemFamily *family) override
Retourne une interface pour synchroniser des variables sur le groupe de la famille family.
Gestionnaire du parallélisme en mode séquentiel.
Parallel::Communicator communicator() const override
Communicateur MPI associé à ce gestionnaire.
ISerializeMessage * createReceiveSerializer(Int32 rank) override
Créé un message non bloquant pour recevoir des données sérialisées du rang rank.
IParallelNonBlockingCollective * nonBlockingCollective() const override
Interface des opérations collectives non blocantes.
ITransferValuesParallelOperation * createTransferValuesOperation() override
Retourne une opération pour transférer des valeurs entre sous-domaine.
IThreadMng * threadMng() const override
Gestionnaire de threads.
UniqueArray< Integer > testSomeRequests(ArrayView< Request > requests) override
Test si une des requêtes rvalues est terminée.
Int32 commRank() const override
Rang de cette instance dans le communicateur.
ISerializeMessage * createSendSerializer(Int32 rank) override
Créé un message non bloquant pour envoyer des données sérialisées au rang rank.
Int32 commSize() const override
Nombre d'instance dans le communicateur.
IParallelMng * sequentialParallelMng() override
Retourne un gestionnaire de parallélisme séquentiel.
void build() override
Construit l'instance.
void barrier() override
Effectue une barière.
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.
IGetVariablesValuesParallelOperation * createGetVariablesValuesOperation() override
Retourne une opération pour récupérer les valeurs d'une variable sur les entités d'un autre sous-doma...
IParallelReplication * replication() const override
Informations sur la réplication.
ITimerMng * timerMng() const override
Gestionnaire de timers.
MessageId probe(const PointToPointMessageInfo &message) override
Sonde si des messages sont disponibles.
Ref< IParallelMngUtilsFactory > _internalUtilsFactory() const override
Fabrique des fonctions utilitaires.
MessageSourceInfo legacyProbe(const PointToPointMessageInfo &message) override
Sonde si des messages sont disponibles.
void processMessages(ConstArrayView< ISerializeMessage * > messages) override
Exécute les opérations des messages messages.
bool isMasterIO() const override
true si l'instance est un gestionnaire maître des entrées/sorties.
bool isThreadImplementation() const override
Indique si l'implémentation utilise les threads.
Ref< IRequestList > createRequestListRef() override
Créé une liste de requêtes pour ce gestionnaire.
Parallel::IStat * stat() override
Gestionnaire des statistiques.
void printStats() override
Affiche des statistiques liées à ce gestionnaire du parallélisme.
ITraceMng * traceMng() const override
Gestionnaire de traces.
void initialize() override
Initialise le gestionnaire du parallélisme.
IParallelMng * worldParallelMng() const override
Gestionnaire de parallélisme sur l'ensemble des ressources allouées.
bool isHybridImplementation() const override
Indique si l'implémentation utilise le mode hybride.
IParallelTopology * createTopology() override
Créé une instance contenant les infos sur la topologie des rangs de ce gestionnnaire.
bool isParallel() const override
Retourne true si l'exécution est parallèle.
void setReplication(IParallelReplication *v) override
Positionne les Informations sur la réplication.
void freeRequests(ArrayView< Parallel::Request > requests) override
Libère les requêtes.
void waitAllRequests(ArrayView< Request > requests) override
Bloque en attendant que les requêtes rvalues soient terminées.
UniqueArray< Integer > waitSomeRequests(ArrayView< Request > requests) override
Bloque en attendant qu'une des requêtes rvalues soit terminée.
void broadcastMemoryBuffer(ByteArray &bytes, Int32 rank) override
Effectue un broadcast d'une zone mémoire.
IVariableSynchronizer * createSynchronizer(const ItemGroup &group) override
Retourne une interface pour synchroniser des variables sur le groupe group.
IIOMng * ioMng() const override
Gestionnaire des entrées/sorties.
Int32 masterIORank() const override
Rang de l'instance gérant les entrées/sorties (pour laquelle isMasterIO() est vrai)
IVariableSynchronizer * createSynchronizer(IItemFamily *family) override
Retourne une interface pour synchroniser des variables sur le groupe de la famille family.
IParallelExchanger * createExchanger() override
Retourne une interface pour transférer des messages entre processeurs.
Request sendSerializer(ISerializer *values, Int32 rank, ByteArray &bytes) override
void * getMPICommunicator() override
Adresse du communicateur MPI associé à ce gestionnaire.
Superviseur du parallélisme en mode séquentiel.
void initialize() override
Initialise l'instance.
Ref< IParallelMng > internalCreateWorldParallelMng(Int32 local_rank) override
Créé un gestionnaire de parallélisme pour l'ensemble des coeurs alloués.
MP::Communicator communicator() const override
Communicateur MPI associé à ce gestionnaire.
void tryAbort() override
Tente de faire un abort.
void build() override
Construction de niveau build du service.
IApplication * m_application
Superviseur associé
IThreadMng * threadMng() const override
Gestionnaire de thread.
void _wait(Parallel::eWaitType wait_mode)
Effectue l'attente ou le test.
Message utilisant un SerializeBuffer.
IApplication * application() const
Accès à l'application IApplication associé.
Structure contenant les informations pour créer un service.
Propriétés de création d'un service.
__host__ __device__ void copy(const U &copy_array)
Recopie le tableau copy_array dans l'instance.
Definition Span.h:360
Vue d'un tableau d'éléments de type T.
Definition Span.h:513
Chaîne de caractères unicode.
Gestionnaire de timer.
Definition TimerMng.h:39
TraceAccessor(ITraceMng *m)
Construit un accesseur via le gestionnaire de trace m.
ITraceMng * traceMng() const
Gestionnaire de trace.
Vecteur 1D de données avec sémantique par valeur (style STL).
#define ARCANE_REGISTER_SERVICE(aclass, a_service_property,...)
Macro pour enregistrer un service.
Déclarations des types et méthodes utilisés par les mécanismes d'échange de messages.
Definition Parallel.h:50
eReduceType
Types des réductions supportées.
IStat * createDefaultStat()
Créé une instance par défaut.
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
Ref< TrueType > createRef(Args &&... args)
Créé une instance de type TrueType avec les arguments Args et retourne une référence dessus.
Int32 Integer
Type représentant un entier.
Array< Byte > ByteArray
Tableau dynamique à une dimension de caractères.
Definition UtilsTypes.h:208
ConstArrayView< Int32 > Int32ConstArrayView
Equivalent C d'un tableau à une dimension d'entiers 32 bits.
Definition UtilsTypes.h:569
@ ST_Application
Le service s'utilise au niveau de l'application.
auto makeRef(InstanceType *t) -> Ref< InstanceType >
Créé une référence sur un pointeur.
std::int32_t Int32
Type entier signé sur 32 bits.
Type
Type of JSON value.
Definition rapidjson.h:665
Infos pour construire un SequentialParallelMng.