alpaka/AccGpuUniformCudaHipRt_8hpp_source.html

/* Copyright 2026 Benjamin Worpitz, René Widera, Jan Stephan, Andrea Bocci, Bernhard Manfred Gruber, Antonio Di Pilato

 * SPDX-License-Identifier: MPL-2.0

 */


#pragma once


// Base classes.

#include "alpaka/atomic/AtomicHierarchy.hpp"

#include "alpaka/atomic/AtomicUniformCudaHipBuiltIn.hpp"

#include "alpaka/block/shared/dyn/BlockSharedMemDynUniformCudaHipBuiltIn.hpp"

#include "alpaka/block/shared/st/BlockSharedMemStUniformCudaHipBuiltIn.hpp"

#include "alpaka/block/sync/BlockSyncUniformCudaHipBuiltIn.hpp"

#include "alpaka/core/DemangleTypeNames.hpp"

#include "alpaka/grid/GridSyncGpuCudaHip.hpp"

#include "alpaka/idx/bt/IdxBtUniformCudaHipBuiltIn.hpp"

#include "alpaka/idx/gb/IdxGbUniformCudaHipBuiltIn.hpp"

#include "alpaka/intrinsic/IntrinsicUniformCudaHipBuiltIn.hpp"

#include "alpaka/math/MathUniformCudaHipBuiltIn.hpp"

#include "alpaka/mem/fence/MemFenceUniformCudaHipBuiltIn.hpp"

#include "alpaka/rand/RandDefault.hpp"

#include "alpaka/rand/RandUniformCudaHipRand.hpp"

#include "alpaka/warp/WarpUniformCudaHipBuiltIn.hpp"

#include "alpaka/workdiv/WorkDivUniformCudaHipBuiltIn.hpp"


// Specialized traits.

#include "alpaka/acc/Traits.hpp"

#include "alpaka/dev/Traits.hpp"

#include "alpaka/idx/Traits.hpp"

#include "alpaka/kernel/Traits.hpp"

#include "alpaka/platform/Traits.hpp"


// Implementation details.

#include "alpaka/core/ClipCast.hpp"

#include "alpaka/core/Cuda.hpp"

#include "alpaka/core/Interface.hpp"

#include "alpaka/dev/DevUniformCudaHipRt.hpp"


#ifdef __cpp_lib_format

#    include <format>

#endif

#include <string>


#if defined(ALPAKA_ACC_GPU_CUDA_ENABLED) || defined(ALPAKA_ACC_GPU_HIP_ENABLED)


namespace alpaka

{

    template<

        typename TApi,

        typename TAcc,

        typename TDim,

        typename TIdx,

        typename TKernelFnObj,

        bool TCooperative,

        typename... TArgs>

    class TaskKernelGpuUniformCudaHipRt;


    //! The GPU CUDA accelerator.

    //!

    //! This accelerator allows parallel kernel execution on devices supporting CUDA.

    template<typename TApi, typename TDim, typename TIdx>


    class AccGpuUniformCudaHipRt final

        : public WorkDivUniformCudaHipBuiltIn<TDim, TIdx>

        , public gb::IdxGbUniformCudaHipBuiltIn<TDim, TIdx>

        , public bt::IdxBtUniformCudaHipBuiltIn<TDim, TIdx>

        , public AtomicHierarchy<

              AtomicUniformCudaHipBuiltIn, // grid atomics

              AtomicUniformCudaHipBuiltIn, // block atomics

              AtomicUniformCudaHipBuiltIn> // thread atomics

        , public math::MathUniformCudaHipBuiltIn

        , public BlockSharedMemDynUniformCudaHipBuiltIn

        , public BlockSharedMemStUniformCudaHipBuiltIn

        , public BlockSyncUniformCudaHipBuiltIn

        , public GridSyncCudaHipBuiltIn

        , public IntrinsicUniformCudaHipBuiltIn

