Arcane  v3.16.9.0
Documentation utilisateur
Chargement...
Recherche...
Aucune correspondance
AcceleratorCoreGlobal.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/* AcceleratorCoreGlobal.h (C) 2000-2025 */
9/* */
10/* Déclarations générales pour le support des accélérateurs. */
11/*---------------------------------------------------------------------------*/
12#ifndef ARCANE_ACCELERATOR_CORE_ACCELERATORCOREGLOBAL_H
13#define ARCANE_ACCELERATOR_CORE_ACCELERATORCOREGLOBAL_H
14/*---------------------------------------------------------------------------*/
15/*---------------------------------------------------------------------------*/
16
18
19#include <iosfwd>
20
21/*!
22 * \file AcceleratorCoreGlobal.h
23 *
24 * Ce fichier contient les déclarations des types de la composante
25 * 'arcane_accelerator_core'.
26 */
27/*---------------------------------------------------------------------------*/
28/*---------------------------------------------------------------------------*/
29
30#ifdef ARCANE_COMPONENT_arcane_accelerator_core
31#define ARCANE_ACCELERATOR_CORE_EXPORT ARCANE_EXPORT
32#else
33#define ARCANE_ACCELERATOR_CORE_EXPORT ARCANE_IMPORT
34#endif
35
36/*---------------------------------------------------------------------------*/
37/*---------------------------------------------------------------------------*/
38
39namespace Arcane::Accelerator
40{
41
42/*---------------------------------------------------------------------------*/
43/*---------------------------------------------------------------------------*/
44
45class IAcceleratorMng;
46class Runner;
47class RunQueue;
48class RunQueuePool;
49class RunCommand;
50class RunQueueEvent;
53class MemoryCopyArgs;
55class DeviceId;
56class DeviceInfo;
58class ProfileRegion;
59class IDeviceInfoList;
61class ViewBuildInfo;
62class RunnerInternal;
63enum class eMemoryAdvice;
64
65namespace impl
66{
67 class KernelLaunchArgs;
68 class RuntimeStaticInfo;
69 class IRunnerRuntime;
70 // typedef pour compatibilité avec anciennes versions (octobre 2022)
71 using IRunQueueRuntime = IRunnerRuntime;
72 class IRunQueueStream;
73 class RunCommandImpl;
75 class ReduceMemoryImpl;
76 class RunQueueImpl;
77 class IRunQueueEventImpl;
79 class RunnerImpl;
80 class RunQueueImplStack;
81 class NativeStream;
82 class CudaUtils;
83 class HipUtils;
84 class SyclUtils;
85} // namespace impl
86
87/*---------------------------------------------------------------------------*/
88/*---------------------------------------------------------------------------*/
89/*!
90 * \brief Politique d'exécution pour un Runner.
91 */
93{
94 //! Aucune politique d'exécution
96 //! Politique d'exécution séquentielle
98 //! Politique d'exécution multi-thread
100 //! Politique d'exécution utilisant l'environnement CUDA
102 //! Politique d'exécution utilisant l'environnement HIP
104 //! Politique d'exécution utilisant l'environnement SYCL
106};
107
108//! Affiche le nom de la politique d'exécution
109extern "C++" ARCANE_ACCELERATOR_CORE_EXPORT
110std::ostream&
111operator<<(std::ostream& o, eExecutionPolicy exec_policy);
112
113/*---------------------------------------------------------------------------*/
114/*---------------------------------------------------------------------------*/
115/*!
116 * \brief Politique des opératations de réduction sur les accélérateurs.
117 *
118 * \note A partir de la version 3.15 de Arcane, seule la politique Grid
119 * est disponible.
120 */
122{
123 /*!
124 * \brief Utilise des opérations atomiques entre les blocs.
125 *
126 * \deprecated Cette politique n'est plus disponible. Si on
127 * spécifie cette politique, elle se comportera comme
128 * eDeviceReducePolicy::Grid.
129 */
130 Atomic ARCANE_DEPRECATED_REASON("Y2025: Use eDeviceReducePolicy::Grid instead") = 1,
131 //! Utilise un noyau de calcul avec une synchronisations entre les blocs.
133};
134
135/*---------------------------------------------------------------------------*/
136/*---------------------------------------------------------------------------*/
137/*!
138 * \brief Niveaux de priorité prédéfinis pour les files d'exécution
139 * sur les accélérateurs
140 */
141enum class eRunQueuePriority : int
142{
143 //! Utilise 0 comme valeur par défaut
145 //! Une valeur arbitraire négative pour définir une priorité élevée
146 High = -100,
147 //! Une valeur arbitraire positive pour définir une priorité faible
148 Low = 100
149};
150
151/*---------------------------------------------------------------------------*/
152/*---------------------------------------------------------------------------*/
153
154//! Type de mémoire pour un pointeur
156{
157 //NOTE: Les valeurs sont équivalentes à cudaMemoryType. Si on
158 // change ces valeurs il faut changer la fonction correspondante
159 // dans le runtime (getPointerAttribute()).
160 Unregistered = 0,
161 Host = 1,
162 Device = 2,
163 Managed = 3
164};
165
166//! Affiche le nom du type de mémoire
167extern "C++" ARCANE_ACCELERATOR_CORE_EXPORT
168std::ostream&
169operator<<(std::ostream& o, ePointerMemoryType mem_type);
170
171/*---------------------------------------------------------------------------*/
172/*---------------------------------------------------------------------------*/
173/*!
174 * \brief Informations d'accessibilité d'une adresse mémoire.
175 *
176 * Indique si une adresse mémoire est accessible sur un accélérateur ou
177 * sur le CPU.
178 *
179 * \sa getPointerAccessibility()
180 */
182{
183 //! Accessibilité inconnue
185 //! Non accessible
186 No = 1,
187 //! Accessible
188 Yes = 2
189};
190
191/*---------------------------------------------------------------------------*/
192/*---------------------------------------------------------------------------*/
193
194//! Indique si \a exec_policy correspond à un accélérateur
195inline bool
197{
198 return exec_policy == eExecutionPolicy::CUDA || exec_policy == eExecutionPolicy::HIP || exec_policy == eExecutionPolicy::SYCL;
199}
200
201/*---------------------------------------------------------------------------*/
202/*---------------------------------------------------------------------------*/
203/*!
204 * \brief Accessibilité de l'adresse \a ptr pour une exécution sur la file \a queue.
205 *
206 * Si \a queue est nul, retourne ePointerAccessibility::Unknown.
207 * Si \a ptr_attr est non nul, il sera remplit avec les informations du pointeur
208 * comme si on avait appelé Runner::fillPointerAttribute().
209 */
210extern "C++" ARCANE_ACCELERATOR_CORE_EXPORT ePointerAccessibility
211getPointerAccessibility(RunQueue* queue, const void* ptr, PointerAttribute* ptr_attr = nullptr);
212
213/*!
214 * \brief Accessibilité de l'adresse \a ptr pour une exécution sur \a runner.
215 *
216 * Si \a runner est nul, retourne ePointerAccessibility::Unknown.
217 * Si \a ptr_attr est non nul, il sera remplit avec les informations du pointeur
218 * comme si on avait appelé Runner::fillPointerAttribute().
219 */
220extern "C++" ARCANE_ACCELERATOR_CORE_EXPORT ePointerAccessibility
221getPointerAccessibility(Runner* runner, const void* ptr, PointerAttribute* ptr_attr = nullptr);
222
223/*!
224 * \brief Accessibilité de l'adresse \a ptr pour une politique d'exécution\a policy.
225 *
226 * Si \a ptr_attr est non nul, il sera remplit avec les informations du pointeur
227 * comme si on avait appelé Runner::fillPointerAttribute().
228 */
229extern "C++" ARCANE_ACCELERATOR_CORE_EXPORT ePointerAccessibility
230getPointerAccessibility(eExecutionPolicy policy, const void* ptr, PointerAttribute* ptr_attr = nullptr);
231
232//! Accessibilité de l'adresse \a ptr pour une exécution sur \a queue_or_runner_or_policy.
233template <typename T> inline ePointerAccessibility
234getPointerAccessibility(T& queue_or_runner_or_policy, const void* ptr, PointerAttribute* ptr_attr = nullptr)
235{
236 return getPointerAccessibility(&queue_or_runner_or_policy, ptr, ptr_attr);
237}
238
239/*---------------------------------------------------------------------------*/
240/*---------------------------------------------------------------------------*/
241
242} // namespace Arcane::Accelerator
243
244/*---------------------------------------------------------------------------*/
245/*---------------------------------------------------------------------------*/
246
247namespace Arcane::Accelerator::impl
248{
250
251/*!
252 * \brief Vérifie si \a ptr est accessible pour une exécution sur \a queue.
253 *
254 * Lève une exception FatalErrorException si ce n'est pas le cas.
255 */
256extern "C++" ARCANE_ACCELERATOR_CORE_EXPORT void
257arcaneCheckPointerIsAccessible(const RunQueue* queue, const void* ptr,
258 const char* name, const TraceInfo& ti);
259
260/*!
261 * \brief Vérifie si \a ptr est accessible pour une exécution sur \a runner.
262 *
263 * Lève une exception FatalErrorException si ce n'est pas le cas.
264 */
265extern "C++" ARCANE_ACCELERATOR_CORE_EXPORT void
266arcaneCheckPointerIsAccessible(const Runner* runner, const void* ptr,
267 const char* name, const TraceInfo& ti);
268
269/*!
270 * \brief Vérifie si \a ptr est accessible pour une exécution \a policy.
271 *
272 * Lève une exception FatalErrorException si ce n'est pas le cas.
273 */
274extern "C++" ARCANE_ACCELERATOR_CORE_EXPORT void
275arcaneCheckPointerIsAccessible(eExecutionPolicy policy, const void* ptr,
276 const char* name, const TraceInfo& ti);
277
278inline void
279arcaneCheckPointerIsAccessible(const RunQueue& queue, const void* ptr,
280 const char* name, const TraceInfo& ti)
281{
282 arcaneCheckPointerIsAccessible(&queue, ptr, name, ti);
283}
284
285inline void
286arcaneCheckPointerIsAccessible(const Runner& runner, const void* ptr,
287 const char* name, const TraceInfo& ti)
288{
289 arcaneCheckPointerIsAccessible(&runner, ptr, name, ti);
290}
291
292} // namespace Arcane::Accelerator::impl
293
294/*---------------------------------------------------------------------------*/
295/*---------------------------------------------------------------------------*/
296/*!
297 * \brief Macro qui vérifie si \a ptr est accessible pour une RunQueue ou un Runner.
298 *
299 * Lance une exception si ce n'est pas le cas.
300 */
301#define ARCANE_CHECK_ACCESSIBLE_POINTER_ALWAYS(queue_or_runner_or_policy, ptr) \
302 ::Arcane::Accelerator::impl::arcaneCheckPointerIsAccessible((queue_or_runner_or_policy), (ptr), #ptr, A_FUNCINFO)
303
304/*---------------------------------------------------------------------------*/
305/*---------------------------------------------------------------------------*/
306
307#ifdef ARCANE_CHECK
308//! Macro qui vérifie en mode check si \a ptr est accessible pour une RunQueue ou un Runner.
309#define ARCANE_CHECK_ACCESSIBLE_POINTER(queue_or_runner_or_policy, ptr) \
310 ARCANE_CHECK_ACCESSIBLE_POINTER_ALWAYS((queue_or_runner_or_policy), (ptr))
311#else
312//! Macro qui vérifie en mode check si \a ptr est accessible pour une RunQueue ou un Runner.
313#define ARCANE_CHECK_ACCESSIBLE_POINTER(queue_or_runner_or_policy, ptr)
314#endif
315
316/*---------------------------------------------------------------------------*/
317/*---------------------------------------------------------------------------*/
318
319#endif
void arcaneCheckPointerIsAccessible(const RunQueue *queue, const void *ptr, const char *name, const TraceInfo &ti)
Vérifie si ptr est accessible pour une exécution sur queue.
Definition RunQueue.cc:403
Déclarations des types utilisés dans Arcane.
Identifiant d'un composant du système.
Definition DeviceId.h:33
Information sur un device.
Definition DeviceInfo.h:32
Information mémoire d'un accélérateur.
Interface du gestionnaire des accélérateurs.
Interface d'une liste de devices.
Arguments pour la copie mémoire.
Definition Memory.h:63
Arguments pour le préfetching mémoire.
Definition Memory.h:125
Informations sur une adresse mémoire.
Région pour le profiling.
Gestion d'une commande sur accélérateur.
Informations pour créer une RunQueue.
Evènement pour une file d'exécution.
Collection de RunQueue.
File d'exécution pour un accélérateur.
Gestionnaire d'exécution pour accélérateur.
Definition core/Runner.h:68
Informations pour construire une vue pour les données sur accélérateur.
Type opaque pour encapsuler une 'stream' native.
Espace de nom pour l'utilisation des accélérateurs.
ePointerAccessibility getPointerAccessibility(eExecutionPolicy policy, const void *ptr, PointerAttribute *ptr_attr)
Accessibilité de l'adresse ptr pour une politique d'exécutionpolicy.
std::ostream & operator<<(std::ostream &o, eExecutionPolicy exec_policy)
Affiche le nom de la politique d'exécution.
eDeviceReducePolicy
Politique des opératations de réduction sur les accélérateurs.
@ Grid
Utilise un noyau de calcul avec une synchronisations entre les blocs.
@ Atomic
Utilise des opérations atomiques entre les blocs.
ePointerAccessibility
Informations d'accessibilité d'une adresse mémoire.
eMemoryAdvice
Conseils pour la gestion mémoire.
Definition Memory.h:36
ePointerMemoryType
Type de mémoire pour un pointeur.
eExecutionPolicy
Politique d'exécution pour un Runner.
@ SYCL
Politique d'exécution utilisant l'environnement SYCL.
@ HIP
Politique d'exécution utilisant l'environnement HIP.
@ None
Aucune politique d'exécution.
@ CUDA
Politique d'exécution utilisant l'environnement CUDA.
@ Sequential
Politique d'exécution séquentielle.
@ Thread
Politique d'exécution multi-thread.
eRunQueuePriority
Niveaux de priorité prédéfinis pour les files d'exécution sur les accélérateurs.
@ Low
Une valeur arbitraire positive pour définir une priorité faible.
@ High
Une valeur arbitraire négative pour définir une priorité élevée.
@ Default
Utilise 0 comme valeur par défaut.
bool isAcceleratorPolicy(eExecutionPolicy exec_policy)
Indique si exec_policy correspond à un accélérateur.