Arcane  v3.16.6.0
Documentation utilisateur
Chargement...
Recherche...
Aucune correspondance
MemoryView.h
1// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
2//-----------------------------------------------------------------------------
3// Copyright 2000-2025 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/* MemoryView.h (C) 2000-2025 */
9/* */
10/* Vues constantes ou modifiables sur une zone mémoire. */
11/*---------------------------------------------------------------------------*/
12#ifndef ARCANE_UTILS_MEMORYVIEW_H
13#define ARCANE_UTILS_MEMORYVIEW_H
14/*---------------------------------------------------------------------------*/
15/*---------------------------------------------------------------------------*/
16
17#include "arcane/utils/ArrayView.h"
18
19/*---------------------------------------------------------------------------*/
20/*---------------------------------------------------------------------------*/
21
22namespace Arcane
23{
24
25/*---------------------------------------------------------------------------*/
26/*---------------------------------------------------------------------------*/
27/*!
28 * \ingroup MemoryView
29 * \brief Vue constante sur une zone mémoire contigue contenant des
30 * éléments de taille fixe.
31 *
32 * Les fonctions makeConstMemoryView() permettent de créer des instances
33 * de cette classe.
34 *
35 * \warning API en cours de définition. Ne pas utiliser en dehors de Arcane.
36 */
37class ARCANE_UTILS_EXPORT ConstMemoryView
38{
39 friend ARCANE_UTILS_EXPORT ConstMemoryView
40 makeConstMemoryView(const void* ptr, Int32 datatype_size, Int64 nb_element);
41
42 public:
43
44 using SpanType = Span<const std::byte>;
45 friend MutableMemoryView;
46
47 public:
48
49 ConstMemoryView() = default;
50 explicit constexpr ConstMemoryView(Span<const std::byte> bytes)
51 : m_bytes(bytes)
52 , m_nb_element(bytes.size())
53 , m_datatype_size(1)
54 {}
55 template <typename DataType> explicit constexpr ConstMemoryView(Span<DataType> v)
56 : ConstMemoryView(Span<const DataType>(v), 1)
57 {}
58 template <typename DataType> explicit constexpr ConstMemoryView(Span<const DataType> v)
59 : ConstMemoryView(v, 1)
60 {}
61 template <typename DataType> explicit constexpr ConstMemoryView(ConstArrayView<DataType> v)
62 : ConstMemoryView(Span<const DataType>(v), 1)
63 {}
64 template <typename DataType> explicit constexpr ConstMemoryView(ArrayView<DataType> v)
65 : ConstMemoryView(Span<const DataType>(v), 1)
66 {}
67 template <typename DataType> constexpr ConstMemoryView(ConstArrayView<DataType> v, Int32 nb_component)
68 : ConstMemoryView(Span<const DataType>(v), nb_component)
69 {}
70 template <typename DataType> constexpr ConstMemoryView(ArrayView<DataType> v, Int32 nb_component)
71 : ConstMemoryView(Span<const DataType>(v), nb_component)
72 {}
73 template <typename DataType> constexpr ConstMemoryView(Span<DataType> v, Int32 nb_component)
74 : ConstMemoryView(Span<const DataType>(v), nb_component)
75 {
76 }
77 template <typename DataType> constexpr ConstMemoryView(Span<const DataType> v, Int32 nb_component)
78 : m_nb_element(v.size())
79 , m_datatype_size(static_cast<Int32>(sizeof(DataType)) * nb_component)
80 {
81 auto x = asBytes(v);
82 m_bytes = SpanType(x.data(), x.size() * nb_component);
83 }
84
85 public:
86
87 template <typename DataType> constexpr ConstMemoryView&
88 operator=(Span<DataType> v)
89 {
90 m_bytes = asBytes(v);
91 m_nb_element = v.size();
92 m_datatype_size = static_cast<Int32>(sizeof(DataType));
93 return (*this);
94 }
95
96 private:
97
98 constexpr ConstMemoryView(Span<const std::byte> bytes, Int32 datatype_size, Int64 nb_element)
99 : m_bytes(bytes)
100 , m_nb_element(nb_element)
101 , m_datatype_size(datatype_size)
102 {}
103
104 public:
105
106 //! Vue sous forme d'octets
107 constexpr SpanType bytes() const { return m_bytes; }
108
109 //! Pointeur sur la zone mémoire
110 constexpr const std::byte* data() const { return m_bytes.data(); }
111
112 //! Nombre d'éléments
113 constexpr Int64 nbElement() const { return m_nb_element; }
114
115 //! Taille du type de donnée associé (1 par défaut)
116 constexpr Int32 datatypeSize() const { return m_datatype_size; }
117
118 //! Sous-vue à partir de l'indice \a begin_index et contenant \a nb_element
119 constexpr ConstMemoryView subView(Int64 begin_index, Int64 nb_element) const
120 {
121 Int64 byte_offset = begin_index * m_datatype_size;
122 auto sub_bytes = m_bytes.subspan(byte_offset, nb_element * m_datatype_size);
123 return { sub_bytes, m_datatype_size, nb_element };
124 }
125
126 public:
127
128 //! Vue convertie en un Span
129 ARCANE_DEPRECATED_REASON("Use bytes() instead")
130 SpanType span() const { return m_bytes; }
131
132 ARCANE_DEPRECATED_REASON("Use bytes().size() instead")
133 constexpr Int64 size() const { return m_bytes.size(); }
134
135 private:
136
137 SpanType m_bytes;
138 Int64 m_nb_element = 0;
139 Int32 m_datatype_size = 0;
140};
141
142/*---------------------------------------------------------------------------*/
143/*---------------------------------------------------------------------------*/
144/*!
145 * \ingroup MemoryView
146 *
147 * \brief Vue modifiable sur une zone mémoire contigue contenant des
148 * éléments de taille fixe.
149 *
150 * Les fonctions makeMutableMemoryView() permettent de créer des instances
151 * de cette classe.
152 *
153 * \warning API en cours de définition. Ne pas utiliser en dehors de Arcane.
154 */
155class ARCANE_UTILS_EXPORT MutableMemoryView
156{
157 friend ARCANE_UTILS_EXPORT MutableMemoryView
158 makeMutableMemoryView(void* ptr, Int32 datatype_size, Int64 nb_element);
159
160 public:
161
162 using SpanType = Span<std::byte>;
163
164 public:
165
166 MutableMemoryView() = default;
167 explicit constexpr MutableMemoryView(SpanType bytes)
168 : m_bytes(bytes)
169 , m_nb_element(bytes.size())
170 , m_datatype_size(1)
171 {}
172 template <typename DataType> explicit constexpr MutableMemoryView(Span<DataType> v)
173 : MutableMemoryView(v, 1)
174 {}
175 template <typename DataType> explicit constexpr MutableMemoryView(ArrayView<DataType> v)
176 : MutableMemoryView(Span<DataType>(v), 1)
177 {}
178 template <typename DataType> explicit constexpr MutableMemoryView(ArrayView<DataType> v, Int32 nb_component)
179 : MutableMemoryView(Span<DataType>(v), nb_component)
180 {}
181 template <typename DataType> constexpr MutableMemoryView(Span<DataType> v, Int32 nb_component)
182 : m_nb_element(v.size())
183 , m_datatype_size(static_cast<Int32>(sizeof(DataType)) * nb_component)
184 {
185 auto x = asWritableBytes(v);
186 m_bytes = SpanType(x.data(), x.size() * nb_component);
187 }
188
189 public:
190
191 template <typename DataType> constexpr MutableMemoryView&
192 operator=(Span<DataType> v)
193 {
194 m_bytes = asWritableBytes(v);
195 m_nb_element = v.size();
196 m_datatype_size = static_cast<Int32>(sizeof(DataType));
197 return (*this);
198 }
199
200 private:
201
202 constexpr MutableMemoryView(Span<std::byte> bytes, Int32 datatype_size, Int64 nb_element)
203 : m_bytes(bytes)
204 , m_nb_element(nb_element)
205 , m_datatype_size(datatype_size)
206 {}
207
208 public:
209
210 constexpr operator ConstMemoryView() const { return { m_bytes, m_datatype_size, m_nb_element }; }
211
212 public:
213
214 //! Vue sous forme d'octets
215 constexpr SpanType bytes() const { return m_bytes; }
216
217 //! Pointeur sur la zone mémoire
218 constexpr std::byte* data() const { return m_bytes.data(); }
219
220 //! Nombre d'éléments
221 constexpr Int64 nbElement() const { return m_nb_element; }
222
223 //! Taille du type de donnée associé (1 par défaut)
224 constexpr Int32 datatypeSize() const { return m_datatype_size; }
225
226 //! Sous-vue à partir de l'indice \a begin_index
227 constexpr MutableMemoryView subView(Int64 begin_index, Int64 nb_element) const
228 {
229 Int64 byte_offset = begin_index * m_datatype_size;
230 auto sub_bytes = m_bytes.subspan(byte_offset, nb_element * m_datatype_size);
231 return { sub_bytes, m_datatype_size, nb_element };
232 }
233
234 public:
235
236 ARCANE_DEPRECATED_REASON("Use bytes() instead")
237 constexpr SpanType span() const { return m_bytes; }
238
239 ARCANE_DEPRECATED_REASON("Use bytes().size() instead")
240 constexpr Int64 size() const { return m_bytes.size(); }
241
242 private:
243
244 SpanType m_bytes;
245 Int64 m_nb_element = 0;
246 Int32 m_datatype_size = 0;
247};
248
249/*---------------------------------------------------------------------------*/
250/*---------------------------------------------------------------------------*/
251/*!
252 * \ingroup MemoryView
253 *
254 * \brief Liste de vues constantes sur des zones mémoires contigues.
255 *
256 * \warning API en cours de définition. Ne pas utiliser en dehors de Arcane.
257 */
258class ARCANE_UTILS_EXPORT ConstMultiMemoryView
259{
260 public:
261
262 ConstMultiMemoryView(SmallSpan<const Span<const std::byte>> views, Int32 datatype_size)
263 : m_views(views)
264 , m_datatype_size(datatype_size)
265 {}
266 ConstMultiMemoryView(SmallSpan<const Span<std::byte>> views, Int32 datatype_size)
267 : m_datatype_size(datatype_size)
268 {
269 auto* ptr = reinterpret_cast<const Span<const std::byte>*>(views.data());
270 m_views = { ptr, views.size() };
271 }
272
273 //! Vues en octets sur la zone mémoire
274 constexpr SmallSpan<const Span<const std::byte>> views() const { return m_views; }
275
276 //! Taille du type de donnée associé (1 par défaut)
277 constexpr Int32 datatypeSize() const { return m_datatype_size; }
278
279 private:
280
282 Int32 m_datatype_size;
283};
284
285/*---------------------------------------------------------------------------*/
286/*---------------------------------------------------------------------------*/
287/*!
288 * \ingroup MemoryView
289 *
290 * \brief Liste de vues modifiables sur des zones mémoires contigues.
291 *
292 * \warning API en cours de définition. Ne pas utiliser en dehors de Arcane.
293 */
294class ARCANE_UTILS_EXPORT MutableMultiMemoryView
295{
296 public:
297
298 MutableMultiMemoryView(SmallSpan<Span<std::byte>> views, Int32 datatype_size)
299 : m_views(views)
300 , m_datatype_size(datatype_size)
301 {}
302
303 public:
304
305 //! Vues en octets sur la zone mémoire
306 constexpr SmallSpan<Span<std::byte>> views() const { return m_views; }
307
308 //! Taille du type de donnée associé (1 par défaut)
309 constexpr Int32 datatypeSize() const { return m_datatype_size; }
310
311 private:
312
314 Int32 m_datatype_size;
315};
316
317/*---------------------------------------------------------------------------*/
318/*---------------------------------------------------------------------------*/
319
320/*---------------------------------------------------------------------------*/
321/*---------------------------------------------------------------------------*/
322
323//! Créé une vue mémoire constante à partir d'un \a Span
324template <typename DataType> ConstMemoryView
329
330//! Créé une vue mémoire constante sur l'adresse \a v
331template <typename DataType> ConstMemoryView
332makeMemoryView(const DataType* v)
333{
335}
336
337/*---------------------------------------------------------------------------*/
338/*---------------------------------------------------------------------------*/
339
340//! Créé une vue mémoire modifiable à partir d'un \a Span
341template <typename DataType> MutableMemoryView
346
347/*---------------------------------------------------------------------------*/
348/*---------------------------------------------------------------------------*/
349
350//! Créé une vue mémoire modifiable sur l'adresse \a v
351template <typename DataType> MutableMemoryView
353{
354 return MutableMemoryView(Span<DataType>(v, 1));
355}
356
357/*---------------------------------------------------------------------------*/
358/*---------------------------------------------------------------------------*/
359/*!
360 * \brief Créé une vue mémoire modifiable.
361 *
362 * \param ptr adresse de la zone mémoire.
363 * \param datatype_size taille (en octet) du type de la donnée.
364 * \param nb_element nombre d'éléments de la vue.
365 *
366 * La zone mémoire aura pour taille datatype_size * nb_element octets.
367 */
368extern "C++" ARCANE_UTILS_EXPORT MutableMemoryView
369makeMutableMemoryView(void* ptr, Int32 datatype_size, Int64 nb_element);
370
371/*---------------------------------------------------------------------------*/
372/*---------------------------------------------------------------------------*/
373/*!
374 * \brief Créé une vue mémoire en lecture seule.
375 *
376 * \param ptr adresse de la zone mémoire.
377 * \param datatype_size taille (en octet) du type de la donnée.
378 * \param nb_element nombre d'éléments de la vue.
379 *
380 * La zone mémoire aura pour taille datatype_size * nb_element octets.
381 */
382extern "C++" ARCANE_UTILS_EXPORT ConstMemoryView
383makeConstMemoryView(const void* ptr, Int32 datatype_size, Int64 nb_element);
384
385/*---------------------------------------------------------------------------*/
386/*---------------------------------------------------------------------------*/
387
388} // End namespace Arcane
389
390/*---------------------------------------------------------------------------*/
391/*---------------------------------------------------------------------------*/
392
393#endif
Vue modifiable d'un tableau d'un type T.
Vue constante d'un tableau de type T.
Vue constante sur une zone mémoire contigue contenant des éléments de taille fixe.
Definition MemoryView.h:38
constexpr ConstMemoryView subView(Int64 begin_index, Int64 nb_element) const
Sous-vue à partir de l'indice begin_index et contenant nb_element.
Definition MemoryView.h:119
constexpr Int32 datatypeSize() const
Taille du type de donnée associé (1 par défaut)
Definition MemoryView.h:116
SpanType span() const
Vue convertie en un Span.
Definition MemoryView.h:130
friend ConstMemoryView makeConstMemoryView(const void *ptr, Int32 datatype_size, Int64 nb_element)
Créé une vue mémoire en lecture seule.
constexpr SpanType bytes() const
Vue sous forme d'octets.
Definition MemoryView.h:107
constexpr const std::byte * data() const
Pointeur sur la zone mémoire.
Definition MemoryView.h:110
constexpr Int64 nbElement() const
Nombre d'éléments.
Definition MemoryView.h:113
constexpr Int32 datatypeSize() const
Taille du type de donnée associé (1 par défaut)
Definition MemoryView.h:277
constexpr SmallSpan< const Span< const std::byte > > views() const
Vues en octets sur la zone mémoire.
Definition MemoryView.h:274
Vue modifiable sur une zone mémoire contigue contenant des éléments de taille fixe.
Definition MemoryView.h:156
constexpr Int32 datatypeSize() const
Taille du type de donnée associé (1 par défaut)
Definition MemoryView.h:224
constexpr Int64 nbElement() const
Nombre d'éléments.
Definition MemoryView.h:221
constexpr std::byte * data() const
Pointeur sur la zone mémoire.
Definition MemoryView.h:218
friend MutableMemoryView makeMutableMemoryView(void *ptr, Int32 datatype_size, Int64 nb_element)
Créé une vue mémoire modifiable.
constexpr MutableMemoryView subView(Int64 begin_index, Int64 nb_element) const
Sous-vue à partir de l'indice begin_index.
Definition MemoryView.h:227
constexpr SpanType bytes() const
Vue sous forme d'octets.
Definition MemoryView.h:215
constexpr Int32 datatypeSize() const
Taille du type de donnée associé (1 par défaut)
Definition MemoryView.h:309
constexpr SmallSpan< Span< std::byte > > views() const
Vues en octets sur la zone mémoire.
Definition MemoryView.h:306
Vue d'un tableau d'éléments de type T.
Definition Span.h:673
constexpr __host__ __device__ SizeType size() const noexcept
Retourne la taille du tableau.
Definition Span.h:212
Vue d'un tableau d'éléments de type T.
Definition Span.h:513
-*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
impl::SpanTypeFromSize< std::byte, SizeType >::SpanType asWritableBytes(const SpanImpl< DataType, SizeType, Extent > &s)
Converti la vue en un tableau d'octets modifiables.
Definition Span.h:919
MutableMemoryView makeMutableMemoryView(void *ptr, Int32 datatype_size, Int64 nb_element)
Créé une vue mémoire modifiable.
std::int64_t Int64
Type entier signé sur 64 bits.
ConstMemoryView makeConstMemoryView(const void *ptr, Int32 datatype_size, Int64 nb_element)
Créé une vue mémoire en lecture seule.
impl::SpanTypeFromSize< conststd::byte, SizeType >::SpanType asBytes(const SpanImpl< DataType, SizeType, Extent > &s)
Converti la vue en un tableau d'octets non modifiables.
Definition Span.h:884
ConstMemoryView makeMemoryView(Span< DataType > v)
Créé une vue mémoire constante à partir d'un Span.
Definition MemoryView.h:325
std::int32_t Int32
Type entier signé sur 32 bits.