        , public MemFenceUniformCudaHipBuiltIn

#    ifdef ALPAKA_DISABLE_VENDOR_RNG

        , public rand::RandDefault

#    else

        , public rand::RandUniformCudaHipRand<TApi>

#    endif

        , public warp::WarpUniformCudaHipBuiltIn

        , public interface::Implements<InterfaceAcc, AccGpuUniformCudaHipRt<TApi, TDim, TIdx>>

    {

        static_assert(

            sizeof(TIdx) >= sizeof(int),

            "Index type is not supported, consider using int or a larger type.");


    public:

        AccGpuUniformCudaHipRt(AccGpuUniformCudaHipRt const&) = delete;

        AccGpuUniformCudaHipRt(AccGpuUniformCudaHipRt&&) = delete;

        auto operator=(AccGpuUniformCudaHipRt const&) -> AccGpuUniformCudaHipRt& = delete;

        auto operator=(AccGpuUniformCudaHipRt&&) -> AccGpuUniformCudaHipRt& = delete;


        ALPAKA_FN_HOST_ACC AccGpuUniformCudaHipRt(Vec<TDim, TIdx> const& threadElemExtent)

            : WorkDivUniformCudaHipBuiltIn<TDim, TIdx>(threadElemExtent)

        {

        }


    };


    namespace trait

    {

        //! The GPU CUDA accelerator accelerator type trait specialization.

        template<typename TApi, typename TDim, typename TIdx>


        struct AccType<AccGpuUniformCudaHipRt<TApi, TDim, TIdx>>

        {

            using type = AccGpuUniformCudaHipRt<TApi, TDim, TIdx>;

        };


        //! The GPU CUDA single thread accelerator type trait specialization.

        template<typename TApi, typename TDim, typename TIdx>


        struct IsSingleThreadAcc<AccGpuUniformCudaHipRt<TApi, TDim, TIdx>> : std::false_type

        {

        };


        //! The GPU CUDA multi thread accelerator type trait specialization.

        template<typename TApi, typename TDim, typename TIdx>


        struct IsMultiThreadAcc<AccGpuUniformCudaHipRt<TApi, TDim, TIdx>> : std::true_type

        {

        };


        //! The GPU CUDA accelerator device properties get trait specialization.

        template<typename TApi, typename TDim, typename TIdx>


        struct GetAccDevProps<AccGpuUniformCudaHipRt<TApi, TDim, TIdx>>

        {


            ALPAKA_FN_HOST static auto getAccDevProps(DevUniformCudaHipRt<TApi> const& dev) -> AccDevProps<TDim, TIdx>

