Arcane  4.1.11.0
Documentation utilisateur
Chargement...
Recherche...
Aucune correspondance
MachineShMemWinVariable.cc
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2026 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/* MachineShMemWinVariable.cc (C) 2000-2026 */
9/* */
10/* Classes permettant d'exploiter l'objet MachineShMemWinVariable pointé de */
11/* la zone mémoire des variables en mémoire partagée. */
12/*---------------------------------------------------------------------------*/
13
14#include "arcane/core/MachineShMemWinVariable.h"
15
16#include "arcane/utils/NumericTypes.h"
17#include "arcane/utils/MDSpan.h"
18
19#include "arcane/core/VariableRefArray.h"
20#include "arcane/core/VariableRefArray2.h"
21#include "arcane/core/MeshVariable.h"
22#include "arcane/core/IVariable.h"
23#include "arcane/core/MeshVariableScalarRef.h"
24#include "arcane/core/internal/MachineShMemWinVariableBase.h"
25
26#include "arccore/base/Span2.h"
27#include "arccore/base/MDIndex.h"
28
29/*---------------------------------------------------------------------------*/
30/*---------------------------------------------------------------------------*/
31
32namespace Arcane
33{
34
35/*---------------------------------------------------------------------------*/
36/*---------------------------------------------------------------------------*/
37
38MachineShMemWinVariableCommon::
39MachineShMemWinVariableCommon(IVariable* var)
40: m_base(makeRef(new MachineShMemWinVariableBase(var)))
41{}
42
43/*---------------------------------------------------------------------------*/
44/*---------------------------------------------------------------------------*/
45
46MachineShMemWinVariableCommon::
47~MachineShMemWinVariableCommon()
48= default;
49
50/*---------------------------------------------------------------------------*/
51/*---------------------------------------------------------------------------*/
52
53ConstArrayView<Int32> MachineShMemWinVariableCommon::
54machineRanks() const
55{
56 return m_base->machineRanks();
57}
58
59/*---------------------------------------------------------------------------*/
60/*---------------------------------------------------------------------------*/
61
62void MachineShMemWinVariableCommon::
63barrier() const
64{
65 m_base->barrier();
66}
67
68/*---------------------------------------------------------------------------*/
69/*---------------------------------------------------------------------------*/
70
71/*---------------------------------------------------------------------------*/
72/*---------------------------------------------------------------------------*/
73
74template <class DataType>
82
83/*---------------------------------------------------------------------------*/
84/*---------------------------------------------------------------------------*/
85
86template <class DataType>
87MachineShMemWinVariableArrayT<DataType>::
88~MachineShMemWinVariableArrayT() = default;
89
90/*---------------------------------------------------------------------------*/
91/*---------------------------------------------------------------------------*/
92
93template <class DataType>
94Span<DataType> MachineShMemWinVariableArrayT<DataType>::
95view(Int32 rank) const
96{
97 return asSpan<DataType>(m_base->segmentView(rank));
98}
99
100/*---------------------------------------------------------------------------*/
101/*---------------------------------------------------------------------------*/
102
103template <class DataType>
104void MachineShMemWinVariableArrayT<DataType>::
105updateVariable()
106{
107 m_base->updateVariable(m_vart.asArray().size(), sizeof(DataType));
108}
109
110/*---------------------------------------------------------------------------*/
111/*---------------------------------------------------------------------------*/
112
113/*---------------------------------------------------------------------------*/
114/*---------------------------------------------------------------------------*/
115
116template <class ItemType, class DataType>
124
125/*---------------------------------------------------------------------------*/
126/*---------------------------------------------------------------------------*/
127
128template <class ItemType, class DataType>
129MachineShMemWinMeshVariableScalarT<ItemType, DataType>::
130~MachineShMemWinMeshVariableScalarT() = default;
131
132/*---------------------------------------------------------------------------*/
133/*---------------------------------------------------------------------------*/
134
135template <class ItemType, class DataType>
136Span<DataType> MachineShMemWinMeshVariableScalarT<ItemType, DataType>::
137view(Int32 rank) const
138{
139 return asSpan<DataType>(m_base->segmentView(rank));
140}
141
142/*---------------------------------------------------------------------------*/
143/*---------------------------------------------------------------------------*/
144
145template <class ItemType, class DataType>
146DataType MachineShMemWinMeshVariableScalarT<ItemType, DataType>::
147operator()(Int32 rank, Int32 notlocal_id)
148{
149 return this->view(rank)[notlocal_id];
150}
151
152/*---------------------------------------------------------------------------*/
153/*---------------------------------------------------------------------------*/
154
155template <class ItemType, class DataType>
156void MachineShMemWinMeshVariableScalarT<ItemType, DataType>::
157updateVariable()
158{
159 m_base->updateVariable(m_vart.asArray().size(), sizeof(DataType));
160}
161
162/*---------------------------------------------------------------------------*/
163/*---------------------------------------------------------------------------*/
164
165/*---------------------------------------------------------------------------*/
166/*---------------------------------------------------------------------------*/
167
168template <class DataType>
169MachineShMemWinVariableArray2T<DataType>::
170MachineShMemWinVariableArray2T(VariableRefArray2T<DataType> var)
171: m_base(makeRef(new MachineShMemWinVariable2DBase(var.variable())))
172, m_vart(var)
173{
174 updateVariable();
175}
176
177/*---------------------------------------------------------------------------*/
178/*---------------------------------------------------------------------------*/
179
180template <class DataType>
181MachineShMemWinVariableArray2T<DataType>::
182~MachineShMemWinVariableArray2T() = default;
183
184/*---------------------------------------------------------------------------*/
185/*---------------------------------------------------------------------------*/
186
187template <class DataType>
188ConstArrayView<Int32> MachineShMemWinVariableArray2T<DataType>::
189machineRanks() const
190{
191 return m_base->machineRanks();
192}
193
194/*---------------------------------------------------------------------------*/
195/*---------------------------------------------------------------------------*/
196
197template <class DataType>
198void MachineShMemWinVariableArray2T<DataType>::
199barrier() const
200{
201 m_base->barrier();
202}
203
204/*---------------------------------------------------------------------------*/
205/*---------------------------------------------------------------------------*/
206
207template <class DataType>
208Span2<DataType> MachineShMemWinVariableArray2T<DataType>::
209view(Int32 rank) const
210{
211 Span<DataType> span1 = asSpan<DataType>(m_base->segmentView(rank));
212 return { span1.data(), m_base->nbElemDim1(rank), m_base->nbElemDim2(rank) };
213}
214
215/*---------------------------------------------------------------------------*/
216/*---------------------------------------------------------------------------*/
217
218template <class DataType>
219void MachineShMemWinVariableArray2T<DataType>::
220updateVariable()
221{
222 Int64 size_dim1 = m_vart.dim1Size();
223 Int64 size_dim2 = m_vart.dim2Size();
224
225 m_base->updateVariable(size_dim1, size_dim2, sizeof(DataType));
226}
227
228/*---------------------------------------------------------------------------*/
229/*---------------------------------------------------------------------------*/
230
231/*---------------------------------------------------------------------------*/
232/*---------------------------------------------------------------------------*/
233
234template <class ItemType, class DataType>
235MachineShMemWinMeshVariableArrayT<ItemType, DataType>::
236MachineShMemWinMeshVariableArrayT(MeshVariableArrayRefT<ItemType, DataType> var)
237: m_base(makeRef(new MachineShMemWinVariableMDBase(var.variable())))
238, m_vart(var)
239{
240 updateVariable();
241}
242
243/*---------------------------------------------------------------------------*/
244/*---------------------------------------------------------------------------*/
245
246template <class ItemType, class DataType>
247MachineShMemWinMeshVariableArrayT<ItemType, DataType>::
248~MachineShMemWinMeshVariableArrayT() = default;
249
250/*---------------------------------------------------------------------------*/
251/*---------------------------------------------------------------------------*/
252
253template <class ItemType, class DataType>
259
260/*---------------------------------------------------------------------------*/
261/*---------------------------------------------------------------------------*/
262
263template <class ItemType, class DataType>
264void MachineShMemWinMeshVariableArrayT<ItemType, DataType>::
265barrier() const
266{
267 m_base->barrier();
268}
269
270/*---------------------------------------------------------------------------*/
271/*---------------------------------------------------------------------------*/
272
273template <class ItemType, class DataType>
274Span2<DataType> MachineShMemWinMeshVariableArrayT<ItemType, DataType>::
275view(Int32 rank) const
276{
277 Span<DataType> span1 = asSpan<DataType>(m_base->segmentView(rank));
278 return { span1.data(), m_base->nbElemDim1(rank), m_nb_elem_dim2 };
279}
280
281/*---------------------------------------------------------------------------*/
282/*---------------------------------------------------------------------------*/
283
284template <class ItemType, class DataType>
285Span<DataType> MachineShMemWinMeshVariableArrayT<ItemType, DataType>::
286operator()(Int32 rank, Int32 notlocal_id)
287{
288 Span<DataType> span1 = asSpan<DataType>(m_base->segmentView(rank));
289 Span2<DataType> span2(span1.data(), m_base->nbElemDim1(rank), m_nb_elem_dim2);
290
291 return span2[notlocal_id];
292}
293
294/*---------------------------------------------------------------------------*/
295/*---------------------------------------------------------------------------*/
296
297template <class ItemType, class DataType>
298void MachineShMemWinMeshVariableArrayT<ItemType, DataType>::
299updateVariable()
300{
301 Int64 size_dim1 = m_vart.asArray().dim1Size();
302 m_nb_elem_dim2 = m_vart.asArray().dim2Size();
303
304 m_base->updateVariable(size_dim1, m_nb_elem_dim2, sizeof(DataType));
305}
306
307/*---------------------------------------------------------------------------*/
308/*---------------------------------------------------------------------------*/
309
310/*---------------------------------------------------------------------------*/
311/*---------------------------------------------------------------------------*/
312
313template <class ItemType, class DataType, class Extents>
314MachineShMemWinMDVariableT<ItemType, DataType, Extents>::
315MachineShMemWinMDVariableT(MeshVariableArrayRefT<ItemType, DataType> var)
316: m_base(makeRef(new MachineShMemWinVariableMDBase(var.variable())))
317, m_vart(var)
318{
319 updateVariable();
320}
321
322/*---------------------------------------------------------------------------*/
323/*---------------------------------------------------------------------------*/
324
325template <class ItemType, class DataType, class Extents>
326MachineShMemWinMDVariableT<ItemType, DataType, Extents>::
327~MachineShMemWinMDVariableT() = default;
328
329/*---------------------------------------------------------------------------*/
330/*---------------------------------------------------------------------------*/
331
332template <class ItemType, class DataType, class Extents>
338
339/*---------------------------------------------------------------------------*/
340/*---------------------------------------------------------------------------*/
341
342template <class ItemType, class DataType, class Extents>
343void MachineShMemWinMDVariableT<ItemType, DataType, Extents>::
344barrier() const
345{
346 m_base->barrier();
347}
348
349/*---------------------------------------------------------------------------*/
350/*---------------------------------------------------------------------------*/
351
352template <class ItemType, class DataType, class Extents>
353MDSpan<DataType, typename MDDimType<Extents::rank() + 1>::DimType> MachineShMemWinMDVariableT<ItemType, DataType, Extents>::
354view(Int32 rank) const
355{
356 Span<DataType> span1 = asSpan<DataType>(m_base->segmentView(rank));
357
358 if constexpr (Extents::rank() == 1) {
359 std::array<Int32, 2> nb_elem_mdim{ static_cast<Int32>(m_base->nbElemDim1(rank)), m_shape_dim2[0] };
360 MDSpan<DataType, MDDim2> mdspan(span1.data(), MDIndex<2>(nb_elem_mdim));
361 return mdspan;
362 }
363 else if constexpr (Extents::rank() == 2) {
364 std::array<Int32, 3> nb_elem_mdim{ static_cast<Int32>(m_base->nbElemDim1(rank)), m_shape_dim2[0], m_shape_dim2[1] };
365 MDSpan<DataType, MDDim3> mdspan(span1.data(), MDIndex<3>(nb_elem_mdim));
366 return mdspan;
367 }
368 else if constexpr (Extents::rank() == 3) {
369 std::array<Int32, 4> nb_elem_mdim{ static_cast<Int32>(m_base->nbElemDim1(rank)), m_shape_dim2[0], m_shape_dim2[1], m_shape_dim2[2] };
370 MDSpan<DataType, MDDim4> mdspan(span1.data(), MDIndex<4>(nb_elem_mdim));
371 return mdspan;
372 }
373 ARCANE_FATAL("Unexpected dimension");
374}
375
376/*---------------------------------------------------------------------------*/
377/*---------------------------------------------------------------------------*/
378
379template <class ItemType, class DataType, class Extents>
380MDSpan<DataType, Extents> MachineShMemWinMDVariableT<ItemType, DataType, Extents>::
381operator()(Int32 rank, Int32 notlocal_id)
382{
383 Span<DataType> span1 = asSpan<DataType>(m_base->segmentView(rank));
384 Span2<DataType> span2(span1.data(), m_base->nbElemDim1(rank), m_nb_elem_dim2);
385 MDSpan<DataType, Extents> mdspan(span2[notlocal_id].data(), MDIndex<Extents::rank()>(m_shape_dim2));
386
387 return mdspan;
388}
389
390/*---------------------------------------------------------------------------*/
391/*---------------------------------------------------------------------------*/
392
393template <class ItemType, class DataType, class Extents>
394void MachineShMemWinMDVariableT<ItemType, DataType, Extents>::
395updateVariable()
396{
397 Int64 nb_elem_dim1 = m_vart.asArray().dim1Size();
398 Int32 nb_elem_dim2 = m_vart.asArray().dim2Size();
399
400 m_base->updateVariable(nb_elem_dim1, nb_elem_dim2, sizeof(DataType));
401
402 SmallSpan<Int32> shape_dim2_view(m_shape_dim2.data(), Extents::rank());
403 shape_dim2_view.copy(m_base->arrayShape().dimensions());
404
405 m_nb_elem_dim2 = nb_elem_dim2;
406}
407
408/*---------------------------------------------------------------------------*/
409/*---------------------------------------------------------------------------*/
410
411/*---------------------------------------------------------------------------*/
412/*---------------------------------------------------------------------------*/
413
414// Macro pour instantier une classe template pour tous les types numériques, tous les items.
415#define ARCANE_INTERNAL_INSTANTIATE_TEMPLATE_FOR_NUMERIC_DATATYPE_WITH_ITEM1(class_name, item) \
416 template class ARCANE_TEMPLATE_EXPORT class_name<item, Real>; \
417 template class ARCANE_TEMPLATE_EXPORT class_name<item, Real3>; \
418 template class ARCANE_TEMPLATE_EXPORT class_name<item, Real3x3>; \
419 template class ARCANE_TEMPLATE_EXPORT class_name<item, Real2>; \
420 template class ARCANE_TEMPLATE_EXPORT class_name<item, Real2x2>; \
421 template class ARCANE_TEMPLATE_EXPORT class_name<item, Int8>; \
422 template class ARCANE_TEMPLATE_EXPORT class_name<item, Int16>; \
423 template class ARCANE_TEMPLATE_EXPORT class_name<item, Int32>; \
424 template class ARCANE_TEMPLATE_EXPORT class_name<item, Int64>;
425
426#define ARCANE_INTERNAL_INSTANTIATE_TEMPLATE_FOR_NUMERIC_DATATYPE_WITH_ITEM(class_name) \
427 ARCANE_INTERNAL_INSTANTIATE_TEMPLATE_FOR_NUMERIC_DATATYPE_WITH_ITEM1(class_name, Node) \
428 ARCANE_INTERNAL_INSTANTIATE_TEMPLATE_FOR_NUMERIC_DATATYPE_WITH_ITEM1(class_name, Face) \
429 ARCANE_INTERNAL_INSTANTIATE_TEMPLATE_FOR_NUMERIC_DATATYPE_WITH_ITEM1(class_name, Cell) \
430 ARCANE_INTERNAL_INSTANTIATE_TEMPLATE_FOR_NUMERIC_DATATYPE_WITH_ITEM1(class_name, Particle) \
431 ARCANE_INTERNAL_INSTANTIATE_TEMPLATE_FOR_NUMERIC_DATATYPE_WITH_ITEM1(class_name, DoF)
432
433/*---------------------------------------------------------------------------*/
434/*---------------------------------------------------------------------------*/
435
436ARCANE_INTERNAL_INSTANTIATE_TEMPLATE_FOR_NUMERIC_DATATYPE(MachineShMemWinVariableArrayT);
437
438template class ARCANE_TEMPLATE_EXPORT MachineShMemWinVariableArray2T<Real>;
439template class ARCANE_TEMPLATE_EXPORT MachineShMemWinVariableArray2T<Real3>;
440template class ARCANE_TEMPLATE_EXPORT MachineShMemWinVariableArray2T<Real3x3>;
441template class ARCANE_TEMPLATE_EXPORT MachineShMemWinVariableArray2T<Real2>;
442template class ARCANE_TEMPLATE_EXPORT MachineShMemWinVariableArray2T<Real2x2>;
443template class ARCANE_TEMPLATE_EXPORT MachineShMemWinVariableArray2T<Int16>;
444template class ARCANE_TEMPLATE_EXPORT MachineShMemWinVariableArray2T<Int32>;
445template class ARCANE_TEMPLATE_EXPORT MachineShMemWinVariableArray2T<Int64>;
446template class ARCANE_TEMPLATE_EXPORT MachineShMemWinVariableArray2T<Byte>;
447
448ARCANE_INTERNAL_INSTANTIATE_TEMPLATE_FOR_NUMERIC_DATATYPE_WITH_ITEM(MachineShMemWinMeshVariableScalarT);
449ARCANE_INTERNAL_INSTANTIATE_TEMPLATE_FOR_NUMERIC_DATATYPE_WITH_ITEM(MachineShMemWinMeshVariableArrayT);
450
451template class ARCANE_TEMPLATE_EXPORT MachineShMemWinMDVariableT<Cell, Real, MDDim1>;
452template class ARCANE_TEMPLATE_EXPORT MachineShMemWinMDVariableT<Cell, Real, MDDim2>;
453template class ARCANE_TEMPLATE_EXPORT MachineShMemWinMDVariableT<Cell, Real, MDDim3>;
454
455// Instantie explicitement pour vérifier la compilation
456template class MachineShMemWinMeshMDVariableT<Cell, Real, MDDim1>;
457template class MachineShMemWinMeshMDVariableT<Cell, Real, MDDim2>;
458template class MachineShMemWinMeshMDVariableT<Cell, Real, MDDim3>;
459
460template class MachineShMemWinMeshVectorMDVariableT<Cell, Real, MDDim1>;
461template class MachineShMemWinMeshVectorMDVariableT<Cell, Real, MDDim2>;
462
463template class MachineShMemWinMeshMatrixMDVariableT<Cell, Real, MDDim1>;
464
465/*---------------------------------------------------------------------------*/
466/*---------------------------------------------------------------------------*/
467
468} // End namespace Arcane
469
470/*---------------------------------------------------------------------------*/
471/*---------------------------------------------------------------------------*/
ARCANE_FATAL
#define ARCANE_FATAL(...)
Macro envoyant une exception FatalErrorException.
Definition ArcaneGlobal.h:740
Span2.h
Types et fonctions associés aux classes Span2Impl, Small2Span and Span2.
Arcane::ConstArrayView
Vue constante d'un tableau de type T.
Definition arccore/src/base/arccore/base/ArrayView.h:533
Arcane::IVariable
Interface d'une variable.
Definition IVariable.h:39
Arcane::MDSpan
Classe de base des vues multi-dimensionnelles.
Definition arccore/src/base/arccore/base/MDSpan.h:43
Arcane::MachineShMemWinMDVariableT
Classe permettant d'accéder aux éléments partagés de la variable en mémoire partagée.
Definition MachineShMemWinVariable.h:439
Arcane::MachineShMemWinMDVariableT::MachineShMemWinMDVariableT
MachineShMemWinMDVariableT(MeshVariableArrayRefT< ItemType, DataType > var)
Constructeur.
Definition MachineShMemWinVariable.cc:315
Arcane::MachineShMemWinMDVariableT::operator()
MDSpan< DataType, Extents > operator()(Int32 rank, Int32 notlocal_id)
Méthode permettant d'obtenir le tableau multi-dimensionnel d'un item d'un autre sous-domaine.
Definition MachineShMemWinVariable.cc:381
Arcane::MachineShMemWinMDVariableT::machineRanks
ConstArrayView< Int32 > machineRanks() const
Méthode permettant d'obtenir les rangs qui possèdent un segment dans la fenêtre.
Definition MachineShMemWinVariable.cc:334
Arcane::MachineShMemWinMDVariableT::view
MDSpan< DataType, typename MDDimType< Extents::rank()+1 >::DimType > view(Int32 rank) const
Méthode permettant d'obtenir une vue sur la variable d'un autre sous-domaine du noeud.
Definition MachineShMemWinVariable.cc:354
Arcane::MachineShMemWinMDVariableT::updateVariable
void updateVariable()
Méthode permettant de mettre à jour cet objet après un changement dans le maillage et/ou après un red...
Definition MachineShMemWinVariable.cc:395
Arcane::MachineShMemWinMDVariableT::barrier
void barrier() const
Méthode permettant d'attendre que tous les processus/threads du noeud appellent cette méthode pour co...
Definition MachineShMemWinVariable.cc:344
Arcane::MachineShMemWinMeshMDVariableT
Classe permettant d'accéder aux éléments partagés de la variable en mémoire partagée.
Definition MachineShMemWinVariable.h:548
Arcane::MachineShMemWinMeshMatrixMDVariableT
Classe permettant d'accéder aux éléments partagés de la variable en mémoire partagée.
Definition MachineShMemWinVariable.h:624
Arcane::MachineShMemWinMeshVariableArrayT
Classe permettant d'accéder aux éléments partagés de la variable en mémoire partagée.
Definition MachineShMemWinVariable.h:333
Arcane::MachineShMemWinMeshVariableArrayT::updateVariable
void updateVariable()
Méthode permettant de mettre à jour cet objet après un changement dans le maillage et/ou après un red...
Definition MachineShMemWinVariable.cc:299
Arcane::MachineShMemWinMeshVariableArrayT::view
Span2< DataType > view(Int32 rank) const
Méthode permettant d'obtenir une vue sur la variable d'un autre sous-domaine du noeud.
Definition MachineShMemWinVariable.cc:275
Arcane::MachineShMemWinMeshVariableArrayT::barrier
void barrier() const
Méthode permettant d'attendre que tous les processus/threads du noeud appellent cette méthode pour co...
Definition MachineShMemWinVariable.cc:265
Arcane::MachineShMemWinMeshVariableArrayT::operator()
Span< DataType > operator()(Int32 rank, Int32 notlocal_id)
Méthode permettant d'obtenir le tableau d'un item d'un autre sous-domaine.
Definition MachineShMemWinVariable.cc:286
Arcane::MachineShMemWinMeshVariableArrayT::MachineShMemWinMeshVariableArrayT
MachineShMemWinMeshVariableArrayT(MeshVariableArrayRefT< ItemType, DataType > var)
Constructeur.
Definition MachineShMemWinVariable.cc:236
Arcane::MachineShMemWinMeshVariableArrayT::machineRanks
ConstArrayView< Int32 > machineRanks() const
Méthode permettant d'obtenir les rangs qui possèdent un segment dans la fenêtre.
Definition MachineShMemWinVariable.cc:255
Arcane::MachineShMemWinMeshVariableScalarT
Classe permettant d'accéder aux éléments partagés de la variable en mémoire partagée.
Definition MachineShMemWinVariable.h:174
Arcane::MachineShMemWinMeshVariableScalarT::updateVariable
void updateVariable()
Méthode permettant de mettre à jour cet objet après un changement dans le maillage.
Definition MachineShMemWinVariable.cc:157
Arcane::MachineShMemWinMeshVariableScalarT::operator()
DataType operator()(Int32 rank, Int32 notlocal_id)
Méthode permettant d'obtenir un élément de la variable d'un autre sous-domaine.
Definition MachineShMemWinVariable.cc:147
Arcane::MachineShMemWinMeshVariableScalarT::view
Span< DataType > view(Int32 rank) const
Méthode permettant d'obtenir une vue sur la variable d'un autre sous-domaine du noeud.
Definition MachineShMemWinVariable.cc:137
Arcane::MachineShMemWinMeshVariableScalarT::MachineShMemWinMeshVariableScalarT
MachineShMemWinMeshVariableScalarT(MeshVariableScalarRefT< ItemType, DataType > var)
Constructeur.
Definition MachineShMemWinVariable.cc:118
Arcane::MachineShMemWinMeshVectorMDVariableT
Classe permettant d'accéder aux éléments partagés de la variable en mémoire partagée.
Definition MachineShMemWinVariable.h:585
Arcane::MachineShMemWinVariableArray2T
Classe permettant d'accéder aux éléments partagés de la variable en mémoire partagée.
Definition MachineShMemWinVariable.h:257
Arcane::MachineShMemWinVariableArray2T::machineRanks
ConstArrayView< Int32 > machineRanks() const
Méthode permettant d'obtenir les rangs qui possèdent un segment dans la fenêtre.
Definition MachineShMemWinVariable.cc:189
Arcane::MachineShMemWinVariableArray2T::view
Span2< DataType > view(Int32 rank) const
Méthode permettant d'obtenir une vue sur le tableau d'un autre sous-domaine du noeud.
Definition MachineShMemWinVariable.cc:209
Arcane::MachineShMemWinVariableArray2T::MachineShMemWinVariableArray2T
MachineShMemWinVariableArray2T(VariableRefArray2T< DataType > var)
Constructeur.
Definition MachineShMemWinVariable.cc:170
Arcane::MachineShMemWinVariableArray2T::barrier
void barrier() const
Méthode permettant d'attendre que tous les processus/threads du noeud appellent cette méthode pour co...
Definition MachineShMemWinVariable.cc:199
Arcane::MachineShMemWinVariableArray2T::updateVariable
void updateVariable()
Méthode permettant de mettre à jour cet objet après un redimensionnement de la variable.
Definition MachineShMemWinVariable.cc:220
Arcane::MachineShMemWinVariableArrayT
Classe permettant d'accéder aux éléments partagés de la variable en mémoire partagée.
Definition MachineShMemWinVariable.h:114
Arcane::MachineShMemWinVariableArrayT::MachineShMemWinVariableArrayT
MachineShMemWinVariableArrayT(VariableRefArrayT< DataType > var)
Constructeur.
Definition MachineShMemWinVariable.cc:76
Arcane::MachineShMemWinVariableArrayT::view
Span< DataType > view(Int32 rank) const
Méthode permettant d'obtenir une vue sur le tableau d'un autre sous-domaine du noeud.
Definition MachineShMemWinVariable.cc:95
Arcane::MachineShMemWinVariableArrayT::updateVariable
void updateVariable()
Méthode permettant de mettre à jour cet objet après un redimensionnement de la variable.
Definition MachineShMemWinVariable.cc:105
Arcane::MachineShMemWinVariableCommon::barrier
void barrier() const
Méthode permettant d'attendre que tous les processus/threads du noeud appellent cette méthode pour co...
Definition MachineShMemWinVariable.cc:63
Arcane::MachineShMemWinVariableCommon::machineRanks
ConstArrayView< Int32 > machineRanks() const
Méthode permettant d'obtenir les rangs qui possèdent un segment dans la fenêtre.
Definition MachineShMemWinVariable.cc:54
Arcane::MachineShMemWinVariableCommon::MachineShMemWinVariableCommon
MachineShMemWinVariableCommon(IVariable *var)
Constructeur.
Definition MachineShMemWinVariable.cc:39
Arcane::MeshVariableArrayRefT
Variable tableau sur un type d'entité du maillage.
Definition MeshVariableArrayRef.h:116
Arcane::MeshVariableScalarRefT
Variable scalaire sur un type d'entité du maillage.
Definition MeshVariableScalarRef.h:207
Arcane::SmallSpan
Vue d'un tableau d'éléments de type T.
Definition Span.h:801
Arcane::Span2
Vue pour un tableau 2D dont la taille est un 'Int64'.
Definition Span2.h:301
Arcane::SpanImpl::copy
__host__ __device__ void copy(const U &copy_array)
Recopie le tableau copy_array dans l'instance.
Definition Span.h:475
Arcane::SpanImpl::data
constexpr __host__ __device__ pointer data() const noexcept
Pointeur sur le début de la vue.
Definition Span.h:537
Arcane::Span
Vue d'un tableau d'éléments de type T.
Definition Span.h:633
Arcane::VariableRefArray2T
Variable tableau bi dimensionnel.
Definition VariableRefArray2.h:37
Arcane
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
Definition AbstractCaseDocumentVisitor.cc:20
Arcane::Int64
std::int64_t Int64
Type entier signé sur 64 bits.
Definition ArccoreGlobal.h:227
Arcane::asSpan
Span< DataType > asSpan(Span< std::byte, Extent > bytes)
Converti un Span<std::byte> en un Span<DataType>.
Definition Span.h:1114
Arcane::makeRef
auto makeRef(InstanceType *t) -> Ref< InstanceType >
Créé une référence sur un pointeur.
Definition arccore/src/base/arccore/base/Ref.h:418
Arcane::Int32
std::int32_t Int32
Type entier signé sur 32 bits.
Definition ArccoreGlobal.h:225