Arcane  v3.16.7.0
Documentation développeur
Chargement...
Recherche...
Aucune correspondance
MemoryUtils.h
Aller à la documentation de ce fichier.
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/* MemoryUtils.h (C) 2000-2025 */
9/* */
10/* Fonctions utilitaires de gestion mémoire. */
11/*---------------------------------------------------------------------------*/
12#ifndef ARCANE_UTILS_MEMORYUTILS_H
13#define ARCANE_UTILS_MEMORYUTILS_H
14/*---------------------------------------------------------------------------*/
15/*---------------------------------------------------------------------------*/
16
17#include "arcane/utils/MemoryRessource.h"
18#include "arcane/utils/MemoryView.h"
19
20#include "arccore/collections/MemoryAllocationArgs.h"
21
22/*---------------------------------------------------------------------------*/
23/*---------------------------------------------------------------------------*/
24
25namespace Arcane::MemoryUtils
26{
27
28/*---------------------------------------------------------------------------*/
29/*---------------------------------------------------------------------------*/
39extern "C++" ARCANE_UTILS_EXPORT eMemoryResource
40getDefaultDataMemoryResource();
41
42/*---------------------------------------------------------------------------*/
43/*---------------------------------------------------------------------------*/
53extern "C++" ARCANE_UTILS_EXPORT eMemoryResource
54getMemoryResourceFromName(const String& name);
55
56/*---------------------------------------------------------------------------*/
57/*---------------------------------------------------------------------------*/
72extern "C++" ARCANE_UTILS_EXPORT IMemoryAllocator*
73getDefaultDataAllocator();
74
75/*---------------------------------------------------------------------------*/
76/*---------------------------------------------------------------------------*/
84extern "C++" ARCANE_UTILS_EXPORT MemoryAllocationOptions
85getDefaultDataAllocator(eMemoryLocationHint hint);
86
87/*---------------------------------------------------------------------------*/
88/*---------------------------------------------------------------------------*/
97extern "C++" ARCANE_UTILS_EXPORT IMemoryAllocator*
98getDeviceOrHostAllocator();
99
100/*---------------------------------------------------------------------------*/
101/*---------------------------------------------------------------------------*/
108extern "C++" ARCANE_UTILS_EXPORT MemoryAllocationOptions
109getAllocatorForMostlyReadOnlyData();
110
111/*---------------------------------------------------------------------------*/
112/*---------------------------------------------------------------------------*/
118extern "C++" ARCANE_DEPRECATED_REASON("Y2024: Use getDefaultDataAllocator() instead.")
119ARCANE_UTILS_EXPORT IMemoryAllocator*
120getAcceleratorHostMemoryAllocator();
121
122/*---------------------------------------------------------------------------*/
123/*---------------------------------------------------------------------------*/
135extern "C++" ARCANE_UTILS_EXPORT MemoryAllocationOptions
136getAllocationOptions(eMemoryResource mem_resource);
137
138/*---------------------------------------------------------------------------*/
139/*---------------------------------------------------------------------------*/
145extern "C++" ARCANE_UTILS_EXPORT IMemoryAllocator*
146getAllocator(eMemoryResource mem_resource);
147
148/*---------------------------------------------------------------------------*/
149/*---------------------------------------------------------------------------*/
150
151namespace impl
152{
154 extern "C++" ARCANE_UTILS_EXPORT Int64
155 computeCapacity(Int64 size);
156} // namespace impl
157
158/*---------------------------------------------------------------------------*/
159/*---------------------------------------------------------------------------*/
173template <typename DataType> inline Int32
174checkResizeArrayWithCapacity(Array<DataType>& array, Int64 new_size, bool force_resize)
175{
176 Int32 ret_value = 0;
177 Int64 s = array.largeSize();
178 if (new_size > s || force_resize) {
179 ret_value = 1;
180 if (new_size > array.capacity()) {
181 array.reserve(impl::computeCapacity(new_size));
182 ret_value = 2;
183 }
184 array.resize(new_size);
185 }
186 return ret_value;
187}
188
189/*---------------------------------------------------------------------------*/
190/*---------------------------------------------------------------------------*/
196template <typename DataType> inline Int32
197checkResizeArrayWithCapacity(Array<DataType>& array, Int64 new_size)
198{
199 return checkResizeArrayWithCapacity(array, new_size, false);
200}
201
202/*---------------------------------------------------------------------------*/
203/*---------------------------------------------------------------------------*/
211extern "C++" ARCANE_UTILS_EXPORT void
212copy(MutableMemoryView destination, eMemoryResource destination_mem,
213 ConstMemoryView source, eMemoryResource source_mem,
214 const RunQueue* queue = nullptr);
215
216/*---------------------------------------------------------------------------*/
217/*---------------------------------------------------------------------------*/
218
220inline void
221copy(MutableMemoryView destination, ConstMemoryView source, const RunQueue* queue = nullptr)
222{
223 eMemoryResource mem_type = eMemoryResource::Unknown;
224 copy(destination, mem_type, source, mem_type, queue);
225}
226
227/*---------------------------------------------------------------------------*/
228/*---------------------------------------------------------------------------*/
229
231template <typename DataType> inline void
232copy(Span<DataType> destination, Span<const DataType> source,
233 const RunQueue* queue = nullptr)
234{
235 ConstMemoryView input(asBytes(source));
236 MutableMemoryView output(asWritableBytes(destination));
237 copy(output, input, queue);
238}
239
240/*---------------------------------------------------------------------------*/
241/*---------------------------------------------------------------------------*/
242
244template <typename DataType> inline void
245copy(SmallSpan<DataType> destination, SmallSpan<const DataType> source,
246 const RunQueue* queue = nullptr)
247{
248 copy(Span<DataType>(destination), Span<const DataType>(source), queue);
249}
250
251/*---------------------------------------------------------------------------*/
252/*---------------------------------------------------------------------------*/
270extern "C++" ARCANE_UTILS_EXPORT void
271copyHostWithIndexedSource(MutableMemoryView destination, ConstMemoryView source,
272 Span<const Int32> indexes);
273
274/*---------------------------------------------------------------------------*/
275/*---------------------------------------------------------------------------*/
293extern "C++" ARCANE_UTILS_EXPORT void
294copyWithIndexedSource(MutableMemoryView destination, ConstMemoryView source,
295 SmallSpan<const Int32> indexes,
296 RunQueue* run_queue = nullptr);
297
298/*---------------------------------------------------------------------------*/
299/*---------------------------------------------------------------------------*/
307extern "C++" ARCANE_UTILS_EXPORT void
308copyHost(MutableMemoryView destination, ConstMemoryView source);
309
310/*---------------------------------------------------------------------------*/
311/*---------------------------------------------------------------------------*/
326extern "C++" ARCANE_UTILS_EXPORT void
327copyHostWithIndexedDestination(MutableMemoryView destination, ConstMemoryView source,
328 Span<const Int32> indexes);
329
330/*---------------------------------------------------------------------------*/
331/*---------------------------------------------------------------------------*/
351extern "C++" ARCANE_UTILS_EXPORT void
352copyWithIndexedDestination(MutableMemoryView destination, ConstMemoryView source,
353 SmallSpan<const Int32> indexes, RunQueue* run_queue = nullptr);
354
355/*---------------------------------------------------------------------------*/
356/*---------------------------------------------------------------------------*/
377extern "C++" ARCANE_UTILS_EXPORT void
378fillIndexed(MutableMemoryView destination, ConstMemoryView source,
379 SmallSpan<const Int32> indexes, const RunQueue* run_queue = nullptr);
380
381/*---------------------------------------------------------------------------*/
382/*---------------------------------------------------------------------------*/
402extern "C++" ARCANE_UTILS_EXPORT void
403fill(MutableMemoryView destination, ConstMemoryView source,
404 const RunQueue* run_queue = nullptr);
405
406/*---------------------------------------------------------------------------*/
407/*---------------------------------------------------------------------------*/
430extern "C++" ARCANE_UTILS_EXPORT void
431copyWithIndexedSource(MutableMemoryView destination, ConstMultiMemoryView source,
432 SmallSpan<const Int32> indexes, RunQueue* run_queue = nullptr);
433
434/*---------------------------------------------------------------------------*/
435/*---------------------------------------------------------------------------*/
458extern "C++" ARCANE_UTILS_EXPORT void
459copyWithIndexedDestination(MutableMultiMemoryView destination, ConstMemoryView source,
460 SmallSpan<const Int32> indexes, RunQueue* run_queue = nullptr);
461
462/*---------------------------------------------------------------------------*/
463/*---------------------------------------------------------------------------*/
487extern "C++" ARCANE_UTILS_EXPORT void
488fillIndexed(MutableMultiMemoryView destination, ConstMemoryView source,
489 SmallSpan<const Int32> indexes, RunQueue* run_queue = nullptr);
490
491/*---------------------------------------------------------------------------*/
492/*---------------------------------------------------------------------------*/
513extern "C++" ARCANE_UTILS_EXPORT void
514fill(MutableMultiMemoryView destination, ConstMemoryView source,
515 RunQueue* run_queue = nullptr);
516
517/*---------------------------------------------------------------------------*/
518/*---------------------------------------------------------------------------*/
519
520} // namespace Arcane::MemoryUtils
521
522/*---------------------------------------------------------------------------*/
523/*---------------------------------------------------------------------------*/
524
525#endif
Arcane::MemoryUtils::impl::computeCapacity
Int64 computeCapacity(Int64 size)
Calcule une capacité adaptée pour une taille de size.
Definition MemoryUtils.cc:199
Arcane::AbstractArray::capacity
Integer capacity() const
Capacité (nombre d'éléments alloués) du vecteur.
Definition arccore/src/collections/arccore/collections/Array.h:427
Arcane::AbstractArray::largeSize
Int64 largeSize() const
Nombre d'éléments du vecteur (en 64 bits)
Definition arccore/src/collections/arccore/collections/Array.h:429
Arcane::Accelerator::RunQueue
File d'exécution pour un accélérateur.
Definition core/RunQueue.h:52
Arcane::Array
Tableau d'items de types quelconques.
Definition AnyItemArray.h:55
Arcane::Array::resize
void resize(Int64 s)
Change le nombre d'éléments du tableau à s.
Definition arccore/src/collections/arccore/collections/Array.h:1213
Arcane::Array::reserve
void reserve(Int64 new_capacity)
Réserve le mémoire pour new_capacity éléments.
Definition arccore/src/collections/arccore/collections/Array.h:1239
Arcane::ConstMemoryView
Vue constante sur une zone mémoire contigue contenant des éléments de taille fixe.
Definition MemoryView.h:38
Arcane::ConstMultiMemoryView
Liste de vues constantes sur des zones mémoires contigues.
Definition MemoryView.h:259
Arcane::MutableMemoryView
Vue modifiable sur une zone mémoire contigue contenant des éléments de taille fixe.
Definition MemoryView.h:156
Arcane::MutableMultiMemoryView
Liste de vues modifiables sur des zones mémoires contigues.
Definition MemoryView.h:295
Arcane::SmallSpan
Vue d'un tableau d'éléments de type T.
Definition Span.h:673
Arcane::Span
Vue d'un tableau d'éléments de type T.
Definition Span.h:513
Arcane::MemoryUtils
Espace de noms pour les fonctions de gestion mémoire et des allocateurs.
Definition MemoryUtilsInternal.h:23
Arcane::MemoryUtils::fill
void fill(MutableMemoryView destination, ConstMemoryView source, const RunQueue *run_queue=nullptr)
Remplit une zone mémoire avec une valeur.
Definition MemoryView.cc:161
Arcane::MemoryUtils::getDeviceOrHostAllocator
IMemoryAllocator * getDeviceOrHostAllocator()
Retourne l'allocateur sur l'hôte ou sur le device.
Definition MemoryUtils.cc:130
Arcane::MemoryUtils::copyWithIndexedDestination
void copyWithIndexedDestination(MutableMemoryView destination, ConstMemoryView source, SmallSpan< const Int32 > indexes, RunQueue *run_queue=nullptr)
Copie mémoire avec indirection.
Definition MemoryView.cc:122
Arcane::MemoryUtils::getAllocatorForMostlyReadOnlyData
MemoryAllocationOptions getAllocatorForMostlyReadOnlyData()
Allocateur par défaut pour les données essentiellement en lecture.
Definition MemoryUtils.cc:170
Arcane::MemoryUtils::getAllocationOptions
MemoryAllocationOptions getAllocationOptions(eMemoryResource mem_resource)
Allocation par défaut pour la ressource mem_resource.
Definition MemoryUtils.cc:161
Arcane::MemoryUtils::getDefaultDataAllocator
IMemoryAllocator * getDefaultDataAllocator()
Allocateur par défaut pour les données.
Definition MemoryUtils.cc:121
Arcane::MemoryUtils::copyHostWithIndexedSource
void copyHostWithIndexedSource(MutableMemoryView destination, ConstMemoryView source, Span< const Int32 > indexes)
Copie sur l'hôte des données avec indirection.
Definition MemoryView.cc:175
Arcane::MemoryUtils::getMemoryResourceFromName
eMemoryResource getMemoryResourceFromName(const String &name)
Retourne la ressource mémoire par son nom.
Definition MemoryUtils.cc:73
Arcane::MemoryUtils::fillIndexed
void fillIndexed(MutableMemoryView destination, ConstMemoryView source, SmallSpan< const Int32 > indexes, const RunQueue *run_queue=nullptr)
Remplit une zone mémoire indexée avec une valeur.
Definition MemoryView.cc:142
Arcane::MemoryUtils::checkResizeArrayWithCapacity
Int32 checkResizeArrayWithCapacity(Array< DataType > &array, Int64 new_size, bool force_resize)
Redimensionne un tableau en ajoutant une réserve de mémoire.
Definition MemoryUtils.h:174
Arcane::MemoryUtils::copyHostWithIndexedDestination
void copyHostWithIndexedDestination(MutableMemoryView destination, ConstMemoryView source, Span< const Int32 > indexes)
Copie dans l'instance les données indexées de v.
Definition MemoryView.cc:112
Arcane::MemoryUtils::copyHost
void copyHost(MutableMemoryView destination, ConstMemoryView source)
Copie dans destination les données de source.
Definition MemoryView.cc:90
Arcane::MemoryUtils::getAcceleratorHostMemoryAllocator
IMemoryAllocator * getAcceleratorHostMemoryAllocator()
Allocateur spécifique pour les accélérateurs.
Definition MemoryUtils.cc:179
Arcane::MemoryUtils::getAllocator
IMemoryAllocator * getAllocator(eMemoryResource mem_resource)
Allocateur par défaut pour la ressource mem_resource.
Definition MemoryUtils.cc:152
Arcane::MemoryUtils::getDefaultDataMemoryResource
eMemoryResource getDefaultDataMemoryResource()
Ressource mémoire utilisée par l'allocateur par défaut pour les données.
Definition MemoryUtils.cc:55
Arcane::MemoryUtils::copy
void copy(MutableMemoryView destination, eMemoryResource destination_mem, ConstMemoryView source, eMemoryResource source_mem, const RunQueue *queue=nullptr)
Copie de source vers destination en utilisant la file queue.
Definition MemoryUtils.cc:214
Arcane::MemoryUtils::copyWithIndexedSource
void copyWithIndexedSource(MutableMemoryView destination, ConstMemoryView source, SmallSpan< const Int32 > indexes, RunQueue *run_queue=nullptr)
Copie sur l'hôte des données avec indirection.
Definition MemoryView.cc:185
Arcane::asWritableBytes
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
Arcane::Int64
std::int64_t Int64
Type entier signé sur 64 bits.
Definition ArccoreGlobal.h:186
Arcane::eMemoryLocationHint
eMemoryLocationHint
Indices sur la localisation mémoire attendue.
Definition CollectionsGlobal.h:87
Arcane::asBytes
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
Arcane::eMemoryResource
eMemoryResource
Liste des ressources mémoire disponibles.
Definition CollectionsGlobal.h:133
Arcane::eMemoryResource::Unknown
@ Unknown
Valeur inconnue ou non initialisée.
Definition CollectionsGlobal.h:135
Arcane::Int32
std::int32_t Int32
Type entier signé sur 32 bits.
Definition ArccoreGlobal.h:184