            {

#    ifdef ALPAKA_ACC_GPU_CUDA_ENABLED

                // Reading only the necessary attributes with cudaDeviceGetAttribute is faster than reading all with

                // cuda https://devblogs.nvidia.com/cuda-pro-tip-the-fast-way-to-query-device-properties/

                int multiProcessorCount = {};

                ALPAKA_UNIFORM_CUDA_HIP_RT_CHECK(TApi::deviceGetAttribute(

                    &multiProcessorCount,

                    TApi::deviceAttributeMultiprocessorCount,

                    dev.getNativeHandle()));


                int maxGridSize[3] = {};

                ALPAKA_UNIFORM_CUDA_HIP_RT_CHECK(TApi::deviceGetAttribute(

                    &maxGridSize[0],

                    TApi::deviceAttributeMaxGridDimX,

                    dev.getNativeHandle()));

                ALPAKA_UNIFORM_CUDA_HIP_RT_CHECK(TApi::deviceGetAttribute(

                    &maxGridSize[1],

                    TApi::deviceAttributeMaxGridDimY,

                    dev.getNativeHandle()));

                ALPAKA_UNIFORM_CUDA_HIP_RT_CHECK(TApi::deviceGetAttribute(

                    &maxGridSize[2],

                    TApi::deviceAttributeMaxGridDimZ,

                    dev.getNativeHandle()));


                int maxBlockDim[3] = {};

                ALPAKA_UNIFORM_CUDA_HIP_RT_CHECK(TApi::deviceGetAttribute(

                    &maxBlockDim[0],

                    TApi::deviceAttributeMaxBlockDimX,

                    dev.getNativeHandle()));

                ALPAKA_UNIFORM_CUDA_HIP_RT_CHECK(TApi::deviceGetAttribute(

                    &maxBlockDim[1],

                    TApi::deviceAttributeMaxBlockDimY,

                    dev.getNativeHandle()));

                ALPAKA_UNIFORM_CUDA_HIP_RT_CHECK(TApi::deviceGetAttribute(

                    &maxBlockDim[2],

                    TApi::deviceAttributeMaxBlockDimZ,

                    dev.getNativeHandle()));


                int maxThreadsPerBlock = {};

                ALPAKA_UNIFORM_CUDA_HIP_RT_CHECK(TApi::deviceGetAttribute(

                    &maxThreadsPerBlock,

                    TApi::deviceAttributeMaxThreadsPerBlock,

                    dev.getNativeHandle()));


                int sharedMemSizeBytes = {};

                ALPAKA_UNIFORM_CUDA_HIP_RT_CHECK(TApi::deviceGetAttribute(

                    &sharedMemSizeBytes,

                    TApi::deviceAttributeMaxSharedMemoryPerBlock,

                    dev.getNativeHandle()));


                int cooperativeLaunch = {};

                ALPAKA_UNIFORM_CUDA_HIP_RT_CHECK(TApi::deviceGetAttribute(

                    &cooperativeLaunch,

                    TApi::deviceAttributeCooperativeLaunch,

                    dev.getNativeHandle()));


                return {// m_multiProcessorCount

                        alpaka::core::clipCast<TIdx>(multiProcessorCount),

                        // m_gridBlockExtentMax

                        getExtentVecEnd<TDim>(Vec<DimInt<3u>, TIdx>(

                            alpaka::core::clipCast<TIdx>(maxGridSize[2u]),

                            alpaka::core::clipCast<TIdx>(maxGridSize[1u]),

                            alpaka::core::clipCast<TIdx>(maxGridSize[0u]))),

                        // m_gridBlockCountMax

                        std::numeric_limits<TIdx>::max(),

                        // m_blockThreadExtentMax

                        getExtentVecEnd<TDim>(Vec<DimInt<3u>, TIdx>(

                            alpaka::core::clipCast<TIdx>(maxBlockDim[2u]),

                            alpaka::core::clipCast<TIdx>(maxBlockDim[1u]),

                            alpaka::core::clipCast<TIdx>(maxBlockDim[0u]))),

                        // m_blockThreadCountMax

                        alpaka::core::clipCast<TIdx>(maxThreadsPerBlock),

                        // m_threadElemExtentMax

                        Vec<TDim, TIdx>::all(std::numeric_limits<TIdx>::max()),

                        // m_threadElemCountMax

                        std::numeric_limits<TIdx>::max(),

                        // m_sharedMemSizeBytes

                        static_cast<size_t>(sharedMemSizeBytes),

                        // m_globalMemSizeBytes

                        getMemBytes(dev),

                        // m_cooperativeLaunch

                        static_cast<bool>(cooperativeLaunch)};


#    else

                typename TApi::DeviceProp_t properties;

                ALPAKA_UNIFORM_CUDA_HIP_RT_CHECK(TApi::getDeviceProperties(&properties, dev.getNativeHandle()));


                return {// m_multiProcessorCount

                        alpaka::core::clipCast<TIdx>(properties.multiProcessorCount),

                        // m_gridBlockExtentMax

                        getExtentVecEnd<TDim>(Vec<DimInt<3u>, TIdx>(

                            alpaka::core::clipCast<TIdx>(properties.maxGridSize[2u]),

                            alpaka::core::clipCast<TIdx>(properties.maxGridSize[1u]),

                            alpaka::core::clipCast<TIdx>(properties.maxGridSize[0u]))),

                        // m_gridBlockCountMax

                        std::numeric_limits<TIdx>::max(),

                        // m_blockThreadExtentMax

                        getExtentVecEnd<TDim>(Vec<DimInt<3u>, TIdx>(

                            alpaka::core::clipCast<TIdx>(properties.maxThreadsDim[2u]),

                            alpaka::core::clipCast<TIdx>(properties.maxThreadsDim[1u]),

                            alpaka::core::clipCast<TIdx>(properties.maxThreadsDim[0u]))),

                        // m_blockThreadCountMax

                        alpaka::core::clipCast<TIdx>(properties.maxThreadsPerBlock),

                        // m_threadElemExtentMax

                        Vec<TDim, TIdx>::all(std::numeric_limits<TIdx>::max()),

                        // m_threadElemCountMax

                        std::numeric_limits<TIdx>::max(),

                        // m_sharedMemSizeBytes

                        static_cast<size_t>(properties.sharedMemPerBlock),

                        // m_globalMemSizeBytes

                        getMemBytes(dev),

                        // m_cooperativeLaunch

                        static_cast<bool>(properties.cooperativeLaunch)};

#    endif

            }


        };


