Arcane  4.1.12.0
Developer documentation
Loading...
Searching...
No Matches
SharedMemoryMachineShMemWinBaseInternal.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/* SharedMemoryMachineShMemWinBaseInternal.cc (C) 2000-2026 */
9/* */
10/* Class allowing the creation of memory windows for all subdomains in */
11/* shared memory. */
12/* The segments of these windows are not contiguous in memory and can be */
13/* resized. */
14/*---------------------------------------------------------------------------*/
15
16#include "arcane/parallel/thread/internal/SharedMemoryMachineShMemWinBaseInternal.h"
17
18#include "arcane/utils/FatalErrorException.h"
19
20#include "arccore/concurrency/IThreadBarrier.h"
21
22/*---------------------------------------------------------------------------*/
23/*---------------------------------------------------------------------------*/
24
25namespace Arcane::MessagePassing
26{
27
28/*---------------------------------------------------------------------------*/
29/*---------------------------------------------------------------------------*/
30
31SharedMemoryMachineShMemWinBaseInternal::
32SharedMemoryMachineShMemWinBaseInternal(Int32 my_rank, ConstArrayView<Int32> ranks, Int32 sizeof_type, Ref<UniqueArray<UniqueArray<std::byte>>> windows, Ref<UniqueArray<Int32>> target_segments, IThreadBarrier* barrier)
33: m_my_rank(my_rank)
34, m_sizeof_type(sizeof_type)
35, m_ranks(ranks)
36, m_windows(windows)
37, m_windows_span(windows->smallSpan())
38, m_target_segments(target_segments)
39, m_target_segments_span(target_segments->smallSpan())
40, m_barrier(barrier)
41{}
42
43/*---------------------------------------------------------------------------*/
44/*---------------------------------------------------------------------------*/
45
46Int32 SharedMemoryMachineShMemWinBaseInternal::
47sizeofOneElem() const
48{
49 return m_sizeof_type;
50}
51
52/*---------------------------------------------------------------------------*/
53/*---------------------------------------------------------------------------*/
54
55ConstArrayView<Int32> SharedMemoryMachineShMemWinBaseInternal::
56machineRanks() const
57{
58 return m_ranks;
59}
60
61/*---------------------------------------------------------------------------*/
62/*---------------------------------------------------------------------------*/
63
64void SharedMemoryMachineShMemWinBaseInternal::
65barrier() const
66{
67 m_barrier->wait();
68}
69
70/*---------------------------------------------------------------------------*/
71/*---------------------------------------------------------------------------*/
72
73Span<std::byte> SharedMemoryMachineShMemWinBaseInternal::
74segmentView()
75{
76 return m_windows_span[m_my_rank];
77}
78
79/*---------------------------------------------------------------------------*/
80/*---------------------------------------------------------------------------*/
81
82Span<std::byte> SharedMemoryMachineShMemWinBaseInternal::
83segmentView(Int32 rank)
84{
85 return m_windows_span[rank];
86}
87
88/*---------------------------------------------------------------------------*/
89/*---------------------------------------------------------------------------*/
90
91Span<const std::byte> SharedMemoryMachineShMemWinBaseInternal::
92segmentConstView() const
93{
94 return m_windows_span[m_my_rank];
95}
96
97/*---------------------------------------------------------------------------*/
98/*---------------------------------------------------------------------------*/
99
100Span<const std::byte> SharedMemoryMachineShMemWinBaseInternal::
101segmentConstView(Int32 rank) const
102{
103 return m_windows_span[rank];
104}
105
106/*---------------------------------------------------------------------------*/
107/*---------------------------------------------------------------------------*/
108
109void SharedMemoryMachineShMemWinBaseInternal::
110add(Span<const std::byte> elem)
111{
112 m_barrier->wait();
113 if (elem.size() % m_sizeof_type != 0) {
114 ARCCORE_FATAL("Sizeof elem not valid");
115 }
116 m_windows_span[m_my_rank].addRange(elem);
117 m_barrier->wait();
118}
119
120/*---------------------------------------------------------------------------*/
121/*---------------------------------------------------------------------------*/
122
123void SharedMemoryMachineShMemWinBaseInternal::
124add()
125{
126 m_barrier->wait();
127 m_barrier->wait();
128}
129
130/*---------------------------------------------------------------------------*/
131/*---------------------------------------------------------------------------*/
132
133void SharedMemoryMachineShMemWinBaseInternal::
134addToAnotherSegment(Int32 rank, Span<const std::byte> elem)
135{
136 if (elem.size() % m_sizeof_type != 0) {
137 ARCCORE_FATAL("Sizeof elem not valid");
138 }
139
140 m_target_segments_span[m_my_rank] = rank;
141 m_barrier->wait();
142
143 bool is_found = false;
144 for (const Int32 rank_asked : m_target_segments_span) {
145 if (rank_asked == rank) {
146 if (!is_found) {
147 is_found = true;
148 }
149 else {
150 ARCANE_FATAL("Two subdomains ask same rank for addToAnotherSegment()");
151 }
152 }
153 }
154
155 m_windows_span[rank].addRange(elem);
156 m_barrier->wait();
157 m_target_segments_span[m_my_rank] = -1;
158}
159
160/*---------------------------------------------------------------------------*/
161/*---------------------------------------------------------------------------*/
162
163void SharedMemoryMachineShMemWinBaseInternal::
164addToAnotherSegment()
165{
166 m_barrier->wait();
167 m_barrier->wait();
168}
169
170/*---------------------------------------------------------------------------*/
171/*---------------------------------------------------------------------------*/
172
173void SharedMemoryMachineShMemWinBaseInternal::
174reserve(Int64 new_capacity)
175{
176 m_barrier->wait();
177 m_windows_span[m_my_rank].reserve(new_capacity);
178 m_barrier->wait();
179}
180
181/*---------------------------------------------------------------------------*/
182/*---------------------------------------------------------------------------*/
183
184void SharedMemoryMachineShMemWinBaseInternal::
185reserve()
186{
187 m_barrier->wait();
188 m_barrier->wait();
189}
190
191/*---------------------------------------------------------------------------*/
192/*---------------------------------------------------------------------------*/
193
194void SharedMemoryMachineShMemWinBaseInternal::
195resize(Int64 new_size)
196{
197 m_barrier->wait();
198 m_windows_span[m_my_rank].resize(new_size);
199 m_barrier->wait();
200}
201
202/*---------------------------------------------------------------------------*/
203/*---------------------------------------------------------------------------*/
204
205void SharedMemoryMachineShMemWinBaseInternal::
206resize()
207{
208 m_barrier->wait();
209 m_barrier->wait();
210}
211
212/*---------------------------------------------------------------------------*/
213/*---------------------------------------------------------------------------*/
214
215void SharedMemoryMachineShMemWinBaseInternal::
216shrink()
217{
218 m_barrier->wait();
219 m_windows_span[m_my_rank].shrink();
220 m_barrier->wait();
221}
222
223/*---------------------------------------------------------------------------*/
224/*---------------------------------------------------------------------------*/
225
226} // namespace Arcane::MessagePassing
227
228/*---------------------------------------------------------------------------*/
229/*---------------------------------------------------------------------------*/
ARCANE_FATAL
#define ARCANE_FATAL(...)
Macro throwing a FatalErrorException.
Definition ArcaneGlobal.h:749
ARCCORE_FATAL
#define ARCCORE_FATAL(...)
Macro throwing a FatalErrorException.
Definition ArccoreGlobal.h:549
Arcane::ConstArrayView
Constant view of an array of type T.
Definition arccore/src/base/arccore/base/ArrayView.h:550
Arcane::SpanImpl::size
constexpr __host__ __device__ SizeType size() const noexcept
Returns the size of the array.
Definition Span.h:327
Arcane::Span
View of an array of elements of type T.
Definition Span.h:635
Arcane::MessagePassing
Declarations of types and methods used by message exchange mechanisms.
Definition ContigMachineShMemWinBase.h:35
Arcane::Int64
std::int64_t Int64
Signed integer type of 64 bits.
Definition ArccoreGlobal.h:235
Arcane::Int32
std::int32_t Int32
Signed integer type of 32 bits.
Definition ArccoreGlobal.h:233