Arcane  v3.16.8.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
DataSynchronizeBuffer.h
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/* DataSynchronizeBuffer.h (C) 2000-2025 */
9/* */
10/* Implémentation d'un buffer générique pour la synchronisation de données. */
11/*---------------------------------------------------------------------------*/
12/*---------------------------------------------------------------------------*/
13#ifndef ARCANE_IMPL_DATASYNCHRONIZEBUFFER_H
14#define ARCANE_IMPL_DATASYNCHRONIZEBUFFER_H
15/*---------------------------------------------------------------------------*/
16/*---------------------------------------------------------------------------*/
17
18#include "arcane/utils/MemoryView.h"
19#include "arcane/utils/Array.h"
20#include "arcane/utils/Array2.h"
21#include "arcane/utils/SmallArray.h"
22#include "arcane/utils/TraceAccessor.h"
23
24#include "arcane/impl/IDataSynchronizeBuffer.h"
25#include "arcane/utils/FixedArray.h"
26
27/*---------------------------------------------------------------------------*/
28/*---------------------------------------------------------------------------*/
29namespace Arcane
30{
31class IBufferCopier;
35class MemoryBuffer;
36
37/*---------------------------------------------------------------------------*/
38/*---------------------------------------------------------------------------*/
51class ARCANE_IMPL_EXPORT DataSynchronizeBufferBase
53{
58 {
59 public:
60
63
65 void setGlobalBuffer(MutableMemoryView v);
66
68 MutableMemoryView localBuffer(Int32 rank_index) const;
69
71 MutableMemoryView dataLocalBuffer(Int32 rank_index, Int32 data_index) const;
72
74 Int64 displacement(Int32 rank_index) const;
75
77 Int64 localBufferSize(Int32 rank_index) const;
78
80 Int64 totalSize() const { return m_total_size; }
81
83 ConstArrayView<Int32> localIds(Int32 index) const;
84
85 void checkValid() const
86 {
87 ARCANE_CHECK_POINTER(m_buffer_info);
88 }
89
90 void initialize(ConstArrayView<Int32> datatype_sizes, const DataSynchronizeBufferInfoList* buffer_info);
91
92 private:
93
108 const DataSynchronizeBufferInfoList* m_buffer_info = nullptr;
109 };
110
111 public:
112
113 Int32 nbRank() const final { return m_nb_rank; }
114 Int32 targetRank(Int32 index) const final;
115 bool hasGlobalBuffer() const final { return true; }
116
117 MutableMemoryView receiveBuffer(Int32 index) final { return m_ghost_buffer_info.localBuffer(index); }
118 MutableMemoryView sendBuffer(Int32 index) final { return m_share_buffer_info.localBuffer(index); }
119
120 Int64 receiveDisplacement(Int32 index) const final { return m_ghost_buffer_info.displacement(index); }
121 Int64 sendDisplacement(Int32 index) const final { return m_share_buffer_info.displacement(index); }
122
124 MutableMemoryView globalSendBuffer() final { return m_share_buffer_info.globalBuffer(); }
125
126 Int64 totalReceiveSize() const final { return m_ghost_buffer_info.totalSize(); }
127 Int64 totalSendSize() const final { return m_share_buffer_info.totalSize(); }
128
129 void barrier() final;
130
131 public:
132
134
135 public:
136
138 bool isCompareSynchronizedValues() const { return m_is_compare_sync_values; }
139
140 void setSynchronizeBuffer(Ref<MemoryBuffer> v)
141 {
142 m_memory = v;
143 }
144
156 virtual void prepareSynchronize(bool is_compare_sync) = 0;
157
158 protected:
159
160 void _allocateBuffers();
162 void _compute(ConstArrayView<Int32> datatype_sizes);
163
164 protected:
165
166 DataSynchronizeInfo* m_sync_info = nullptr;
173
174 protected:
175
176 Int32 m_nb_rank = 0;
177 bool m_is_compare_sync_values = false;
178
181
182 Ref<IBufferCopier> m_buffer_copier;
183};
184
185/*---------------------------------------------------------------------------*/
186/*---------------------------------------------------------------------------*/
190class ARCANE_IMPL_EXPORT SingleDataSynchronizeBuffer
191: public TraceAccessor
192, public DataSynchronizeBufferBase
193{
194 public:
195
196 SingleDataSynchronizeBuffer(ITraceMng* tm, DataSynchronizeInfo* sync_info, Ref<IBufferCopier> copier)
197 : TraceAccessor(tm)
198 , DataSynchronizeBufferBase(sync_info, copier)
199 {}
200
201 public:
202
203 void copyReceiveAsync(Int32 index) final;
204 void copySendAsync(Int32 index) final;
205
206 public:
207
208 void setDataView(MutableMemoryView v)
209 {
210 m_data_view = v;
212 }
215 void prepareSynchronize(bool is_compare_sync) override;
216
220 DataSynchronizeResult finalizeSynchronize();
221
222 private:
223
228};
229
230/*---------------------------------------------------------------------------*/
231/*---------------------------------------------------------------------------*/
235class ARCANE_IMPL_EXPORT MultiDataSynchronizeBuffer
236: public TraceAccessor
237, public DataSynchronizeBufferBase
238{
239
240 public:
241
242 MultiDataSynchronizeBuffer(ITraceMng* tm, DataSynchronizeInfo* sync_info,
243 Ref<IBufferCopier> copier)
244 : TraceAccessor(tm)
245 , DataSynchronizeBufferBase(sync_info, copier)
246 {}
247
248 public:
249
250 void copyReceiveAsync(Int32 rank_index) final;
251 void copySendAsync(Int32 rank_index) final;
252
253 public:
254
255 void setNbData(Int32 nb_data)
256 {
257 m_data_views.resize(nb_data);
258 m_datatype_sizes.resize(nb_data);
259 }
260 void setDataView(Int32 index, MutableMemoryView v)
261 {
262 m_data_views[index] = v;
263 m_datatype_sizes[index] = v.datatypeSize();
264 }
265
266 void prepareSynchronize(bool is_compare_sync) override;
267
268 private:
269
274};
275
276/*---------------------------------------------------------------------------*/
277/*---------------------------------------------------------------------------*/
278
279} // namespace Arcane
280
281/*---------------------------------------------------------------------------*/
282/*---------------------------------------------------------------------------*/
283
284#endif
#define ARCANE_CHECK_POINTER(ptr)
Macro retournant le pointeur ptr s'il est non nul ou lancant une exception s'il est nul.
Vue constante d'un tableau de type T.
Buffer pour un élément de la synchronisation (envoi, réception ou comparaison)
Int64 totalSize() const
Taille totale en octet du buffer global.
Int64 m_total_size
Taille total (en octet) du buffer.
SmallArray< Int64 > m_local_buffer_size
Taille (en octet) de chaque buffer local.
MutableMemoryView m_memory_view
Vue sur la zone mémoire du buffer.
ConstArrayView< Int32 > m_datatype_sizes
Taille (en octet) du type de chaque donnée.
UniqueArray2< Int64 > m_displacements
Offset (en octet) dans globalBuffer() de chaque donnée.
MutableMemoryView globalBuffer() const
Buffer global.
Classe de base de l'implémentation de IDataSynchronizeBuffer.
Int64 receiveDisplacement(Int32 index) const final
Déplacement (en octets) depuis le début de receiveBuffer() pour le index-ème rang.
void _allocateBuffers()
Calcul et alloue les tampons nécessaires aux envois et réceptions pour les synchronisations des varia...
bool isCompareSynchronizedValues() const
Indique si on compare les valeurs avant/après la synchronisation.
BufferInfo m_compare_sync_buffer_info
Buffer pour tester si la synchronisation a modifié les valeurs des mailles fantômes.
Int32 nbRank() const final
Nombre de rangs.
Int64 sendDisplacement(Int32 index) const final
Déplacement (en octets) depuis le début de sendBuffer() pour le index-ème rang.
BufferInfo m_share_buffer_info
Buffer pour toutes les données des entités partagées qui serviront en envoi.
MutableMemoryView globalReceiveBuffer() final
Buffer de réception.
Int64 totalSendSize() const final
Taille totale à envoyer en octet.
MutableMemoryView globalSendBuffer() final
Buffer d'envoi.
MutableMemoryView receiveBuffer(Int32 index) final
Buffer de réception pour le index-ème rang.
virtual void prepareSynchronize(bool is_compare_sync)=0
Prépare la synchronisation.
Int64 totalReceiveSize() const final
Taille totale à recevoir en octet.
void _compute(ConstArrayView< Int32 > datatype_sizes)
Calcule les informations pour la synchronisation.
BufferInfo m_ghost_buffer_info
Buffer pour toutes les données des entités fantômes qui serviront en réception.
Ref< MemoryBuffer > m_memory
Buffer contenant les données concaténées en envoi et réception.
MutableMemoryView sendBuffer(Int32 index) final
Buffer d'envoi pour le index-ème rang.
bool hasGlobalBuffer() const final
Indique si les buffers sont globaux.
Informations pour les messages d'envoi (share) ou de réception (ghost)
Informations nécessaires pour synchroniser les entités sur un groupe.
Informations sur le résultat d'une synchronisation.
Tableau 1D de taille fixe.
Definition FixedArray.h:45
Interface pour copier des éléments entre deux zones avec indexation.
Buffer générique pour la synchronisation de données.
Interface du gestionnaire de traces.
Gestion d'un buffer mémoire.
SmallArray< Int32 > m_datatype_sizes
Tableau contenant les tailles des types de donnée.
void prepareSynchronize(bool is_compare_sync) override
void copyReceiveAsync(Int32 rank_index) final
Recopie dans les données depuis le buffer de réception du index-ème rang.
SmallArray< MutableMemoryView > m_data_views
Vue sur les données de la variable.
void copySendAsync(Int32 rank_index) final
Recopie dans le buffer d'envoi les données du index-ème rang.
Vue modifiable sur une zone mémoire contigue contenant des éléments de taille fixe.
Definition MemoryView.h:156
constexpr Int32 datatypeSize() const
Taille du type de donnée associé (1 par défaut)
Definition MemoryView.h:224
Référence à une instance.
MutableMemoryView m_data_view
Vue sur les données de la variable.
FixedArray< Int32, 1 > m_datatype_sizes
Tableau contenant les tailles des types de donnée.
void copyReceiveAsync(Int32 index) final
Recopie dans les données depuis le buffer de réception du index-ème rang.
void copySendAsync(Int32 index) final
Recopie dans le buffer d'envoi les données du index-ème rang.
MutableMemoryView dataView()
Zone mémoire contenant les valeurs de la donnée à synchroniser.
Tableau 1D de données avec buffer pré-alloué sur la pile.
Definition SmallArray.h:89
TraceAccessor(ITraceMng *m)
Construit un accesseur via le gestionnaire de trace m.
Vecteur de données 2D avec sémantique par valeur (style STL).
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
std::int64_t Int64
Type entier signé sur 64 bits.
std::int32_t Int32
Type entier signé sur 32 bits.