        //! The GPU CUDA accelerator name trait specialization.

        template<typename TApi, typename TDim, typename TIdx>


        struct GetAccName<AccGpuUniformCudaHipRt<TApi, TDim, TIdx>>

        {


            ALPAKA_FN_HOST static auto getAccName() -> std::string

            {

#    if ALPAKA_COMP_CLANG

#        pragma clang diagnostic push

#        pragma clang diagnostic ignored "-Wexit-time-destructors"

#    endif

                using namespace std::literals;

                static std::string const accName =

#    ifdef __cpp_lib_format

                    std::format("AccGpu{}Rt<{},{}>", TApi::name, TDim::value, core::demangled<TIdx>);

#    else

                    "AccGpu"s + TApi::name + "Rt<"s + std::to_string(TDim::value) + ","s

                    + std::string(core::demangled<TIdx>) + ">"s;

#    endif

                return accName;

#    if ALPAKA_COMP_CLANG

#        pragma clang diagnostic pop

#    endif

            }


        };


        //! The GPU CUDA accelerator device type trait specialization.

        template<typename TApi, typename TDim, typename TIdx>


        struct DevType<AccGpuUniformCudaHipRt<TApi, TDim, TIdx>>

        {

            using type = DevUniformCudaHipRt<TApi>;

        };


        //! The GPU CUDA accelerator dimension getter trait specialization.

        template<typename TApi, typename TDim, typename TIdx>


        struct DimType<AccGpuUniformCudaHipRt<TApi, TDim, TIdx>>

        {

            using type = TDim;

        };


    } // namespace trait


    namespace trait

    {

        //! The GPU CUDA accelerator execution task type trait specialization.

        template<

            typename TApi,

            typename TDim,

            typename TIdx,

            typename TWorkDiv,

            typename TKernelFnObj,

            typename... TArgs>


        struct CreateTaskKernel<AccGpuUniformCudaHipRt<TApi, TDim, TIdx>, TWorkDiv, TKernelFnObj, TArgs...>

        {


            ALPAKA_FN_HOST static auto createTaskKernel(

                TWorkDiv const& workDiv,

                TKernelFnObj const& kernelFnObj,

                TArgs&&... args)

            {

                return TaskKernelGpuUniformCudaHipRt<

                    TApi,

                    AccGpuUniformCudaHipRt<TApi, TDim, TIdx>,

                    TDim,

                    TIdx,

                    TKernelFnObj,

                    false,

                    TArgs...>(workDiv, kernelFnObj, std::forward<TArgs>(args)...);

            }


        };


        //! The GPU CUDA accelerator execution cooperative task type trait specialization.

        template<

            typename TApi,

            typename TDim,

            typename TIdx,

            typename TWorkDiv,

            typename TKernelFnObj,

            typename... TArgs>


        struct CreateTaskCooperativeKernel<AccGpuUniformCudaHipRt<TApi, TDim, TIdx>, TWorkDiv, TKernelFnObj, TArgs...>

        {


            ALPAKA_FN_HOST static auto createTaskCooperativeKernel(

                TWorkDiv const& workDiv,

                TKernelFnObj const& kernelFnObj,

                TArgs&&... args)

            {

                return TaskKernelGpuUniformCudaHipRt<

                    TApi,

                    AccGpuUniformCudaHipRt<TApi, TDim, TIdx>,

                    TDim,

                    TIdx,

                    TKernelFnObj,

                    true,

                    TArgs...>(workDiv, kernelFnObj, std::forward<TArgs>(args)...);

            }


        };


        //! The CPU CUDA execution task platform type trait specialization.

        template<typename TApi, typename TDim, typename TIdx>


        struct PlatformType<AccGpuUniformCudaHipRt<TApi, TDim, TIdx>>

        {

            using type = PlatformUniformCudaHipRt<TApi>;

        };


        //! The GPU CUDA accelerator idx type trait specialization.

        template<typename TApi, typename TDim, typename TIdx>


        struct IdxType<AccGpuUniformCudaHipRt<TApi, TDim, TIdx>>

        {

            using type = TIdx;

        };


    } // namespace trait

} // namespace alpaka


#endif

AtomicHierarchy.hpp

AtomicUniformCudaHipBuiltIn.hpp

BlockSharedMemDynUniformCudaHipBuiltIn.hpp

BlockSharedMemStUniformCudaHipBuiltIn.hpp

BlockSyncUniformCudaHipBuiltIn.hpp

ClipCast.hpp

Cuda.hpp

DemangleTypeNames.hpp

DevUniformCudaHipRt.hpp

GridSyncGpuCudaHip.hpp

IdxBtUniformCudaHipBuiltIn.hpp

IdxGbUniformCudaHipBuiltIn.hpp

Interface.hpp

IntrinsicUniformCudaHipBuiltIn.hpp

MathUniformCudaHipBuiltIn.hpp

MemFenceUniformCudaHipBuiltIn.hpp

RandDefault.hpp

RandUniformCudaHipRand.hpp

ALPAKA_UNIFORM_CUDA_HIP_RT_CHECK
#define ALPAKA_UNIFORM_CUDA_HIP_RT_CHECK(cmd)
CUDA/HIP runtime error checking with log and exception.
Definition UniformCudaHip.hpp:105

WarpUniformCudaHipBuiltIn.hpp

WorkDivUniformCudaHipBuiltIn.hpp

Traits.hpp

alpaka::AccGpuUniformCudaHipRt
The GPU CUDA accelerator.
Definition AccGpuUniformCudaHipRt.hpp:83

alpaka::AccGpuUniformCudaHipRt::AccGpuUniformCudaHipRt
ALPAKA_FN_HOST_ACC AccGpuUniformCudaHipRt(Vec< TDim, TIdx > const &threadElemExtent)
Definition AccGpuUniformCudaHipRt.hpp:94

alpaka::AccGpuUniformCudaHipRt::operator=
auto operator=(AccGpuUniformCudaHipRt &&) -> AccGpuUniformCudaHipRt &=delete

alpaka::AccGpuUniformCudaHipRt::AccGpuUniformCudaHipRt
AccGpuUniformCudaHipRt(AccGpuUniformCudaHipRt const &)=delete

alpaka::AccGpuUniformCudaHipRt::AccGpuUniformCudaHipRt
AccGpuUniformCudaHipRt(AccGpuUniformCudaHipRt &&)=delete

