cms::alpakatools Namespace Reference

Namespaces
	config
	detail
	impl
	traits

Classes
class	CachingAllocator
struct	CopyToDevice
struct	CopyToDevice< cms::alpakatest::AlpakaESTestDataB< alpaka_common::DevHost > >
struct	CopyToDevice< PortableHostCollection< TLayout > >
struct	CopyToHost
struct	CopyToHost< PortableDeviceCollection< TLayout, TDevice > >
class	elements_with_stride
class	elements_with_stride_nd
class	EventCache
class	QueueCache
struct	requires_single_thread_per_block
class	ScopedContextAcquire
class	ScopedContextAnalyze
class	ScopedContextProduce
class	ScopedContextTask

Typedefs
template<typename TDev , typename T , typename = std::enable_if_t<alpaka::isDevice<TDev>>>
using	const_device_buffer = alpaka::ViewConst< device_buffer< TDev, T > >
template<typename T >
using	const_host_buffer = alpaka::ViewConst< host_buffer< T > >
template<typename TDev , typename T , typename = std::enable_if_t<alpaka::isDevice<TDev>>>
using	device_buffer = typename detail::buffer_type< TDev, T >::type
template<typename TDev , typename T , typename = std::enable_if_t<alpaka::isDevice<TDev>>>
using	device_view = typename detail::view_type< TDev, T >::type
template<typename T >
using	host_buffer = typename detail::buffer_type< DevHost, T >::type
template<typename T >
using	host_view = typename detail::view_type< DevHost, T >::type

Enumerations
enum	AllocatorPolicy { AllocatorPolicy::Synchronous = 0, AllocatorPolicy::Asynchronous = 1, AllocatorPolicy::Caching = 2 }

