common/initialization.hpp

Go to the documentation of this file.

#pragma once
 
#include "memory_diagnostics.hpp"
#include <uni20/core/numeric_limits.hpp>
#include <uni20/core/scalar_traits.hpp>
 
#include <algorithm>
#include <cstddef>
#include <stdexcept>
#include <type_traits>
 
namespace uni20
{
 
struct uninitialized_t
{
    explicit constexpr uninitialized_t() = default;
};
 
inline constexpr uninitialized_t uninitialized{};
 
enum class StorageInitialization
{
  Zero,
  Uninitialized
};
 
template <typename T>
inline constexpr bool enable_uninitialized_storage =
    std::is_trivially_copyable_v<T> && std::is_trivially_destructible_v<T>;
 
template <typename Real>
inline constexpr bool enable_uninitialized_storage<uni20::detail::standard_complex<Real>> =
    std::is_trivially_destructible_v<uni20::detail::standard_complex<Real>>;
 
template <typename T>
concept uninitialized_ok = enable_uninitialized_storage<std::remove_cv_t<T>>;
 
namespace detail
{
 
template <typename T>
inline constexpr bool zero_initializable_v = [] {
  if constexpr (is_complex_v<T>)
  {
    using real_type = typename T::value_type;
    return requires { T{real_type{0}, real_type{0}}; };
  }
  else if constexpr (is_scalar_v<T>)
  {
    return requires { T{0}; };
  }
  else
  {
    return requires { T{}; };
  }
}();
 
template <typename T>
  requires zero_initializable_v<T>
T zero_value()
{
  if constexpr (is_complex_v<T>)
  {
    using real_type = typename T::value_type;
    return T{real_type{0}, real_type{0}};
  }
  else if constexpr (is_scalar_v<T>)
  {
    return T{0};
  }
  else
  {
    return T{};
  }
}
 
template <typename T>
inline constexpr bool has_signaling_nan_v = [] {
  if constexpr (is_complex_v<T>)
  {
    return has_signaling_nan_v<typename T::value_type>;
  }
  else if constexpr (is_real_v<T>)
  {
    // A numeric specialization need not implement every optional capability.
    return requires { requires uni20::numeric_limits<T>::has_signaling_NaN; };
  }
  else
  {
    return false;
  }
}();
 
template <typename T>
  requires has_signaling_nan_v<T>
T signaling_nan_value()
{
  if constexpr (is_complex_v<T>)
  {
    auto const value = uni20::numeric_limits<typename T::value_type>::signaling_NaN();
    return T{value, value};
  }
  else
  {
    return uni20::numeric_limits<T>::signaling_NaN();
  }
}
 
template <typename T> void initialize_host_elements(T* data, std::size_t count, StorageInitialization initialization)
{
  if (count == 0) return;
  if (initialization == StorageInitialization::Zero)
  {
    if constexpr (!zero_initializable_v<T>)
    {
      throw std::invalid_argument("Zero initialization requires an element type with a zero/default value");
    }
    else if constexpr (std::is_assignable_v<T&, T>)
    {
      for (std::size_t i = 0; i < count; ++i)
        data[i] = zero_value<T>();
    }
    return;
  }
#if UNI20_FILL_UNINITIALIZED_SNAN
  if constexpr (uninitialized_ok<T> && has_signaling_nan_v<T>)
  {
    std::fill_n(data, count, signaling_nan_value<T>());
  }
#endif
  if constexpr (uninitialized_ok<T>)
  {
    memory_diagnostics::mark_uninitialized(data, count * sizeof(T));
  }
}
 
} // namespace detail
} // namespace uni20