14#include "arcane/impl/internal/IDataSynchronizeDispatcher.h"
16#include "arcane/utils/FatalErrorException.h"
17#include "arcane/utils/PlatformUtils.h"
18#include "arcane/utils/MemoryView.h"
19#include "arcane/utils/ValueConvert.h"
20#include "arcane/utils/ITraceMng.h"
21#include "arcane/utils/internal/MemoryBuffer.h"
23#include "arcane/core/ParallelMngUtils.h"
24#include "arcane/core/IParallelExchanger.h"
25#include "arcane/core/ISerializeMessage.h"
26#include "arcane/core/ISerializer.h"
27#include "arcane/core/IParallelMng.h"
28#include "arcane/core/IData.h"
29#include "arcane/core/internal/IDataInternal.h"
31#include "arcane/impl/DataSynchronizeInfo.h"
32#include "arcane/impl/internal/DataSynchronizeBuffer.h"
46 void* data = bytes.
data();
47 Int32 size = bytes.smallView().size();
48 return { size,
reinterpret_cast<Byte*
>(data) };
58class DataSynchronizeDispatcherBase
63 ~DataSynchronizeDispatcherBase();
68 Runner* m_runner =
nullptr;
80DataSynchronizeDispatcherBase::
82: m_parallel_mng(bi.parallelMng())
83, m_sync_info(bi.synchronizeInfo())
84, m_synchronize_implementation(bi.synchronizeImplementation())
91DataSynchronizeDispatcherBase::
92~DataSynchronizeDispatcherBase()
105 m_synchronize_implementation->compute();
116class ARCANE_IMPL_EXPORT DataSynchronizeDispatcher
118,
public DataSynchronizeDispatcherBase
126 : DataSynchronizeDispatcherBase(bi)
142 bool m_is_in_sync =
false;
143 bool m_is_empty_sync =
false;
160 ARCANE_FATAL(
"_beginSynchronize() has already been called");
163 m_is_empty_sync = (mem_view.
bytes().size() == 0);
168 m_synchronize_implementation->beginSynchronize(&
m_sync_buffer);
178 ARCANE_FATAL(
"No pending synchronize(). You need to call beginSynchronize() before");
180 if (!m_is_empty_sync) {
181 m_synchronize_implementation->endSynchronize(&
m_sync_buffer);
184 m_is_in_sync =
false;
208class ARCANE_IMPL_EXPORT DataSynchronizeMultiDispatcher
214 : m_parallel_mng(bi.parallelMng())
215 , m_sync_info(bi.synchronizeInfo())
232void DataSynchronizeMultiDispatcher::
233synchronize(ConstArrayView<IVariable*> vars)
236 Integer nb_rank = m_sync_info->size();
238 for (
Integer i = 0; i < nb_rank; ++i) {
239 Int32 rank = m_sync_info->targetRank(i);
240 exchanger->addSender(rank);
241 recv_ranks[i] = rank;
243 exchanger->initializeCommunicationsMessages(recv_ranks);
244 for (
Integer i = 0; i < nb_rank; ++i) {
245 ISerializeMessage* msg = exchanger->messageToSend(i);
246 ISerializer* sbuf = msg->serializer();
248 sbuf->setMode(ISerializer::ModeReserve);
249 for (IVariable* var : vars) {
250 var->serialize(sbuf, share_ids,
nullptr);
252 sbuf->allocateBuffer();
254 for (IVariable* var : vars) {
255 var->serialize(sbuf, share_ids,
nullptr);
258 exchanger->processExchange();
259 for (
Integer i = 0; i < nb_rank; ++i) {
260 ISerializeMessage* msg = exchanger->messageToReceive(i);
261 ISerializer* sbuf = msg->serializer();
264 for (IVariable* var : vars) {
265 var->serialize(sbuf, ghost_ids,
nullptr);
281class ARCANE_IMPL_EXPORT DataSynchronizeMultiDispatcherV2
282:
public DataSynchronizeDispatcherBase
288 : DataSynchronizeDispatcherBase(bi)
289 , m_sync_buffer(bi.parallelMng()->
traceMng(), m_sync_info.get(), bi.bufferCopier())
305void DataSynchronizeMultiDispatcherV2::
306synchronize(ConstArrayView<IVariable*> vars)
308 const Int32 nb_var = vars.size();
309 m_sync_buffer.setNbData(nb_var);
314 for (IVariable* var : vars) {
315 INumericDataInternal* numapi = var->data()->_commonInternal()->numericData();
317 ARCANE_FATAL(
"Variable '{0}' can not be synchronized because it is not a numeric data", var->name());
318 MutableMemoryView mem_view = numapi->memoryView();
319 m_sync_buffer.setDataView(index, mem_view);
325 bool is_compare_sync =
false;
326 m_sync_buffer.prepareSynchronize(is_compare_sync);
328 m_synchronize_implementation->beginSynchronize(&m_sync_buffer);
329 m_synchronize_implementation->endSynchronize(&m_sync_buffer);
342class SimpleDataSynchronizeImplementation
348 explicit SimpleDataSynchronizeImplementation(
Factory* f);
352 void compute()
override {}
376 auto* x =
new SimpleDataSynchronizeImplementation(
this);
388SimpleDataSynchronizeImplementation::
389SimpleDataSynchronizeImplementation(
Factory* f)
390: m_parallel_mng(f->m_parallel_mng)
398arcaneCreateSimpleVariableSynchronizerFactory(
IParallelMng* pm)
407void SimpleDataSynchronizeImplementation::
408beginSynchronize(IDataSynchronizeBuffer* vs_buf)
411 IParallelMng* pm = m_parallel_mng;
413 const bool use_blocking_send =
false;
414 Int32 nb_message = vs_buf->nbRank();
421 for (
Integer i = 0; i < nb_message; ++i) {
422 Int32 target_rank = vs_buf->targetRank(i);
423 auto buf = _toLegacySmallView(vs_buf->receiveBuffer(i));
425 Parallel::Request rval = pm->recv(buf, target_rank,
false);
426 m_all_requests.add(rval);
430 vs_buf->copyAllSend();
433 for (
Integer i = 0; i < nb_message; ++i) {
434 Int32 target_rank = vs_buf->targetRank(i);
435 auto buf = _toLegacySmallView(vs_buf->sendBuffer(i));
442 Parallel::Request rval = pm->send(buf, target_rank, use_blocking_send);
443 if (!use_blocking_send)
444 m_all_requests.add(rval);
452void SimpleDataSynchronizeImplementation::
453endSynchronize(IDataSynchronizeBuffer* vs_buf)
455 IParallelMng* pm = m_parallel_mng;
463 m_all_requests.clear();
466 vs_buf->copyAllReceive();
475IDataSynchronizeMultiDispatcher* IDataSynchronizeMultiDispatcher::
476create(
const DataSynchronizeDispatcherBuildInfo& bi)
483 return new DataSynchronizeMultiDispatcher(bi);
484 return new DataSynchronizeMultiDispatcherV2(bi);
#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.
#define ARCCORE_DEFINE_REFERENCE_COUNTED_INCLASS_METHODS()
Macro pour définir les méthodes gérant les compteurs de référence.
Gestionnaire d'exécution pour accélérateur.
Vue modifiable d'un tableau d'un type T.
Vue constante d'un tableau de type T.
static std::optional< Int32 > tryParseFromEnvironment(StringView s, bool throw_if_invalid)
void _compute()
Notifie l'implémentation que les informations de synchronisation ont changé.
Infos pour construire un DataSynchronizeDispatcher.
Gestion de la synchronisation pour une donnée.
DataSynchronizeResult endSynchronize() override
Termine la synchronisation.
void setSynchronizeBuffer(Ref< MemoryBuffer > buffer) override
Positionne le buffer de synchronisation.
void compute() override
Recalcule les informations nécessaires après une mise à jour des informations de DataSynchronizeInfo.
SingleDataSynchronizeBuffer m_sync_buffer
Gère les buffers d'envoi et réception pour la synchronisation.
void beginSynchronize(INumericDataInternal *data, bool is_compare_sync) override
Commence l'exécution pour la synchronisation pour la donnée data.
void compute() override
Recalcule les informations nécessaires après une mise à jour des informations de DataSynchronizeInfo.
void setSynchronizeBuffer(Ref< MemoryBuffer > buffer) override
Positionne le buffer de synchronisation.
void compute() override
Recalcule les informations nécessaires après une mise à jour des informations de DataSynchronizeInfo.
void setSynchronizeBuffer(Ref< MemoryBuffer >) override
Positionne le buffer de synchronisation.
Informations sur le résultat d'une synchronisation.
Buffer générique pour la synchronisation de données.
Interface pour gérer la synchronisation d'une donnée.
Interface d'une fabrique dispatcher générique.
Interface de la synchronisation d'une liste de variables.
Interface pour un 'IData' d'un type numérique.
virtual MutableMemoryView memoryView()=0
Vue mémoire sur la donnée.
Interface du gestionnaire de parallélisme pour un sous-domaine.
virtual ITraceMng * traceMng() const =0
Gestionnaire de traces.
virtual void waitAllRequests(ArrayView< Request > rvalues)=0
Bloque en attendant que les requêtes rvalues soient terminées.
@ ModePut
Le sérialiseur attend des reserve()
@ ModeGet
Le sérialiseur attend des get()
Implémentation de IDataSynchronizeBuffer pour plusieurs données.
Vue modifiable sur une zone mémoire contigue contenant des éléments de taille fixe.
constexpr SpanType bytes() const
Vue sous forme d'octets.
Référence à une instance.
Implémentation thread-safe d'un compteur de référence.
Implémentation de IDataSynchronizeBuffer pour une donnée.
constexpr __host__ __device__ pointer data() const noexcept
Pointeur sur le début de la vue.
Vue d'un tableau d'éléments de type T.
Vecteur 1D de données avec sémantique par valeur (style STL).
Ref< IParallelExchanger > createExchangerRef(IParallelMng *pm)
Retourne une interface pour transférer des messages entre rangs.
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
Int32 Integer
Type représentant un entier.
ConstArrayView< Int32 > Int32ConstArrayView
Equivalent C d'un tableau à une dimension d'entiers 32 bits.
UniqueArray< Int32 > Int32UniqueArray
Tableau dynamique à une dimension d'entiers 32 bits.
unsigned char Byte
Type d'un octet.
auto makeRef(InstanceType *t) -> Ref< InstanceType >
Créé une référence sur un pointeur.
std::int32_t Int32
Type entier signé sur 32 bits.