alpaka::AccGpuUniformCudaHipRt::operator=
auto operator=(AccGpuUniformCudaHipRt const &) -> AccGpuUniformCudaHipRt &=delete

alpaka::BlockSharedMemDynUniformCudaHipBuiltIn
The GPU CUDA/HIP block shared memory allocator.
Definition BlockSharedMemDynUniformCudaHipBuiltIn.hpp:21

alpaka::BlockSharedMemStUniformCudaHipBuiltIn
The GPU CUDA/HIP block shared memory allocator.
Definition BlockSharedMemStUniformCudaHipBuiltIn.hpp:21

alpaka::BlockSyncUniformCudaHipBuiltIn
The GPU CUDA/HIP block synchronization.
Definition BlockSyncUniformCudaHipBuiltIn.hpp:18

alpaka::DevUniformCudaHipRt
The CUDA/HIP RT device handle.
Definition QueueUniformCudaHipRt.hpp:35

alpaka::GridSyncCudaHipBuiltIn
The GPU CUDA/HIP grid synchronization.
Definition GridSyncGpuCudaHip.hpp:37

alpaka::IntrinsicUniformCudaHipBuiltIn
The GPU CUDA/HIP intrinsic.
Definition IntrinsicUniformCudaHipBuiltIn.hpp:18

alpaka::MemFenceUniformCudaHipBuiltIn
The GPU CUDA/HIP memory fence.
Definition MemFenceUniformCudaHipBuiltIn.hpp:21

alpaka::TaskKernelGpuUniformCudaHipRt
The GPU CUDA/HIP accelerator execution task.
Definition TaskKernelGpuUniformCudaHipRt.hpp:139

alpaka::Vec
A n-dimensional vector.
Definition Vec.hpp:38

alpaka::Vec::all
ALPAKA_NO_HOST_ACC_WARNING static ALPAKA_FN_HOST_ACC constexpr auto all(TVal const &val) -> Vec< TDim, TVal >
Single value constructor.
Definition Vec.hpp:89

alpaka::WorkDivUniformCudaHipBuiltIn
The GPU CUDA/HIP accelerator work division.
Definition WorkDivUniformCudaHipBuiltIn.hpp:23

alpaka::bt::IdxBtUniformCudaHipBuiltIn
The CUDA/HIP accelerator ND index provider.
Definition IdxBtUniformCudaHipBuiltIn.hpp:26

alpaka::gb::IdxGbUniformCudaHipBuiltIn
The CUDA/HIP accelerator ND index provider.
Definition IdxGbUniformCudaHipBuiltIn.hpp:26

alpaka::math::MathUniformCudaHipBuiltIn
The standard library math trait specializations.
Definition MathUniformCudaHipBuiltIn.hpp:262

alpaka::meta::InheritFromList
Definition InheritFromList.hpp:10

alpaka::rand::RandDefault
Definition RandDefault.hpp:19

alpaka::rand::RandUniformCudaHipRand
The CUDA/HIP rand implementation.
Definition RandUniformCudaHipRand.hpp:42

ALPAKA_FN_HOST
#define ALPAKA_FN_HOST
Definition Common.hpp:43

ALPAKA_FN_HOST_ACC
#define ALPAKA_FN_HOST_ACC
Definition Common.hpp:42

Traits.hpp

Traits.hpp

Traits.hpp

alpaka::core::demangled
constexpr std::string_view demangled
Definition DemangleTypeNames.hpp:111

alpaka::core::clipCast
auto clipCast(V const &val) -> T
Definition ClipCast.hpp:16

alpaka
The alpaka accelerator library.
Definition AccCpuOmp2Blocks.hpp:54

alpaka::getMemBytes
ALPAKA_FN_HOST auto getMemBytes(TDev const &dev) -> std::size_t
Definition Traits.hpp:102

