Arcane  v3.16.8.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
SharedMemoryParallelMng.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/* SharedMemoryParallelMng.cc (C) 2000-2025 */
9/* */
10/* Implémentation des messages en mode mémoire partagé. */
11/*---------------------------------------------------------------------------*/
12/*---------------------------------------------------------------------------*/
13
14#include "arcane/parallel/thread/SharedMemoryParallelMng.h"
15
16#include "arcane/utils/NotImplementedException.h"
17#include "arcane/utils/NotSupportedException.h"
18#include "arcane/utils/PlatformUtils.h"
19#include "arcane/utils/TraceInfo.h"
20#include "arcane/utils/NumericTypes.h"
21#include "arcane/utils/ArgumentException.h"
22#include "arcane/utils/FatalErrorException.h"
23#include "arcane/utils/ITraceMng.h"
24
25#include "arcane/parallel/IStat.h"
26
27#include "arcane/parallel/thread/SharedMemoryParallelDispatch.h"
28#include "arcane/parallel/thread/ISharedMemoryMessageQueue.h"
29#include "arcane/parallel/thread/internal/SharedMemoryMachineMemoryWindowBaseInternalCreator.h"
30#include "arcane/parallel/thread/internal/SharedMemoryMachineMemoryWindowBaseInternal.h"
31#include "arcane/parallel/thread/internal/SharedMemoryDynamicMachineMemoryWindowBaseInternal.h"
32
33#include "arcane/core/Timer.h"
34#include "arcane/core/IIOMng.h"
35#include "arcane/core/ISerializeMessageList.h"
36#include "arcane/core/IItemFamily.h"
37#include "arcane/core/internal/SerializeMessage.h"
38#include "arcane/core/internal/ParallelMngInternal.h"
39
40#include "arcane/impl/TimerMng.h"
41#include "arcane/impl/ParallelReplication.h"
42#include "arcane/impl/internal/ParallelMngUtilsFactoryBase.h"
43
44#include "arccore/message_passing/RequestListBase.h"
45#include "arccore/message_passing/SerializeMessageList.h"
46
47#include <map>
48
49/*---------------------------------------------------------------------------*/
50/*---------------------------------------------------------------------------*/
51
52namespace Arcane
53{
54extern "C++" ARCANE_IMPL_EXPORT IIOMng*
55arcaneCreateIOMng(IParallelMng* psm);
56}
57
59{
60
61/*---------------------------------------------------------------------------*/
62/*---------------------------------------------------------------------------*/
68{
70 public:
71
72 explicit RequestList(SharedMemoryParallelMng* pm)
73 : m_parallel_mng(pm), m_message_queue(pm->m_message_queue),
74 m_local_rank(m_parallel_mng->commRank()){}
75 public:
76 void _wait(Parallel::eWaitType wait_type) override
77 {
78 switch(wait_type){
79 case Parallel::WaitAll:
80 return m_message_queue->waitAll(_requests());
82 return m_message_queue->waitSome(m_local_rank,_requests(),_requestsDone(),false);
84 return m_message_queue->waitSome(m_local_rank,_requests(),_requestsDone(),true);
85 }
86 }
87 private:
88 SharedMemoryParallelMng* m_parallel_mng;
89 ISharedMemoryMessageQueue* m_message_queue;
90 Int32 m_local_rank;
91};
92
93/*---------------------------------------------------------------------------*/
94/*---------------------------------------------------------------------------*/
95
97: public ParallelMngInternal
98{
99 public:
100
101 explicit Impl(SharedMemoryParallelMng* pm, SharedMemoryMachineMemoryWindowBaseInternalCreator* window_creator)
102 : ParallelMngInternal(pm)
103 , m_parallel_mng(pm)
104 , m_window_creator(window_creator)
105 {}
106
107 ~Impl() override = default;
108
109 public:
110
112 {
113 return makeRef(m_window_creator->createWindow(m_parallel_mng->commRank(), sizeof_segment, sizeof_type));
114 }
115
117 {
118 return makeRef(m_window_creator->createDynamicWindow(m_parallel_mng->commRank(), sizeof_segment, sizeof_type));
119 }
120
121 private:
122
123 SharedMemoryParallelMng* m_parallel_mng;
125};
126
127/*---------------------------------------------------------------------------*/
128/*---------------------------------------------------------------------------*/
129
130SharedMemoryParallelMng::
131SharedMemoryParallelMng(const SharedMemoryParallelMngBuildInfo& build_info)
132: ParallelMngDispatcher(ParallelMngDispatcherBuildInfo(build_info.rank,build_info.nb_rank))
133, m_trace(build_info.trace_mng)
134, m_thread_mng(build_info.thread_mng)
135, m_sequential_parallel_mng(build_info.sequential_parallel_mng)
136, m_timer_mng(nullptr)
137, m_replication(new ParallelReplication())
138, m_world_parallel_mng(build_info.world_parallel_mng)
139, m_io_mng(nullptr)
140, m_message_queue(build_info.message_queue)
141, m_is_parallel(build_info.nb_rank!=1)
142, m_rank(build_info.rank)
143, m_nb_rank(build_info.nb_rank)
144, m_is_initialized(false)
145, m_stat(Parallel::createDefaultStat())
146, m_thread_barrier(build_info.thread_barrier)
147, m_all_dispatchers(build_info.all_dispatchers)
148, m_sub_builder_factory(build_info.sub_builder_factory)
149, m_parent_container_ref(build_info.container)
150, m_mpi_communicator(build_info.communicator)
151, m_utils_factory(createRef<ParallelMngUtilsFactoryBase>())
152, m_parallel_mng_internal(new Impl(this, build_info.window_creator))
153{
154 if (!m_world_parallel_mng)
155 m_world_parallel_mng = this;
156}
157
158/*---------------------------------------------------------------------------*/
159/*---------------------------------------------------------------------------*/
160
161SharedMemoryParallelMng::
162~SharedMemoryParallelMng()
163{
164 delete m_parallel_mng_internal;
165 delete m_replication;
166 m_sequential_parallel_mng.reset();
167 delete m_io_mng;
168 delete m_timer_mng;
169 delete m_stat;
170}
171
172/*---------------------------------------------------------------------------*/
173/*---------------------------------------------------------------------------*/
174
175namespace
176{
177// Classe pour créer les différents dispatchers
178class DispatchCreator
179{
180 public:
181 DispatchCreator(ITraceMng* tm,SharedMemoryParallelMng* mpm,
182 ISharedMemoryMessageQueue* message_queue,
183 SharedMemoryAllDispatcher* all_dispatchers)
184 : m_tm(tm), m_mpm(mpm), m_message_queue(message_queue),
185 m_all_dispatchers(all_dispatchers){}
186 public:
187 template<typename DataType> SharedMemoryParallelDispatch<DataType>*
188 create()
189 {
190 ISharedMemoryMessageQueue* tmq = m_message_queue;
191 SharedMemoryAllDispatcher* ad = m_all_dispatchers;
192 auto& field = ad->instance((DataType*)nullptr);
193 return new SharedMemoryParallelDispatch<DataType>(m_tm,m_mpm,tmq,field);
194 }
195
196 ITraceMng* m_tm;
197 SharedMemoryParallelMng* m_mpm;
198 ISharedMemoryMessageQueue* m_message_queue;
199 SharedMemoryAllDispatcher* m_all_dispatchers;
200};
201}
202
203/*---------------------------------------------------------------------------*/
204/*---------------------------------------------------------------------------*/
205
207build()
208{
209 m_message_queue->setTraceMng(m_rank,traceMng());
210 m_timer_mng = new TimerMng(traceMng());
211
212 DispatchCreator creator(m_trace.get(),this,m_message_queue,m_all_dispatchers);
213 this->createDispatchers(creator);
214
215 m_io_mng = arcaneCreateIOMng(this);
216}
217
218/*----------------------------------------------------------------------------*/
219/*---------------------------------------------------------------------------*/
220
223{
224 Trace::Setter mci(m_trace.get(),"Thread");
225 if (m_is_initialized){
226 m_trace->warning() << "SharedMemoryParallelMng already initialized";
227 return;
228 }
229
230 m_is_initialized = true;
231}
232
233/*---------------------------------------------------------------------------*/
234/*---------------------------------------------------------------------------*/
235
238{
239 return m_utils_factory->createGetVariablesValuesOperation(this)._release();
240}
241
244{
245 return m_utils_factory->createTransferValuesOperation(this)._release();
246}
247
250{
251 return m_utils_factory->createExchanger(this)._release();
252}
253
254/*---------------------------------------------------------------------------*/
255/*---------------------------------------------------------------------------*/
256
257/*---------------------------------------------------------------------------*/
258/*---------------------------------------------------------------------------*/
259
260void SharedMemoryParallelMng::
261sendSerializer(ISerializer* values,Int32 dest_rank)
262{
263 auto p2p_message = buildMessage(dest_rank,Parallel::Blocking);
264 Request r = m_message_queue->addSend(p2p_message,SendBufferInfo(values));
265 m_message_queue->waitAll(ArrayView<Request>(1,&r));
266}
267
268/*---------------------------------------------------------------------------*/
269/*---------------------------------------------------------------------------*/
270
271Parallel::Request SharedMemoryParallelMng::
272sendSerializer(ISerializer* values,Int32 rank,ByteArray& bytes)
273{
274 ARCANE_UNUSED(bytes);
275 return m_message_queue->addSend(buildMessage(rank,Parallel::Blocking),SendBufferInfo(values));
276}
277
278/*---------------------------------------------------------------------------*/
279/*---------------------------------------------------------------------------*/
280
283{
284 return m_utils_factory->createSendSerializeMessage(this, rank)._release();
285}
286
287/*---------------------------------------------------------------------------*/
288/*---------------------------------------------------------------------------*/
289
290void SharedMemoryParallelMng::
291broadcastSerializer(ISerializer* values,Int32 rank)
292{
293 // Implementation basique pour l'instant.
294 // Le rank qui broadcast envoie le message à tout le monde.
295 if (m_rank==rank){
297 for( Int32 i=0; i<m_nb_rank; ++i ){
298 if (i!=m_rank){
299 requests.add(m_message_queue->addSend(buildMessage(i,Parallel::NonBlocking),SendBufferInfo(values)));
300 }
301 }
302 m_message_queue->waitAll(requests);
303 }
304 else{
305 recvSerializer(values,rank);
306 }
307}
308
309/*---------------------------------------------------------------------------*/
310/*---------------------------------------------------------------------------*/
311
312void SharedMemoryParallelMng::
313recvSerializer(ISerializer* values,Int32 rank)
314{
315 auto p2p_message = buildMessage(rank,Parallel::Blocking);
316 Request r = m_message_queue->addReceive(p2p_message,ReceiveBufferInfo(values));
317 m_message_queue->waitAll(ArrayView<Request>(1,&r));
318}
319
320/*---------------------------------------------------------------------------*/
321/*---------------------------------------------------------------------------*/
322
325{
326 return m_utils_factory->createReceiveSerializeMessage(this, rank)._release();
327}
328
329/*---------------------------------------------------------------------------*/
330/*---------------------------------------------------------------------------*/
331
334{
335 ARCANE_UNUSED(requests);
336 throw NotImplementedException(A_FUNCINFO);
337}
338
339/*---------------------------------------------------------------------------*/
340/*---------------------------------------------------------------------------*/
341
344{
345 if (m_stat)
346 m_stat->print(m_trace.get());
347}
348
349/*---------------------------------------------------------------------------*/
350/*---------------------------------------------------------------------------*/
351
353barrier()
354{
355 m_thread_barrier->wait();
356}
357
358/*---------------------------------------------------------------------------*/
359/*---------------------------------------------------------------------------*/
360
363{
364 Real begin_time = platform::getRealTime();
365 m_message_queue->waitAll(requests);
366 Real end_time = platform::getRealTime();
367 m_stat->add("WaitAll",(end_time-begin_time),0);
368}
369
370/*---------------------------------------------------------------------------*/
371/*---------------------------------------------------------------------------*/
372
373ISerializeMessageList* SharedMemoryParallelMng::
374_createSerializeMessageList()
375{
376 return new MP::internal::SerializeMessageList(messagePassingMng());
377}
378
379/*---------------------------------------------------------------------------*/
380/*---------------------------------------------------------------------------*/
381
383probe(const PointToPointMessageInfo& message)
384{
385 PointToPointMessageInfo p2p_message(message);
386 p2p_message.setEmiterRank(MessageRank(m_rank));
387 return m_message_queue->probe(p2p_message);
388}
389
390/*---------------------------------------------------------------------------*/
391/*---------------------------------------------------------------------------*/
392
395{
396 PointToPointMessageInfo p2p_message(message);
397 p2p_message.setEmiterRank(MessageRank(m_rank));
398 return m_message_queue->legacyProbe(p2p_message);
399}
400
401/*---------------------------------------------------------------------------*/
402/*---------------------------------------------------------------------------*/
403
404auto SharedMemoryParallelMng::
405sendSerializer(const ISerializer* values,const PointToPointMessageInfo& message) -> Request
406{
407 auto p2p_message = buildMessage(message);
408 return m_message_queue->addSend(p2p_message,SendBufferInfo(values));
409}
410
411/*---------------------------------------------------------------------------*/
412/*---------------------------------------------------------------------------*/
413
414auto SharedMemoryParallelMng::
415receiveSerializer(ISerializer* values,const PointToPointMessageInfo& message) -> Request
416{
417 auto p2p_message = buildMessage(message);
418 return m_message_queue->addReceive(p2p_message,ReceiveBufferInfo(values));
419}
420
421/*---------------------------------------------------------------------------*/
422/*---------------------------------------------------------------------------*/
423
426{
427 return m_utils_factory->createSynchronizer(this,family)._release();
428}
429
430/*---------------------------------------------------------------------------*/
431/*---------------------------------------------------------------------------*/
432
434createSynchronizer(const ItemGroup& group)
435{
436 return m_utils_factory->createSynchronizer(this,group)._release();
437}
438
439/*---------------------------------------------------------------------------*/
440/*---------------------------------------------------------------------------*/
441
444{
445 return m_utils_factory->createTopology(this)._release();
446}
447
448/*---------------------------------------------------------------------------*/
449/*---------------------------------------------------------------------------*/
450
452replication() const
453{
454 return m_replication;
455}
456
457/*---------------------------------------------------------------------------*/
458/*---------------------------------------------------------------------------*/
459
462{
463 delete m_replication;
464 m_replication = v;
465}
466
467/*---------------------------------------------------------------------------*/
468/*---------------------------------------------------------------------------*/
469
470IParallelMng* SharedMemoryParallelMng::
471_createSubParallelMng(Int32ConstArrayView kept_ranks)
472{
473 ARCANE_UNUSED(kept_ranks);
474 // On ne peut pas implémenter cette méthode car on passe par
475 // IParallelMngContainer::_createParallelMng() qui créé obligatoirement
476 // un 'Ref<IParallelMng>'.
477 ARCANE_THROW(NotSupportedException,"Use createSubParallelMngRef() instead");
478}
479
480/*---------------------------------------------------------------------------*/
481/*---------------------------------------------------------------------------*/
482
485{
486 if (kept_ranks.empty())
487 ARCANE_FATAL("kept_ranks is empty");
488 ARCANE_CHECK_POINTER(m_sub_builder_factory);
489
491 Int32 nb_rank = kept_ranks.size();
492
493 // Regarde si je suis dans les listes des rangs conservés et si oui
494 // détermine mon rang dans le IParallelMng créé
495 Int32 my_new_rank = (-1);
496 for( Integer i=0; i<nb_rank; ++i )
497 if (kept_ranks[i]==m_rank){
498 my_new_rank = i;
499 break;
500 }
501
502 barrier();
503 // Le rang 0 créé le builder
504 if (m_rank==0){
505 builder = m_sub_builder_factory->_createParallelMngBuilder(nb_rank,m_mpi_communicator);
506 // Positionne le builder pour tout le monde
507 m_all_dispatchers->m_create_sub_parallel_mng_info.m_builder = builder;
508 }
509 barrier();
510
511 builder = m_all_dispatchers->m_create_sub_parallel_mng_info.m_builder;
512 ARCANE_CHECK_POINTER(builder.get());
513
514 Ref<IParallelMng> new_parallel_mng;
515 if (my_new_rank>=0){
516 new_parallel_mng = builder->_createParallelMng(my_new_rank,traceMng());
517 //auto* new_sm = dynamic_cast<SharedMemoryParallelMng*>(new_parallel_mng.get());
518 //if (new_sm)
519 //new_sm->m_mpi_communicator = m_mpi_communicator;
520 }
521 barrier();
522 // Ici, tout le monde a créé son IParallelMng. On peut donc
523 // supprimer la référence au builder.
524 // TODO: il faudra ajouter un compteur de référence sur le builder
525 // sinon il ne sera jamais détruit.
526 if (m_rank==0){
527 m_all_dispatchers->m_create_sub_parallel_mng_info.m_builder.reset();
528 }
529 barrier();
530
531 return new_parallel_mng;
532}
533
534/*---------------------------------------------------------------------------*/
535/*---------------------------------------------------------------------------*/
536
543
544/*---------------------------------------------------------------------------*/
545/*---------------------------------------------------------------------------*/
546
547Ref<IParallelMng> SharedMemoryParallelMng::
548sequentialParallelMngRef()
549{
550 return m_sequential_parallel_mng;
551}
552
555{
556 return m_sequential_parallel_mng.get();
557}
558
559/*---------------------------------------------------------------------------*/
560/*---------------------------------------------------------------------------*/
561
563buildMessage(const PointToPointMessageInfo& orig_message)
564{
565 PointToPointMessageInfo p2p_message{orig_message};
566 p2p_message.setEmiterRank(MessageRank(m_rank));
567 return p2p_message;
568}
569
570/*---------------------------------------------------------------------------*/
571/*---------------------------------------------------------------------------*/
572
573PointToPointMessageInfo SharedMemoryParallelMng::
574buildMessage(Int32 dest,Parallel::eBlockingType blocking_mode)
575{
576 return buildMessage({MessageRank(dest),blocking_mode});
577}
578
579/*---------------------------------------------------------------------------*/
580/*---------------------------------------------------------------------------*/
581
587
588/*---------------------------------------------------------------------------*/
589/*---------------------------------------------------------------------------*/
590
591} // End namespace Arcane::MessagePassing
592
593/*---------------------------------------------------------------------------*/
594/*---------------------------------------------------------------------------*/
#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_THROW(exception_class,...)
Macro pour envoyer une exception avec formattage.
#define ARCANE_FATAL(...)
Macro envoyant une exception FatalErrorException.
Vue modifiable d'un tableau d'un type T.
void add(ConstReferenceType val)
Ajoute l'élément val à la fin du tableau.
constexpr Integer size() const noexcept
Nombre d'éléments du tableau.
constexpr bool empty() const noexcept
true si le tableau est vide (size()==0)
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
Échange d'informations entre processeurs.
Interface du gestionnaire de parallélisme pour un sous-domaine.
Informations sur la réplication des sous-domaines en parallèle.
Informations sur la topologie d'allocation des coeurs de calcul.
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
Interface d'un message de sérialisation entre IMessagePassingMng.
Interface d'une file de messages avec les threads.
Informations sur la source d'un message.
Informations pour envoyer/recevoir un message point à point.
void setEmiterRank(MessageRank rank)
Positionne le rang de l'émetteur du message.
Informations des buffers de réception.
Requête d'un message.
Definition Request.h:77
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.
Ref< IMachineMemoryWindowBaseInternal > createMachineMemoryWindowBase(Int64 sizeof_segment, Int32 sizeof_type) override
Méthode permettant de créer une fenêtre mémoire sur le noeud.
Implémentation de IRequestList pour SharedMemoryParallelMng.
void _wait(Parallel::eWaitType wait_type) override
Effectue l'attente ou le test.
IParallelTopology * createTopology() override
Créé une instance contenant les infos sur la topologie des rangs de ce gestionnnaire.
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...
Ref< Parallel::IRequestList > createRequestListRef() override
Créé une liste de requêtes pour ce gestionnaire.
void printStats() override
Affiche des statistiques liées à ce gestionnaire du parallélisme.
void initialize() override
Initialise le gestionnaire du parallélisme.
void setReplication(IParallelReplication *v) override
Positionne les Informations sur la réplication.
PointToPointMessageInfo buildMessage(Int32 dest, MP::eBlockingType is_blocking)
Construit un message avec pour destinataire dest.
void waitAllRequests(ArrayView< Request > requests) override
Bloque en attendant que les requêtes rvalues soient terminées.
Ref< IParallelMngUtilsFactory > _internalUtilsFactory() const override
Fabrique des fonctions utilitaires.
IVariableSynchronizer * createSynchronizer(IItemFamily *family) override
Retourne une interface pour synchroniser des variables sur le groupe de la famille family.
MessageId probe(const PointToPointMessageInfo &message) override
Sonde si des messages sont disponibles.
ISerializeMessage * createSendSerializer(Int32 rank) override
Créé un message non bloquant pour envoyer des données sérialisées au rang rank.
ITraceMng * traceMng() const override
Gestionnaire de traces.
IParallelMng * sequentialParallelMng() override
Retourne un gestionnaire de parallélisme séquentiel.
IParallelExchanger * createExchanger() override
Retourne une interface pour transférer des messages entre processeurs.
void freeRequests(ArrayView< Parallel::Request > requests) override
Libère les requêtes.
ISerializeMessage * createReceiveSerializer(Int32 rank) override
Créé un message non bloquant pour recevoir des données sérialisées du rang rank.
Ref< IParallelMng > createSubParallelMngRef(Int32ConstArrayView kept_ranks) override
Créé un nouveau gestionnaire de parallélisme pour un sous-ensemble des rangs.
ITransferValuesParallelOperation * createTransferValuesOperation() override
Retourne une opération pour transférer des valeurs entre sous-domaine.
MessageSourceInfo legacyProbe(const PointToPointMessageInfo &message) override
Sonde si des messages sont disponibles.
IParallelReplication * replication() const override
Informations sur la réplication.
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.
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.
Référence à une instance.
InstanceType * get() const
Instance associée ou nullptr si aucune.
Gestionnaire de timer.
Definition TimerMng.h:39
Positionne une classe de message.
Vecteur 1D de données avec sémantique par valeur (style STL).
Déclarations des types et méthodes utilisés par les mécanismes d'échange de messages.
@ WaitSome
Attend que tous les messages de la liste soient traités.
eBlockingType
Type indiquant si un message est bloquant ou non.
Implémentation de la concurrence.
ARCCORE_BASE_EXPORT Real getRealTime()
Temps Real utilisé en secondes.
-*- 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
double Real
Type représentant un réel.
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 SharedMemoryParallelMng.