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)
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, and cms::alpakatools::config::minBin.

                                      {
      using Allocator = CachingAllocator<TDev, TQueue>;
      auto const& devices = cms::alpakatools::devices<alpaka::Platform<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 41 of file CachingAllocator.h.

References SiStripPI::max, and 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";
      }
    }

power()

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

inline

Definition at line 28 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;
    }