Functions
template<typename TElem , typename TIdx , typename TExtent , typename TQueue , typename TDev , typename = std::enable_if_t<alpaka::isDevice<TDev> and alpaka::isQueue<TQueue>>>
ALPAKA_FN_HOST auto	allocCachedBuf (TDev const &dev, TQueue queue, TExtent const &extent=TExtent())
template<typename TPlatform , typename = std::enable_if_t<alpaka::isPlatform<TPlatform>>>
alpaka::Dev< TPlatform > const &	chooseDevice (edm::StreamID id)
template<typename TPlatform , typename = std::enable_if_t<alpaka::isPlatform<TPlatform>>>
std::vector< alpaka::Dev< TPlatform > > const &	devices ()
constexpr Idx	divide_up_by (Idx value, Idx divisor)
template<typename TDev , typename TQueue , typename = std::enable_if_t<alpaka::isDevice<TDev> and alpaka::isQueue<TQueue>>>
CachingAllocator< TDev, TQueue > &	getDeviceCachingAllocator (TDev const &device)
template<typename Event >
EventCache< Event > &	getEventCache ()
template<typename TQueue , typename = std::enable_if_t<alpaka::isQueue<TQueue>>>
CachingAllocator< alpaka_common::DevHost, TQueue > &	getHostCachingAllocator ()
template<typename Queue >
QueueCache< Queue > &	getQueueCache ()
alpaka::DevCpu const &	host ()
template<typename T , typename TDev >
std::enable_if_t< alpaka::isDevice< TDev > and not std::is_array_v< T >, device_buffer< TDev, T > >	make_device_buffer (TDev const &device)
template<typename T , typename TDev >
std::enable_if_t< alpaka::isDevice< TDev > and cms::is_unbounded_array_v< T > and not std::is_array_v< std::remove_extent_t< T > >, device_buffer< TDev, T > >	make_device_buffer (TDev const &device, Extent extent)
template<typename T , typename TDev >
std::enable_if_t< alpaka::isDevice< TDev > and cms::is_bounded_array_v< T > and not std::is_array_v< std::remove_extent_t< T > >, device_buffer< TDev, T > >	make_device_buffer (TDev const &device)
template<typename T , typename TQueue >
std::enable_if_t< alpaka::isQueue< TQueue > and not std::is_array_v< T >, device_buffer< alpaka::Dev< TQueue >, T > >	make_device_buffer (TQueue const &queue)
template<typename T , typename TQueue >
std::enable_if_t< alpaka::isQueue< TQueue > and cms::is_unbounded_array_v< T > and not std::is_array_v< std::remove_extent_t< T > >, device_buffer< alpaka::Dev< TQueue >, T > >	make_device_buffer (TQueue const &queue, Extent extent)
template<typename T , typename TQueue >
std::enable_if_t< alpaka::isQueue< TQueue > and cms::is_bounded_array_v< T > and not std::is_array_v< std::remove_extent_t< T > >, device_buffer< alpaka::Dev< TQueue >, T > >	make_device_buffer (TQueue const &queue)
template<typename T , typename TDev >
std::enable_if_t< not std::is_array_v< T >, device_view< TDev, T > >	make_device_view (TDev const &device, T &data)
template<typename T , typename TDev >
device_view< TDev, T[]>	make_device_view (TDev const &device, T *data, Extent extent)
template<typename T , typename TDev >
std::enable_if_t< cms::is_unbounded_array_v< T > and not std::is_array_v< std::remove_extent_t< T > >, device_view< TDev, T > >	make_device_view (TDev const &device, T &data, Extent extent)
template<typename T , typename TDev >
std::enable_if_t< cms::is_bounded_array_v< T > and not std::is_array_v< std::remove_extent_t< T > >, device_view< TDev, T > >	make_device_view (TDev const &device, T &data)
template<typename T >
std::enable_if_t< not std::is_array_v< T >, host_buffer< T > >	make_host_buffer ()
template<typename T >
std::enable_if_t< cms::is_unbounded_array_v< T > and not std::is_array_v< std::remove_extent_t< T > >, host_buffer< T > >	make_host_buffer (Extent extent)
template<typename T >
std::enable_if_t< cms::is_bounded_array_v< T > and not std::is_array_v< std::remove_extent_t< T > >, host_buffer< T > >	make_host_buffer ()
template<typename T , typename TPlatform >
std::enable_if_t< not std::is_array_v< T >, host_buffer< T > >	make_host_buffer ()
template<typename T , typename TPlatform >
std::enable_if_t< cms::is_unbounded_array_v< T > and not std::is_array_v< std::remove_extent_t< T > >, host_buffer< T > >	make_host_buffer (Extent extent)
template<typename T , typename TPlatform >
std::enable_if_t< cms::is_bounded_array_v< T > and not std::is_array_v< std::remove_extent_t< T > >, host_buffer< T > >	make_host_buffer ()
template<typename T , typename TQueue >
std::enable_if_t< alpaka::isQueue< TQueue > and not std::is_array_v< T >, host_buffer< T > >	make_host_buffer (TQueue const &queue)
template<typename T , typename TQueue >
std::enable_if_t< alpaka::isQueue< TQueue > and cms::is_unbounded_array_v< T > and not std::is_array_v< std::remove_extent_t< T > >, host_buffer< T > >	make_host_buffer (TQueue const &queue, Extent extent)
template<typename T , typename TQueue >
std::enable_if_t< alpaka::isQueue< TQueue > and cms::is_bounded_array_v< T > and not std::is_array_v< std::remove_extent_t< T > >, host_buffer< T > >	make_host_buffer (TQueue const &queue)
template<typename T >
std::enable_if_t< not std::is_array_v< T >, host_view< T > >	make_host_view (T &data)
template<typename T >
host_view< T[]>	make_host_view (T *data, Extent extent)
template<typename T >
std::enable_if_t< cms::is_unbounded_array_v< T > and not std::is_array_v< std::remove_extent_t< T > >, host_view< T > >	make_host_view (T &data, Extent extent)
template<typename T >
std::enable_if_t< cms::is_bounded_array_v< T > and not std::is_array_v< std::remove_extent_t< T > >, host_view< T > >	make_host_view (T &data)
template<typename TAcc , typename = std::enable_if_t<alpaka::isAccelerator<TAcc> and alpaka::Dim<TAcc>::value == 1>>
WorkDiv< Dim1D >	make_workdiv (Idx blocks, Idx elements)
template<typename TAcc , typename = std::enable_if_t<alpaka::isAccelerator<TAcc>>>
WorkDiv< alpaka::Dim< TAcc > >	make_workdiv (const Vec< alpaka::Dim< TAcc >> &blocks, const Vec< alpaka::Dim< TAcc >> &elements)
void	module_backend_config (edm::ConfigurationDescriptions &iDesc)
constexpr Idx	round_up_by (Idx value, Idx divisor)

Variables
template<typename TDev , typename = std::enable_if_t<alpaka::isDevice<TDev>>>
constexpr AllocatorPolicy	allocator_policy = AllocatorPolicy::Synchronous
template<typename TAcc , typename = std::enable_if_t<alpaka::isAccelerator<TAcc>>>
constexpr bool	requires_single_thread_per_block_v = requires_single_thread_per_block<TAcc>::value

Typedef Documentation

const_device_buffer

template<typename TDev , typename T , typename = std::enable_if_t<alpaka::isDevice<TDev>>>

using cms::alpakatools::const_device_buffer = typedef alpaka::ViewConst<device_buffer<TDev, T> >

