Arcane  v3.16.8.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#include "arcane/core/internal/ParallelMngInternal.h"
44
45#include "arcane/parallel/IStat.h"
46
47#include "arcane/impl/TimerMng.h"
48#include "arcane/impl/GetVariablesValuesParallelOperation.h"
49#include "arcane/impl/ParallelExchanger.h"
50#include "arcane/impl/ParallelTopology.h"
51#include "arcane/impl/ParallelReplication.h"
52#include "arcane/impl/SequentialParallelSuperMng.h"
53#include "arcane/impl/SequentialParallelMng.h"
54#include "arcane/impl/internal/ParallelMngUtilsFactoryBase.h"
55#include "arcane/impl/internal/VariableSynchronizer.h"
56
57#include "arccore/message_passing/RequestListBase.h"
58#include "arccore/message_passing/SerializeMessageList.h"
59#include "arccore/message_passing/internal/IMachineMemoryWindowBaseInternal.h"
60#include "arccore/message_passing/internal/IDynamicMachineMemoryWindowBaseInternal.h"
61
62/*---------------------------------------------------------------------------*/
63/*---------------------------------------------------------------------------*/
64
65namespace Arcane
66{
69using namespace Arcane::MessagePassing;
70
71/*---------------------------------------------------------------------------*/
72/*---------------------------------------------------------------------------*/
73
74extern "C++" IVariableSynchronizer*
75createNullVariableSynchronizer(IParallelMng* pm,const ItemGroup& group);
76
77/*---------------------------------------------------------------------------*/
78/*---------------------------------------------------------------------------*/
79
81: public RequestListBase
82{
83 public:
84 void _wait(Parallel::eWaitType wait_mode)
85 {
86 ARCANE_UNUSED(wait_mode);
87 }
88};
89
90/*---------------------------------------------------------------------------*/
91/*---------------------------------------------------------------------------*/
95template<class Type>
96class SequentialParallelDispatchT
97: public TraceAccessor
98, public IParallelDispatchT<Type>
99, public ITypeDispatcher<Type>
100{
101 public:
102 typedef Parallel::Request Request;
103 typedef Parallel::eReduceType eReduceType;
104 public:
105 SequentialParallelDispatchT(ITraceMng* tm)
106 : TraceAccessor(tm) {}
107 void finalize() override {}
108 public:
109 void broadcast(ArrayView<Type> send_buf,Int32 rank) override
110 {
111 ARCANE_UNUSED(send_buf);
112 ARCANE_UNUSED(rank);
113 }
114 void broadcast(Span<Type> send_buf,Int32 rank) override
115 {
116 ARCANE_UNUSED(send_buf);
117 ARCANE_UNUSED(rank);
118 }
119 void allGather(ConstArrayView<Type> send_buf,ArrayView<Type> recv_buf) override
120 {
121 recv_buf.copy(send_buf);
122 }
123 void allGather(Span<const Type> send_buf,Span<Type> recv_buf) override
124 {
125 recv_buf.copy(send_buf);
126 }
127 void gather(ConstArrayView<Type> send_buf,ArrayView<Type> recv_buf,Int32 rank) override
128 {
129 ARCANE_UNUSED(rank);
130 recv_buf.copy(send_buf);
131 }
132 void gather(Span<const Type> send_buf,Span<Type> recv_buf,Int32 rank) override
133 {
134 ARCANE_UNUSED(rank);
135 recv_buf.copy(send_buf);
136 }
137 void scatterVariable(ConstArrayView<Type> send_buf,ArrayView<Type> recv_buf,Int32 root) override
138 {
139 ARCANE_UNUSED(root);
140 recv_buf.copy(send_buf);
141 }
142 void scatterVariable(Span<const Type> send_buf,Span<Type> recv_buf,Int32 root) override
143 {
144 ARCANE_UNUSED(root);
145 recv_buf.copy(send_buf);
146 }
147 void allGatherVariable(ConstArrayView<Type> send_buf,Array<Type>& recv_buf) override
148 {
149 gatherVariable(send_buf,recv_buf,0);
150 }
151 void allGatherVariable(Span<const Type> send_buf,Array<Type>& recv_buf) override
152 {
153 gatherVariable(send_buf,recv_buf,0);
154 }
155 void gatherVariable(ConstArrayView<Type> send_buf,Array<Type>& recv_buf,Int32 rank) override
156 {
157 ARCANE_UNUSED(rank);
158 recv_buf.resize(send_buf.size());
159 ArrayView<Type> av(recv_buf);
160 av.copy(send_buf);
161 }
162 void gatherVariable(Span<const Type> send_buf,Array<Type>& recv_buf,Int32 rank) override
163 {
164 ARCANE_UNUSED(rank);
165 recv_buf.resize(send_buf.size());
166 Span<Type> av(recv_buf.span());
167 av.copy(send_buf);
168 }
169 void allToAll(ConstArrayView<Type> send_buf,ArrayView<Type> recv_buf,Integer count) override
170 {
171 ARCANE_UNUSED(count);
172 recv_buf.copy(send_buf);
173 }
174 void allToAll(Span<const Type> send_buf,Span<Type> recv_buf,Int32 count) override
175 {
176 ARCANE_UNUSED(count);
177 recv_buf.copy(send_buf);
178 }
179 void allToAllVariable(ConstArrayView<Type> send_buf,
180 Int32ConstArrayView send_count,
181 Int32ConstArrayView send_index,
182 ArrayView<Type> recv_buf,
183 Int32ConstArrayView recv_count,
184 Int32ConstArrayView recv_index) override
185 {
186 ARCANE_UNUSED(send_count);
187 ARCANE_UNUSED(recv_count);
188 ARCANE_UNUSED(send_index);
189 ARCANE_UNUSED(recv_index);
190 recv_buf.copy(send_buf);
191 }
192 void allToAllVariable(Span<const Type> send_buf,
193 ConstArrayView<Int32> send_count,
194 ConstArrayView<Int32> send_index,
195 Span<Type> recv_buf,
196 ConstArrayView<Int32> recv_count,
197 ConstArrayView<Int32> recv_index) override
198 {
199 ARCANE_UNUSED(send_count);
200 ARCANE_UNUSED(recv_count);
201 ARCANE_UNUSED(send_index);
202 ARCANE_UNUSED(recv_index);
203 recv_buf.copy(send_buf);
204 }
205 Request send(ConstArrayView<Type> send_buffer,Int32 rank,bool is_blocked) override
206 {
207 return send(Span<const Type>(send_buffer),rank,is_blocked);
208 }
209 Request send(Span<const Type> send_buffer,Int32 rank,bool is_blocked) override
210 {
211 ARCANE_UNUSED(send_buffer);
212 ARCANE_UNUSED(rank);
213 if (is_blocked)
214 throw NotSupportedException(A_FUNCINFO,"blocking send is not allowed in sequential");
215 return Request();
216 }
217 Request send(Span<const Type> send_buffer,const PointToPointMessageInfo& message) override
218 {
219 ARCANE_UNUSED(send_buffer);
220 if (message.isBlocking())
221 throw NotSupportedException(A_FUNCINFO,"blocking send is not allowed in sequential");
222 return Request();
223 }
224 Request recv(ArrayView<Type> recv_buffer,Int32 rank,bool is_blocked) override
225 {
226 return receive(Span<Type>(recv_buffer),rank,is_blocked);
227 }
228 void send(ConstArrayView<Type> send_buffer,Int32 rank) override
229 {
230 ARCANE_UNUSED(send_buffer);
231 ARCANE_UNUSED(rank);
232 throw NotSupportedException(A_FUNCINFO,"send is not allowed in sequential");
233 }
234 void recv(ArrayView<Type> recv_buffer,Int32 rank) override
235 {
236 ARCANE_UNUSED(recv_buffer);
237 ARCANE_UNUSED(rank);
238 throw NotSupportedException(A_FUNCINFO,"recv is not allowed in sequential");
239 }
240 Request receive(Span<Type> recv_buffer,Int32 rank,bool is_blocked) override
241 {
242 ARCANE_UNUSED(recv_buffer);
243 ARCANE_UNUSED(rank);
244 if (is_blocked)
245 throw NotSupportedException(A_FUNCINFO,"blocking receive is not allowed in sequential");
246 return Request();
247 }
248 Request receive(Span<Type> recv_buffer,const PointToPointMessageInfo& message) override
249 {
250 ARCANE_UNUSED(recv_buffer);
251 if (message.isBlocking())
252 throw NotSupportedException(A_FUNCINFO,"blocking receive is not allowed in sequential");
253 return Request();
254 }
255 void sendRecv(ConstArrayView<Type> send_buffer,ArrayView<Type> recv_buffer,Int32 rank) override
256 {
257 ARCANE_UNUSED(rank);
258 recv_buffer.copy(send_buffer);
259 }
260 Type allReduce(eReduceType op,Type v) override
261 {
262 ARCANE_UNUSED(op);
263 return v;
264 }
265 void allReduce(eReduceType op,ArrayView<Type> send_buf) override
266 {
267 ARCANE_UNUSED(op);
268 ARCANE_UNUSED(send_buf);
269 }
270 void allReduce(eReduceType op,Span<Type> send_buf) override
271 {
272 ARCANE_UNUSED(op);
273 ARCANE_UNUSED(send_buf);
274 }
275 Request nonBlockingAllReduce(eReduceType op,Span<const Type> send_buf,Span<Type> recv_buf) override
276 {
277 ARCANE_UNUSED(op);
278 ARCANE_UNUSED(send_buf);
279 ARCANE_UNUSED(recv_buf);
280 return Request();
281 }
282 Request nonBlockingAllGather(Span<const Type> send_buf, Span<Type> recv_buf) override
283 {
284 recv_buf.copy(send_buf);
285 return Request();
286 }
287 Request nonBlockingBroadcast(Span<Type> send_buf, Int32 rank) override
288 {
289 ARCANE_UNUSED(send_buf);
290 ARCANE_UNUSED(rank);
291 return Request();
292 }
293 Request nonBlockingGather(Span<const Type> send_buf, Span<Type> recv_buf, Int32 rank) override
294 {
295 ARCANE_UNUSED(rank);
296 recv_buf.copy(send_buf);
297 return Request();
298 }
299 Request nonBlockingAllToAll(Span<const Type> send_buf, Span<Type> recv_buf, Int32 count) override
300 {
301 ARCANE_UNUSED(count);
302 recv_buf.copy(send_buf);
303 return Request();
304 }
305 Request nonBlockingAllToAllVariable(Span<const Type> send_buf, ConstArrayView<Int32> send_count,
306 ConstArrayView<Int32> send_index, Span<Type> recv_buf,
307 ConstArrayView<Int32> recv_count, ConstArrayView<Int32> recv_index) override
308 {
309 ARCANE_UNUSED(send_count);
310 ARCANE_UNUSED(recv_count);
311 ARCANE_UNUSED(send_index);
312 ARCANE_UNUSED(recv_index);
313 recv_buf.copy(send_buf);
314 return Request();
315 }
316 Type scan(eReduceType op,Type v) override
317 {
318 ARCANE_UNUSED(op);
319 return v;
320 }
321 void scan(eReduceType op,ArrayView<Type> send_buf) override
322 {
323 ARCANE_UNUSED(op);
324 ARCANE_UNUSED(send_buf);
325 }
326 void computeMinMaxSum(Type val,Type& min_val,Type& max_val,Type& sum_val,
327 Int32& min_rank,
328 Int32& max_rank) override
329 {
330 min_val = max_val = sum_val = val;
331 min_rank = max_rank = 0;
332 }
333 void computeMinMaxSum(ConstArrayView<Type> values,
334 ArrayView<Type> min_values,
335 ArrayView<Type> max_values,
336 ArrayView<Type> sum_values,
337 ArrayView<Int32> min_ranks,
338 ArrayView<Int32> max_ranks) override
339 {
340 const Integer n = values.size();
341 for(Integer i=0;i<n;++i) {
342 min_values[i] = max_values[i] = sum_values[i] = values[i];
343 min_ranks[i] = max_ranks[i] = 0;
344 }
345 }
346 ITypeDispatcher<Type>* toArccoreDispatcher() override { return this; }
347};
348
349/*---------------------------------------------------------------------------*/
350/*---------------------------------------------------------------------------*/
351
352class SequentialMachineMemoryWindowBaseInternal
354{
355 public:
356
357 SequentialMachineMemoryWindowBaseInternal(Int64 sizeof_segment, Int32 sizeof_type)
358 : m_sizeof_segment(sizeof_segment)
359 , m_max_sizeof_segment(sizeof_segment)
360 , m_sizeof_type(sizeof_type)
361 , m_segment(sizeof_segment)
362 {}
363
364 ~SequentialMachineMemoryWindowBaseInternal() override = default;
365
366 public:
367
368 Int32 sizeofOneElem() const override
369 {
370 return m_sizeof_type;
371 }
372
374 {
375 return m_segment.span().subSpan(0, m_sizeof_segment);
376 }
377 Span<std::byte> segmentView(const Int32 rank) override
378 {
379 if (rank != 0) {
380 ARCANE_FATAL("Rank {0} is unavailable (Sequential)", rank);
381 }
382 return m_segment.span().subSpan(0, m_sizeof_segment);
383 }
385 {
386 return m_segment.span().subSpan(0, m_sizeof_segment);
387 }
388
390 {
391 return m_segment.constSpan().subSpan(0, m_sizeof_segment);
392 }
394 {
395 if (rank != 0) {
396 ARCANE_FATAL("Rank {0} is unavailable (Sequential)", rank);
397 }
398 return m_segment.constSpan().subSpan(0, m_sizeof_segment);
399 }
401 {
402 return m_segment.constSpan().subSpan(0, m_sizeof_segment);
403 }
404
405 void resizeSegment(const Int64 new_sizeof_segment) override
406 {
407 if (new_sizeof_segment > m_max_sizeof_segment) {
408 ARCANE_FATAL("New size of window (sum of size of all segments) is superior than the old size");
409 }
410 m_sizeof_segment = new_sizeof_segment;
411 }
412
414 {
415 return ConstArrayView<Int32>{ 1, &m_my_rank };
416 }
417
418 void barrier() const override {}
419
420 private:
421
422 Int64 m_sizeof_segment = 0;
423 Int64 m_max_sizeof_segment = 0;
424
425 Int32 m_sizeof_type = 0;
426 UniqueArray<std::byte> m_segment;
427 Int32 m_my_rank = 0;
428};
429
430/*---------------------------------------------------------------------------*/
431/*---------------------------------------------------------------------------*/
432
433class SequentialDynamicMachineMemoryWindowBaseInternal
435{
436 public:
437
438 SequentialDynamicMachineMemoryWindowBaseInternal(Int64 sizeof_segment, Int32 sizeof_type)
439 : m_sizeof_type(sizeof_type)
440 , m_segment(sizeof_segment)
441 {}
442 ~SequentialDynamicMachineMemoryWindowBaseInternal() override = default;
443
444 public:
445
446 Int32 sizeofOneElem() const override
447 {
448 return m_sizeof_type;
449 }
451 {
452 return ConstArrayView<Int32>{ 1, &m_my_rank };
453 }
454 void barrier() const override {}
455
457 {
458 return m_segment;
459 }
461 {
462 if (rank != 0) {
463 ARCANE_FATAL("Rank {0} is unavailable (Sequential)", rank);
464 }
465 return m_segment;
466 }
468 {
469 return m_segment;
470 }
472 {
473 if (rank != 0) {
474 ARCANE_FATAL("Rank {0} is unavailable (Sequential)", rank);
475 }
476 return m_segment;
477 }
478 void add(Span<const std::byte> elem) override
479 {
480 if (elem.size() % m_sizeof_type != 0) {
481 ARCCORE_FATAL("Sizeof elem not valid");
482 }
483 m_segment.addRange(elem);
484 }
485 void add() override {}
487 {
488 if (rank != 0) {
489 ARCANE_FATAL("Rank {0} is unavailable (Sequential)", rank);
490 }
491 if (elem.size() % m_sizeof_type != 0) {
492 ARCCORE_FATAL("Sizeof elem not valid");
493 }
494 m_segment.addRange(elem);
495 }
496 void addToAnotherSegment() override {}
497
498 void reserve(Int64 new_capacity) override
499 {
500 m_segment.reserve(new_capacity);
501 }
502 void reserve() override {}
503 void resize(Int64 new_size) override
504 {
505 m_segment.resize(new_size);
506 }
507 void resize() override {}
508 void shrink() override
509 {
510 m_segment.shrink();
511 }
512
513 private:
514
515 Int32 m_sizeof_type;
516 UniqueArray<std::byte> m_segment;
517 Int32 m_my_rank = 0;
518};
519
520/*---------------------------------------------------------------------------*/
521/*---------------------------------------------------------------------------*/
522
525{
526 public:
532 {
533 return makeRef(createNullVariableSynchronizer(pm,family->allItems()));
534 }
536 {
537 return makeRef(createNullVariableSynchronizer(pm,group));
538 }
539};
540
541/*---------------------------------------------------------------------------*/
542/*---------------------------------------------------------------------------*/
549class SequentialParallelMng
550: public ParallelMngDispatcher
551{
552 public:
553
554 class Impl;
555
556 private:
557 // Construit un gestionnaire séquentiel.
558 SequentialParallelMng(const SequentialParallelMngBuildInfo& bi);
559 public:
560 ~SequentialParallelMng();
561
562 bool isParallel() const override { return false; }
563 Int32 commRank() const override { return 0; }
564 Int32 commSize() const override { return 1; }
565 void* getMPICommunicator() override { return m_communicator.communicatorAddress(); }
566 Parallel::Communicator communicator() const override { return m_communicator; }
567 bool isThreadImplementation() const override { return false; }
568 bool isHybridImplementation() const override { return false; }
569 void setBaseObject(IBase* m);
570 ITraceMng* traceMng() const override { return m_trace.get(); }
571 IThreadMng* threadMng() const override { return m_thread_mng; }
572 ITimerMng* timerMng() const override { return m_timer_mng; }
573 IParallelMng* worldParallelMng() const override { return m_world_parallel_mng; }
574 IIOMng* ioMng() const override { return m_io_mng; }
575
576 void initialize() override ;
577 bool isMasterIO() const override { return true; }
578 Int32 masterIORank() const override { return 0; }
579
580 public:
581
582 void allGather(ISerializer* send_serializer, ISerializer* recv_serializer) override
583 {
584 recv_serializer->copy(send_serializer);
585 }
586 void sendSerializer(ISerializer* values,Int32 rank) override
587 {
588 ARCANE_UNUSED(values);
589 ARCANE_UNUSED(rank);
590 }
591 Request sendSerializer(ISerializer* values,Int32 rank,ByteArray& bytes) override
592 {
593 ARCANE_UNUSED(values);
594 ARCANE_UNUSED(rank);
595 ARCANE_UNUSED(bytes);
596 return Parallel::Request();
597 }
599 {
600 ARCANE_UNUSED(rank);
601 return new SerializeMessage(0,0,ISerializeMessage::MT_Send);
602 }
603 void recvSerializer(ISerializer* values,Int32 rank) override
604 {
605 ARCANE_UNUSED(values);
606 ARCANE_UNUSED(rank);
607 }
609 {
610 ARCANE_UNUSED(rank);
611 return new SerializeMessage(0,0,ISerializeMessage::MT_Recv);
612 }
613
614 void broadcastString(String& str,Int32 rank) override
615 {
616 ARCANE_UNUSED(str);
617 ARCANE_UNUSED(rank);
618 }
619 void broadcastMemoryBuffer(ByteArray& bytes,Int32 rank) override
620 {
621 ARCANE_UNUSED(bytes);
622 ARCANE_UNUSED(rank);
623 }
624 void broadcastSerializer(ISerializer* values,Int32 rank) override
625 {
626 ARCANE_UNUSED(values);
627 ARCANE_UNUSED(rank);
628 }
629 MessageId probe(const PointToPointMessageInfo& message) override
630 {
631 ARCANE_UNUSED(message);
632 return MessageId();
633 }
635 {
636 ARCANE_UNUSED(message);
637 return MessageSourceInfo();
638 }
639 Request sendSerializer(const ISerializer* values,const PointToPointMessageInfo& message) override
640 {
641 ARCANE_UNUSED(values);
642 ARCANE_UNUSED(message);
643 return Parallel::Request();
644 }
645 Request receiveSerializer(ISerializer* values,const PointToPointMessageInfo& message) override
646 {
647 ARCANE_UNUSED(values);
648 ARCANE_UNUSED(message);
649 return Parallel::Request();
650 }
651
653 {
654 ARCANE_UNUSED(messages);
655 }
657 {
658 ARCANE_UNUSED(requests);
659 }
660
661 void printStats() override {}
662 void barrier() override {}
663
664 IParallelMng* sequentialParallelMng() override { return this; }
665 Ref<IParallelMng> sequentialParallelMngRef() override { return makeRef<IParallelMng>(this); }
666
667 void waitAllRequests(ArrayView<Request> requests) override
668 {
669 ARCANE_UNUSED(requests);
670 }
671
672 // Les requetes sont forcement deja satisfaites.
674 {
675 ARCANE_UNUSED(requests);
676 return UniqueArray<Integer>();
677 }
679 {
680 return waitSomeRequests(requests);
681 }
682
683 ISerializeMessageList* _createSerializeMessageList() override
684 {
686 }
687 Real reduceRank(eReduceType rt,Real v,Int32* rank)
688 {
689 Real rv = reduce(rt,v);
690 if (rank)
691 *rank = 0;
692 return rv;
693 }
703 {
704 return new ParallelExchanger(this);
705 }
707 {
708 return createNullVariableSynchronizer(this,family->allItems());
709 }
711 {
712 return createNullVariableSynchronizer(this,group);
713 }
715 {
716 ParallelTopology* t = new ParallelTopology(this);
717 t->initialize();
718 return t;
719 }
720
722 {
723 return m_replication;
724 }
725
727 {
728 delete m_replication;
729 m_replication = v;
730 }
731
733 {
735 return makeRef(r);
736 }
737
739 {
740 return m_utils_factory;
741 }
742
744 {
745 return m_stat;
746 }
747
748 void build() override;
749
751
752 IParallelMngInternal* _internalApi() override { return m_parallel_mng_internal; }
753
754 public:
755
756 static IParallelMng* create(const SequentialParallelMngBuildInfo& bi)
757 {
758 if (!bi.traceMng())
759 ARCANE_THROW(ArgumentException,"null traceMng()");
760 if (!bi.threadMng())
761 ARCANE_THROW(ArgumentException,"null threadMng()");
762 auto x = new SequentialParallelMng(bi);
763 x->build();
764 return x;
765 }
767 {
768 return makeRef(create(bi));
769 }
770
771 protected:
772
773 IParallelMng* _createSubParallelMng(Int32ConstArrayView kept_ranks) override
774 {
775 ARCANE_UNUSED(kept_ranks);
776 SequentialParallelMngBuildInfo bi(m_timer_mng,m_world_parallel_mng);
777 bi.setThreadMng(m_thread_mng);
778 bi.setTraceMng(m_trace.get());
779 bi.setCommunicator(m_communicator);
780 return create(bi);
781 }
782
783 private:
784
785 ReferenceCounter<ITraceMng> m_trace;
786 IThreadMng* m_thread_mng = nullptr;
787 ITimerMng* m_timer_mng = nullptr;
788 IParallelMng* m_world_parallel_mng = nullptr;
789 IIOMng* m_io_mng;
790 Parallel::IStat* m_stat;
791 IParallelReplication* m_replication;
792 MP::Communicator m_communicator;
793 Ref<IParallelMngUtilsFactory> m_utils_factory;
794 IParallelMngInternal* m_parallel_mng_internal = nullptr;
795};
796
797/*---------------------------------------------------------------------------*/
798/*---------------------------------------------------------------------------*/
799
800extern "C++" IIOMng*
801arcaneCreateIOMng(IParallelMng* psm);
802
803/*---------------------------------------------------------------------------*/
804/*---------------------------------------------------------------------------*/
805
806extern "C++" IParallelMng*
807arcaneCreateSequentialParallelMng(const SequentialParallelMngBuildInfo& bi)
808{
809 return SequentialParallelMng::create(bi);
810}
811extern "C++" Ref<IParallelMng>
812arcaneCreateSequentialParallelMngRef(const SequentialParallelMngBuildInfo& bi)
813{
814 return SequentialParallelMng::createRef(bi);
815}
816
817/*---------------------------------------------------------------------------*/
818/*---------------------------------------------------------------------------*/
819
821: public ParallelMngInternal
822{
823 public:
824
825 explicit Impl(SequentialParallelMng* pm)
826 : ParallelMngInternal(pm)
827 {}
828
829 ~Impl() override = default;
830
831 public:
832
834 {
835 return makeRef(new SequentialMachineMemoryWindowBaseInternal(sizeof_segment, sizeof_type));
836 }
837
839 {
840 return makeRef(new SequentialDynamicMachineMemoryWindowBaseInternal(sizeof_segment, sizeof_type));
841 }
842};
843
844/*---------------------------------------------------------------------------*/
845/*---------------------------------------------------------------------------*/
846
847SequentialParallelMng::
848SequentialParallelMng(const SequentialParallelMngBuildInfo& bi)
850, m_trace(bi.traceMng())
851, m_thread_mng(bi.threadMng())
852, m_timer_mng(bi.m_timer_mng)
853, m_world_parallel_mng(bi.m_world_parallel_mng)
854, m_io_mng(nullptr)
855, m_stat(nullptr)
856, m_replication(new ParallelReplication())
857, m_communicator(bi.communicator())
859, m_parallel_mng_internal(new Impl(this))
860{
861 ARCANE_CHECK_PTR(m_trace);
862 ARCANE_CHECK_PTR(m_thread_mng);
863 if (!m_world_parallel_mng)
864 m_world_parallel_mng = this;
866 _messagePassingMng()->setCommunicator(m_communicator);
867}
868
869/*---------------------------------------------------------------------------*/
870/*---------------------------------------------------------------------------*/
871
872SequentialParallelMng::
873~SequentialParallelMng()
874{
875 delete m_parallel_mng_internal;
876 delete m_stat;
877 delete m_replication;
878 delete m_io_mng;
879}
880
881/*---------------------------------------------------------------------------*/
882/*---------------------------------------------------------------------------*/
883
884void SequentialParallelMng::
885setBaseObject(IBase* sd)
886{
887 ARCANE_UNUSED(sd);
888}
889
890/*---------------------------------------------------------------------------*/
891/*---------------------------------------------------------------------------*/
892
893namespace
894{
895// Classe pour créer les différents dispatchers
896class DispatchCreator
897{
898 public:
899 DispatchCreator(ITraceMng* tm) : m_tm(tm){}
900 public:
901 template<typename DataType> SequentialParallelDispatchT<DataType>*
902 create()
903 {
904 return new SequentialParallelDispatchT<DataType>(m_tm);
905 }
906 ITraceMng* m_tm;
907};
908}
909
911build()
912{
913 m_io_mng = arcaneCreateIOMng(this);
914 DispatchCreator creator(m_trace.get());
915 this->createDispatchers(creator);
916}
917
918/*---------------------------------------------------------------------------*/
919/*---------------------------------------------------------------------------*/
920
923{
924 traceMng()->info() << "** ** MPI Communicator = " << getMPICommunicator();
925}
926
927/*---------------------------------------------------------------------------*/
928/*---------------------------------------------------------------------------*/
929
930/*---------------------------------------------------------------------------*/
931/*---------------------------------------------------------------------------*/
932
933// Construit un superviseur séquentiel lié au superviseur \a sm
934SequentialParallelSuperMng::
935SequentialParallelSuperMng(const ServiceBuildInfo& sbi)
936: AbstractService(sbi)
937, m_application(sbi.application())
938, m_thread_mng(new NullThreadMng())
939, m_timer_mng(nullptr)
940{
941}
942
943/*---------------------------------------------------------------------------*/
944/*---------------------------------------------------------------------------*/
945
946// Construit un superviseur séquentiel lié au superviseur \a sm
947SequentialParallelSuperMng::
948SequentialParallelSuperMng(const ServiceBuildInfo& sbi,Parallel::Communicator comm)
949: AbstractService(sbi)
950, m_application(sbi.application())
951, m_thread_mng(new NullThreadMng())
952, m_timer_mng(nullptr)
953, m_communicator(comm)
954{
955}
956
957/*---------------------------------------------------------------------------*/
958/*---------------------------------------------------------------------------*/
959
960// Construit un superviseur séquentiel lié au superviseur \a sm
961SequentialParallelSuperMng::
962~SequentialParallelSuperMng()
963{
964 delete m_thread_mng;
965}
966
967/*---------------------------------------------------------------------------*/
968/*---------------------------------------------------------------------------*/
969
981
982/*---------------------------------------------------------------------------*/
983/*---------------------------------------------------------------------------*/
984
986build()
987{
988 if (!m_timer_mng){
989 m_owned_timer_mng = new TimerMng(traceMng());
990 m_timer_mng = m_owned_timer_mng.get();
991 }
992}
993
994/*---------------------------------------------------------------------------*/
995/*---------------------------------------------------------------------------*/
996
999{
1000 if (local_rank!=0)
1001 ARCANE_THROW(ArgumentException,"Bad local_rank '{0}' (should be 0)",local_rank);
1002
1003 SequentialParallelMngBuildInfo bi(m_timer_mng,nullptr);
1004 bi.setThreadMng(threadMng());
1005 bi.setTraceMng(traceMng());
1006 bi.setCommunicator(communicator());
1007 return SequentialParallelMng::createRef(bi);
1008}
1009
1010/*---------------------------------------------------------------------------*/
1011/*---------------------------------------------------------------------------*/
1012
1017
1018/*---------------------------------------------------------------------------*/
1019/*---------------------------------------------------------------------------*/
1020
1023
1024/*---------------------------------------------------------------------------*/
1025/*---------------------------------------------------------------------------*/
1026
1027class SequentialParallelMngBuilder
1029{
1030 public:
1031 SequentialParallelMngBuilder(IApplication* app,Parallel::Communicator comm)
1032 : m_application(app), m_thread_mng(new NullThreadMng()),
1033 m_timer_mng(new TimerMng(app->traceMng())), m_communicator(comm){}
1034 ~SequentialParallelMngBuilder() override
1035 {
1036 delete m_timer_mng;
1037 delete m_thread_mng;
1038 }
1039
1040 public:
1041
1042 void build() {}
1043 Ref<IParallelMng> _createParallelMng(Int32 local_rank,ITraceMng* tm) override;
1044
1045 public:
1046 IApplication* m_application;
1047 IThreadMng* m_thread_mng;
1048 ITimerMng* m_timer_mng;
1049 Parallel::Communicator m_communicator;
1050};
1051
1052/*---------------------------------------------------------------------------*/
1053/*---------------------------------------------------------------------------*/
1054
1056_createParallelMng(Int32 local_rank,ITraceMng* tm)
1057{
1058 if (local_rank!=0)
1059 ARCANE_THROW(ArgumentException,"Bad local_rank '{0}' (should be 0)",local_rank);
1060
1061 SequentialParallelMngBuildInfo bi(m_timer_mng,nullptr);
1062 bi.setTraceMng(tm);
1063 bi.setThreadMng(m_thread_mng);
1064 bi.setCommunicator(m_communicator);
1065 return arcaneCreateSequentialParallelMngRef(bi);
1066}
1067
1068/*---------------------------------------------------------------------------*/
1069/*---------------------------------------------------------------------------*/
1070
1071class SequentialParallelMngContainerFactory
1072: public AbstractService
1074{
1075 public:
1076 SequentialParallelMngContainerFactory(const ServiceBuildInfo& sbi)
1077 : AbstractService(sbi), m_application(sbi.application()){}
1078 public:
1081 {
1082 ARCANE_UNUSED(nb_rank);
1083 auto x = new SequentialParallelMngBuilder(m_application,comm);
1084 x->build();
1086 }
1087 private:
1088 IApplication* m_application;
1089};
1090
1091/*---------------------------------------------------------------------------*/
1092/*---------------------------------------------------------------------------*/
1093
1095 ServiceProperty("SequentialParallelMngContainerFactory",ST_Application),
1097
1098/*---------------------------------------------------------------------------*/
1099/*---------------------------------------------------------------------------*/
1100
1101} // End namespace Arcane
1102
1103/*---------------------------------------------------------------------------*/
1104/*---------------------------------------------------------------------------*/
1105
#define ARCANE_THROW(exception_class,...)
Macro pour envoyer une exception avec formattage.
#define ARCANE_FATAL(...)
Macro envoyant une exception FatalErrorException.
#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:31
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:36
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.
Échange d'informations entre processeurs.
Interface d'une fabrique de conteneur de 'IParallelMng'.
Partie interne 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:49
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.
Classe permettant de créer des fenêtres mémoires pour un noeud de calcul.
Classe permettant de créer une fenêtre mémoire pour un noeud de calcul.
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.
Span< std::byte > segmentView(Int32 rank) override
Méthode permettant d'obtenir une vue sur le segment d'un autre sous-domaine du noeud.
void resize(Int64 new_size) override
Méthode permettant de redimensionner notre segment.
void barrier() const override
Méthode permettant d'attendre que tous les processus/threads du noeud appellent cette méthode pour co...
Int32 sizeofOneElem() const override
Méthode permettant d'obtenir la taille d'un élement de la fenêtre.
void addToAnotherSegment(Int32 rank, Span< const std::byte > elem) override
Méthode permettant d'ajouter des éléments dans le segment d'un autre sous-domaine.
ConstArrayView< Int32 > machineRanks() const override
Méthode permettant d'obtenir les rangs qui possèdent un segment dans la fenêtre.
Span< const std::byte > segmentConstView() const override
Méthode permettant d'obtenir une vue sur notre segment.
void add(Span< const std::byte > elem) override
Méthode permettant d'ajouter des élements dans notre segment.
Span< const std::byte > segmentConstView(Int32 rank) const override
Méthode permettant d'obtenir une vue sur le segment d'un autre sous-domaine du noeud.
Span< std::byte > segmentView() override
Méthode permettant d'obtenir une vue sur notre segment.
void reserve(Int64 new_capacity) override
Méthode permettant de réserver de l'espace mémoire dans notre segment.
void shrink() override
Méthode permettant de réduire l'espace mémoire réservé pour les segments au minimum nécessaire.
Span< std::byte > segmentView() override
Méthode permettant d'obtenir une vue sur son segment.
Span< std::byte > segmentView(const Int32 rank) override
Méthode permettant d'obtenir une vue sur le segment d'un autre sous-domaine du noeud.
void barrier() const override
Méthode permettant d'attendre que tous les processus/threads du noeud appellent cette méthode pour co...
void resizeSegment(const Int64 new_sizeof_segment) override
Méthode permettant de redimensionner les segments de la fenêtre.
ConstArrayView< Int32 > machineRanks() const override
Méthode permettant d'obtenir les rangs qui possèdent un segment dans la fenêtre.
Span< std::byte > windowView() override
Méthode permettant d'obtenir une vue sur toute la fenêtre.
Int32 sizeofOneElem() const override
Méthode permettant d'obtenir la taille d'un élement de la fenêtre.
Span< const std::byte > segmentConstView(const Int32 rank) const override
Méthode permettant d'obtenir une vue sur le segment d'un autre sous-domaine du noeud.
Span< const std::byte > segmentConstView() const override
Méthode permettant d'obtenir une vue sur son segment.
Span< const std::byte > windowConstView() const override
Méthode permettant d'obtenir une vue sur toute la fenêtre.
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.
Ref< IMachineMemoryWindowBaseInternal > createMachineMemoryWindowBase(Int64 sizeof_segment, Int32 sizeof_type) override
Méthode permettant de créer une fenêtre mémoire sur le noeud.
Ref< IDynamicMachineMemoryWindowBaseInternal > createDynamicMachineMemoryWindowBase(Int64 sizeof_segment, Int32 sizeof_type) override
Méthode permettant de créer une fenêtre mémoire dynamique sur le noeud.
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.
IParallelMngInternal * _internalApi() override
API interne à Arcane.
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
constexpr __host__ __device__ SizeType size() const noexcept
Retourne la taille du tableau.
Definition Span.h:212
Vue d'un tableau d'éléments de type T.
Definition Span.h:513
constexpr __host__ __device__ Span< T, DynExtent > subSpan(Int64 abegin, Int64 asize) const
Sous-vue à partir de l'élément abegin et contenant asize éléments.
Definition Span.h:605
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.
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.
std::int64_t Int64
Type entier signé sur 64 bits.
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:730
Infos pour construire un SequentialParallelMng.