CaloRecGPU::Helpers Namespace Reference

Namespaces
namespace	Constants
	!
namespace	MemoryContext
	! Holds dummy classes just to identify the place in which memory lives.

Classes
struct	maybe_allocate
	Possibly holds an object in its internal buffer. More...
class	MemoryManagement
	! Handles allocation of a type T, using indexer as the integer type to indicate sizes. More...
struct	separate_thread_accessor
	! More...
class	separate_thread_holder
	Manages objects of type T in a thread-safe way, ensuring that there's an object available for each separate thread while minimizing the number of allocations. More...
class	SimpleContainer
	Holds a run-time amount of objects of type \T, measuring sizes with indexer, in memory context Context. More...
class	SimpleContainer< T, indexer, Context, false >
class	SimpleContainer< T, indexer, Context, true >
class	SimpleHolder
	Holds one objects of type \T in memory context Context. More...
class	SimpleHolder< T, Context, false >
class	SimpleHolder< T, Context, true >

Typedefs
template<class T, class indexer = unsigned int>
using	CPU_array = SimpleContainer<T, indexer, MemoryContext::CPU, true>
	Holds a run-time specified amount of objects of type T in CPU memory.
template<class T, class indexer = unsigned int>
using	CUDA_array = SimpleContainer<T, indexer, MemoryContext::CUDAGPU, true>
	Holds a run-time specified amount of objects of type T in CUDA GPU memory.
template<class T, class indexer = unsigned int>
using	CUDA_kernel_array = SimpleContainer<T, indexer, MemoryContext::CUDAGPU, false>
	Non-owning pointer to an array of T in CUDA GPU memory.
template<class T>
using	CPU_object = SimpleHolder<T, MemoryContext::CPU, true>
	Holds an object of type T in CPU memory.
template<class T>
using	CUDA_object = SimpleHolder<T, MemoryContext::CUDAGPU, true>
	Holds an object of type T in CUDA GPU memory.
template<class T>
using	CUDA_kernel_object = SimpleHolder<T, MemoryContext::CUDAGPU, false>
	Non-owning pointer to an object of type T in CUDA GPU memory.
template<class T>
using	CUDA_pinned_CPU_object = SimpleHolder<T, MemoryContext::CUDAPinnedCPU, true>
	Holds an object of type T in CUDA GPU memory.

Functions
template<class T1, class T2>
constexpr auto	int_ceil_div (const T1 num, const T2 denom)
	Returns the ceiling of num/denom, with proper rounding.
template<class T1, class T2>
constexpr auto	int_floor_div (const T1 num, const T2 denom)
	Returns the floor of num/denom, with proper rounding.
template<class Base = float, class Exp = int>
constexpr Base	compile_time_pow2 (const Exp exp)
	Returns 2 to the power of exp.
