Arcane  v3.16.0.0
Documentation développeur
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-2024 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-2024 */
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
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;
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;
79 class RunnerImpl;
81 class NativeStream;
82 class CudaUtils;
83 class HipUtils;
84 class SyclUtils;
85} // namespace impl
86
87/*---------------------------------------------------------------------------*/
88/*---------------------------------------------------------------------------*/
107
109extern "C++" ARCANE_ACCELERATOR_CORE_EXPORT
110std::ostream&
111operator<<(std::ostream& o, eExecutionPolicy exec_policy);
112
113/*---------------------------------------------------------------------------*/
114/*---------------------------------------------------------------------------*/
119{
124};
125
126/*---------------------------------------------------------------------------*/
127/*---------------------------------------------------------------------------*/
132enum class eRunQueuePriority : int
133{
137 High = -100,
139 Low = 100
140};
141
142/*---------------------------------------------------------------------------*/
143/*---------------------------------------------------------------------------*/
144
147{
148 //NOTE: Les valeurs sont équivalentes à cudaMemoryType. Si on
149 // change ces valeurs il faut changer la fonction correspondante
150 // dans le runtime (getPointerAttribute()).
151 Unregistered = 0,
152 Host = 1,
153 Device = 2,
154 Managed = 3
155};
156
158extern "C++" ARCANE_ACCELERATOR_CORE_EXPORT
159std::ostream&
160operator<<(std::ostream& o, ePointerMemoryType mem_type);
161
162/*---------------------------------------------------------------------------*/
163/*---------------------------------------------------------------------------*/
173{
177 No = 1,
179 Yes = 2
180};
181
182/*---------------------------------------------------------------------------*/
183/*---------------------------------------------------------------------------*/
184
186inline bool
188{
189 return exec_policy == eExecutionPolicy::CUDA || exec_policy == eExecutionPolicy::HIP || exec_policy == eExecutionPolicy::SYCL;
190}
191
192/*---------------------------------------------------------------------------*/
193/*---------------------------------------------------------------------------*/
201extern "C++" ARCANE_ACCELERATOR_CORE_EXPORT ePointerAccessibility
202getPointerAccessibility(RunQueue* queue, const void* ptr, PointerAttribute* ptr_attr = nullptr);
203
211extern "C++" ARCANE_ACCELERATOR_CORE_EXPORT ePointerAccessibility
212getPointerAccessibility(Runner* runner, const void* ptr, PointerAttribute* ptr_attr = nullptr);
213
220extern "C++" ARCANE_ACCELERATOR_CORE_EXPORT ePointerAccessibility
221getPointerAccessibility(eExecutionPolicy policy, const void* ptr, PointerAttribute* ptr_attr = nullptr);
222
224template <typename T> inline ePointerAccessibility
225getPointerAccessibility(T& queue_or_runner_or_policy, const void* ptr, PointerAttribute* ptr_attr = nullptr)
226{
227 return getPointerAccessibility(&queue_or_runner_or_policy, ptr, ptr_attr);
228}
229
230/*---------------------------------------------------------------------------*/
231/*---------------------------------------------------------------------------*/
232
233} // namespace Arcane::Accelerator
234
235/*---------------------------------------------------------------------------*/
236/*---------------------------------------------------------------------------*/
237
238namespace Arcane::Accelerator::impl
239{
241
247extern "C++" ARCANE_ACCELERATOR_CORE_EXPORT void
248arcaneCheckPointerIsAccessible(const RunQueue* queue, const void* ptr,
249 const char* name, const TraceInfo& ti);
250
256extern "C++" ARCANE_ACCELERATOR_CORE_EXPORT void
257arcaneCheckPointerIsAccessible(const Runner* runner, const void* ptr,
258 const char* name, const TraceInfo& ti);
259
265extern "C++" ARCANE_ACCELERATOR_CORE_EXPORT void
266arcaneCheckPointerIsAccessible(eExecutionPolicy policy, const void* ptr,
267 const char* name, const TraceInfo& ti);
268
269inline void
270arcaneCheckPointerIsAccessible(const RunQueue& queue, const void* ptr,
271 const char* name, const TraceInfo& ti)
272{
273 arcaneCheckPointerIsAccessible(&queue, ptr, name, ti);
274}
275
276inline void
277arcaneCheckPointerIsAccessible(const Runner& runner, const void* ptr,
278 const char* name, const TraceInfo& ti)
279{
280 arcaneCheckPointerIsAccessible(&runner, ptr, name, ti);
281}
282
283} // namespace Arcane::Accelerator::impl
284
285/*---------------------------------------------------------------------------*/
286/*---------------------------------------------------------------------------*/
292#define ARCANE_CHECK_ACCESSIBLE_POINTER_ALWAYS(queue_or_runner_or_policy, ptr) \
293 ::Arcane::Accelerator::impl::arcaneCheckPointerIsAccessible((queue_or_runner_or_policy), (ptr), #ptr, A_FUNCINFO)
294
295/*---------------------------------------------------------------------------*/
296/*---------------------------------------------------------------------------*/
297
298#ifdef ARCANE_CHECK
300#define ARCANE_CHECK_ACCESSIBLE_POINTER(queue_or_runner_or_policy, ptr) \
301 ARCANE_CHECK_ACCESSIBLE_POINTER_ALWAYS((queue_or_runner_or_policy), (ptr))
302#else
304#define ARCANE_CHECK_ACCESSIBLE_POINTER(queue_or_runner_or_policy, ptr)
305#endif
306
307/*---------------------------------------------------------------------------*/
308/*---------------------------------------------------------------------------*/
309
310#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.
Interface de la gestion mémoire pour les réductions.
Interface de l'implémentation d'un évènement.
Interface d'un flux d'exécution pour une RunQueue.
Interface du runtime associé à un accélérateur.
Arguments pour lancer un kernel.
Type opaque pour encapsuler une 'stream' native.
Implémentation d'une commande pour accélérateur.
Object temporaire pour conserver les informations d'exécution d'une commande et regrouper les tests.
File d'exécution pour accélérateur.
Classe statique fournissant des fonctions internes à Arcane.
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.