14#include "arccore/base/ReferenceCounter.h"
16#include "arccore/message_passing/PointToPointMessageInfo.h"
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"
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"
45#include "arcane/parallel/IStat.h"
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"
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"
81:
public RequestListBase
86 ARCANE_UNUSED(wait_mode);
96class SequentialParallelDispatchT
105 SequentialParallelDispatchT(
ITraceMng* tm)
107 void finalize()
override {}
111 ARCANE_UNUSED(send_buf);
116 ARCANE_UNUSED(send_buf);
121 recv_buf.
copy(send_buf);
125 recv_buf.
copy(send_buf);
130 recv_buf.
copy(send_buf);
135 recv_buf.
copy(send_buf);
140 recv_buf.
copy(send_buf);
145 recv_buf.
copy(send_buf);
149 gatherVariable(send_buf,recv_buf,0);
153 gatherVariable(send_buf,recv_buf,0);
158 recv_buf.resize(send_buf.
size());
165 recv_buf.resize(send_buf.
size());
171 ARCANE_UNUSED(count);
172 recv_buf.
copy(send_buf);
176 ARCANE_UNUSED(count);
177 recv_buf.
copy(send_buf);
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);
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);
211 ARCANE_UNUSED(send_buffer);
217 Request send(
Span<const Type> send_buffer,
const PointToPointMessageInfo& message)
override
219 ARCANE_UNUSED(send_buffer);
226 return receive(
Span<Type>(recv_buffer),rank,is_blocked);
230 ARCANE_UNUSED(send_buffer);
236 ARCANE_UNUSED(recv_buffer);
240 Request receive(
Span<Type> recv_buffer,
Int32 rank,
bool is_blocked)
override
242 ARCANE_UNUSED(recv_buffer);
248 Request receive(
Span<Type> recv_buffer,
const PointToPointMessageInfo& message)
override
250 ARCANE_UNUSED(recv_buffer);
258 recv_buffer.
copy(send_buffer);
260 Type allReduce(eReduceType op,
Type v)
override
268 ARCANE_UNUSED(send_buf);
270 void allReduce(eReduceType op,
Span<Type> send_buf)
override
273 ARCANE_UNUSED(send_buf);
278 ARCANE_UNUSED(send_buf);
279 ARCANE_UNUSED(recv_buf);
284 recv_buf.
copy(send_buf);
289 ARCANE_UNUSED(send_buf);
296 recv_buf.
copy(send_buf);
301 ARCANE_UNUSED(count);
302 recv_buf.
copy(send_buf);
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);
316 Type scan(eReduceType op,
Type v)
override
324 ARCANE_UNUSED(send_buf);
328 Int32& max_rank)
override
330 min_val = max_val = sum_val = val;
331 min_rank = max_rank = 0;
342 min_values[i] = max_values[i] = sum_values[i] = values[i];
343 min_ranks[i] = max_ranks[i] = 0;
352class SequentialMachineMemoryWindowBaseInternal
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)
364 ~SequentialMachineMemoryWindowBaseInternal()
override =
default;
370 return m_sizeof_type;
375 return m_segment.span().
subSpan(0, m_sizeof_segment);
380 ARCANE_FATAL(
"Rank {0} is unavailable (Sequential)", rank);
382 return m_segment.span().
subSpan(0, m_sizeof_segment);
386 return m_segment.span().
subSpan(0, m_sizeof_segment);
391 return m_segment.constSpan().
subSpan(0, m_sizeof_segment);
396 ARCANE_FATAL(
"Rank {0} is unavailable (Sequential)", rank);
398 return m_segment.constSpan().
subSpan(0, m_sizeof_segment);
402 return m_segment.constSpan().
subSpan(0, m_sizeof_segment);
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");
410 m_sizeof_segment = new_sizeof_segment;
422 Int64 m_sizeof_segment = 0;
423 Int64 m_max_sizeof_segment = 0;
425 Int32 m_sizeof_type = 0;
433class SequentialDynamicMachineMemoryWindowBaseInternal
438 SequentialDynamicMachineMemoryWindowBaseInternal(
Int64 sizeof_segment,
Int32 sizeof_type)
439 : m_sizeof_type(sizeof_type)
440 , m_segment(sizeof_segment)
442 ~SequentialDynamicMachineMemoryWindowBaseInternal()
override =
default;
448 return m_sizeof_type;
463 ARCANE_FATAL(
"Rank {0} is unavailable (Sequential)", rank);
474 ARCANE_FATAL(
"Rank {0} is unavailable (Sequential)", rank);
480 if (elem.
size() % m_sizeof_type != 0) {
481 ARCCORE_FATAL(
"Sizeof elem not valid");
483 m_segment.addRange(elem);
489 ARCANE_FATAL(
"Rank {0} is unavailable (Sequential)", rank);
491 if (elem.
size() % m_sizeof_type != 0) {
492 ARCCORE_FATAL(
"Sizeof elem not valid");
494 m_segment.addRange(elem);
500 m_segment.reserve(new_capacity);
505 m_segment.resize(new_size);
537 return makeRef(createNullVariableSynchronizer(pm,group));
549class SequentialParallelMng
550:
public ParallelMngDispatcher
560 ~SequentialParallelMng();
569 void setBaseObject(
IBase* m);
584 recv_serializer->
copy(send_serializer);
588 ARCANE_UNUSED(values);
593 ARCANE_UNUSED(values);
595 ARCANE_UNUSED(bytes);
605 ARCANE_UNUSED(values);
614 void broadcastString(
String& str,
Int32 rank)
override
621 ARCANE_UNUSED(bytes);
626 ARCANE_UNUSED(values);
631 ARCANE_UNUSED(message);
636 ARCANE_UNUSED(message);
641 ARCANE_UNUSED(values);
642 ARCANE_UNUSED(message);
647 ARCANE_UNUSED(values);
648 ARCANE_UNUSED(message);
654 ARCANE_UNUSED(messages);
658 ARCANE_UNUSED(requests);
669 ARCANE_UNUSED(requests);
675 ARCANE_UNUSED(requests);
708 return createNullVariableSynchronizer(
this,family->
allItems());
712 return createNullVariableSynchronizer(
this,group);
723 return m_replication;
728 delete m_replication;
740 return m_utils_factory;
748 void build()
override;
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);
785 ReferenceCounter<ITraceMng> m_trace;
786 IThreadMng* m_thread_mng =
nullptr;
787 ITimerMng* m_timer_mng =
nullptr;
788 IParallelMng* m_world_parallel_mng =
nullptr;
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;
809 return SequentialParallelMng::create(bi);
814 return SequentialParallelMng::createRef(bi);
821:
public ParallelMngInternal
825 explicit Impl(SequentialParallelMng* pm)
826 : ParallelMngInternal(pm)
829 ~Impl()
override =
default;
847SequentialParallelMng::
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)
857, m_communicator(bi.communicator())
859, m_parallel_mng_internal(new Impl(this))
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);
872SequentialParallelMng::
873~SequentialParallelMng()
875 delete m_parallel_mng_internal;
877 delete m_replication;
884void SequentialParallelMng::
885setBaseObject(IBase* sd)
899 DispatchCreator(ITraceMng* tm) : m_tm(tm){}
901 template<
typename DataType> SequentialParallelDispatchT<DataType>*
904 return new SequentialParallelDispatchT<DataType>(m_tm);
913 m_io_mng = arcaneCreateIOMng(
this);
914 DispatchCreator creator(m_trace.get());
915 this->createDispatchers(creator);
934SequentialParallelSuperMng::
937, m_application(sbi.application())
939, m_timer_mng(nullptr)
947SequentialParallelSuperMng::
950, m_application(sbi.application())
952, m_timer_mng(nullptr)
953, m_communicator(comm)
961SequentialParallelSuperMng::
962~SequentialParallelSuperMng()
979 _setDispatchers(c,i32,i64,r);
990 m_timer_mng = m_owned_timer_mng.get();
1007 return SequentialParallelMng::createRef(bi);
1027class SequentialParallelMngBuilder
1034 ~SequentialParallelMngBuilder()
override
1037 delete m_thread_mng;
1063 bi.setThreadMng(m_thread_mng);
1064 bi.setCommunicator(m_communicator);
1065 return arcaneCreateSequentialParallelMngRef(bi);
1071class SequentialParallelMngContainerFactory
1082 ARCANE_UNUSED(nb_rank);
#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 ©_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.
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.
Interface d'une famille d'entités.
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.
Interface d'un sérialiseur.
virtual void copy(const ISerializer *from)=0
Copie les données de from dans cette instance.
Interface d'un gestionnaire de thread.
Interface d'un gestionnaire de timer.
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.
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.
Liste de requête de messages.
Interface d'une liste de messages de sérialisation.
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.
Classe de base d'une liste de requêtes.
Liste de messages de sérialisation.
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...
void addToAnotherSegment() override
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 ©_array)
Recopie le tableau copy_array dans l'instance.
constexpr __host__ __device__ SizeType size() const noexcept
Retourne la taille du tableau.
Vue d'un tableau d'éléments de type T.
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.
Chaîne de caractères unicode.
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.
ConstArrayView< Int32 > Int32ConstArrayView
Equivalent C d'un tableau à une dimension d'entiers 32 bits.
@ 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.
Infos pour construire un SequentialParallelMng.