cms::alpakatools::detail Namespace Reference

Classes
struct	buffer_type
struct	buffer_type< TDev, T[]>
struct	buffer_type< TDev, T[N]>
class	IndependentGroupElementsAlong
class	IndependentGroupsAlong
class	UniformElementsAlong
class	UniformElementsND
class	UniformGroupElementsAlong
class	UniformGroupsAlong
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 (AllocatorConfig const &config, bool debug)
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	(	AllocatorConfig const &	config,
		bool	debug
	)

Definition at line 22 of file getDeviceCachingAllocator.h.

References DDDCmsTrackerContruction::construct(), debug, cms::alpakatools::devices(), and mps_fire::i.

                                                                               {
      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,
              true,  // reuseSameQueueAllocations
              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* allocators) {
        for (size_t i = size; i > 0; --i) {
          std::destroy_at(allocators + i - 1);
        }
        std::allocator<Allocator>().deallocate(allocators, 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 >= (1ul << 40) and value % (1ul << 40) == 0) {
        return std::to_string(value >> 40) + " TiB";
      } else if (value >= (1ul << 30) and value % (1ul << 30) == 0) {
        return std::to_string(value >> 30) + " GiB";
      } else if (value >= (1ul << 20) and value % (1ul << 20) == 0) {
        return std::to_string(value >> 20) + " MiB";
      } else if (value >= (1ul << 10) and value % (1ul << 10) == 0) {
        return std::to_string(value >> 10) + " KiB";
      } 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_2024v14_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;
    }