Definition at line 172 of file memory.h.

const_host_buffer

template<typename T >

using cms::alpakatools::const_host_buffer = typedef alpaka::ViewConst<host_buffer<T> >

Definition at line 59 of file memory.h.

device_buffer

template<typename TDev , typename T , typename = std::enable_if_t<alpaka::isDevice<TDev>>>

using cms::alpakatools::device_buffer = typedef typename detail::buffer_type<TDev, T>::type

Definition at line 169 of file memory.h.

device_view

template<typename TDev , typename T , typename = std::enable_if_t<alpaka::isDevice<TDev>>>

using cms::alpakatools::device_view = typedef typename detail::view_type<TDev, T>::type

Definition at line 249 of file memory.h.

host_buffer

template<typename T >

using cms::alpakatools::host_buffer = typedef typename detail::buffer_type<DevHost, T>::type

Definition at line 56 of file memory.h.

host_view

template<typename T >

using cms::alpakatools::host_view = typedef typename detail::view_type<DevHost, T>::type

Definition at line 142 of file memory.h.

Enumeration Type Documentation

AllocatorPolicy

enum cms::alpakatools::AllocatorPolicy

strong

Enumerator
Synchronous
Asynchronous
Caching

Definition at line 14 of file AllocatorPolicy.h.

{ Synchronous = 0, Asynchronous = 1, Caching = 2 };

Function Documentation

allocCachedBuf()

template<typename TElem , typename TIdx , typename TExtent , typename TQueue , typename TDev , typename = std::enable_if_t<alpaka::isDevice<TDev> and alpaka::isQueue<TQueue>>>

ALPAKA_FN_HOST auto cms::alpakatools::allocCachedBuf	(	TDev const &	dev,
		TQueue	queue,
		TExtent const &	extent = TExtent()
	)

Definition at line 197 of file CachedBufAlloc.h.

References createBeamHaloJobs::queue.

                                                                                                       {
    return traits::CachedBufAlloc<TElem, alpaka::Dim<TExtent>, TIdx, TDev, TQueue>::allocCachedBuf(dev, queue, extent);
  }

chooseDevice()

template<typename TPlatform , typename = std::enable_if_t<alpaka::isPlatform<TPlatform>>>

alpaka::Dev<TPlatform> const& cms::alpakatools::chooseDevice

(

edm::StreamID

id

)

Definition at line 16 of file chooseDevice.h.

References cms::Exception::addContext(), and devices().

                                                           {
    edm::Service<ALPAKA_TYPE_ALIAS(AlpakaService)> service;
    if (not service->enabled()) {
      cms::Exception ex("RuntimeError");
      ex << "Unable to choose current device because " << ALPAKA_TYPE_ALIAS_NAME(AlpakaService) << " is disabled.\n"
         << "If " << ALPAKA_TYPE_ALIAS_NAME(AlpakaService) << " was not explicitly disabled in the configuration,\n"
         << "the probable cause is that there is no accelerator or there is some problem\n"
         << "with the accelerator runtime or drivers.";
      ex.addContext("Calling cms::alpakatools::chooseDevice()");
      throw ex;
    }

    // For startes we "statically" assign the device based on
    // edm::Stream number. This is suboptimal if the number of
    // edm::Streams is not a multiple of the number of devices
    // (and even then there is no load balancing).

    // TODO: improve the "assignment" logic
    auto const& devices = cms::alpakatools::devices<TPlatform>();
    return devices[id % devices.size()];
  }

devices()

template<typename TPlatform , typename = std::enable_if_t<alpaka::isPlatform<TPlatform>>>

std::vector<alpaka::Dev<TPlatform> > const& cms::alpakatools::devices ( )

inline

Definition at line 35 of file devices.h.

Referenced by cms::alpakatools::detail::allocate_device_allocators(), ALPAKA_ACCELERATOR_NAMESPACE::AlpakaService::AlpakaService(), SiStripFedCablingBuilderFromDb::buildFecCabling(), ALPAKA_ACCELERATOR_NAMESPACE::detail::chooseDevice(), chooseDevice(), FastFedCablingHistosUsingDb::connections(), cms::alpakatools::detail::enumerate_devices(), getDeviceCachingAllocator(), SiStripConfigDb::printDeviceDescriptions(), ALPAKA_ACCELERATOR_NAMESPACE::ESProducer::setWhatProducedDevice(), cms::cudatest::testDevices(), cms::rocmtest::testDevices(), ApvTimingHistosUsingDb::update(), OptoScanHistosUsingDb::update(), VpspScanHistosUsingDb::update(), LatencyHistosUsingDb::update(), CalibrationHistosUsingDb::update(), FineDelayHistosUsingDb::update(), VpspScanHistosUsingDb::uploadConfigurations(), ApvTimingHistosUsingDb::uploadConfigurations(), OptoScanHistosUsingDb::uploadConfigurations(), LatencyHistosUsingDb::uploadConfigurations(), CalibrationHistosUsingDb::uploadConfigurations(), and FineDelayHistosUsingDb::uploadConfigurations().

                                                          {
    static const auto devices = detail::enumerate_devices<TPlatform>();
    return devices;
  }

