CommonAcceleratorGlobal.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2026 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* AcceleratorCoreGlobal.h                                     (C) 2000-2026 */
/*                                                                           */
/* General declarations for accelerator support.                             */
/*---------------------------------------------------------------------------*/
#ifndef ARCCORE_COMMON_ACCELERATOR_COMMONACCELERATORCOREGLOBAL_H
#define ARCCORE_COMMON_ACCELERATOR_COMMONACCELERATORCOREGLOBAL_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arccore/common/CommonGlobal.h"
#include "arccore/trace/TraceGlobal.h"
 
#include <iosfwd>

 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane::Accelerator
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
class IAcceleratorMng;
class Runner;
class RunQueue;
class RunQueuePool;
class RunCommand;
class RunQueueEvent;
class AcceleratorRuntimeInitialisationInfo;
class RunQueueBuildInfo;
class MemoryCopyArgs;
class MemoryPrefetchArgs;
class DeviceId;
class DeviceInfo;
class DeviceMemoryInfo;
class ProfileRegion;
class IDeviceInfoList;
class PointerAttribute;
class ViewBuildInfo;
class RunnerInternal;
enum class eMemoryAdvice;
 
namespace Impl
{
  class RuntimeStaticInfo;
  class IRunnerRuntime;
  // typedef for compatibility with older versions (October 2022)
  using IRunQueueRuntime = IRunnerRuntime;
  class IRunQueueStream;
  class RunCommandImpl;
  class IReduceMemoryImpl;
  class ReduceMemoryImpl;
  class RunQueueImpl;
  class IRunQueueEventImpl;
  class RunnerImpl;
  class RunQueueImplStack;
  class KernelLaunchArgs;
  class RunCommandLaunchInfo;
  class NativeStream;
  class CudaUtils;
  class HipUtils;
  class SyclUtils;
} // namespace Impl
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

enum class eExecutionPolicy
{
  None,
  Sequential,
  Thread,
  CUDA,
  HIP,
  SYCL
};

extern "C++" ARCCORE_COMMON_EXPORT
std::ostream&
operator<<(std::ostream& o, eExecutionPolicy exec_policy);
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

enum class eDeviceReducePolicy
{
  Atomic ARCCORE_DEPRECATED_REASON("Y2025: Use eDeviceReducePolicy::Grid instead") = 1,
  Grid = 2
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

enum class eRunQueuePriority : int
{
  Default = 0,
  High = -100,
  Low = 100
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

enum class ePointerMemoryType
{
  //NOTE: The values are equivalent to cudaMemoryType. If
  // these values are changed, the corresponding function
  // in the runtime (getPointerAttribute()) must be changed.
  Unregistered = 0,
  Host = 1,
  Device = 2,
  Managed = 3
};

extern "C++" ARCCORE_COMMON_EXPORT
std::ostream&
operator<<(std::ostream& o, ePointerMemoryType mem_type);
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

enum class ePointerAccessibility
{
  Unknown = 0,
  No = 1,
  Yes = 2
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

inline bool
isAcceleratorPolicy(eExecutionPolicy exec_policy)
{
  return exec_policy == eExecutionPolicy::CUDA || exec_policy == eExecutionPolicy::HIP || exec_policy == eExecutionPolicy::SYCL;
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

extern "C++" ARCCORE_COMMON_EXPORT ePointerAccessibility
getPointerAccessibility(RunQueue* queue, const void* ptr, PointerAttribute* ptr_attr = nullptr);

extern "C++" ARCCORE_COMMON_EXPORT ePointerAccessibility
getPointerAccessibility(Runner* runner, const void* ptr, PointerAttribute* ptr_attr = nullptr);

extern "C++" ARCCORE_COMMON_EXPORT ePointerAccessibility
getPointerAccessibility(eExecutionPolicy policy, const void* ptr, PointerAttribute* ptr_attr = nullptr);

template <typename T> inline ePointerAccessibility
getPointerAccessibility(T& queue_or_runner_or_policy, const void* ptr, PointerAttribute* ptr_attr = nullptr)
{
  return getPointerAccessibility(&queue_or_runner_or_policy, ptr, ptr_attr);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane::Accelerator
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane::Accelerator::Impl
{

extern "C++" ARCCORE_COMMON_EXPORT void
arcaneCheckPointerIsAccessible(const RunQueue* queue, const void* ptr,
                               const char* name, const TraceInfo& ti);

extern "C++" ARCCORE_COMMON_EXPORT void
arcaneCheckPointerIsAccessible(const Runner* runner, const void* ptr,
                               const char* name, const TraceInfo& ti);

extern "C++" ARCCORE_COMMON_EXPORT void
arcaneCheckPointerIsAccessible(eExecutionPolicy policy, const void* ptr,
                               const char* name, const TraceInfo& ti);
 
inline void
arcaneCheckPointerIsAccessible(const RunQueue& queue, const void* ptr,
                               const char* name, const TraceInfo& ti)
{
  arcaneCheckPointerIsAccessible(&queue, ptr, name, ti);
}
 
inline void
arcaneCheckPointerIsAccessible(const Runner& runner, const void* ptr,
                               const char* name, const TraceInfo& ti)
{
  arcaneCheckPointerIsAccessible(&runner, ptr, name, ti);
}
 
} // namespace Arcane::Accelerator::Impl
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

#define ARCCORE_CHECK_ACCESSIBLE_POINTER_ALWAYS(queue_or_runner_or_policy, ptr) \
  ::Arcane::Accelerator::Impl::arcaneCheckPointerIsAccessible((queue_or_runner_or_policy), (ptr), #ptr, A_FUNCINFO)
 
#define ARCANE_CHECK_ACCESSIBLE_POINTER_ALWAYS(queue_or_runner_or_policy, ptr) \
  ARCANE_CHECK_ACCESSIBLE_POINTER_ALWAYS((queue_or_runner_or_policy), (ptr))
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#if defined(ARCCORE_CHECK)

#define ARCCORE_CHECK_ACCESSIBLE_POINTER(queue_or_runner_or_policy, ptr) \
  ARCCORE_CHECK_ACCESSIBLE_POINTER_ALWAYS((queue_or_runner_or_policy), (ptr))
 
#define ARCANE_CHECK_ACCESSIBLE_POINTER(queue_or_runner_or_policy, ptr) \
  ARCCORE_CHECK_ACCESSIBLE_POINTER((queue_or_runner_or_policy), (ptr))

#else

#define ARCCORE_CHECK_ACCESSIBLE_POINTER(queue_or_runner_or_policy, ptr)
 
#define ARCANE_CHECK_ACCESSIBLE_POINTER(queue_or_runner_or_policy, ptr)
 
#endif
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane::Accelerator::impl
{
 
// For compatibility with older versions of Arcane.
// To be deprecated by the end of 2026.
using Arcane::Accelerator::isAcceleratorPolicy;
} // namespace Arcane::Accelerator::impl
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif