cms::alpakatools::detail Namespace Reference

Classes
struct	buffer_type
struct	buffer_type< TDev, T[]>
struct	buffer_type< TDev, T[N]>
struct	view_type
struct	view_type< TDev, T[]>
struct	view_type< TDev, T[N]>

Functions
template<typename TDev , typename TQueue , typename = std::enable_if_t<alpaka::isDevice<TDev> and alpaka::isQueue<TQueue>>>
auto	allocate_device_allocators ()
std::string	as_bytes (size_t value)
template<typename TPlatform , typename = std::enable_if_t<alpaka::isPlatform<TPlatform>>>
std::vector< alpaka::Dev< TPlatform > >	enumerate_devices ()
alpaka::DevCpu	enumerate_host ()
constexpr unsigned int	power (unsigned int base, unsigned int exponent)

Function Documentation

allocate_device_allocators()

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

auto cms::alpakatools::detail::allocate_device_allocators

(

)

Definition at line 22 of file getDeviceCachingAllocator.h.

References cms::alpakatools::config::binGrowth, DDDCmsTrackerContruction::construct(), cms::alpakatools::devices(), mps_fire::i, cms::alpakatools::config::maxBin, cms::alpakatools::config::maxCachedBytes, cms::alpakatools::config::maxCachedFraction, cms::alpakatools::config::minBin, and findQualityFiles::size.

                                      {
      using Allocator = CachingAllocator<TDev, TQueue>;
      auto const& devices = cms::alpakatools::devices<alpaka::Pltf<TDev>>();
      ssize_t const size = devices.size();

      // allocate the storage for the objects
      auto ptr = std::allocator<Allocator>().allocate(size);

      // construct the objects in the storage
      ptrdiff_t index = 0;
      try {
        for (; index < size; ++index) {
#if __cplusplus >= 202002L
          std::construct_at(
#else
          std::allocator<Allocator>().construct(
#endif
              ptr + index,
              devices[index],
              config::binGrowth,
              config::minBin,
              config::maxBin,
              config::maxCachedBytes,
              config::maxCachedFraction,
              true,    // reuseSameQueueAllocations
              false);  // debug
        }
      } catch (...) {
        --index;
        // destroy any object that had been succesfully constructed
        while (index >= 0) {
          std::destroy_at(ptr + index);
          --index;
        }
        // deallocate the storage
        std::allocator<Allocator>().deallocate(ptr, size);
        // rethrow the exception
        throw;
      }

      // use a custom deleter to destroy all objects and deallocate the memory
      auto deleter = [size](Allocator* ptr) {
        for (size_t i = size; i > 0; --i) {
          std::destroy_at(ptr + i - 1);
        }
        std::allocator<Allocator>().deallocate(ptr, size);
      };

      return std::unique_ptr<Allocator[], decltype(deleter)>(ptr, deleter);
    }

as_bytes()

std::string cms::alpakatools::detail::as_bytes ( size_t  value )

inline

Definition at line 40 of file CachingAllocator.h.

References SiStripPI::max, and cond::impl::to_string().

Referenced by cms::alpakatools::CachingAllocator< TDev, TQueue >::CachingAllocator().

                                            {
      if (value == std::numeric_limits<size_t>::max()) {
        return "unlimited";
      } else if (value >= (1 << 30) and value % (1 << 30) == 0) {
        return std::to_string(value >> 30) + " GB";
      } else if (value >= (1 << 20) and value % (1 << 20) == 0) {
        return std::to_string(value >> 20) + " MB";
      } else if (value >= (1 << 10) and value % (1 << 10) == 0) {
        return std::to_string(value >> 10) + " kB";
      } else {
        return std::to_string(value) + "  B";
      }
    }

enumerate_devices()

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

std::vector<alpaka::Dev<TPlatform> > cms::alpakatools::detail::enumerate_devices ( )

inline

Definition at line 16 of file devices.h.

References cms::cuda::assert(), cms::alpakatools::devices(), mps_fire::i, and dqmiodumpmetadata::n.

                                                               {
      using Platform = TPlatform;
      using Device = alpaka::Dev<Platform>;

      std::vector<Device> devices;
      uint32_t n = alpaka::getDevCount<Platform>();
      devices.reserve(n);
      for (uint32_t i = 0; i < n; ++i) {
        devices.push_back(alpaka::getDevByIdx<Platform>(i));
        assert(alpaka::getNativeHandle(devices.back()) == static_cast<int>(i));
      }

      return devices;
    }

enumerate_host()

alpaka::DevCpu cms::alpakatools::detail::enumerate_host ( )

inline

Definition at line 10 of file host.h.

References cms::cuda::assert(), and cms::alpakatools::host().

Referenced by cms::alpakatools::host().

                                         {
      using Platform = alpaka::PltfCpu;
      using Host = alpaka::DevCpu;

      assert(alpaka::getDevCount<Platform>() == 1);
      Host host = alpaka::getDevByIdx<Platform>(0);
      assert(alpaka::getNativeHandle(host) == 0);

      return host;
    }

power()

constexpr unsigned int cms::alpakatools::detail::power ( unsigned int  base, unsigned int  exponent  )

inline

Definition at line 27 of file CachingAllocator.h.

References newFWLiteAna::base, and HLT_2023v12_cff::exponent.

Referenced by cms::alpakatools::CachingAllocator< TDev, TQueue >::CachingAllocator(), trklet::ilog2(), CompareAlignments::MergeRootfile(), MuonResidualsFitter_compute_log_convolution(), trklet::ProcessBase::nbits(), notcub::CachingHostAllocator::NearestPowerOf(), notcub::CachingDeviceAllocator::NearestPowerOf(), edm::operator<<(), and trklet::FitTrack::trackFitChisq().

                                                                                  {
      unsigned int power = 1;
      while (exponent > 0) {
        if (exponent & 1) {
          power = power * base;
        }
        base = base * base;
        exponent = exponent >> 1;
      }
      return power;
    }