divide_up_by()

constexpr Idx cms::alpakatools::divide_up_by ( Idx  value, Idx  divisor  )

inline

Definition at line 19 of file workdivision.h.

Referenced by ALPAKA_ACCELERATOR_NAMESPACE::TestAlgo::fill().

{ return (value + divisor - 1) / divisor; }

getDeviceCachingAllocator()

template<typename TDev , typename TQueue , typename = std::enable_if_t<alpaka::isDevice<TDev> and alpaka::isQueue<TQueue>>>

CachingAllocator<TDev, TQueue>& cms::alpakatools::getDeviceCachingAllocator ( TDev const &  device )

inline

Definition at line 78 of file getDeviceCachingAllocator.h.

References cms::cuda::assert(), CMS_THREAD_SAFE, devices(), and findQualityFiles::size.

                                                                                       {
    // initialise all allocators, one per device
    CMS_THREAD_SAFE static auto allocators = detail::allocate_device_allocators<TDev, TQueue>();

    size_t const index = alpaka::getNativeHandle(device);
    assert(index < cms::alpakatools::devices<alpaka::Pltf<TDev>>().size());

    // the public interface is thread safe
    return allocators[index];
  }

getEventCache()

template<typename Event >

EventCache<Event>& cms::alpakatools::getEventCache

(

)

Definition at line 91 of file EventCache.h.

References utilities::cache(), and CMS_THREAD_SAFE.

                                     {
    // the public interface is thread safe
    CMS_THREAD_SAFE static EventCache<Event> cache;
    return cache;
  }

getHostCachingAllocator()

template<typename TQueue , typename = std::enable_if_t<alpaka::isQueue<TQueue>>>

CachingAllocator<alpaka_common::DevHost, TQueue>& cms::alpakatools::getHostCachingAllocator ( )

inline

Definition at line 16 of file getHostCachingAllocator.h.

References cms::alpakatools::config::binGrowth, CMS_THREAD_SAFE, host(), cms::alpakatools::config::maxBin, cms::alpakatools::config::maxCachedBytes, cms::alpakatools::config::maxCachedFraction, and cms::alpakatools::config::minBin.

                                                                                   {
    // thread safe initialisation of the host allocator
    CMS_THREAD_SAFE static CachingAllocator<alpaka_common::DevHost, TQueue> allocator(
        host(),
        config::binGrowth,
        config::minBin,
        config::maxBin,
        config::maxCachedBytes,
        config::maxCachedFraction,
        false,   // reuseSameQueueAllocations
        false);  // debug

    // the public interface is thread safe
    return allocator;
  }

getQueueCache()

template<typename Queue >

QueueCache<Queue>& cms::alpakatools::getQueueCache

(

)

Definition at line 64 of file QueueCache.h.

References utilities::cache(), and CMS_THREAD_SAFE.

                                     {
    // the public interface is thread safe
    CMS_THREAD_SAFE static QueueCache<Queue> cache;
    return cache;
  }

host()

alpaka::DevCpu const& cms::alpakatools::host ( )

inline

Definition at line 24 of file host.h.

References cms::alpakatools::detail::enumerate_host().

Referenced by cms::alpakatools::detail::enumerate_host(), getHostCachingAllocator(), make_host_buffer(), make_host_view(), ALPAKA_ACCELERATOR_NAMESPACE::TestAlpakaESProducerA::produce(), ALPAKA_ACCELERATOR_NAMESPACE::TestAlpakaESProducerC::produce(), and PortableHostCollection< TestSoA >::ROOTReadStreamer().

                                    {
    static const auto host = detail::enumerate_host();
    return host;
  }

make_device_buffer() [1/6]

template<typename T , typename TDev >

std::enable_if_t<alpaka::isDevice<TDev> and not std::is_array_v<T>, device_buffer<TDev, T> > cms::alpakatools::make_device_buffer

(

TDev const &

device

)

Definition at line 177 of file memory.h.

                          {
    return alpaka::allocBuf<T, Idx>(device, Scalar{});
  }

make_device_buffer() [2/6]

