Arcane  v4.1.5.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
MachineShMemWinBase.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/* MachineShMemWinBase.cc (C) 2000-2026 */
9/* */
10/* Classe permettant de créer des fenêtres mémoires pour un noeud de calcul. */
11/* Les segments de ces fenêtres ne sont pas contigües en mémoire et peuvent */
12/* être redimensionnées. */
13/*---------------------------------------------------------------------------*/
14
15#include "arcane/core/MachineShMemWinBase.h"
16
17#include "arcane/utils/NumericTypes.h"
18
19#include "arcane/core/IParallelMng.h"
20#include "arcane/core/internal/IParallelMngInternal.h"
21
22#include "arccore/message_passing/internal/IMachineShMemWinBaseInternal.h"
23
24/*---------------------------------------------------------------------------*/
25/*---------------------------------------------------------------------------*/
26
27namespace Arcane
28{
29
30/*---------------------------------------------------------------------------*/
31/*---------------------------------------------------------------------------*/
32
33MachineShMemWinBase::
34MachineShMemWinBase(IParallelMng* pm, Int64 nb_elem_segment, Int32 sizeof_elem)
35: m_pm_internal(pm->_internalApi())
36, m_node_window_base(m_pm_internal->createMachineShMemWinBase(nb_elem_segment * static_cast<Int64>(sizeof_elem), sizeof_elem))
37, m_sizeof_elem(sizeof_elem)
38{}
39
40/*---------------------------------------------------------------------------*/
41/*---------------------------------------------------------------------------*/
42
43ConstArrayView<Int32> MachineShMemWinBase::
44machineRanks() const
45{
46 return m_node_window_base->machineRanks();
47}
48
49/*---------------------------------------------------------------------------*/
50/*---------------------------------------------------------------------------*/
51
52void MachineShMemWinBase::
53barrier() const
54{
55 m_node_window_base->barrier();
56}
57
58/*---------------------------------------------------------------------------*/
59/*---------------------------------------------------------------------------*/
60
61Span<std::byte> MachineShMemWinBase::
62segmentView()
63{
64 return m_node_window_base->segmentView();
65}
66
67/*---------------------------------------------------------------------------*/
68/*---------------------------------------------------------------------------*/
69
70Span<std::byte> MachineShMemWinBase::
71segmentView(Int32 rank)
72{
73 return m_node_window_base->segmentView(rank);
74}
75
76/*---------------------------------------------------------------------------*/
77/*---------------------------------------------------------------------------*/
78
79Span<const std::byte> MachineShMemWinBase::
80segmentConstView() const
81{
82 return m_node_window_base->segmentConstView();
83}
84
85/*---------------------------------------------------------------------------*/
86/*---------------------------------------------------------------------------*/
87
88Span<const std::byte> MachineShMemWinBase::
89segmentConstView(Int32 rank) const
90{
91 return m_node_window_base->segmentConstView(rank);
92}
93
94/*---------------------------------------------------------------------------*/
95/*---------------------------------------------------------------------------*/
96
97void MachineShMemWinBase::
98add(Span<const std::byte> elem)
99{
100 return m_node_window_base->add(elem);
101}
102
103/*---------------------------------------------------------------------------*/
104/*---------------------------------------------------------------------------*/
105
106void MachineShMemWinBase::
107add()
108{
109 return m_node_window_base->add();
110}
111
112/*---------------------------------------------------------------------------*/
113/*---------------------------------------------------------------------------*/
114
115void MachineShMemWinBase::
116addToAnotherSegment(Int32 rank, Span<const std::byte> elem)
117{
118 m_node_window_base->addToAnotherSegment(rank, elem);
119}
120
121/*---------------------------------------------------------------------------*/
122/*---------------------------------------------------------------------------*/
123
124void MachineShMemWinBase::
125addToAnotherSegment()
126{
127 m_node_window_base->addToAnotherSegment();
128}
129
130/*---------------------------------------------------------------------------*/
131/*---------------------------------------------------------------------------*/
132
133void MachineShMemWinBase::
134reserve(Int64 new_nb_elem_segment_capacity)
135{
136 m_node_window_base->reserve(new_nb_elem_segment_capacity * static_cast<Int64>(m_sizeof_elem));
137}
138
139/*---------------------------------------------------------------------------*/
140/*---------------------------------------------------------------------------*/
141
142void MachineShMemWinBase::
143reserve()
144{
145 m_node_window_base->reserve();
146}
147
148/*---------------------------------------------------------------------------*/
149/*---------------------------------------------------------------------------*/
150
151void MachineShMemWinBase::
152resize(Int64 new_nb_elem_segment)
153{
154 m_node_window_base->resize(new_nb_elem_segment * static_cast<Int64>(m_sizeof_elem));
155}
156
157/*---------------------------------------------------------------------------*/
158/*---------------------------------------------------------------------------*/
159
160void MachineShMemWinBase::
161resize()
162{
163 m_node_window_base->resize();
164}
165
166/*---------------------------------------------------------------------------*/
167/*---------------------------------------------------------------------------*/
168
169void MachineShMemWinBase::
170shrink()
171{
172 m_node_window_base->shrink();
173}
174
175/*---------------------------------------------------------------------------*/
176/*---------------------------------------------------------------------------*/
177
178} // End namespace Arcane
179
180/*---------------------------------------------------------------------------*/
181/*---------------------------------------------------------------------------*/
Arcane::ConstArrayView
Vue constante d'un tableau de type T.
Definition arccore/src/base/arccore/base/ArrayView.h:533
Arcane::IParallelMng
Interface du gestionnaire de parallélisme pour un sous-domaine.
Definition IParallelMng.h:52
Arcane::MachineShMemWinBase::barrier
void barrier() const
Méthode permettant d'attendre que tous les processus/threads du noeud appellent cette méthode pour co...
Definition MachineShMemWinBase.cc:53
Arcane::MachineShMemWinBase::MachineShMemWinBase
MachineShMemWinBase(IParallelMng *pm, Int64 sizeof_segment, Int32 sizeof_elem)
Constructeur.
Definition MachineShMemWinBase.cc:34
Arcane::MachineShMemWinBase::segmentConstView
Span< const std::byte > segmentConstView() const
Méthode permettant d'obtenir une vue sur notre segment.
Definition MachineShMemWinBase.cc:80
Arcane::MachineShMemWinBase::reserve
void reserve()
Méthode à appeler par le ou les sous-domaines ne souhaitant pas réserver davantage de mémoire pour le...
Definition MachineShMemWinBase.cc:143
Arcane::MachineShMemWinBase::shrink
void shrink()
Méthode permettant de réduire l'espace mémoire réservé pour les segments au minimum nécessaire.
Definition MachineShMemWinBase.cc:170
Arcane::MachineShMemWinBase::add
void add()
Méthode à appeler par le ou les sous-domaines ne souhaitant pas ajouter d'éléments dans son segment.
Definition MachineShMemWinBase.cc:107
Arcane::MachineShMemWinBase::resize
void resize()
Méthode à appeler par le ou les sous-domaines ne souhaitant pas redimensionner leurs segments.
Definition MachineShMemWinBase.cc:161
Arcane::MachineShMemWinBase::machineRanks
ConstArrayView< Int32 > machineRanks() const
Méthode permettant d'obtenir les rangs qui possèdent un segment dans la fenêtre.
Definition MachineShMemWinBase.cc:44
Arcane::MachineShMemWinBase::addToAnotherSegment
void addToAnotherSegment()
Méthode à appeler par le ou les sous-domaines ne souhaitant pas ajouter d'éléments dans le segment d'...
Definition MachineShMemWinBase.cc:125
Arcane::MachineShMemWinBase::segmentView
Span< std::byte > segmentView()
Méthode permettant d'obtenir une vue sur notre segment.
Definition MachineShMemWinBase.cc:62
Arcane::Span
Vue d'un tableau d'éléments de type T.
Definition Span.h:633
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
Type entier signé sur 64 bits.
Definition ArccoreGlobal.h:227
Arcane::Int32
std::int32_t Int32
Type entier signé sur 32 bits.
Definition ArccoreGlobal.h:225