d5/dd2/MachineShMemWinVariable_8cc_source.html

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-

//-----------------------------------------------------------------------------

// Copyright 2000-2026 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)

// See the top-level COPYRIGHT file for details.

// SPDX-License-Identifier: Apache-2.0

//-----------------------------------------------------------------------------

/*---------------------------------------------------------------------------*/

/* MachineShMemWinVariable.cc                                  (C) 2000-2026 */

/*                                                                           */

/* Classes enabling the use of the MachineShMemWinVariable object pointed    */

/* to by the shared memory variable area.                                    */

/*---------------------------------------------------------------------------*/


#include "arcane/core/MachineShMemWinVariable.h"


#include "arcane/utils/NumericTypes.h"

#include "arcane/utils/MDSpan.h"


#include "arcane/core/VariableRefArray.h"

#include "arcane/core/VariableRefArray2.h"

#include "arcane/core/MeshVariable.h"

#include "arcane/core/IVariable.h"

#include "arcane/core/MeshVariableScalarRef.h"

#include "arcane/core/internal/MachineShMemWinVariableBase.h"


#include "arccore/base/Span2.h"

#include "arccore/base/MDIndex.h"


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


namespace Arcane

{


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


MachineShMemWinVariableCommon::

MachineShMemWinVariableCommon(IVariable* var)

: m_base(makeRef(new MachineShMemWinVariableBase(var)))

{}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


MachineShMemWinVariableCommon::

~MachineShMemWinVariableCommon() = default;


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


ConstArrayView<Int32> MachineShMemWinVariableCommon::

machineRanks() const

{

  return m_base->machineRanks();

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


void MachineShMemWinVariableCommon::

barrier() const

{

  m_base->barrier();

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


template <class DataType>


MachineShMemWinVariableArrayT<DataType>::

MachineShMemWinVariableArrayT(VariableRefArrayT<DataType> var)

: MachineShMemWinVariableCommon(var.variable())

, m_vart(var)

{

  updateVariable();

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


template <class DataType>

MachineShMemWinVariableArrayT<DataType>::

~MachineShMemWinVariableArrayT() = default;


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


template <class DataType>


Span<DataType> MachineShMemWinVariableArrayT<DataType>::

view(Int32 rank) const

{

  return asSpan<DataType>(m_base->segmentView(rank));

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


template <class DataType>


void MachineShMemWinVariableArrayT<DataType>::

updateVariable()

{

  m_base->updateVariable(m_vart.asArray().size(), sizeof(DataType));

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


template <class ItemType, class DataType>


MachineShMemWinMeshVariableScalarT<ItemType, DataType>::

MachineShMemWinMeshVariableScalarT(MeshVariableScalarRefT<ItemType, DataType> var)

: MachineShMemWinVariableCommon(var.variable())

, m_vart(var)

{

  updateVariable();

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


template <class ItemType, class DataType>

MachineShMemWinMeshVariableScalarT<ItemType, DataType>::

~MachineShMemWinMeshVariableScalarT() = default;


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


template <class ItemType, class DataType>


Span<DataType> MachineShMemWinMeshVariableScalarT<ItemType, DataType>::

view(Int32 rank) const

{

  return asSpan<DataType>(m_base->segmentView(rank));

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


template <class ItemType, class DataType>


DataType MachineShMemWinMeshVariableScalarT<ItemType, DataType>::

operator()(Int32 rank, Int32 notlocal_id)

{

  return this->view(rank)[notlocal_id];

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


template <class ItemType, class DataType>


void MachineShMemWinMeshVariableScalarT<ItemType, DataType>::

updateVariable()

{

  m_base->updateVariable(m_vart.asArray().size(), sizeof(DataType));

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


template <class DataType>


MachineShMemWinVariableArray2T<DataType>::

MachineShMemWinVariableArray2T(VariableRefArray2T<DataType> var)

: m_base(makeRef(new MachineShMemWinVariable2DBase(var.variable())))

, m_vart(var)

{

  updateVariable();

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


template <class DataType>

MachineShMemWinVariableArray2T<DataType>::

~MachineShMemWinVariableArray2T() = default;


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


template <class DataType>


ConstArrayView<Int32> MachineShMemWinVariableArray2T<DataType>::

machineRanks() const

{

  return m_base->machineRanks();

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


template <class DataType>


void MachineShMemWinVariableArray2T<DataType>::

barrier() const

{

  m_base->barrier();

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


template <class DataType>


Span2<DataType> MachineShMemWinVariableArray2T<DataType>::

view(Int32 rank) const

{

  Span<DataType> span1 = asSpan<DataType>(m_base->segmentView(rank));

  return { span1.data(), m_base->nbElemDim1(rank), m_base->nbElemDim2(rank) };

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


template <class DataType>


void MachineShMemWinVariableArray2T<DataType>::

updateVariable()

{

  Int64 size_dim1 = m_vart.dim1Size();

  Int64 size_dim2 = m_vart.dim2Size();


  m_base->updateVariable(size_dim1, size_dim2, sizeof(DataType));

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


template <class ItemType, class DataType>


MachineShMemWinMeshVariableArrayT<ItemType, DataType>::

MachineShMemWinMeshVariableArrayT(MeshVariableArrayRefT<ItemType, DataType> var)

: m_base(makeRef(new MachineShMemWinVariableMDBase(var.variable())))

, m_vart(var)

{

  updateVariable();

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


template <class ItemType, class DataType>

MachineShMemWinMeshVariableArrayT<ItemType, DataType>::

~MachineShMemWinMeshVariableArrayT() = default;


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


template <class ItemType, class DataType>


ConstArrayView<Int32> MachineShMemWinMeshVariableArrayT<ItemType, DataType>::

machineRanks() const

{

  return m_base->machineRanks();

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


template <class ItemType, class DataType>


void MachineShMemWinMeshVariableArrayT<ItemType, DataType>::

barrier() const

{

  m_base->barrier();

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


template <class ItemType, class DataType>


Span2<DataType> MachineShMemWinMeshVariableArrayT<ItemType, DataType>::

view(Int32 rank) const

{

  Span<DataType> span1 = asSpan<DataType>(m_base->segmentView(rank));

  return { span1.data(), m_base->nbElemDim1(rank), m_nb_elem_dim2 };

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


template <class ItemType, class DataType>


Span<DataType> MachineShMemWinMeshVariableArrayT<ItemType, DataType>::

operator()(Int32 rank, Int32 notlocal_id)

{

  Span<DataType> span1 = asSpan<DataType>(m_base->segmentView(rank));

  Span2<DataType> span2(span1.data(), m_base->nbElemDim1(rank), m_nb_elem_dim2);


  return span2[notlocal_id];

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


template <class ItemType, class DataType>


void MachineShMemWinMeshVariableArrayT<ItemType, DataType>::

updateVariable()

{

  Int64 size_dim1 = m_vart.asArray().dim1Size();

  m_nb_elem_dim2 = m_vart.asArray().dim2Size();


  m_base->updateVariable(size_dim1, m_nb_elem_dim2, sizeof(DataType));

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


template <class ItemType, class DataType, class Extents>


MachineShMemWinMDVariableT<ItemType, DataType, Extents>::

MachineShMemWinMDVariableT(MeshVariableArrayRefT<ItemType, DataType> var)

: m_base(makeRef(new MachineShMemWinVariableMDBase(var.variable())))

, m_vart(var)

{

  updateVariable();

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


template <class ItemType, class DataType, class Extents>

MachineShMemWinMDVariableT<ItemType, DataType, Extents>::

~MachineShMemWinMDVariableT() = default;


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


template <class ItemType, class DataType, class Extents>


ConstArrayView<Int32> MachineShMemWinMDVariableT<ItemType, DataType, Extents>::

machineRanks() const

{

  return m_base->machineRanks();

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


template <class ItemType, class DataType, class Extents>


void MachineShMemWinMDVariableT<ItemType, DataType, Extents>::

barrier() const

{

  m_base->barrier();

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


template <class ItemType, class DataType, class Extents>


MDSpan<DataType, typename MDDimType<Extents::rank() + 1>::DimType> MachineShMemWinMDVariableT<ItemType, DataType, Extents>::

view(Int32 rank) const

{

  Span<DataType> span1 = asSpan<DataType>(m_base->segmentView(rank));


  if constexpr (Extents::rank() == 1) {

    std::array<Int32, 2> nb_elem_mdim{ static_cast<Int32>(m_base->nbElemDim1(rank)), m_shape_dim2[0] };

    MDSpan<DataType, MDDim2> mdspan(span1.data(), MDIndex<2>(nb_elem_mdim));

    return mdspan;

  }

  else if constexpr (Extents::rank() == 2) {

    std::array<Int32, 3> nb_elem_mdim{ static_cast<Int32>(m_base->nbElemDim1(rank)), m_shape_dim2[0], m_shape_dim2[1] };

    MDSpan<DataType, MDDim3> mdspan(span1.data(), MDIndex<3>(nb_elem_mdim));

    return mdspan;

  }

  else if constexpr (Extents::rank() == 3) {

    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] };

    MDSpan<DataType, MDDim4> mdspan(span1.data(), MDIndex<4>(nb_elem_mdim));

    return mdspan;

  }

  ARCANE_FATAL("Unexpected dimension");

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


template <class ItemType, class DataType, class Extents>


MDSpan<DataType, Extents> MachineShMemWinMDVariableT<ItemType, DataType, Extents>::

operator()(Int32 rank, Int32 notlocal_id)

{

  Span<DataType> span1 = asSpan<DataType>(m_base->segmentView(rank));

  Span2<DataType> span2(span1.data(), m_base->nbElemDim1(rank), m_nb_elem_dim2);

  MDSpan<DataType, Extents> mdspan(span2[notlocal_id].data(), MDIndex<Extents::rank()>(m_shape_dim2));


  return mdspan;

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


template <class ItemType, class DataType, class Extents>


void MachineShMemWinMDVariableT<ItemType, DataType, Extents>::

updateVariable()

{

  Int64 nb_elem_dim1 = m_vart.asArray().dim1Size();

  Int32 nb_elem_dim2 = m_vart.asArray().dim2Size();


  m_base->updateVariable(nb_elem_dim1, nb_elem_dim2, sizeof(DataType));


  SmallSpan<Int32> shape_dim2_view(m_shape_dim2.data(), Extents::rank());

  shape_dim2_view.copy(m_base->arrayShape().dimensions());


  m_nb_elem_dim2 = nb_elem_dim2;

}


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


// Macro to instantiate a template class for all numeric data types, all items.

#define ARCANE_INTERNAL_INSTANTIATE_TEMPLATE_FOR_NUMERIC_DATATYPE_WITH_ITEM1(class_name, item) \

  template class ARCANE_TEMPLATE_EXPORT class_name<item, Real>; \

  template class ARCANE_TEMPLATE_EXPORT class_name<item, Real3>; \

  template class ARCANE_TEMPLATE_EXPORT class_name<item, Real3x3>; \

  template class ARCANE_TEMPLATE_EXPORT class_name<item, Real2>; \

  template class ARCANE_TEMPLATE_EXPORT class_name<item, Real2x2>; \

  template class ARCANE_TEMPLATE_EXPORT class_name<item, Int8>; \

  template class ARCANE_TEMPLATE_EXPORT class_name<item, Int16>; \

  template class ARCANE_TEMPLATE_EXPORT class_name<item, Int32>; \

  template class ARCANE_TEMPLATE_EXPORT class_name<item, Int64>;


#define ARCANE_INTERNAL_INSTANTIATE_TEMPLATE_FOR_NUMERIC_DATATYPE_WITH_ITEM(class_name) \

  ARCANE_INTERNAL_INSTANTIATE_TEMPLATE_FOR_NUMERIC_DATATYPE_WITH_ITEM1(class_name, Node) \

  ARCANE_INTERNAL_INSTANTIATE_TEMPLATE_FOR_NUMERIC_DATATYPE_WITH_ITEM1(class_name, Face) \

  ARCANE_INTERNAL_INSTANTIATE_TEMPLATE_FOR_NUMERIC_DATATYPE_WITH_ITEM1(class_name, Cell) \

  ARCANE_INTERNAL_INSTANTIATE_TEMPLATE_FOR_NUMERIC_DATATYPE_WITH_ITEM1(class_name, Particle) \

  ARCANE_INTERNAL_INSTANTIATE_TEMPLATE_FOR_NUMERIC_DATATYPE_WITH_ITEM1(class_name, DoF)


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


ARCANE_INTERNAL_INSTANTIATE_TEMPLATE_FOR_NUMERIC_DATATYPE(MachineShMemWinVariableArrayT);


template class ARCANE_TEMPLATE_EXPORT MachineShMemWinVariableArray2T<Real>;

template class ARCANE_TEMPLATE_EXPORT MachineShMemWinVariableArray2T<Real3>;

template class ARCANE_TEMPLATE_EXPORT MachineShMemWinVariableArray2T<Real3x3>;

template class ARCANE_TEMPLATE_EXPORT MachineShMemWinVariableArray2T<Real2>;

template class ARCANE_TEMPLATE_EXPORT MachineShMemWinVariableArray2T<Real2x2>;

template class ARCANE_TEMPLATE_EXPORT MachineShMemWinVariableArray2T<Int16>;

template class ARCANE_TEMPLATE_EXPORT MachineShMemWinVariableArray2T<Int32>;

template class ARCANE_TEMPLATE_EXPORT MachineShMemWinVariableArray2T<Int64>;

template class ARCANE_TEMPLATE_EXPORT MachineShMemWinVariableArray2T<Byte>;


ARCANE_INTERNAL_INSTANTIATE_TEMPLATE_FOR_NUMERIC_DATATYPE_WITH_ITEM(MachineShMemWinMeshVariableScalarT);

ARCANE_INTERNAL_INSTANTIATE_TEMPLATE_FOR_NUMERIC_DATATYPE_WITH_ITEM(MachineShMemWinMeshVariableArrayT);


template class ARCANE_TEMPLATE_EXPORT MachineShMemWinMDVariableT<Cell, Real, MDDim1>;

template class ARCANE_TEMPLATE_EXPORT MachineShMemWinMDVariableT<Cell, Real, MDDim2>;

template class ARCANE_TEMPLATE_EXPORT MachineShMemWinMDVariableT<Cell, Real, MDDim3>;


// Explicit instantiation to check compilation

template class MachineShMemWinMeshMDVariableT<Cell, Real, MDDim1>;

template class MachineShMemWinMeshMDVariableT<Cell, Real, MDDim2>;

template class MachineShMemWinMeshMDVariableT<Cell, Real, MDDim3>;


template class MachineShMemWinMeshVectorMDVariableT<Cell, Real, MDDim1>;

template class MachineShMemWinMeshVectorMDVariableT<Cell, Real, MDDim2>;


template class MachineShMemWinMeshMatrixMDVariableT<Cell, Real, MDDim1>;


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


} // End namespace Arcane


/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/


ARCANE_FATAL
#define ARCANE_FATAL(...)
Macro throwing a FatalErrorException.
Definition ArcaneGlobal.h:749

Span2.h
Types and functions associated with the classes Span2Impl, Small2Span and Span2.

Arcane::ConstArrayView
Constant view of an array of type T.
Definition arccore/src/base/arccore/base/ArrayView.h:550

Arcane::IVariable
Interface of a variable.
Definition IVariable.h:40

Arcane::MDDimType
Definition BaseTypes.h:173

Arcane::MDIndex
Definition BaseTypes.h:193

Arcane::MDSpan
Base class for multi-dimensional views.
Definition arccore/src/base/arccore/base/MDSpan.h:44

Arcane::MachineShMemWinMDVariableT
Class allowing access to shared elements of the variable in shared memory.
Definition MachineShMemWinVariable.h:438

Arcane::MachineShMemWinMDVariableT::MachineShMemWinMDVariableT
MachineShMemWinMDVariableT(MeshVariableArrayRefT< ItemType, DataType > var)
Constructor.
Definition MachineShMemWinVariable.cc:314

Arcane::MachineShMemWinMDVariableT::operator()
MDSpan< DataType, Extents > operator()(Int32 rank, Int32 notlocal_id)
Method to get the multi-dimensional array of an item from another subdomain.
Definition MachineShMemWinVariable.cc:380

Arcane::MachineShMemWinMDVariableT::machineRanks
ConstArrayView< Int32 > machineRanks() const
Method to get the ranks that possess a segment in the window.
Definition MachineShMemWinVariable.cc:333

Arcane::MachineShMemWinMDVariableT::view
MDSpan< DataType, typename MDDimType< Extents::rank()+1 >::DimType > view(Int32 rank) const
Method to get a view of the variable from another subdomain on the node.
Definition MachineShMemWinVariable.cc:353

Arcane::MachineShMemWinMDVariableT::updateVariable
void updateVariable()
Method to update this object after a change in the mesh and/or after a resizing of the variable.
Definition MachineShMemWinVariable.cc:394

Arcane::MachineShMemWinMDVariableT::barrier
void barrier() const
Method to wait until all processes/threads on the node call this method to continue execution.
Definition MachineShMemWinVariable.cc:343

Arcane::MachineShMemWinMeshMDVariableT
Class allowing access to shared elements of the variable in shared memory.
Definition MachineShMemWinVariable.h:547

Arcane::MachineShMemWinMeshMatrixMDVariableT
Class allowing access to shared elements of the variable in shared memory.
Definition MachineShMemWinVariable.h:623

Arcane::MachineShMemWinMeshVariableArrayT
Class allowing access to the shared elements of the variable in shared memory.
Definition MachineShMemWinVariable.h:332

Arcane::MachineShMemWinMeshVariableArrayT::updateVariable
void updateVariable()
Method to update this object after a change in the mesh and/or after a resizing of the variable.
Definition MachineShMemWinVariable.cc:298

Arcane::MachineShMemWinMeshVariableArrayT::view
Span2< DataType > view(Int32 rank) const
Method to get a view of the variable from another subdomain on the node.
Definition MachineShMemWinVariable.cc:274

Arcane::MachineShMemWinMeshVariableArrayT::barrier
void barrier() const
Method to wait until all processes/threads on the node call this method to continue execution.
Definition MachineShMemWinVariable.cc:264

Arcane::MachineShMemWinMeshVariableArrayT::operator()
Span< DataType > operator()(Int32 rank, Int32 notlocal_id)
Method to get the array of an item from another subdomain.
Definition MachineShMemWinVariable.cc:285

Arcane::MachineShMemWinMeshVariableArrayT::MachineShMemWinMeshVariableArrayT
MachineShMemWinMeshVariableArrayT(MeshVariableArrayRefT< ItemType, DataType > var)
Constructor.
Definition MachineShMemWinVariable.cc:235

Arcane::MachineShMemWinMeshVariableArrayT::machineRanks
ConstArrayView< Int32 > machineRanks() const
Method to get the ranks that possess a segment in the window.
Definition MachineShMemWinVariable.cc:254

Arcane::MachineShMemWinMeshVariableScalarT
Class allowing access to the shared elements of the variable in shared memory.
Definition MachineShMemWinVariable.h:173

Arcane::MachineShMemWinMeshVariableScalarT::updateVariable
void updateVariable()
Method allowing updating this object after a change in the mesh.
Definition MachineShMemWinVariable.cc:156

Arcane::MachineShMemWinMeshVariableScalarT::operator()
DataType operator()(Int32 rank, Int32 notlocal_id)
Method allowing retrieval of an element of the variable from another subdomain.
Definition MachineShMemWinVariable.cc:146

Arcane::MachineShMemWinMeshVariableScalarT::view
Span< DataType > view(Int32 rank) const
Method allowing retrieval of a view on the variable of another subdomain on the node.
Definition MachineShMemWinVariable.cc:136

Arcane::MachineShMemWinMeshVariableScalarT::MachineShMemWinMeshVariableScalarT
MachineShMemWinMeshVariableScalarT(MeshVariableScalarRefT< ItemType, DataType > var)
Constructor.
Definition MachineShMemWinVariable.cc:117

Arcane::MachineShMemWinMeshVectorMDVariableT
Class allowing access to shared elements of the variable in shared memory.
Definition MachineShMemWinVariable.h:584

Arcane::MachineShMemWinVariable2DBase
Class allowing access to the shared memory part between sub-domains of the same node of a 2D array va...
Definition MachineShMemWinVariableBase.h:116

Arcane::MachineShMemWinVariableArray2T
Class allowing access to the shared elements of the variable in shared memory.
Definition MachineShMemWinVariable.h:256

Arcane::MachineShMemWinVariableArray2T::machineRanks
ConstArrayView< Int32 > machineRanks() const
Method allowing retrieval of ranks that possess a segment in the window.
Definition MachineShMemWinVariable.cc:188

Arcane::MachineShMemWinVariableArray2T::view
Span2< DataType > view(Int32 rank) const
Method allowing retrieval of a view on the array of another subdomain on the node.
Definition MachineShMemWinVariable.cc:208

Arcane::MachineShMemWinVariableArray2T::MachineShMemWinVariableArray2T
MachineShMemWinVariableArray2T(VariableRefArray2T< DataType > var)
Constructor.
Definition MachineShMemWinVariable.cc:169

Arcane::MachineShMemWinVariableArray2T::barrier
void barrier() const
Method allowing waiting until all processes/threads on the node call this method to continue executio...
Definition MachineShMemWinVariable.cc:198

Arcane::MachineShMemWinVariableArray2T::updateVariable
void updateVariable()
Method allowing updating this object after a resizing of the variable.
Definition MachineShMemWinVariable.cc:219

Arcane::MachineShMemWinVariableArrayT
Class allowing access to the shared elements of the variable in shared memory.
Definition MachineShMemWinVariable.h:113

Arcane::MachineShMemWinVariableArrayT::MachineShMemWinVariableArrayT
MachineShMemWinVariableArrayT(VariableRefArrayT< DataType > var)
Constructor.
Definition MachineShMemWinVariable.cc:75

Arcane::MachineShMemWinVariableArrayT::view
Span< DataType > view(Int32 rank) const
Method allowing retrieval of a view on the array of another subdomain on the node.
Definition MachineShMemWinVariable.cc:94

Arcane::MachineShMemWinVariableArrayT::updateVariable
void updateVariable()
Method allowing updating this object after a resizing of the variable.
Definition MachineShMemWinVariable.cc:104

Arcane::MachineShMemWinVariableBase
Class allowing access to the shared memory part between sub-domains of the same node of a variable.
Definition MachineShMemWinVariableBase.h:41

Arcane::MachineShMemWinVariableCommon::barrier
void barrier() const
Method allowing waiting until all processes/threads on the node call this method to continue executio...
Definition MachineShMemWinVariable.cc:62

Arcane::MachineShMemWinVariableCommon::machineRanks
ConstArrayView< Int32 > machineRanks() const
Method allowing retrieval of ranks that possess a segment in the window.
Definition MachineShMemWinVariable.cc:53

Arcane::MachineShMemWinVariableCommon::MachineShMemWinVariableCommon
MachineShMemWinVariableCommon(IVariable *var)
Constructor.
Definition MachineShMemWinVariable.cc:39

Arcane::MachineShMemWinVariableMDBase
Class allowing access to the shared memory part between sub-domains of the same node of a 2D array va...
Definition MachineShMemWinVariableBase.h:165

Arcane::MeshVariableArrayRefT
Array variable on a mesh entity type.
Definition MeshVariableArrayRef.h:118

Arcane::MeshVariableScalarRefT
Scalar variable on a mesh entity type.
Definition MeshVariableScalarRef.h:218

Arcane::SmallSpan
View of an array of elements of type T.
Definition Span.h:805

Arcane::Span2
View for a 2D array whose size is an 'Int64'.
Definition Span2.h:324

Arcane::SpanImpl::copy
__host__ __device__ void copy(const U &copy_array)
Copies the array copy_array into the instance.
Definition Span.h:477

Arcane::SpanImpl::data
constexpr __host__ __device__ pointer data() const noexcept
Pointer to the start of the view.
Definition Span.h:539

Arcane::Span
View of an array of elements of type T.
Definition Span.h:635

Arcane::VariableRefArray2T
Two-dimensional array variable.
Definition VariableRefArray2.h:38

Arcane::VariableRefArrayT
Array variable.
Definition VariableRefArray.h:40

Arcane
-- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature --
Definition arcane/src/arcane/accelerator/AcceleratorGlobal.h:37

Arcane::Int64
std::int64_t Int64
Signed integer type of 64 bits.
Definition ArccoreGlobal.h:235

Arcane::asSpan
Span< DataType > asSpan(Span< std::byte, Extent > bytes)
Converts a Span<std::byte> into a Span<DataType>.
Definition Span.h:1126

Arcane::makeRef
auto makeRef(InstanceType *t) -> Ref< InstanceType >
Creates a reference on a pointer.
Definition arccore/src/base/arccore/base/Ref.h:425

Arcane::Int32
std::int32_t Int32
Signed integer type of 32 bits.
Definition ArccoreGlobal.h:233