template<typename T , typename TDev >

std::enable_if_t<alpaka::isDevice<TDev> and cms::is_unbounded_array_v<T> and not std::is_array_v<std::remove_extent_t<T> >, device_buffer<TDev, T> > cms::alpakatools::make_device_buffer	(	TDev const &	device,
		Extent	extent
	)

Definition at line 186 of file memory.h.

                                                        {
    return alpaka::allocBuf<std::remove_extent_t<T>, Idx>(device, Vec1D{extent});
  }

make_device_buffer() [3/6]

template<typename T , typename TDev >

std::enable_if_t<alpaka::isDevice<TDev> and cms::is_bounded_array_v<T> and not std::is_array_v<std::remove_extent_t<T> >, device_buffer<TDev, T> > cms::alpakatools::make_device_buffer

(

TDev const &

device

)

Definition at line 194 of file memory.h.

                                         {
    return alpaka::allocBuf<std::remove_extent_t<T>, Idx>(device, Vec1D{std::extent_v<T>});
  }

make_device_buffer() [4/6]

template<typename T , typename TQueue >

std::enable_if_t<alpaka::isQueue<TQueue> and not std::is_array_v<T>, device_buffer<alpaka::Dev<TQueue>, T> > cms::alpakatools::make_device_buffer

(

TQueue const &

queue

)

Definition at line 202 of file memory.h.

References allocator_policy, Asynchronous, Caching, createBeamHaloJobs::queue, and Synchronous.

                                          {
    if constexpr (allocator_policy<alpaka::Dev<TQueue>> == AllocatorPolicy::Caching) {
      return allocCachedBuf<T, Idx>(alpaka::getDev(queue), queue, Scalar{});
    }
    if constexpr (allocator_policy<alpaka::Dev<TQueue>> == AllocatorPolicy::Asynchronous) {
      return alpaka::allocAsyncBuf<T, Idx>(queue, Scalar{});
    }
    if constexpr (allocator_policy<alpaka::Dev<TQueue>> == AllocatorPolicy::Synchronous) {
      return alpaka::allocBuf<T, Idx>(alpaka::getDev(queue), Scalar{});
    }
  }

make_device_buffer() [5/6]

template<typename T , typename TQueue >

std::enable_if_t<alpaka::isQueue<TQueue> and cms::is_unbounded_array_v<T> and not std::is_array_v<std::remove_extent_t<T> >, device_buffer<alpaka::Dev<TQueue>, T> > cms::alpakatools::make_device_buffer	(	TQueue const &	queue,
		Extent	extent
	)

Definition at line 218 of file memory.h.

References allocator_policy, Asynchronous, Caching, createBeamHaloJobs::queue, and Synchronous.

                                                         {
    if constexpr (allocator_policy<alpaka::Dev<TQueue>> == AllocatorPolicy::Caching) {
      return allocCachedBuf<std::remove_extent_t<T>, Idx>(alpaka::getDev(queue), queue, Vec1D{extent});
    }
    if constexpr (allocator_policy<alpaka::Dev<TQueue>> == AllocatorPolicy::Asynchronous) {
      return alpaka::allocAsyncBuf<std::remove_extent_t<T>, Idx>(queue, Vec1D{extent});
    }
    if constexpr (allocator_policy<alpaka::Dev<TQueue>> == AllocatorPolicy::Synchronous) {
      return alpaka::allocBuf<std::remove_extent_t<T>, Idx>(alpaka::getDev(queue), Vec1D{extent});
    }
  }

make_device_buffer() [6/6]

template<typename T , typename TQueue >

std::enable_if_t<alpaka::isQueue<TQueue> and cms::is_bounded_array_v<T> and not std::is_array_v<std::remove_extent_t<T> >, device_buffer<alpaka::Dev<TQueue>, T> > cms::alpakatools::make_device_buffer

(

TQueue const &

queue

)

Definition at line 234 of file memory.h.

References allocator_policy, Asynchronous, Caching, createBeamHaloJobs::queue, and Synchronous.

                                          {
    if constexpr (allocator_policy<alpaka::Dev<TQueue>> == AllocatorPolicy::Caching) {
      return allocCachedBuf<std::remove_extent_t<T>, Idx>(alpaka::getDev(queue), queue, Vec1D{std::extent_v<T>});
    }
    if constexpr (allocator_policy<alpaka::Dev<TQueue>> == AllocatorPolicy::Asynchronous) {
      return alpaka::allocAsyncBuf<std::remove_extent_t<T>, Idx>(queue, Vec1D{std::extent_v<T>});
    }
    if constexpr (allocator_policy<alpaka::Dev<TQueue>> == AllocatorPolicy::Synchronous) {
      return alpaka::allocBuf<std::remove_extent_t<T>, Idx>(alpaka::getDev(queue), Vec1D{std::extent_v<T>});
    }
  }

make_device_view() [1/4]

template<typename T , typename TDev >

std::enable_if_t<not std::is_array_v<T>, device_view<TDev, T> > cms::alpakatools::make_device_view	(	TDev const &	device,
		T &	data
	)

Definition at line 252 of file memory.h.

References data.

                                                                                                           {
    return alpaka::ViewPlainPtr<TDev, T, Dim0D, Idx>(&data, device, Scalar{});
  }

make_device_view() [2/4]

template<typename T , typename TDev >

device_view<TDev, T[]> cms::alpakatools::make_device_view	(	TDev const &	device,
		T *	data,
		Extent	extent
	)

Definition at line 257 of file memory.h.

References data.

                                                                                      {
    return alpaka::ViewPlainPtr<TDev, T, Dim1D, Idx>(data, device, Vec1D{extent});
  }

make_device_view() [3/4]

template<typename T , typename TDev >

std::enable_if_t<cms::is_unbounded_array_v<T> and not std::is_array_v<std::remove_extent_t<T> >, device_view<TDev, T> > cms::alpakatools::make_device_view	(	TDev const &	device,
		T &	data,
		Extent	extent
	)

Definition at line 263 of file memory.h.

References data.

                                                               {
    return alpaka::ViewPlainPtr<TDev, std::remove_extent_t<T>, Dim1D, Idx>(data, device, Vec1D{extent});
  }

make_device_view() [4/4]

template<typename T , typename TDev >

std::enable_if_t<cms::is_bounded_array_v<T> and not std::is_array_v<std::remove_extent_t<T> >, device_view<TDev, T> > cms::alpakatools::make_device_view	(	TDev const &	device,
		T &	data
	)

Definition at line 269 of file memory.h.

References data.

                                                {
    return alpaka::ViewPlainPtr<TDev, std::remove_extent_t<T>, Dim1D, Idx>(data, device, Vec1D{std::extent_v<T>});
  }

make_host_buffer() [1/9]

template<typename T >

std::enable_if_t<not std::is_array_v<T>, host_buffer<T> > cms::alpakatools::make_host_buffer

(

)

Definition at line 64 of file memory.h.

References host().

                                                                          {
    return alpaka::allocBuf<T, Idx>(host(), Scalar{});
  }

make_host_buffer() [2/9]

template<typename T >

std::enable_if_t<cms::is_unbounded_array_v<T> and not std::is_array_v<std::remove_extent_t<T> >, host_buffer<T> > cms::alpakatools::make_host_buffer

(

Extent

extent

)

Definition at line 70 of file memory.h.

References host().

                                  {
    return alpaka::allocBuf<std::remove_extent_t<T>, Idx>(host(), Vec1D{extent});
  }

make_host_buffer() [3/9]

template<typename T >

std::enable_if_t<cms::is_bounded_array_v<T> and not std::is_array_v<std::remove_extent_t<T> >, host_buffer<T> > cms::alpakatools::make_host_buffer

(

)

Definition at line 76 of file memory.h.

References host().

                     {
    return alpaka::allocBuf<std::remove_extent_t<T>, Idx>(host(), Vec1D{std::extent_v<T>});
  }

make_host_buffer() [4/9]

template<typename T , typename TPlatform >

std::enable_if_t<not std::is_array_v<T>, host_buffer<T> > cms::alpakatools::make_host_buffer

(

)

Definition at line 84 of file memory.h.

References host().

                                                                          {
    return alpaka::allocMappedBuf<TPlatform, T, Idx>(host(), Scalar{});
  }

make_host_buffer() [5/9]

template<typename T , typename TPlatform >

std::enable_if_t<cms::is_unbounded_array_v<T> and not std::is_array_v<std::remove_extent_t<T> >, host_buffer<T> > cms::alpakatools::make_host_buffer

(

Extent

extent

)

Definition at line 90 of file memory.h.

References host().

                                  {
    return alpaka::allocMappedBuf<TPlatform, std::remove_extent_t<T>, Idx>(host(), Vec1D{extent});
  }

make_host_buffer() [6/9]

template<typename T , typename TPlatform >

std::enable_if_t<cms::is_bounded_array_v<T> and not std::is_array_v<std::remove_extent_t<T> >, host_buffer<T> > cms::alpakatools::make_host_buffer

(

)

Definition at line 96 of file memory.h.

