Arcane  v4.1.7.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/core/VariableRefArray.h"
17#include "arcane/core/VariableRefArray2.h"
18#include "arcane/core/MeshVariable.h"
19#include "arcane/core/IVariable.h"
20#include "arcane/core/MeshVariableScalarRef.h"
21#include "internal/MachineShMemWinVariableBase.h"
22
23#include "arcane/utils/NumericTypes.h"
24#include "arcane/utils/MDSpan.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_nb_elem_dim1[rank], m_nb_elem_dim2[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 m_nb_elem_dim1 = m_base->nbElemDim1();
228 m_nb_elem_dim2 = m_base->nbElemDim2();
229}
230
231/*---------------------------------------------------------------------------*/
232/*---------------------------------------------------------------------------*/
233
234/*---------------------------------------------------------------------------*/
235/*---------------------------------------------------------------------------*/
236
237template <class ItemType, class DataType>
238MachineShMemWinMeshVariableArrayT<ItemType, DataType>::
239MachineShMemWinMeshVariableArrayT(MeshVariableArrayRefT<ItemType, DataType> var)
240: m_base(makeRef(new MachineShMemWinVariableMDBase(var.variable())))
241, m_vart(var)
242{
243 updateVariable();
244}
245
246/*---------------------------------------------------------------------------*/
247/*---------------------------------------------------------------------------*/
248
249template <class ItemType, class DataType>
250MachineShMemWinMeshVariableArrayT<ItemType, DataType>::
251~MachineShMemWinMeshVariableArrayT() = default;
252
253/*---------------------------------------------------------------------------*/
254/*---------------------------------------------------------------------------*/
255
256template <class ItemType, class DataType>
262
263/*---------------------------------------------------------------------------*/
264/*---------------------------------------------------------------------------*/
265
266template <class ItemType, class DataType>
267void MachineShMemWinMeshVariableArrayT<ItemType, DataType>::
268barrier() const
269{
270 m_base->barrier();
271}
272
273/*---------------------------------------------------------------------------*/
274/*---------------------------------------------------------------------------*/
275
276template <class ItemType, class DataType>
277Span2<DataType> MachineShMemWinMeshVariableArrayT<ItemType, DataType>::
278view(Int32 rank) const
279{
280 Span<DataType> span1 = asSpan<DataType>(m_base->segmentView(rank));
281 return { span1.data(), m_nb_elem_dim1[rank], m_nb_elem_dim2 };
282}
283
284/*---------------------------------------------------------------------------*/
285/*---------------------------------------------------------------------------*/
286
287template <class ItemType, class DataType>
288Span<DataType> MachineShMemWinMeshVariableArrayT<ItemType, DataType>::
289operator()(Int32 rank, Int32 notlocal_id)
290{
291 Span<DataType> span1 = asSpan<DataType>(m_base->segmentView(rank));
292 Span2<DataType> span2(span1.data(), m_nb_elem_dim1[rank], m_nb_elem_dim2);
293
294 return span2[notlocal_id];
295}
296
297/*---------------------------------------------------------------------------*/
298/*---------------------------------------------------------------------------*/
299
300template <class ItemType, class DataType>
301void MachineShMemWinMeshVariableArrayT<ItemType, DataType>::
302updateVariable()
303{
304 Int64 size_dim1 = m_vart.asArray().dim1Size();
305 m_nb_elem_dim2 = m_vart.asArray().dim2Size();
306
307 m_base->updateVariable(size_dim1, m_nb_elem_dim2, sizeof(DataType));
308
309 m_nb_elem_dim1 = m_base->nbElemDim1();
310}
311
312/*---------------------------------------------------------------------------*/
313/*---------------------------------------------------------------------------*/
314
315/*---------------------------------------------------------------------------*/
316/*---------------------------------------------------------------------------*/
317
318template <class ItemType, class DataType, class Extents>
319MachineShMemWinMDVariableT<ItemType, DataType, Extents>::
320MachineShMemWinMDVariableT(MeshVariableArrayRefT<ItemType, DataType> var)
321: m_base(makeRef(new MachineShMemWinVariableMDBase(var.variable())))
322, m_vart(var)
323{
324 updateVariable();
325}
326
327/*---------------------------------------------------------------------------*/
328/*---------------------------------------------------------------------------*/
329
330template <class ItemType, class DataType, class Extents>
331MachineShMemWinMDVariableT<ItemType, DataType, Extents>::
332~MachineShMemWinMDVariableT() = default;
333
334/*---------------------------------------------------------------------------*/
335/*---------------------------------------------------------------------------*/
336
337template <class ItemType, class DataType, class Extents>
343
344/*---------------------------------------------------------------------------*/
345/*---------------------------------------------------------------------------*/
346
347template <class ItemType, class DataType, class Extents>
348void MachineShMemWinMDVariableT<ItemType, DataType, Extents>::
349barrier() const
350{
351 m_base->barrier();
352}
353
354/*---------------------------------------------------------------------------*/
355/*---------------------------------------------------------------------------*/
356
357template <class ItemType, class DataType, class Extents>
358MDSpan<DataType, typename MDDimType<Extents::rank() + 1>::DimType> MachineShMemWinMDVariableT<ItemType, DataType, Extents>::
359view(Int32 rank) const
360{
361 Span<DataType> span1 = asSpan<DataType>(m_base->segmentView(rank));
362
363 if constexpr (Extents::rank() == 1) {
364 std::array<Int32, 2> nb_elem_mdim{ static_cast<Int32>(m_nb_elem_dim1[rank]), m_shape_dim2[0] };
365 MDSpan<DataType, MDDim2> mdspan(span1.data(), MDIndex<2>(nb_elem_mdim));
366 return mdspan;
367 }
368 else if constexpr (Extents::rank() == 2) {
369 std::array<Int32, 3> nb_elem_mdim{ static_cast<Int32>(m_nb_elem_dim1[rank]), m_shape_dim2[0], m_shape_dim2[1] };
370 MDSpan<DataType, MDDim3> mdspan(span1.data(), MDIndex<3>(nb_elem_mdim));
371 return mdspan;
372 }
373 else if constexpr (Extents::rank() == 3) {
374 std::array<Int32, 4> nb_elem_mdim{ static_cast<Int32>(m_nb_elem_dim1[rank]), m_shape_dim2[0], m_shape_dim2[1], m_shape_dim2[2] };
375 MDSpan<DataType, MDDim4> mdspan(span1.data(), MDIndex<4>(nb_elem_mdim));
376 return mdspan;
377 }
378 ARCANE_FATAL("Unexpected dimension");
379}
380
381/*---------------------------------------------------------------------------*/
382/*---------------------------------------------------------------------------*/
383
384template <class ItemType, class DataType, class Extents>
385MDSpan<DataType, Extents> MachineShMemWinMDVariableT<ItemType, DataType, Extents>::
386operator()(Int32 rank, Int32 notlocal_id)
387{
388 Span<DataType> span1 = asSpan<DataType>(m_base->segmentView(rank));
389 Span2<DataType> span2(span1.data(), m_nb_elem_dim1[rank], m_nb_elem_dim2);
390 MDSpan<DataType, Extents> mdspan(span2[notlocal_id].data(), MDIndex<Extents::rank()>(m_shape_dim2));
391
392 return mdspan;
393}
394
395/*---------------------------------------------------------------------------*/
396/*---------------------------------------------------------------------------*/
397
398template <class ItemType, class DataType, class Extents>
399void MachineShMemWinMDVariableT<ItemType, DataType, Extents>::
400updateVariable()
401{
402 Int64 nb_elem_dim1 = m_vart.asArray().dim1Size();
403 Int32 nb_elem_dim2 = m_vart.asArray().dim2Size();
404
405 m_base->updateVariable(nb_elem_dim1, nb_elem_dim2, sizeof(DataType));
406
407 SmallSpan<Int32> shape_dim2_view(m_shape_dim2.data(), Extents::rank());
408 shape_dim2_view.copy(m_base->arrayShape().dimensions());
409
410 m_nb_elem_dim1 = m_base->nbElemDim1();
411 m_nb_elem_dim2 = nb_elem_dim2;
412}
413
414/*---------------------------------------------------------------------------*/
415/*---------------------------------------------------------------------------*/
416
417/*---------------------------------------------------------------------------*/
418/*---------------------------------------------------------------------------*/
419
420// Macro pour instantier une classe template pour tous les types numériques, tous les items.
421#define ARCANE_INTERNAL_INSTANTIATE_TEMPLATE_FOR_NUMERIC_DATATYPE_WITH_ITEM1(class_name, item) \
422 template class ARCANE_TEMPLATE_EXPORT class_name<item, Real>; \
423 template class ARCANE_TEMPLATE_EXPORT class_name<item, Real3>; \
424 template class ARCANE_TEMPLATE_EXPORT class_name<item, Real3x3>; \
425 template class ARCANE_TEMPLATE_EXPORT class_name<item, Real2>; \
426 template class ARCANE_TEMPLATE_EXPORT class_name<item, Real2x2>; \
427 template class ARCANE_TEMPLATE_EXPORT class_name<item, Int8>; \
428 template class ARCANE_TEMPLATE_EXPORT class_name<item, Int16>; \
429 template class ARCANE_TEMPLATE_EXPORT class_name<item, Int32>; \
430 template class ARCANE_TEMPLATE_EXPORT class_name<item, Int64>;
431
432#define ARCANE_INTERNAL_INSTANTIATE_TEMPLATE_FOR_NUMERIC_DATATYPE_WITH_ITEM(class_name) \
433 ARCANE_INTERNAL_INSTANTIATE_TEMPLATE_FOR_NUMERIC_DATATYPE_WITH_ITEM1(class_name, Node) \
434 ARCANE_INTERNAL_INSTANTIATE_TEMPLATE_FOR_NUMERIC_DATATYPE_WITH_ITEM1(class_name, Face) \
435 ARCANE_INTERNAL_INSTANTIATE_TEMPLATE_FOR_NUMERIC_DATATYPE_WITH_ITEM1(class_name, Cell) \
436 ARCANE_INTERNAL_INSTANTIATE_TEMPLATE_FOR_NUMERIC_DATATYPE_WITH_ITEM1(class_name, Particle) \
437 ARCANE_INTERNAL_INSTANTIATE_TEMPLATE_FOR_NUMERIC_DATATYPE_WITH_ITEM1(class_name, DoF)
438
439/*---------------------------------------------------------------------------*/
440/*---------------------------------------------------------------------------*/
441
442ARCANE_INTERNAL_INSTANTIATE_TEMPLATE_FOR_NUMERIC_DATATYPE(MachineShMemWinVariableArrayT);
443
444template class ARCANE_TEMPLATE_EXPORT MachineShMemWinVariableArray2T<Real>;
445template class ARCANE_TEMPLATE_EXPORT MachineShMemWinVariableArray2T<Real3>;
446template class ARCANE_TEMPLATE_EXPORT MachineShMemWinVariableArray2T<Real3x3>;
447template class ARCANE_TEMPLATE_EXPORT MachineShMemWinVariableArray2T<Real2>;
448template class ARCANE_TEMPLATE_EXPORT MachineShMemWinVariableArray2T<Real2x2>;
449template class ARCANE_TEMPLATE_EXPORT MachineShMemWinVariableArray2T<Int16>;
450template class ARCANE_TEMPLATE_EXPORT MachineShMemWinVariableArray2T<Int32>;
451template class ARCANE_TEMPLATE_EXPORT MachineShMemWinVariableArray2T<Int64>;
452template class ARCANE_TEMPLATE_EXPORT MachineShMemWinVariableArray2T<Byte>;
453
454ARCANE_INTERNAL_INSTANTIATE_TEMPLATE_FOR_NUMERIC_DATATYPE_WITH_ITEM(MachineShMemWinMeshVariableScalarT);
455ARCANE_INTERNAL_INSTANTIATE_TEMPLATE_FOR_NUMERIC_DATATYPE_WITH_ITEM(MachineShMemWinMeshVariableArrayT);
456
457template class ARCANE_TEMPLATE_EXPORT MachineShMemWinMDVariableT<Cell, Real, MDDim1>;
458template class ARCANE_TEMPLATE_EXPORT MachineShMemWinMDVariableT<Cell, Real, MDDim2>;
459template class ARCANE_TEMPLATE_EXPORT MachineShMemWinMDVariableT<Cell, Real, MDDim3>;
460
461// Instantie explicitement pour vérifier la compilation
462template class MachineShMemWinMeshMDVariableT<Cell, Real, MDDim1>;
463template class MachineShMemWinMeshMDVariableT<Cell, Real, MDDim2>;
464template class MachineShMemWinMeshMDVariableT<Cell, Real, MDDim3>;
465
466template class MachineShMemWinMeshVectorMDVariableT<Cell, Real, MDDim1>;
467template class MachineShMemWinMeshVectorMDVariableT<Cell, Real, MDDim2>;
468
469template class MachineShMemWinMeshMatrixMDVariableT<Cell, Real, MDDim1>;
470
471/*---------------------------------------------------------------------------*/
472/*---------------------------------------------------------------------------*/
473
474} // End namespace Arcane
475
476/*---------------------------------------------------------------------------*/
477/*---------------------------------------------------------------------------*/
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:442
Arcane::MachineShMemWinMDVariableT::MachineShMemWinMDVariableT
MachineShMemWinMDVariableT(MeshVariableArrayRefT< ItemType, DataType > var)
Constructeur.
Definition MachineShMemWinVariable.cc:320
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:386
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:339
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:359
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:400
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:349
Arcane::MachineShMemWinMeshMDVariableT
Classe permettant d'accéder aux éléments partagés de la variable en mémoire partagée.
Definition MachineShMemWinVariable.h:555
Arcane::MachineShMemWinMeshMatrixMDVariableT
Classe permettant d'accéder aux éléments partagés de la variable en mémoire partagée.
Definition MachineShMemWinVariable.h:631
Arcane::MachineShMemWinMeshVariableArrayT
Classe permettant d'accéder aux éléments partagés de la variable en mémoire partagée.
Definition MachineShMemWinVariable.h:335
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:302
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:278
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:268
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:289
Arcane::MachineShMemWinMeshVariableArrayT::MachineShMemWinMeshVariableArrayT
MachineShMemWinMeshVariableArrayT(MeshVariableArrayRefT< ItemType, DataType > var)
Constructeur.
Definition MachineShMemWinVariable.cc:239
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:258
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:592
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:356
Arcane::Int32
std::int32_t Int32
Type entier signé sur 32 bits.
Definition ArccoreGlobal.h:225