template<class T>
constexpr unsigned int	int_ceil_log_2 (T num)
	Returns the ceiling of the base-2 logarithm of a number (i.
template<class T>
constexpr unsigned char	Pearson_hash (const T number)
	Calculates a Pearson hash from @ number.
template<class T>
constexpr unsigned short	Pearson_hash_16_bit (const T number)
	Calculates a 16-bit Pearson hash from @ number.
static CUDA_HOS_DEV float	erf_inv_wrapper (const float x)
static CUDA_HOS_DEV float	regularize_angle (const float b, const float a=0.f)
static CUDA_HOS_DEV double	regularize_angle (const double b, const double a=0.)
template<class T>
static CUDA_HOS_DEV T	angular_difference (const T x, const T y)
static CUDA_HOS_DEV float	eta_from_coordinates (const float x, const float y, const float z)
static CUDA_HOS_DEV double	eta_from_coordinates (const double x, const double y, const double z)
static CUDA_HOS_DEV void	partial_kahan_babushka_neumaier_sum (const float &to_add, float &sum, float &corr)
	Implements one step of a Kahan-Babushka-Neumaier sum by adding to_add to sum with the correction term corr.
template<class ... Floats, class disabler = std::enable_if_t < (std::is_same_v<std::decay_t<Floats>, float> && ...) >>
CUDA_HOS_DEV float	sum_kahan_babushka_neumaier (const Floats &... fs)
	Adds a list of floats using the Kahan-Babushka-Neumaier algorithm for greater precision (at the cost of additional operations).
static CUDA_HOS_DEV float	product_sum_cornea_harrison_tang (const float a, const float b, const float c, const float d)
static CUDA_HOS_DEV float	corrected_dot_product (const float a_1, const float a_2, const float a_3, const float b_1, const float b_2, const float b_3)
CUDA_HOS_DEV float	corrected_dot_product (const float(&a)[3], const float(&b)[3])
static CUDA_HOS_DEV void	corrected_cross_product (float(&res)[3], const float a1, const float a2, const float a3, const float b1, const float b2, const float b3)
static CUDA_HOS_DEV void	corrected_cross_product (float(&res)[3], const float(&x)[3], const float(&y)[3])
static CUDA_HOS_DEV float	corrected_magn_cross_product (const float a1, const float a2, const float a3, const float b1, const float b2, const float b3)
static CUDA_HOS_DEV float	corrected_magn_cross_product (const float(&x)[3], const float(&y)[3])

Typedef Documentation

CPU_array

template<class T, class indexer = unsigned int>

using CaloRecGPU::Helpers::CPU_array = SimpleContainer<T, indexer, MemoryContext::CPU, true>

Holds a run-time specified amount of objects of type T in CPU memory.

Definition at line 1241 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

CPU_object

template<class T>

using CaloRecGPU::Helpers::CPU_object = SimpleHolder<T, MemoryContext::CPU, true>

Holds an object of type T in CPU memory.

Definition at line 1659 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

CUDA_array

template<class T, class indexer = unsigned int>

using CaloRecGPU::Helpers::CUDA_array = SimpleContainer<T, indexer, MemoryContext::CUDAGPU, true>

Holds a run-time specified amount of objects of type T in CUDA GPU memory.

Definition at line 1245 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

CUDA_kernel_array

template<class T, class indexer = unsigned int>

using CaloRecGPU::Helpers::CUDA_kernel_array = SimpleContainer<T, indexer, MemoryContext::CUDAGPU, false>

Non-owning pointer to an array of T in CUDA GPU memory.

Definition at line 1249 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

CUDA_kernel_object

template<class T>

using CaloRecGPU::Helpers::CUDA_kernel_object = SimpleHolder<T, MemoryContext::CUDAGPU, false>

Non-owning pointer to an object of type T in CUDA GPU memory.

Definition at line 1667 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

CUDA_object

template<class T>

using CaloRecGPU::Helpers::CUDA_object = SimpleHolder<T, MemoryContext::CUDAGPU, true>

Holds an object of type T in CUDA GPU memory.

Definition at line 1663 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

CUDA_pinned_CPU_object

template<class T>

using CaloRecGPU::Helpers::CUDA_pinned_CPU_object = SimpleHolder<T, MemoryContext::CUDAPinnedCPU, true>

Holds an object of type T in CUDA GPU memory.

Definition at line 1671 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

Function Documentation

angular_difference()

template<class T>

CUDA_HOS_DEV T CaloRecGPU::Helpers::angular_difference ( const T x, const T y )

inlinestatic

Definition at line 444 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

    {
      return regularize_angle(regularize_angle(x) - regularize_angle(y));
    }

compile_time_pow2()

template<class Base = float, class Exp = int>

Base CaloRecGPU::Helpers::compile_time_pow2 ( const Exp exp )

inlineconstexpr

Returns 2 to the power of exp.

Definition at line 233 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

    {
      Base ret = 1;
      if (exp < 0)
        {
          for (Exp i = 0; i < -exp; ++i)
            {
              ret /= Base(2);
            }
        }
      else
        {
          for (Exp i = 0; i < exp; ++i)
            {
              ret *= Base(2);
            }
        }
      return ret;
    }

corrected_cross_product() [1/2]

CUDA_HOS_DEV void CaloRecGPU::Helpers::corrected_cross_product ( float(&) res[3], const float a1, const float a2, const float a3, const float b1, const float b2, const float b3 )

inlinestatic

Definition at line 589 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

    {
      res[0] = product_sum_cornea_harrison_tang(a2, b3, -a3, b2);
      res[1] = product_sum_cornea_harrison_tang(a3, b1, -a1, b3);
      res[2] = product_sum_cornea_harrison_tang(a1, b2, -a2, b1);
    }

corrected_cross_product() [2/2]

CUDA_HOS_DEV void CaloRecGPU::Helpers::corrected_cross_product ( float(&) res[3], const float(&) x[3], const float(&) y[3] )

inlinestatic

Definition at line 598 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

    {
      corrected_cross_product(res, x[0], x[1], x[2], y[0], y[1], y[2]);
    }

corrected_dot_product() [1/2]

CUDA_HOS_DEV float CaloRecGPU::Helpers::corrected_dot_product ( const float a_1, const float a_2, const float a_3, const float b_1, const float b_2, const float b_3 )

inlinestatic

Definition at line 564 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

    {
      using namespace std;
 
      const float w_1 = a_1 * b_1;
      const float w_2 = a_2 * b_2;
      const float w_3 = a_3 * b_3;
 
      const float e_1 = fmaf(a_1, b_1, -w_1);
      const float e_2 = fmaf(a_2, b_2, -w_2);
      const float e_3 = fmaf(a_3, b_3, -w_3);
 
      return sum_kahan_babushka_neumaier(w_1, w_2, w_3, e_1, e_2, e_3);
    }

corrected_dot_product() [2/2]

CUDA_HOS_DEV float CaloRecGPU::Helpers::corrected_dot_product ( const float(&) a[3], const float(&) b[3] )

inline

Definition at line 582 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

    {
      return corrected_dot_product(a[0], a[1], a[2], b[0], b[1], b[2]);
    }

corrected_magn_cross_product() [1/2]

CUDA_HOS_DEV float CaloRecGPU::Helpers::corrected_magn_cross_product ( const float a1, const float a2, const float a3, const float b1, const float b2, const float b3 )

inlinestatic

Definition at line 605 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

    {
      using namespace std;
 
      const float r_1 = product_sum_cornea_harrison_tang(a2, b3, -a3, b2);
      const float r_2 = product_sum_cornea_harrison_tang(a3, b1, -a1, b3);
      const float r_3 = product_sum_cornea_harrison_tang(a1, b2, -a2, b1);
 
#ifdef __CUDA_ARCH__
      return norm3df(r_1, r_2, r_3);
#else
      return hypot(r_1, r_2, r_3);
#endif
 
    }

corrected_magn_cross_product() [2/2]

CUDA_HOS_DEV float CaloRecGPU::Helpers::corrected_magn_cross_product ( const float(&) x[3], const float(&) y[3] )

inlinestatic

Definition at line 623 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

    {
      return corrected_magn_cross_product(x[0], x[1], x[2], y[0], y[1], y[2]);
    }

erf_inv_wrapper()

CUDA_HOS_DEV float CaloRecGPU::Helpers::erf_inv_wrapper ( const float x )

inlinestatic

Definition at line 357 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

    {
      using namespace std;
#ifdef __CUDA_ARCH__
      return erfinvf(x);
#else
      //Copied directly from ROOT...
 
      int kMaxit    = 50;
      float kEps   = 1e-14f;
      float kConst = 0.8862269254527579f;     // sqrt(pi)/2.0
 
      if (abs(x) <= kEps)
        {
          return kConst * x;
        }
 
      // Newton iterations
      float erfi, derfi, y0, y1, dy0, dy1;
      if (fabsf(x) < 1.0f)
        {
          erfi  = kConst * fabsf(x);
          y0    = erff(0.9f * erfi);
          derfi = 0.1f * erfi;
          for (int iter = 0; iter < kMaxit; iter++)
            {
              y1  = 1.f - erfc(erfi);
              dy1 = fabsf(x) - y1;
              if (fabsf(dy1) < kEps)
                {
                  if (x < 0)
                    {
                      return -erfi;
                    }
                  else
                    {
                      return erfi;
                    }
                }
              dy0    = y1 - y0;
              derfi *= dy1 / dy0;
              y0     = y1;
              erfi  += derfi;
              if (fabsf(derfi / erfi) < kEps)
                {
                  if (x < 0.f)
                    {
                      return -erfi;
                    }
                  else
                    {
                      return erfi;
                    }
                }
            }
        }
      return 0; //did not converge
#endif
    }

eta_from_coordinates() [1/2]

CUDA_HOS_DEV double CaloRecGPU::Helpers::eta_from_coordinates ( const double x, const double y, const double z )

inlinestatic

Definition at line 471 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

    {
      using namespace std;
      if (x != 0 || y != 0)
        {
#ifdef __CUDA_ARCH__
          const float m = norm3d(x, y, z);
#else
          const float m = hypot(x, y, z);
#endif
          return 0.5 * log((m + z) / (m - z));
        }
      else
        {
          constexpr double s_etaMax = 22756.0;
          return z + ((z > 0) - (z < 0)) * s_etaMax;
        }
    }

eta_from_coordinates() [2/2]

CUDA_HOS_DEV float CaloRecGPU::Helpers::eta_from_coordinates ( const float x, const float y, const float z )

inlinestatic

Definition at line 450 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

    {
      using namespace std;
      
      if (x != 0 || y != 0)
        {
#ifdef __CUDA_ARCH__
          const float m = norm3df(x, y, z);
#else
          const float m = hypot(x, y, z);
#endif
          return 0.5f * logf((m + z) / (m - z));
        }
      else
        {
          constexpr float s_etaMax = 22756.0f;
          return z + ((z > 0) - (z < 0)) * s_etaMax;
        }
    }

int_ceil_div()

template<class T1, class T2>

auto CaloRecGPU::Helpers::int_ceil_div ( const T1 num, const T2 denom )

inlineconstexpr

Returns the ceiling of num/denom, with proper rounding.

Definition at line 219 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

    {
      return num / denom + (num % denom != 0);
    }

int_ceil_log_2()

template<class T>

unsigned int CaloRecGPU::Helpers::int_ceil_log_2 ( T num )

inlineconstexpr

Returns the ceiling of the base-2 logarithm of a number (i.

e. the minimum number of bits to represent this number).

Definition at line 259 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

    {
#if __cpp_lib_bitops
      return sizeof(T) * CHAR_BIT - std::countl_zero(num);
#else
      unsigned int ret = 64;
    
      for (unsigned long long int mask = 0x8000000000000000U; mask > 0; mask >>= 1U)
        {
          if (num & mask)
            {
              return ret;
            }
          --ret;
        }
 
      return ret;
#endif
    }

int_floor_div()

template<class T1, class T2>

auto CaloRecGPU::Helpers::int_floor_div ( const T1 num, const T2 denom )

inlineconstexpr

Returns the floor of num/denom, with proper rounding.

Definition at line 226 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

    {
      return num / denom;
    }

partial_kahan_babushka_neumaier_sum()

CUDA_HOS_DEV void CaloRecGPU::Helpers::partial_kahan_babushka_neumaier_sum ( const float & to_add, float & sum, float & corr )

inlinestatic

Implements one step of a Kahan-Babushka-Neumaier sum by adding to_add to sum with the correction term corr.

Definition at line 493 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

    {
      const float t = sum + to_add;
 
      const bool test = fabsf(sum) >= fabsf(to_add);
 
      const float opt_1 = (sum - t) + to_add;
      const float opt_2 = (to_add - t) + sum;
 
      corr += (test) * opt_1 + (!test) * opt_2;
 
      sum = t;
    }

Pearson_hash()

template<class T>

unsigned char CaloRecGPU::Helpers::Pearson_hash ( const T number )

inlineconstexpr

Calculates a Pearson hash from @ number.

Definition at line 282 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

    {
      constexpr unsigned char initial_value = 42;
      //The answer.
 
      constexpr unsigned char c_mult = 7;
      constexpr unsigned char c_add = 1;
      //For our "look up table": table[i] = c_mult * i + c_add
      //For an appropriate choice of constants (such as this),
      //this will be bijective (modulo 255), as required.
 
      unsigned char ret = initial_value;
 
      for (unsigned int i = 0; i < sizeof(T); i += sizeof(unsigned char))
        {
          const unsigned char to_hash = number >> (i * CHAR_BIT);
          const unsigned char operand = ret ^ to_hash;
          ret = c_mult * operand + c_add;
        }
 
      return ret;
    }

Pearson_hash_16_bit()

template<class T>

unsigned short CaloRecGPU::Helpers::Pearson_hash_16_bit ( const T number )

inlineconstexpr

Calculates a 16-bit Pearson hash from @ number.

Definition at line 309 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

    {
      constexpr unsigned short initial_value = 42754;
      //The answer and the standard.
 
      constexpr unsigned short c_mult = 7;
      constexpr unsigned short c_add = 1;
      //For our "look up table": table[i] = c_mult * i + c_add
      //For an appropriate choice of constants (such as this),
      //this will be bijective (modulo 255), as required.
 
      unsigned short ret = initial_value;
 
      for (unsigned int i = 0; i < sizeof(T); i += sizeof(unsigned short))
        {
          const unsigned short to_hash = number >> (i * CHAR_BIT);
          const unsigned short operand = ret ^ to_hash;
          ret = c_mult * operand + c_add;
        }
 
      return ret;
    }

product_sum_cornea_harrison_tang()

CUDA_HOS_DEV float CaloRecGPU::Helpers::product_sum_cornea_harrison_tang ( const float a, const float b, const float c, const float d )

inlinestatic

Definition at line 549 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

    {
      using namespace std;
 
      const float w_1 = a * b;
      const float w_2 = c * d;
 
      const float e_1 = fmaf(a, b, -w_1);
      const float e_2 = fmaf(c, d, -w_2);
 
      return sum_kahan_babushka_neumaier(w_1, w_2, e_1, e_2);
    }

regularize_angle() [1/2]

CUDA_HOS_DEV double CaloRecGPU::Helpers::regularize_angle ( const double b, const double a = 0. )

inlinestatic

Definition at line 432 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

    {
      using namespace std;
      constexpr double pi = Helpers::Constants::pi<double>;
      constexpr double two_pi = 2 * pi;
      const double ret = remainderf(b, two_pi);
      return ret + ((ret < a - pi) - (ret > a + pi)) * two_pi;
    }

regularize_angle() [2/2]

CUDA_HOS_DEV float CaloRecGPU::Helpers::regularize_angle ( const float b, const float a = 0.f )

inlinestatic

Definition at line 421 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

    {
      using namespace std;
      constexpr float pi = Helpers::Constants::pi<float>;
      constexpr float two_pi = 2 * pi;
      const float ret = remainderf(b, two_pi);
      return ret + ((ret < a - pi) - (ret > a + pi)) * two_pi;
    }

sum_kahan_babushka_neumaier()

template<class ... Floats, class disabler = std::enable_if_t < (std::is_same_v<std::decay_t<Floats>, float> && ...) >>

CUDA_HOS_DEV float CaloRecGPU::Helpers::sum_kahan_babushka_neumaier ( const Floats &... fs )

inline

Adds a list of floats using the Kahan-Babushka-Neumaier algorithm for greater precision (at the cost of additional operations).

Definition at line 511 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

    {
      float ret = 0.f;
      float corr = 0.f;
 
      (partial_kahan_babushka_neumaier_sum(fs, ret, corr), ...);
 
      return ret + corr;
    }