References host().

                     {
    return alpaka::allocMappedBuf<TPlatform, std::remove_extent_t<T>, Idx>(host(), Vec1D{std::extent_v<T>});
  }

make_host_buffer() [7/9]

template<typename T , typename TQueue >

std::enable_if_t<alpaka::isQueue<TQueue> and not std::is_array_v<T>, host_buffer<T> > cms::alpakatools::make_host_buffer

(

TQueue const &

queue

)

Definition at line 104 of file memory.h.

References allocator_policy, Caching, host(), and createBeamHaloJobs::queue.

                           {
    if constexpr (allocator_policy<alpaka::Dev<TQueue>> == AllocatorPolicy::Caching) {
      return allocCachedBuf<T, Idx>(host(), queue, Scalar{});
    } else {
      return alpaka::allocMappedBuf<alpaka::Pltf<alpaka::Dev<TQueue>>, T, Idx>(host(), Scalar{});
    }
  }

make_host_buffer() [8/9]

template<typename T , typename TQueue >

std::enable_if_t<alpaka::isQueue<TQueue> and cms::is_unbounded_array_v<T> and not std::is_array_v<std::remove_extent_t<T> >, host_buffer<T> > cms::alpakatools::make_host_buffer	(	TQueue const &	queue,
		Extent	extent
	)

Definition at line 117 of file memory.h.

References allocator_policy, Caching, host(), and createBeamHaloJobs::queue.

                                                       {
    if constexpr (allocator_policy<alpaka::Dev<TQueue>> == AllocatorPolicy::Caching) {
      return allocCachedBuf<std::remove_extent_t<T>, Idx>(host(), queue, Vec1D{extent});
    } else {
      return alpaka::allocMappedBuf<alpaka::Pltf<alpaka::Dev<TQueue>>, std::remove_extent_t<T>, Idx>(host(),
                                                                                                     Vec1D{extent});
    }
  }

make_host_buffer() [9/9]

template<typename T , typename TQueue >

std::enable_if_t<alpaka::isQueue<TQueue> and cms::is_bounded_array_v<T> and not std::is_array_v<std::remove_extent_t<T> >, host_buffer<T> > cms::alpakatools::make_host_buffer

(

TQueue const &

queue

)

Definition at line 130 of file memory.h.

References allocator_policy, Caching, host(), and createBeamHaloJobs::queue.

                                        {
    if constexpr (allocator_policy<alpaka::Dev<TQueue>> == AllocatorPolicy::Caching) {
      return allocCachedBuf<std::remove_extent_t<T>, Idx>(host(), queue, Vec1D{std::extent_v<T>});
    } else {
      return alpaka::allocMappedBuf<alpaka::Pltf<alpaka::Dev<TQueue>>, std::remove_extent_t<T>, Idx>(
          host(), Vec1D{std::extent_v<T>});
    }
  }

make_host_view() [1/4]

template<typename T >

std::enable_if_t<not std::is_array_v<T>, host_view<T> > cms::alpakatools::make_host_view

(

T &

data

)

Definition at line 145 of file memory.h.

References data, and host().

                                                                             {
    return alpaka::ViewPlainPtr<DevHost, T, Dim0D, Idx>(&data, host(), Scalar{});
  }

make_host_view() [2/4]

template<typename T >

host_view<T[]> cms::alpakatools::make_host_view	(	T *	data,
		Extent	extent
	)

Definition at line 150 of file memory.h.

References data, and host().

                                                        {
    return alpaka::ViewPlainPtr<DevHost, T, Dim1D, Idx>(data, host(), Vec1D{extent});
  }

make_host_view() [3/4]

template<typename T >

std::enable_if_t<cms::is_unbounded_array_v<T> and not std::is_array_v<std::remove_extent_t<T> >, host_view<T> > cms::alpakatools::make_host_view	(	T &	data,
		Extent	extent
	)

Definition at line 156 of file memory.h.

References data, and host().

                                         {
    return alpaka::ViewPlainPtr<DevHost, std::remove_extent_t<T>, Dim1D, Idx>(data, host(), Vec1D{extent});
  }

make_host_view() [4/4]

template<typename T >

std::enable_if_t<cms::is_bounded_array_v<T> and not std::is_array_v<std::remove_extent_t<T> >, host_view<T> > cms::alpakatools::make_host_view

(

T &

data

)

Definition at line 162 of file memory.h.

References data, and host().

                          {
    return alpaka::ViewPlainPtr<DevHost, std::remove_extent_t<T>, Dim1D, Idx>(data, host(), Vec1D{std::extent_v<T>});
  }

make_workdiv() [1/2]