alpaka::getExtentVecEnd
ALPAKA_NO_HOST_ACC_WARNING ALPAKA_FN_HOST_ACC constexpr auto getExtentVecEnd(T const &object={}) -> Vec< TDim, Idx< T > >
Definition Traits.hpp:78

alpaka::DimInt
std::integral_constant< std::size_t, N > DimInt
Definition DimIntegralConst.hpp:15

Traits.hpp

alpaka::AccDevProps
The acceleration properties on a device.
Definition AccDevProps.hpp:18

alpaka::PlatformUniformCudaHipRt
The CUDA/HIP RT platform.
Definition QueueUniformCudaHipRt.hpp:38

alpaka::interface::Implements
Tag used in class inheritance hierarchies that describes that a specific interface (TInterface) is im...
Definition Interface.hpp:15

alpaka::trait::AccType
The accelerator type trait.
Definition Traits.hpp:42

alpaka::trait::CreateTaskCooperativeKernel< AccGpuUniformCudaHipRt< TApi, TDim, TIdx >, TWorkDiv, TKernelFnObj, TArgs... >::createTaskCooperativeKernel
static ALPAKA_FN_HOST auto createTaskCooperativeKernel(TWorkDiv const &workDiv, TKernelFnObj const &kernelFnObj, TArgs &&... args)
Definition AccGpuUniformCudaHipRt.hpp:321

alpaka::trait::CreateTaskCooperativeKernel
The cooperative kernel execution task creation trait.
Definition Traits.hpp:46

alpaka::trait::CreateTaskKernel< AccGpuUniformCudaHipRt< TApi, TDim, TIdx >, TWorkDiv, TKernelFnObj, TArgs... >::createTaskKernel
static ALPAKA_FN_HOST auto createTaskKernel(TWorkDiv const &workDiv, TKernelFnObj const &kernelFnObj, TArgs &&... args)
Definition AccGpuUniformCudaHipRt.hpp:295

alpaka::trait::CreateTaskKernel
The kernel execution task creation trait.
Definition Traits.hpp:37

alpaka::trait::DevType
The device type trait.
Definition Traits.hpp:23

alpaka::trait::DimType< AccGpuUniformCudaHipRt< TApi, TDim, TIdx > >::type
TDim type
Definition AccGpuUniformCudaHipRt.hpp:279

alpaka::trait::DimType
The dimension getter type trait.
Definition Traits.hpp:14

alpaka::trait::GetAccDevProps< AccGpuUniformCudaHipRt< TApi, TDim, TIdx > >::getAccDevProps
static ALPAKA_FN_HOST auto getAccDevProps(DevUniformCudaHipRt< TApi > const &dev) -> AccDevProps< TDim, TIdx >
Definition AccGpuUniformCudaHipRt.hpp:125

alpaka::trait::GetAccDevProps
The device properties get trait.
Definition Traits.hpp:66

alpaka::trait::GetAccName< AccGpuUniformCudaHipRt< TApi, TDim, TIdx > >::getAccName
static ALPAKA_FN_HOST auto getAccName() -> std::string
Definition AccGpuUniformCudaHipRt.hpp:247

alpaka::trait::GetAccName
The accelerator name trait.
Definition Traits.hpp:73

alpaka::trait::IdxType< AccGpuUniformCudaHipRt< TApi, TDim, TIdx > >::type
TIdx type
Definition AccGpuUniformCudaHipRt.hpp:348

alpaka::trait::IdxType
The idx type trait.
Definition Traits.hpp:25

alpaka::trait::IsMultiThreadAcc
The multi thread accelerator trait.
Definition Traits.hpp:61

alpaka::trait::IsSingleThreadAcc
The single thread accelerator trait.
Definition Traits.hpp:51

alpaka::trait::PlatformType
The platform type trait.
Definition Traits.hpp:38

alpaka::warp::WarpUniformCudaHipBuiltIn
The GPU CUDA/HIP warp.
Definition WarpUniformCudaHipBuiltIn.hpp:20