Arcane  v3.16.0.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
MpiParallelMng.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/* MpiParallelMng.cc (C) 2000-2025 */
9/* */
10/* Gestionnaire de parallélisme utilisant MPI. */
11/*---------------------------------------------------------------------------*/
12/*---------------------------------------------------------------------------*/
13
14#include "arcane/utils/Collection.h"
15#include "arcane/utils/Enumerator.h"
16#include "arcane/utils/ScopedPtr.h"
17#include "arcane/utils/PlatformUtils.h"
18#include "arcane/utils/TimeoutException.h"
19#include "arcane/utils/NotImplementedException.h"
20#include "arcane/utils/ArgumentException.h"
21#include "arcane/utils/ITraceMng.h"
22#include "arcane/utils/ValueConvert.h"
23#include "arcane/utils/Exception.h"
24#include "arcane/utils/HPReal.h"
25
26#include "arcane/core/IIOMng.h"
27#include "arcane/core/Timer.h"
28#include "arcane/core/IItemFamily.h"
29#include "arcane/core/parallel/IStat.h"
30#include "arcane/core/internal/SerializeMessage.h"
31
32#include "arcane/parallel/mpi/MpiParallelMng.h"
33#include "arcane/parallel/mpi/MpiParallelDispatch.h"
34#include "arcane/parallel/mpi/MpiTimerMng.h"
35#include "arcane/parallel/mpi/MpiSerializeMessage.h"
36#include "arcane/parallel/mpi/MpiParallelNonBlockingCollective.h"
37#include "arcane/parallel/mpi/MpiDatatype.h"
38#include "arcane/parallel/mpi/IVariableSynchronizerMpiCommunicator.h"
39
40#include "arcane/impl/ParallelReplication.h"
41#include "arcane/impl/SequentialParallelMng.h"
42#include "arcane/impl/internal/ParallelMngUtilsFactoryBase.h"
43#include "arcane/impl/internal/VariableSynchronizer.h"
44
45#include "arccore/message_passing_mpi/MpiMessagePassingMng.h"
46#include "arccore/message_passing_mpi/internal/MpiSerializeDispatcher.h"
47#include "arccore/message_passing_mpi/internal/MpiRequestList.h"
48#include "arccore/message_passing_mpi/internal/MpiAdapter.h"
49#include "arccore/message_passing_mpi/internal/MpiLock.h"
50#include "arccore/message_passing/Dispatchers.h"
52#include "arccore/message_passing/SerializeMessageList.h"
53
54//#define ARCANE_TRACE_MPI
55
56/*---------------------------------------------------------------------------*/
57/*---------------------------------------------------------------------------*/
58
59namespace Arcane
60{
61using namespace Arcane::MessagePassing;
62using namespace Arcane::MessagePassing::Mpi;
64
65/*---------------------------------------------------------------------------*/
66/*---------------------------------------------------------------------------*/
67
68extern "C++" IIOMng*
69arcaneCreateIOMng(IParallelMng* psm);
70
71#if defined(ARCANE_HAS_MPI_NEIGHBOR)
72// Défini dans MpiNeighborVariableSynchronizeDispatcher
74arcaneCreateMpiNeighborVariableSynchronizerFactory(MpiParallelMng* mpi_pm,
75 Ref<IVariableSynchronizerMpiCommunicator> synchronizer_communicator);
76#endif
78arcaneCreateMpiBlockVariableSynchronizerFactory(MpiParallelMng* mpi_pm, Int32 block_size, Int32 nb_sequence);
80arcaneCreateMpiVariableSynchronizerFactory(MpiParallelMng* mpi_pm);
82arcaneCreateMpiDirectSendrecvVariableSynchronizerFactory(MpiParallelMng* mpi_pm);
84arcaneCreateMpiLegacyVariableSynchronizerFactory(MpiParallelMng* mpi_pm);
85
86/*---------------------------------------------------------------------------*/
87/*---------------------------------------------------------------------------*/
88
89MpiParallelMngBuildInfo::
90MpiParallelMngBuildInfo(MPI_Comm comm)
91: is_parallel(false)
92, comm_rank(MessagePassing::A_NULL_RANK)
93, comm_nb_rank(0)
94, stat(nullptr)
95, trace_mng(nullptr)
96, timer_mng(nullptr)
97, thread_mng(nullptr)
98, mpi_comm(comm)
99, is_mpi_comm_owned(true)
100, mpi_lock(nullptr)
101{
102 ::MPI_Comm_rank(comm,&comm_rank);
103 ::MPI_Comm_size(comm,&comm_nb_rank);
104
105 m_dispatchers_ref = createRef<MP::Dispatchers>();
106 MP::Mpi::MpiMessagePassingMng::BuildInfo bi(comm_rank,comm_nb_rank,m_dispatchers_ref.get(),mpi_comm);
107
108 m_message_passing_mng_ref = createRef<MP::Mpi::MpiMessagePassingMng>(bi);
109}
110
111/*---------------------------------------------------------------------------*/
112/*---------------------------------------------------------------------------*/
113
114/*---------------------------------------------------------------------------*/
115/*---------------------------------------------------------------------------*/
119class VariableSynchronizerMpiCommunicator
121{
122 public:
123 explicit VariableSynchronizerMpiCommunicator(MpiParallelMng* pm)
124 : m_mpi_parallel_mng(pm){}
125 ~VariableSynchronizerMpiCommunicator() override
126 {
127 _checkFreeCommunicator();
128 }
129 MPI_Comm communicator() const override
130 {
131 return m_topology_communicator;
132 }
133 void compute(VariableSynchronizer* var_syncer) override
134 {
135 Int32ConstArrayView comm_ranks = var_syncer->communicatingRanks();
136 const Int32 nb_message = comm_ranks.size();
137
138 MpiParallelMng* pm = m_mpi_parallel_mng;
139
140 MPI_Comm old_comm = pm->communicator();
141
142 UniqueArray<int> destinations(nb_message);
143 for( Integer i=0; i<nb_message; ++i ){
144 destinations[i] = comm_ranks[i];
145 }
146
147 _checkFreeCommunicator();
148
149 int r = MPI_Dist_graph_create_adjacent(old_comm, nb_message, destinations.data(), MPI_UNWEIGHTED,
150 nb_message, destinations.data(), MPI_UNWEIGHTED,
151 MPI_INFO_NULL, 0, &m_topology_communicator);
152
153 if (r!=MPI_SUCCESS)
154 ARCANE_FATAL("Error '{0}' in MPI_Dist_graph_create",r);
155
156 // Vérifie que l'ordre des rangs pour l'implémentation MPI est le même que celui qu'on a dans
157 // le VariableSynchronizer.
158 {
159 int indegree = 0;
160 int outdegree = 0;
161 int weighted = 0;
162 MPI_Dist_graph_neighbors_count(m_topology_communicator,&indegree,&outdegree,&weighted);
163
164 if (indegree!=nb_message)
165 ARCANE_FATAL("Bad value '{0}' for 'indegree' (expected={1})",indegree,nb_message);
166 if (outdegree!=nb_message)
167 ARCANE_FATAL("Bad value '{0}' for 'outdegree' (expected={1})",outdegree,nb_message);
168
169 UniqueArray<int> srcs(indegree);
170 UniqueArray<int> dsts(outdegree);
171
172 MPI_Dist_graph_neighbors(m_topology_communicator,indegree,srcs.data(),MPI_UNWEIGHTED,outdegree,dsts.data(),MPI_UNWEIGHTED);
173
174 for(int k=0; k<outdegree; ++k){
175 int x = dsts[k];
176 if (x!=comm_ranks[k])
177 ARCANE_FATAL("Invalid destination rank order k={0} v={1} expected={2}",k,x,comm_ranks[k]);
178 }
179
180 for(int k=0; k<indegree; ++k ){
181 int x = srcs[k];
182 if (x!=comm_ranks[k])
183 ARCANE_FATAL("Invalid source rank order k={0} v={1} expected={2}",k,x,comm_ranks[k]);
184 }
185 }
186 }
187
188 private:
189
190 MpiParallelMng* m_mpi_parallel_mng = nullptr;
191 MPI_Comm m_topology_communicator = MPI_COMM_NULL;
192
193 private:
194
195 void _checkFreeCommunicator()
196 {
197 if (m_topology_communicator!=MPI_COMM_NULL)
198 MPI_Comm_free(&m_topology_communicator);
199 m_topology_communicator = MPI_COMM_NULL;
200 }
201};
202
203/*---------------------------------------------------------------------------*/
204/*---------------------------------------------------------------------------*/
211class MpiVariableSynchronizer
212: public VariableSynchronizer
213{
214 public:
215 MpiVariableSynchronizer(IParallelMng* pm,const ItemGroup& group,
216 Ref<IDataSynchronizeImplementationFactory> implementation_factory,
218 : VariableSynchronizer(pm,group,implementation_factory)
219 , m_topology_info(topology_info)
220 {
221 }
222 public:
223 void compute() override
224 {
226 // Si non nul, calcule la topologie
227 if (m_topology_info.get())
228 m_topology_info->compute(this);
229 }
230 private:
232};
233
234/*---------------------------------------------------------------------------*/
235/*---------------------------------------------------------------------------*/
236
237class MpiParallelMngUtilsFactory
239{
240 public:
241 MpiParallelMngUtilsFactory()
242 : m_synchronizer_version(2)
243 {
244 if (platform::getEnvironmentVariable("ARCANE_SYNCHRONIZE_VERSION")=="1")
245 m_synchronizer_version = 1;
246 if (platform::getEnvironmentVariable("ARCANE_SYNCHRONIZE_VERSION")=="2")
247 m_synchronizer_version = 2;
248 if (platform::getEnvironmentVariable("ARCANE_SYNCHRONIZE_VERSION")=="3")
249 m_synchronizer_version = 3;
250 if (platform::getEnvironmentVariable("ARCANE_SYNCHRONIZE_VERSION")=="4"){
251 m_synchronizer_version = 4;
252 String v = platform::getEnvironmentVariable("ARCANE_SYNCHRONIZE_BLOCK_SIZE");
253 if (!v.null()){
254 Int32 block_size = 0;
255 if (!builtInGetValue(block_size,v))
256 m_synchronize_block_size = block_size;
257 m_synchronize_block_size = std::clamp(m_synchronize_block_size,0,1000000000);
258 }
259 v = platform::getEnvironmentVariable("ARCANE_SYNCHRONIZE_NB_SEQUENCE");
260 if (!v.null()){
261 Int32 nb_sequence = 0;
262 if (!builtInGetValue(nb_sequence,v))
263 m_synchronize_nb_sequence = nb_sequence;
264 m_synchronize_nb_sequence = std::clamp(m_synchronize_nb_sequence,1,1024*1024);
265 }
266 }
267 if (platform::getEnvironmentVariable("ARCANE_SYNCHRONIZE_VERSION")=="5")
268 m_synchronizer_version = 5;
269 }
270 public:
271
273 {
274 return _createSynchronizer(pm,family->allItems());
275 }
276
278 {
279 return _createSynchronizer(pm,group);
280 }
281
282 private:
283
284 Ref<IVariableSynchronizer> _createSynchronizer(IParallelMng* pm,const ItemGroup& group)
285 {
287 MpiParallelMng* mpi_pm = ARCANE_CHECK_POINTER(dynamic_cast<MpiParallelMng*>(pm));
288 ITraceMng* tm = pm->traceMng();
290 // N'affiche les informations que pour le groupe de toutes les mailles pour éviter d'afficher
291 // plusieurs fois le même message.
292 bool do_print = (group.isAllItems() && group.itemKind()==IK_Cell);
293 if (m_synchronizer_version == 2){
294 if (do_print)
295 tm->info() << "Using MpiSynchronizer V2";
296 generic_factory = arcaneCreateMpiVariableSynchronizerFactory(mpi_pm);
297 }
298 else if (m_synchronizer_version == 3 ){
299 if (do_print)
300 tm->info() << "Using MpiSynchronizer V3";
301 generic_factory = arcaneCreateMpiDirectSendrecvVariableSynchronizerFactory(mpi_pm);
302 }
303 else if (m_synchronizer_version == 4){
304 if (do_print)
305 tm->info() << "Using MpiSynchronizer V4 block_size=" << m_synchronize_block_size
306 << " nb_sequence=" << m_synchronize_nb_sequence;
307 generic_factory = arcaneCreateMpiBlockVariableSynchronizerFactory(mpi_pm,m_synchronize_block_size,m_synchronize_nb_sequence);
308 }
309 else if (m_synchronizer_version == 5){
310 if (do_print)
311 tm->info() << "Using MpiSynchronizer V5";
312 topology_info = createRef<VariableSynchronizerMpiCommunicator>(mpi_pm);
313#if defined(ARCANE_HAS_MPI_NEIGHBOR)
314 generic_factory = arcaneCreateMpiNeighborVariableSynchronizerFactory(mpi_pm,topology_info);
315#else
316 throw NotSupportedException(A_FUNCINFO,"Synchronize implementation V5 is not supported with this version of MPI");
317#endif
318 }
319 else{
320 if (do_print)
321 tm->info() << "Using MpiSynchronizer V1";
322 generic_factory = arcaneCreateMpiLegacyVariableSynchronizerFactory(mpi_pm);
323 }
324 if (!generic_factory.get())
325 ARCANE_FATAL("No factory created");
326 return createRef<MpiVariableSynchronizer>(pm,group,generic_factory,topology_info);
327 }
328
329 private:
330
331 Integer m_synchronizer_version = 1;
332 Int32 m_synchronize_block_size = 32000;
333 Int32 m_synchronize_nb_sequence = 1;
334};
335
336/*---------------------------------------------------------------------------*/
337/*---------------------------------------------------------------------------*/
338
339/*---------------------------------------------------------------------------*/
340/*---------------------------------------------------------------------------*/
341
342MpiParallelMng::
343MpiParallelMng(const MpiParallelMngBuildInfo& bi)
344: ParallelMngDispatcher(ParallelMngDispatcherBuildInfo(bi.dispatchersRef(),bi.messagePassingMngRef()))
345, m_trace(bi.trace_mng)
346, m_thread_mng(bi.thread_mng)
347, m_world_parallel_mng(bi.world_parallel_mng)
348, m_timer_mng(bi.timer_mng)
349, m_replication(new ParallelReplication())
350, m_is_parallel(bi.is_parallel)
351, m_comm_rank(bi.commRank())
352, m_comm_size(bi.commSize())
353, m_stat(bi.stat)
354, m_communicator(bi.mpiComm())
355, m_is_communicator_owned(bi.is_mpi_comm_owned)
356, m_mpi_lock(bi.mpi_lock)
357, m_non_blocking_collective(nullptr)
358, m_utils_factory(createRef<MpiParallelMngUtilsFactory>())
359{
360 if (!m_world_parallel_mng){
361 m_trace->debug()<<"[MpiParallelMng] No m_world_parallel_mng found, reverting to ourselves!";
362 m_world_parallel_mng = this;
363 }
364}
365
366/*---------------------------------------------------------------------------*/
367/*---------------------------------------------------------------------------*/
368
369MpiParallelMng::
370~MpiParallelMng()
371{
372 delete m_non_blocking_collective;
373 m_sequential_parallel_mng.reset();
374 if (m_is_communicator_owned){
375 MpiLock::Section ls(m_mpi_lock);
376 MPI_Comm_free(&m_communicator);
377 }
378 delete m_replication;
379 delete m_io_mng;
380 if (m_is_timer_owned)
381 delete m_timer_mng;
382 arcaneCallFunctionAndTerminateIfThrow([&]() { m_adapter->destroy(); });
383 delete m_datatype_list;
384}
385
386/*---------------------------------------------------------------------------*/
387/*---------------------------------------------------------------------------*/
388
389namespace
390{
391
392/*---------------------------------------------------------------------------*/
393/*---------------------------------------------------------------------------*/
394// Classe pour créer les différents dispatchers
395class DispatchCreator
396{
397 public:
398 DispatchCreator(ITraceMng* tm,IMessagePassingMng* mpm,MpiAdapter* adapter,MpiDatatypeList* datatype_list)
399 : m_tm(tm), m_mpm(mpm), m_adapter(adapter), m_datatype_list(datatype_list){}
400 public:
401 template<typename DataType> MpiParallelDispatchT<DataType>*
402 create()
403 {
404 MpiDatatype* dt = m_datatype_list->datatype(DataType());
405 return new MpiParallelDispatchT<DataType>(m_tm,m_mpm,m_adapter,dt);
406 }
407
408 ITraceMng* m_tm;
409 IMessagePassingMng* m_mpm;
410 MpiAdapter* m_adapter;
411 MpiDatatypeList* m_datatype_list;
412};
413
414/*---------------------------------------------------------------------------*/
415/*---------------------------------------------------------------------------*/
416
417class ControlDispatcherDecorator
419{
420 public:
421
422 ControlDispatcherDecorator(IParallelMng* pm, MpiAdapter* adapter)
423 : ParallelMngDispatcher::DefaultControlDispatcher(pm), m_adapter(adapter) {}
424
425 IMessagePassingMng* commSplit(bool keep) override
426 {
427 return m_adapter->commSplit(keep);
428 }
429 MP::IProfiler* profiler() const override { return m_adapter->profiler(); }
430 void setProfiler(MP::IProfiler* p) override { m_adapter->setProfiler(p); }
431
432 private:
433 MpiAdapter* m_adapter;
434};
435}
436
437/*---------------------------------------------------------------------------*/
438/*---------------------------------------------------------------------------*/
439
441build()
442{
443 ITraceMng* tm = traceMng();
444 if (!m_timer_mng){
445 m_timer_mng = new MpiTimerMng(tm);
446 m_is_timer_owned = true;
447 }
448
449 // Créé le gestionnaire séquentiel associé.
450 {
452 bi.setTraceMng(traceMng());
453 bi.setCommunicator(communicator());
454 bi.setThreadMng(threadMng());
455 m_sequential_parallel_mng = arcaneCreateSequentialParallelMngRef(bi);
456 }
457
458 // Indique que les reduces doivent être fait dans l'ordre des processeurs
459 // afin de garantir une exécution déterministe
460 bool is_ordered_reduce = false;
461 if (platform::getEnvironmentVariable("ARCANE_ORDERED_REDUCE")=="TRUE")
462 is_ordered_reduce = true;
463 m_datatype_list = new MpiDatatypeList(is_ordered_reduce);
464
465 ARCANE_CHECK_POINTER(m_stat);
466
467 MpiAdapter* adapter = new MpiAdapter(m_trace,m_stat->toArccoreStat(),m_communicator,m_mpi_lock);
468 m_adapter = adapter;
469 auto mpm = _messagePassingMng();
470
471 // NOTE: cette instance sera détruite par le ParallelMngDispatcher
472 auto* control_dispatcher = new ControlDispatcherDecorator(this,m_adapter);
473 _setControlDispatcher(control_dispatcher);
474
475 // NOTE: cette instance sera détruite par le ParallelMngDispatcher
476 auto* serialize_dispatcher = new MpiSerializeDispatcher(m_adapter, mpm);
477 m_mpi_serialize_dispatcher = serialize_dispatcher;
478 _setSerializeDispatcher(serialize_dispatcher);
479
480 DispatchCreator creator(m_trace,mpm,m_adapter,m_datatype_list);
481 this->createDispatchers(creator);
482
483 m_io_mng = arcaneCreateIOMng(this);
484
485 m_non_blocking_collective = new MpiParallelNonBlockingCollective(tm,this,adapter);
486 m_non_blocking_collective->build();
487 if (m_mpi_lock)
488 m_trace->info() << "Using mpi with locks.";
489}
490
491/*---------------------------------------------------------------------------*/
492/*---------------------------------------------------------------------------*/
493
494/*----------------------------------------------------------------------------*/
495/*---------------------------------------------------------------------------*/
496
499{
500 Trace::Setter mci(m_trace,"Mpi");
501 if (m_is_initialized){
502 m_trace->warning() << "MpiParallelMng already initialized";
503 return;
504 }
505
506 m_trace->info() << "Initialisation de MpiParallelMng";
507 m_sequential_parallel_mng->initialize();
508
509 m_adapter->setTimeMetricCollector(timeMetricCollector());
510
511 m_is_initialized = true;
512}
513
514/*---------------------------------------------------------------------------*/
515/*---------------------------------------------------------------------------*/
516
517void MpiParallelMng::
518sendSerializer(ISerializer* s,Int32 rank)
519{
520 Trace::Setter mci(m_trace,"Mpi");
521 Timer::Phase tphase(timeStats(),TP_Communication);
523 m_mpi_serialize_dispatcher->legacySendSerializer(s,{MessageRank(rank),mpi_tag,Blocking});
524}
525
526/*---------------------------------------------------------------------------*/
527/*---------------------------------------------------------------------------*/
528
531{
532 return m_utils_factory->createSendSerializeMessage(this, rank)._release();
533}
534
535/*---------------------------------------------------------------------------*/
536/*---------------------------------------------------------------------------*/
537
538Request MpiParallelMng::
539sendSerializer(ISerializer* s,Int32 rank,[[maybe_unused]] ByteArray& bytes)
540{
541 Trace::Setter mci(m_trace,"Mpi");
542 Timer::Phase tphase(timeStats(),TP_Communication);
544 return m_mpi_serialize_dispatcher->legacySendSerializer(s,{MessageRank(rank),mpi_tag,NonBlocking});
545}
546
547/*---------------------------------------------------------------------------*/
548/*---------------------------------------------------------------------------*/
549
550void MpiParallelMng::
551broadcastSerializer(ISerializer* values,Int32 rank)
552{
553 Timer::Phase tphase(timeStats(),TP_Communication);
554 m_mpi_serialize_dispatcher->broadcastSerializer(values,MessageRank(rank));
555}
556
557/*---------------------------------------------------------------------------*/
558/*---------------------------------------------------------------------------*/
559
560void MpiParallelMng::
561recvSerializer(ISerializer* values,Int32 rank)
562{
563 Trace::Setter mci(m_trace,"Mpi");
564 Timer::Phase tphase(timeStats(),TP_Communication);
566 m_mpi_serialize_dispatcher->legacyReceiveSerializer(values,MessageRank(rank),mpi_tag);
567}
568
569/*---------------------------------------------------------------------------*/
570/*---------------------------------------------------------------------------*/
571
574{
575 return m_utils_factory->createReceiveSerializeMessage(this, rank)._release();
576}
577
578/*---------------------------------------------------------------------------*/
579/*---------------------------------------------------------------------------*/
580
582probe(const PointToPointMessageInfo& message) -> MessageId
583{
584 return m_adapter->probeMessage(message);
585}
586
587/*---------------------------------------------------------------------------*/
588/*---------------------------------------------------------------------------*/
589
592{
593 return m_adapter->legacyProbeMessage(message);
594}
595
596/*---------------------------------------------------------------------------*/
597/*---------------------------------------------------------------------------*/
598
599Request MpiParallelMng::
600sendSerializer(const ISerializer* s,const PointToPointMessageInfo& message)
601{
602 return m_mpi_serialize_dispatcher->sendSerializer(s,message);
603}
604
605/*---------------------------------------------------------------------------*/
606/*---------------------------------------------------------------------------*/
607
608Request MpiParallelMng::
609receiveSerializer(ISerializer* s,const PointToPointMessageInfo& message)
610{
611 return m_mpi_serialize_dispatcher->receiveSerializer(s,message);
612}
613
614/*---------------------------------------------------------------------------*/
615/*---------------------------------------------------------------------------*/
616
619{
620 for( Integer i=0, is=requests.size(); i<is; ++i )
621 m_adapter->freeRequest(requests[i]);
622}
623
624/*---------------------------------------------------------------------------*/
625/*---------------------------------------------------------------------------*/
626
627void MpiParallelMng::
628_checkFinishedSubRequests()
629{
630 m_mpi_serialize_dispatcher->checkFinishedSubRequests();
631}
632
633/*---------------------------------------------------------------------------*/
634/*---------------------------------------------------------------------------*/
635
636Ref<IParallelMng> MpiParallelMng::
637sequentialParallelMngRef()
638{
639 return m_sequential_parallel_mng;
640}
641
644{
645 return m_sequential_parallel_mng.get();
646}
647
648/*---------------------------------------------------------------------------*/
649/*---------------------------------------------------------------------------*/
650
653{
654 if (m_stat)
655 m_stat->print(m_trace);
656}
657
658/*---------------------------------------------------------------------------*/
659/*---------------------------------------------------------------------------*/
660
662barrier()
663{
664 traceMng()->flush();
665 m_adapter->barrier();
666}
667
668/*---------------------------------------------------------------------------*/
669/*---------------------------------------------------------------------------*/
670
673{
674 m_adapter->waitAllRequests(requests);
675 _checkFinishedSubRequests();
676}
677
678/*---------------------------------------------------------------------------*/
679/*---------------------------------------------------------------------------*/
680
683{
684 return _waitSomeRequests(requests, false);
685}
686
687/*---------------------------------------------------------------------------*/
688/*---------------------------------------------------------------------------*/
689
692{
693 return _waitSomeRequests(requests, true);
694}
695
696/*---------------------------------------------------------------------------*/
697/*---------------------------------------------------------------------------*/
698
699UniqueArray<Integer> MpiParallelMng::
700_waitSomeRequests(ArrayView<Request> requests, bool is_non_blocking)
701{
702 UniqueArray<Integer> results;
703 UniqueArray<bool> done_indexes(requests.size());
704
705 m_adapter->waitSomeRequests(requests, done_indexes, is_non_blocking);
706 for (int i = 0 ; i < requests.size() ; i++) {
707 if (done_indexes[i])
708 results.add(i);
709 }
710 return results;
711}
712
713/*---------------------------------------------------------------------------*/
714/*---------------------------------------------------------------------------*/
715
716ISerializeMessageList* MpiParallelMng::
717_createSerializeMessageList()
718{
719 return new MP::internal::SerializeMessageList(messagePassingMng());
720}
721
722/*---------------------------------------------------------------------------*/
723/*---------------------------------------------------------------------------*/
724
727{
728 return m_utils_factory->createGetVariablesValuesOperation(this)._release();
729}
730
731/*---------------------------------------------------------------------------*/
732/*---------------------------------------------------------------------------*/
733
736{
737 return m_utils_factory->createTransferValuesOperation(this)._release();
738}
739
740/*---------------------------------------------------------------------------*/
741/*---------------------------------------------------------------------------*/
742
745{
746 return m_utils_factory->createExchanger(this)._release();
747}
748
749/*---------------------------------------------------------------------------*/
750/*---------------------------------------------------------------------------*/
751
754{
755 return m_utils_factory->createSynchronizer(this,family)._release();
756}
757
758/*---------------------------------------------------------------------------*/
759/*---------------------------------------------------------------------------*/
760
762createSynchronizer(const ItemGroup& group)
763{
764 return m_utils_factory->createSynchronizer(this,group)._release();
765}
766
767/*---------------------------------------------------------------------------*/
768/*---------------------------------------------------------------------------*/
769
772{
773 return m_utils_factory->createTopology(this)._release();
774}
775
776/*---------------------------------------------------------------------------*/
777/*---------------------------------------------------------------------------*/
778
780replication() const
781{
782 return m_replication;
783}
784
785/*---------------------------------------------------------------------------*/
786/*---------------------------------------------------------------------------*/
787
790{
791 delete m_replication;
792 m_replication = v;
793}
794
795/*---------------------------------------------------------------------------*/
796/*---------------------------------------------------------------------------*/
797
798IParallelMng* MpiParallelMng::
799_createSubParallelMng(MPI_Comm sub_communicator)
800{
801 // Si nul, ce rang ne fait pas partie du sous-communicateur
802 if (sub_communicator==MPI_COMM_NULL)
803 return nullptr;
804
805 int sub_rank = -1;
806 MPI_Comm_rank(sub_communicator,&sub_rank);
807
808 MpiParallelMngBuildInfo bi(sub_communicator);
809 bi.is_parallel = isParallel();
810 bi.stat = m_stat;
811 bi.timer_mng = m_timer_mng;
812 bi.thread_mng = m_thread_mng;
813 bi.trace_mng = m_trace;
814 bi.world_parallel_mng = m_world_parallel_mng;
815 bi.mpi_lock = m_mpi_lock;
816
817 IParallelMng* sub_pm = new MpiParallelMng(bi);
818 sub_pm->build();
819 return sub_pm;
820}
821
822/*---------------------------------------------------------------------------*/
823/*---------------------------------------------------------------------------*/
824
825Ref<IParallelMng> MpiParallelMng::
826_createSubParallelMngRef(Int32 color, Int32 key)
827{
828 if (color < 0)
829 color = MPI_UNDEFINED;
830 MPI_Comm sub_communicator = MPI_COMM_NULL;
831 MPI_Comm_split(m_communicator, color, key, &sub_communicator);
832 IParallelMng* sub_pm = _createSubParallelMng(sub_communicator);
833 return makeRef(sub_pm);
834}
835
836/*---------------------------------------------------------------------------*/
837/*---------------------------------------------------------------------------*/
838
839IParallelMng* MpiParallelMng::
840_createSubParallelMng(Int32ConstArrayView kept_ranks)
841{
842 MPI_Group mpi_group = MPI_GROUP_NULL;
843 MPI_Comm_group(m_communicator, &mpi_group);
844 Integer nb_sub_rank = kept_ranks.size();
845 UniqueArray<int> mpi_kept_ranks(nb_sub_rank);
846 for (Integer i = 0; i < nb_sub_rank; ++i)
847 mpi_kept_ranks[i] = (int)kept_ranks[i];
848
849 MPI_Group final_group = MPI_GROUP_NULL;
850 MPI_Group_incl(mpi_group, nb_sub_rank, mpi_kept_ranks.data(), &final_group);
851 MPI_Comm sub_communicator = MPI_COMM_NULL;
852
853 MPI_Comm_create(m_communicator, final_group, &sub_communicator);
854 MPI_Group_free(&final_group);
855 return _createSubParallelMng(sub_communicator);
856}
857
858/*---------------------------------------------------------------------------*/
859/*---------------------------------------------------------------------------*/
868: public MpiRequestList
869{
870 using Base = MpiRequestList;
871 public:
872 explicit RequestList(MpiParallelMng* pm)
873 : Base(pm->m_adapter), m_parallel_mng(pm){}
874 public:
875 void _wait(Parallel::eWaitType wait_type) override
876 {
877 Base::_wait(wait_type);
878 m_parallel_mng->_checkFinishedSubRequests();
879 };
880 private:
881 MpiParallelMng* m_parallel_mng;
882};
883
884/*---------------------------------------------------------------------------*/
885/*---------------------------------------------------------------------------*/
886
892
893/*---------------------------------------------------------------------------*/
894/*---------------------------------------------------------------------------*/
895
898{
899 return m_utils_factory;
900}
901
902/*---------------------------------------------------------------------------*/
903/*---------------------------------------------------------------------------*/
904
905bool MpiParallelMng::
906_isAcceleratorAware() const
907{
909}
910
911/*---------------------------------------------------------------------------*/
912/*---------------------------------------------------------------------------*/
913
914} // End namespace Arcane
915
916/*---------------------------------------------------------------------------*/
917/*---------------------------------------------------------------------------*/
#define ARCANE_CHECK_POINTER(ptr)
Macro retournant le pointeur ptr s'il est non nul ou lancant une exception s'il est nul.
#define ARCANE_FATAL(...)
Macro envoyant une exception FatalErrorException.
Liste des fonctions d'échange de message.
Vue modifiable d'un tableau d'un type T.
constexpr Integer size() const noexcept
Retourne la taille du tableau.
const T * data() const
Accès à la racine du tableau hors toute protection.
void add(ConstReferenceType val)
Ajoute l'élément val à la fin du tableau.
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 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.
Echange d'informations entre processeurs.
Interface du gestionnaire de parallélisme pour un sous-domaine.
virtual ITraceMng * traceMng() const =0
Gestionnaire de traces.
virtual void build()=0
Construit l'instance.
Informations sur la réplication des sous-domaines en parallèle.
Informations sur la topologie d'allocation des coeurs de calcul.
Interface du gestionnaire de traces.
virtual void flush()=0
Flush tous les flots.
virtual TraceMessage info()=0
Flot pour un message d'information.
Envoie de valeurs sur différents processeurs.
Interface d'un communicateur MPI spécifique pour les synchronisations.
Interface d'un service de synchronisation de variable.
Groupe d'entités de maillage.
Definition ItemGroup.h:49
eItemKind itemKind() const
Genre du groupe. Il s'agit du genre de ses éléments.
Definition ItemGroup.h:109
bool isAllItems() const
Indique si le groupe est celui de toutes les entités.
Definition ItemGroup.cc:609
Interface d'un message de sérialisation entre IMessagePassingMng.
Informations sur la source d'un message.
void _wait(eWaitType wait_type) override
Effectue l'attente ou le test.
Request receiveSerializer(ISerializer *s, const PointToPointMessageInfo &message) override
Message de réception.
Request sendSerializer(const ISerializer *s, const PointToPointMessageInfo &message) override
Message d'envoi.
Informations pour envoyer/recevoir un message point à point.
Requête d'un message.
Definition Request.h:77
Message de sérialisation utilisant un BasicSerializer.
static MessageTag defaultTag()
Tag par défaut pour les messages de sérialisation.
Gère les MPI_Datatype associées aux types Arcane.
Ref< IVariableSynchronizer > createSynchronizer(IParallelMng *pm, IItemFamily *family) override
Retourne une interface pour synchroniser des variables sur le groupe de la famille family.
Ref< IVariableSynchronizer > createSynchronizer(IParallelMng *pm, const ItemGroup &group) override
Retourne une interface pour synchroniser des variables sur le groupe group.
Spécialisation de MpiRequestList pour MpiParallelMng.
void _wait(Parallel::eWaitType wait_type) override
Effectue l'attente ou le test.
Gestionnaire du parallélisme utilisant MPI.
IParallelMng * worldParallelMng() const override
Gestionnaire de parallélisme sur l'ensemble des ressources allouées.
MessageSourceInfo legacyProbe(const PointToPointMessageInfo &message) override
Sonde si des messages sont disponibles.
void barrier() override
Effectue une barière.
UniqueArray< Integer > waitSomeRequests(ArrayView< Request > requests) override
Bloque en attendant qu'une des requêtes rvalues soit terminée.
void waitAllRequests(ArrayView< Request > requests) override
Bloque en attendant que les requêtes rvalues soient terminées.
MessageId probe(const PointToPointMessageInfo &message) override
Sonde si des messages sont disponibles.
void build() override
Construit l'instance.
void printStats() override
Affiche des statistiques liées à ce gestionnaire du parallélisme.
bool m_is_initialized
true si déjà initialisé
IParallelMng * sequentialParallelMng() override
Retourne un gestionnaire de parallélisme séquentiel.
IThreadMng * threadMng() const override
Gestionnaire de threads.
ITimerMng * timerMng() const override
Gestionnaire de timers.
void initialize() override
Initialise le gestionnaire du parallélisme.
IVariableSynchronizer * createSynchronizer(IItemFamily *family) override
Retourne une interface pour synchroniser des variables sur le groupe de la famille family.
ISerializeMessage * createSendSerializer(Int32 rank) override
Créé un message non bloquant pour envoyer des données sérialisées au rang rank.
bool isParallel() const override
Retourne true si l'exécution est parallèle.
Ref< IParallelMngUtilsFactory > _internalUtilsFactory() const override
Fabrique des fonctions utilitaires.
ITraceMng * traceMng() const override
Gestionnaire de traces.
IParallelTopology * createTopology() override
Créé une instance contenant les infos sur la topologie des rangs de ce gestionnnaire.
Communicator communicator() const override
Communicateur MPI associé à ce gestionnaire.
IParallelExchanger * createExchanger() override
Retourne une interface pour transférer des messages entre processeurs.
IParallelReplication * replication() const override
Informations sur la réplication.
void setReplication(IParallelReplication *v) override
Positionne les Informations sur la réplication.
Ref< Parallel::IRequestList > createRequestListRef() override
Créé une liste de requêtes pour ce gestionnaire.
ITransferValuesParallelOperation * createTransferValuesOperation() override
Retourne une opération pour transférer des valeurs entre sous-domaine.
UniqueArray< Integer > testSomeRequests(ArrayView< Request > requests) override
Test si une des requêtes rvalues est terminée.
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...
ISerializeMessage * createReceiveSerializer(Int32 rank) override
Créé un message non bloquant pour recevoir des données sérialisées du rang rank.
void freeRequests(ArrayView< Parallel::Request > requests) override
Libère les requêtes.
Gestionnaire du parallélisme utilisant MPI.
Gestionnaire de timer utisant la bibliothèque MPI.
Definition MpiTimerMng.h:39
void compute() override
Recalcule les infos de synchronisation.
Implémentation de Arccore::MessagePassing::IControlDispatcher.
Redirige la gestion des messages des sous-domaines suivant le type de l'argument.
IMessagePassingMng * messagePassingMng() const override
Gestionnaire de message de Arccore associé
ITimeMetricCollector * timeMetricCollector() const override
Collecteur Arccore des statistiques temporelles (peut être nul)
ITimeStats * timeStats() const override
Gestionnaire de statistiques associé (peut être nul)
Classe de base d'une fabrique pour les fonctions utilitaires de IParallelMng.
Informations sur la réplication des sous-domaines en parallèle.
Référence à une instance.
InstanceType * get() const
Instance associée ou nullptr si aucune.
Chaîne de caractères unicode.
bool null() const
Retourne true si la chaîne est nulle.
Definition String.cc:304
Positionne la phase de l'action en cours d'exécution.
Definition Timer.h:128
Positionne une classe de message.
Vecteur 1D de données avec sémantique par valeur (style STL).
MPI_Comm communicator() const override
Récupère le communicateur spécifique de la topologie.
void compute(VariableSynchronizer *var_syncer) override
Calcul le communicateur spécifique.
Interface d'un service de synchronisation de variable.
void compute() override
Création de la liste des éléments de synchronisation.
Int32ConstArrayView communicatingRanks() override
Rangs des sous-domaines avec lesquels on communique.
Déclarations des types et méthodes utilisés par les mécanismes d'échange de messages.
Definition Parallel.h:50
ARCCORE_BASE_EXPORT String getEnvironmentVariable(const String &name)
Variable d'environnement du nom name.
-*- 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.
ARCANE_MPI_EXPORT bool arcaneIsAcceleratorAwareMPI()
Indique si le runtime actuel de MPI a le support des accélérateurs.
Definition ArcaneMpi.cc:82
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
@ IK_Cell
Entité de maillage de genre maille.
void arcaneCallFunctionAndTerminateIfThrow(std::function< void()> function)
auto makeRef(InstanceType *t) -> Ref< InstanceType >
Créé une référence sur un pointeur.
std::int32_t Int32
Type entier signé sur 32 bits.
Infos pour construire un MpiParallelMng.
Infos pour construire un SequentialParallelMng.