template<typename TAcc , typename = std::enable_if_t<alpaka::isAccelerator<TAcc> and alpaka::Dim<TAcc>::value == 1>>

WorkDiv<Dim1D> cms::alpakatools::make_workdiv ( Idx  blocks, Idx  elements  )

inline

Definition at line 41 of file workdivision.h.

References gather_cfg::blocks, and bookConverter::elements.

                                                               {
    if constexpr (not requires_single_thread_per_block_v<TAcc>) {
      // On GPU backends, each thread is looking at a single element:
      //   - the number of threads per block is "elements";
      //   - the number of elements per thread is always 1.
      return WorkDiv<Dim1D>(blocks, elements, Idx{1});
    } else {
      // On CPU backends, run serially with a single thread per block:
      //   - the number of threads per block is always 1;
      //   - the number of elements per thread is "elements".
      return WorkDiv<Dim1D>(blocks, Idx{1}, elements);
    }
  }

make_workdiv() [2/2]

template<typename TAcc , typename = std::enable_if_t<alpaka::isAccelerator<TAcc>>>

WorkDiv<alpaka::Dim<TAcc> > cms::alpakatools::make_workdiv ( const Vec< alpaka::Dim< TAcc >> &  blocks, const Vec< alpaka::Dim< TAcc >> &  elements  )

inline

Definition at line 57 of file workdivision.h.

References gather_cfg::blocks, and bookConverter::elements.

                                                                                       {
    using Dim = alpaka::Dim<TAcc>;
    if constexpr (not requires_single_thread_per_block_v<TAcc>) {
      // On GPU backends, each thread is looking at a single element:
      //   - the number of threads per block is "elements";
      //   - the number of elements per thread is always 1.
      return WorkDiv<Dim>(blocks, elements, Vec<Dim>::ones());
    } else {
      // On CPU backends, run serially with a single thread per block:
      //   - the number of threads per block is always 1;
      //   - the number of elements per thread is "elements".
      return WorkDiv<Dim>(blocks, Vec<Dim>::ones(), elements);
    }
  }

module_backend_config()

void cms::alpakatools::module_backend_config

(

edm::ConfigurationDescriptions &

iDesc

)

Definition at line 13 of file module_backend_config.cc.

References edm::ParameterSetDescription::addUntracked(), edm::ConfigurationDescriptions::defaultDescription(), edm::ParameterSetDescription::isLabelUnused(), kComment, AlCaHLTBitMon_QueryRunRegistry::string, and findQualityFiles::v.

Referenced by ALPAKA_ACCELERATOR_NAMESPACE::ESProducer::prevalidate(), and ALPAKA_ACCELERATOR_NAMESPACE::ProducerBase< edm::global::EDProducer, Args... >::prevalidate().

                                                                  {
    // the code below leads to 'alpaka = untracked.PSet(backend = untracked.string)' to be added to the generated cfi files
    // TODO: I don't know if this is a desired behavior for HLT
    edm::ParameterSetDescription descAlpaka;
    descAlpaka.addUntracked<std::string>("backend", "")
        ->setComment(
            "Alpaka backend for this module. Can be empty string (for the global default), 'serial_sync', or "
            " - depending on the architecture and available hardware - 'cuda_async', 'rocm_async'");

    if (iDesc.defaultDescription()) {
      if (iDesc.defaultDescription()->isLabelUnused(kPSetName)) {
        iDesc.defaultDescription()
            ->addUntracked<edm::ParameterSetDescription>(kPSetName, descAlpaka)
            ->setComment(kComment);
      }
    }
    for (auto& v : iDesc) {
      if (v.second.isLabelUnused(kPSetName)) {
        v.second.addUntracked<edm::ParameterSetDescription>(kPSetName, descAlpaka)->setComment(kComment);
      }
    }
  }

round_up_by()

constexpr Idx cms::alpakatools::round_up_by ( Idx  value, Idx  divisor  )

inline

Definition at line 16 of file workdivision.h.

{ return (value + divisor - 1) / divisor * divisor; }

Variable Documentation

allocator_policy

template<typename TDev , typename = std::enable_if_t<alpaka::isDevice<TDev>>>

constexpr AllocatorPolicy cms::alpakatools::allocator_policy = AllocatorPolicy::Synchronous

inline

Definition at line 17 of file AllocatorPolicy.h.

Referenced by make_device_buffer(), and make_host_buffer().

requires_single_thread_per_block_v

template<typename TAcc , typename = std::enable_if_t<alpaka::isAccelerator<TAcc>>>

constexpr bool cms::alpakatools::requires_single_thread_per_block_v = requires_single_thread_per_block<TAcc>::value

inline

Definition at line 37 of file workdivision.h.