14#include "arcane/accelerator/core/Runner.h"
16#include "arcane/utils/FatalErrorException.h"
17#include "arcane/utils/NotImplementedException.h"
18#include "arcane/utils/ArgumentException.h"
19#include "arcane/utils/MemoryView.h"
20#include "arcane/utils/ValueConvert.h"
21#include "arcane/utils/Profiling.h"
22#include "arcane/utils/internal/ProfilingInternal.h"
24#include "arcane/accelerator/core/RunQueueBuildInfo.h"
25#include "arcane/accelerator/core/DeviceId.h"
26#include "arcane/accelerator/core/DeviceMemoryInfo.h"
27#include "arcane/accelerator/core/IDeviceInfoList.h"
28#include "arcane/accelerator/core/PointerAttribute.h"
29#include "arcane/accelerator/core/KernelLaunchArgs.h"
30#include "arcane/accelerator/core/internal/IRunnerRuntime.h"
31#include "arcane/accelerator/core/internal/AcceleratorCoreGlobalInternal.h"
32#include "arcane/accelerator/core/internal/RunQueueImpl.h"
33#include "arcane/accelerator/core/internal/RunnerImpl.h"
51 return impl::getSYCLRunQueueRuntime();
53 return impl::getHIPRunQueueRuntime();
55 return impl::getCUDARunQueueRuntime();
57 return impl::getSequentialRunQueueRuntime();
59 return impl::getThreadRunQueueRuntime();
67 auto* x = _getRuntimeNoCheck(p);
69 ARCANE_FATAL(
"No runtime is available for execution policy '{0}'", p);
76 auto* x = _getRuntimeNoCheck(p);
83 auto* x = _getRuntimeNoCheck(p);
96namespace Arcane::Accelerator::impl
108 ARCANE_THROW(ArgumentException,
"executionPolicy should not be eExecutionPolicy::None");
109 if (device.isHost() || device.isNull())
110 ARCANE_THROW(ArgumentException,
"device should not be Device::hostDevice() or Device::nullDevice()");
112 m_execution_policy = v;
113 m_device_id = device;
114 m_runtime = _getRuntime(v);
115 m_device_info = m_runtime->deviceInfoList()->deviceInfo(m_device_id.asInt32());
124 m_run_queue_pool.initialize(runner->_impl());
134 ARCANE_FATAL(
"Runner is not initialized. Call method initialize() before");
143 RunQueueImplStack& s = m_run_queue_pool;
145 RunQueueImpl* q = s.top();
146 RunQueueImpl::_destroy(q);
157 return &m_run_queue_pool;
166 RunnerImpl::Lock my_lock(
this);
173impl::RunQueueImpl* RunnerImpl::
174_internalCreateOrGetRunQueueImpl()
178 auto pool = getPool();
181 impl::RunnerImpl::Lock my_lock(
this);
182 if (!pool->empty()) {
183 impl::RunQueueImpl* p = pool->top();
189 return pool->createRunQueue(RunQueueBuildInfo{});
195impl::RunQueueImpl* RunnerImpl::
196_internalCreateOrGetRunQueueImpl(
const RunQueueBuildInfo& bi)
202 return _internalCreateOrGetRunQueueImpl();
203 impl::IRunnerRuntime* runtime = m_runtime;
205 auto* queue =
new impl::RunQueueImpl(
this, 0, bi);
213createRunQueue(
const RunQueueBuildInfo& bi)
217 Int32 x = ++m_nb_created;
218 auto* q =
new impl::RunQueueImpl(m_runner_impl, x, bi);
219 q->m_is_in_pool =
true;
230 return m_runtime->createEventImpl();
237_createEventWithTimer()
240 return m_runtime->createEventImplWithTimer();
251namespace Arcane::Accelerator
262: m_p(std::make_shared<impl::RunnerImpl>())
293_internalRuntime()
const
296 return m_p->runtime();
305 return m_p->executionPolicy();
314 return m_p->isInit();
342 std::cout <<
"Warning: Runner::setDeviceReducePolicy(): only 'eDeviceReducePolicy::Grid' is supported\n";
351 return m_p->m_reduce_policy;
360 m_p->initialize(
this, v,
DeviceId());
369 m_p->initialize(
this, v, device_id);
379 ARCANE_FATAL(
"Runner is not initialized. Call method initialize() before");
388 return m_p->cumulativeCommandTime();
398 m_p->runtime()->setMemoryAdvice(buffer, advice, m_p->m_device_id);
408 m_p->runtime()->unsetMemoryAdvice(buffer, advice, m_p->m_device_id);
418 m_p->runtime()->setCurrentDevice(m_p->m_device_id);
427 return m_p->m_device_id;
442 if (device_id >= nb_device)
456 return r->deviceInfoList();
466 return m_p->runtime()->getDeviceMemoryInfo(
deviceId());
476 m_p->runtime()->getPointerAttribute(attr, ptr);
483_isAutoPrefetchCommand()
const
485 return m_p->isAutoPrefetchCommand();
494 return m_p->_internalApi();
531 m_runner_impl->runtime()->startProfiling();
540 m_runner_impl->runtime()->stopProfiling();
549 return m_runner_impl->runtime()->isProfilingActive();
583 return impl::RuntimeStaticInfo::getPointerAccessibility(runner->
executionPolicy(), ptr, ptr_attr);
586extern "C++" void impl::
587arcaneCheckPointerIsAccessible(
const Runner* runner,
const void* ptr,
592 return impl::RuntimeStaticInfo::checkPointerIsAcccessible(runner->
executionPolicy(), ptr, name, ti);
601void impl::IRunnerRuntime::
604 int device,
const void* pointer,
const void* device_pointer,
605 const void* host_pointer)
607 attribute =
PointerAttribute(mem_type, device, pointer, device_pointer, host_pointer);
613void impl::IRunnerRuntime::
622impl::KernelLaunchArgs impl::IRunnerRuntime::
623computeKernalLaunchArgs(
const KernelLaunchArgs& orig_args,
624 [[maybe_unused]]
const void* kernel_ptr,
625 [[maybe_unused]] Int64 total_loop_size,
626 [[maybe_unused]] Int32 wanted_shared_memory)
#define ARCANE_CHECK_POINTER(ptr)
Macro retournant le pointeur ptr s'il est non nul ou lancant une exception s'il est nul.
#define ARCANE_THROW(exception_class,...)
Macro pour envoyer une exception avec formattage.
#define ARCANE_FATAL(...)
Macro envoyant une exception FatalErrorException.
Identifiant d'un composant du système.
Int32 asInt32() const
Valeur numérique du device.
Information sur un device.
Information mémoire d'un accélérateur.
Interface d'une liste de devices.
virtual const DeviceInfo & deviceInfo(Int32 i) const =0
Informations du i-ème device.
virtual Int32 nbDevice() const =0
Nombre de device de la liste.
Informations sur une adresse mémoire.
static void finalize(ITraceMng *tm)
Finalise l'exécution.
void startProfiling()
Démarre le profiling pour le runtime associé
bool isProfilingActive()
Indique si le profiling est actif pour le runtime associé
static void stopAllProfiling()
Stoppe toutes les activités de profiling.
void stopProfiling()
Stoppe le profiling pour le runtime associé
void printProfilingInfos(std::ostream &o)
Affiche les informations de profiling.
Gestionnaire d'exécution pour accélérateur.
void fillPointerAttribute(PointerAttribute &attr, const void *ptr)
Remplit attr avec les informations concernant la zone mémoire pointée par ptr.
void setConcurrentQueueCreation(bool v)
Indique si on autorise la création de RunQueue depuis plusieurs threads.
static const IDeviceInfoList * deviceInfoList(eExecutionPolicy policy)
Liste des devices pour la politique d'exécution policy.
bool isInitialized() const
Indique si l'instance a été initialisée.
Runner()
Créé un gestionnaire d'exécution non initialisé.
RunnerInternal * _internalApi()
API interne à Arcane.
double cumulativeCommandTime() const
Temps total passé dans les commandes associées à cette instance.
bool isConcurrentQueueCreation() const
Indique si la création concurrent de plusieurs RunQueue est autorisé
DeviceId deviceId() const
Device associé à cette instance.
void setDeviceReducePolicy(eDeviceReducePolicy v)
Positionne la politique d'exécution des réductions.
const DeviceInfo & deviceInfo() const
Information sur le device associé à cette instance.
DeviceMemoryInfo deviceMemoryInfo() const
Information sur le device associé à cette instance.
void initialize(eExecutionPolicy v)
Initialise l'instance. Cette méthode ne doit être appelée qu'une seule fois.
void setAsCurrentDevice()
Positionne le device associé à cette instance comme le device par défaut du contexte.
eDeviceReducePolicy deviceReducePolicy() const
politique d'exécution des réductions
void setMemoryAdvice(ConstMemoryView buffer, eMemoryAdvice advice)
Positionne un conseil sur la gestion d'une zone mémoire.
void unsetMemoryAdvice(ConstMemoryView buffer, eMemoryAdvice advice)
Supprime un conseil sur la gestion d'une zone mémoire.
eExecutionPolicy executionPolicy() const
Politique d'exécution associée.
Interface de l'implémentation d'un évènement.
Interface du runtime associé à un accélérateur.
File d'exécution pour accélérateur.
bool m_is_auto_prefetch_command
Indique si on pré-copie les données avant une commande de cette RunQueue.
Vue constante sur une zone mémoire contigue contenant des éléments de taille fixe.
static std::optional< Int32 > tryParseFromEnvironment(StringView s, bool throw_if_invalid)
Interface du gestionnaire de traces.
static void visitAcceleratorStat(const std::function< void(const impl::AcceleratorStatInfoList &)> &f)
Visite la liste des statistiques sur accélérateur.
Statistiques pour les accélérateurs.
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.
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.
ePointerAccessibility
Informations d'accessibilité d'une adresse mémoire.
@ Unknown
Accessibilité inconnue.
eMemoryAdvice
Conseils pour la gestion mémoire.
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.
std::int32_t Int32
Type entier signé sur 32 bits.