common.h

Go to the documentation of this file.

#pragma once
#include "native/attributes.h"
#include "native/isa.h"
#include "native/mask_traits.h"
#include "native/value_traits.h"
#include <array>
#include <span>
#include <concepts>
#include <utility>
#include <cstddef>
#include <cstdint>
#include <type_traits>
#include <limits>

namespace native {
  static_assert(sizeof(float) == 4 && std::numeric_limits<float>::is_iec559 &&
    std::numeric_limits<float>::radix == 2 && std::numeric_limits<float>::digits == 24 &&
    std::numeric_limits<float>::min_exponent == -125 && std::numeric_limits<float>::max_exponent == 128,
    "native math requires IEEE 754 binary32 float");
 
  using std::int8_t;
  using std::int16_t;
  using std::int32_t;
  using std::int64_t;
  using std::uint8_t;
  using std::uint16_t;
  using std::uint32_t;
  using std::uint64_t;
 
  template <class T> concept simd_integer_element =
    std::same_as<T,int8_t> || std::same_as<T,int16_t> ||
    std::same_as<T,int32_t> || std::same_as<T,int64_t> ||
    std::same_as<T,uint8_t> || std::same_as<T,uint16_t> ||
    std::same_as<T,uint32_t> || std::same_as<T,uint64_t>;

  template<class V> requires requires { typename V::value_type; } &&
    (std::same_as<typename V::value_type,float> ||
     std::same_as<typename V::value_type,std::int32_t> ||
     std::same_as<typename V::value_type,std::uint32_t>)
  struct compaction_result {
    V value;
    std::size_t count;
  };

  template <std::size_t K> struct imm_t {
    static constexpr std::size_t value = K;
    native_nodiscard native_inline native_const consteval operator std::size_t() const noexcept { return K; }
  };

  template <std::size_t K> inline constexpr imm_t<K> imm{};

  template<class U> requires (std::is_unsigned_v<U> && !std::same_as<U,bool> && (sizeof(U)==1 || sizeof(U)==2 || sizeof(U)==4 || sizeof(U)==8))
  struct mask_lane {
    using storage_type=U;
    native_inline constexpr mask_lane() noexcept = default;
    explicit native_inline constexpr mask_lane(bool value) noexcept : value_(value?U(~U(0)):U(0)) {}
    native_nodiscard static native_inline native_const constexpr mask_lane from_bits(U value) noexcept { return mask_lane(value!=0); }
    native_nodiscard native_inline native_pure constexpr U to_bits() const noexcept { return value_; }
    native_nodiscard native_inline native_pure constexpr bool to_bool() const noexcept { return value_!=0; }
    native_nodiscard friend native_inline native_const constexpr mask_lane operator!(mask_lane a) noexcept { return mask_lane(!a.to_bool()); }
    native_nodiscard friend native_inline native_const constexpr mask_lane operator~(mask_lane a) noexcept { return !a; }
    native_nodiscard friend native_inline native_const constexpr mask_lane operator&(mask_lane a,mask_lane b) noexcept { return mask_lane(a.to_bool()&&b.to_bool()); }
    native_nodiscard friend native_inline native_const constexpr mask_lane operator|(mask_lane a,mask_lane b) noexcept { return mask_lane(a.to_bool()||b.to_bool()); }
    native_nodiscard friend native_inline native_const constexpr mask_lane operator^(mask_lane a,mask_lane b) noexcept { return mask_lane(a.to_bool()!=b.to_bool()); }
    native_nodiscard friend native_inline native_const constexpr bool operator==(mask_lane,mask_lane) noexcept = default;
  private:
    U value_=0;
  };
  using mask8=mask_lane<std::uint8_t>;
  using mask16=mask_lane<std::uint16_t>;
  using mask32=mask_lane<std::uint32_t>;
  using mask64=mask_lane<std::uint64_t>;
  template<class T> concept simd_mask_element=detail::is_mask_lane<T>;
 
  // Custom elements supply their storage register and their own value semantics.
  // The core never lifts raw arithmetic into a user-defined element implicitly.
  template <class T> struct simd_traits;
  template <class T, class Raw, class Self> struct simd_customization;
  template <class T> concept simd_custom_element = requires {
    typename simd_traits<T>::storage_type;
  };
  namespace detail {
    template<class V,class U,class=void> struct memory_architecture : value_architecture<V> {};
    template<class V,simd_custom_element U>
      requires std::same_as<typename V::value_type,typename simd_traits<U>::storage_type> &&
        value_architecture<V>::known &&
        value_architecture<typename V::template rebind<U>>::known
    struct memory_architecture<V,U,std::void_t<typename V::template rebind<U>>> {
      static constexpr isa<> value=value_architecture_v<V> &
        value_architecture_v<typename V::template rebind<U>>;
      static constexpr bool known=true;
    };
    template<class V,class U> inline constexpr isa<> memory_architecture_v=memory_architecture<V,U>::value;
  }
 
  namespace detail {
  // Native registers are trivial values: default initialization leaves lanes
  // unspecified; broadcast, load, or value initialization supplies every lane.
  // Partial operations touch exactly n lanes (0 <= n <= lanes).
  template<class V, std::size_t L> struct register_memory;
  }
  template<class T, std::size_t N, isa<> Arch> struct simd;
  template<std::size_t N, isa<> Arch> struct predicate;

  template<class T, std::size_t N, isa<> Arch>
    requires requires { typename simd<T, N, Arch>::mask_type; }
  struct mask_traits<simd<T, N, Arch>> {
    using type = typename simd<T, N, Arch>::mask_type;
  };

  template<std::size_t N, isa<> Arch>
    requires requires { typename predicate<N, Arch>::native_type; }
  struct mask_traits<predicate<N, Arch>> { using type = predicate<N, Arch>; };

  template<class U> requires requires { typename mask_lane<U>; }
  struct mask_traits<mask_lane<U>> { using type = mask_lane<U>; };
 
  namespace detail { template<class T,std::size_t N,isa<> Arch> struct swizzle_access {}; }
 
  // Native-register conversions must not make different architectures mix.
  template<class T,class U,std::size_t N,std::size_t M,isa<> A,isa<> B> requires(A!=B || (N!=M && (N==2 || N==3 || M==2 || M==3)))
  void operator+(simd<T,N,A>,simd<U,M,B>) = delete;
  template<class T,class U,std::size_t N,std::size_t M,isa<> A,isa<> B> requires(A!=B || (N!=M && (N==2 || N==3 || M==2 || M==3)))
  void operator-(simd<T,N,A>,simd<U,M,B>) = delete;
  template<class T,class U,std::size_t N,std::size_t M,isa<> A,isa<> B> requires(A!=B || (N!=M && (N==2 || N==3 || M==2 || M==3)))
  void operator*(simd<T,N,A>,simd<U,M,B>) = delete;
  template<class T,class U,std::size_t N,std::size_t M,isa<> A,isa<> B> requires(A!=B || (N!=M && (N==2 || N==3 || M==2 || M==3)))
  void operator/(simd<T,N,A>,simd<U,M,B>) = delete;
  template<class T,class U,std::size_t N,std::size_t M,isa<> A,isa<> B> requires(A!=B || (N!=M && (N==2 || N==3 || M==2 || M==3)))
  void operator%(simd<T,N,A>,simd<U,M,B>) = delete;
  template<class T,class U,std::size_t N,std::size_t M,isa<> A,isa<> B> requires(A!=B || (N!=M && (N==2 || N==3 || M==2 || M==3)))
  void operator&(simd<T,N,A>,simd<U,M,B>) = delete;
  template<class T,class U,std::size_t N,std::size_t M,isa<> A,isa<> B> requires(A!=B || (N!=M && (N==2 || N==3 || M==2 || M==3)))
  void operator|(simd<T,N,A>,simd<U,M,B>) = delete;
  template<class T,class U,std::size_t N,std::size_t M,isa<> A,isa<> B> requires(A!=B || (N!=M && (N==2 || N==3 || M==2 || M==3)))
  void operator^(simd<T,N,A>,simd<U,M,B>) = delete;
  template<class T,class U,std::size_t N,std::size_t M,isa<> A,isa<> B> requires(A!=B || (N!=M && (N==2 || N==3 || M==2 || M==3)))
  void operator<<(simd<T,N,A>,simd<U,M,B>) = delete;
  template<class T,class U,std::size_t N,std::size_t M,isa<> A,isa<> B> requires(A!=B || (N!=M && (N==2 || N==3 || M==2 || M==3)))
  void operator>>(simd<T,N,A>,simd<U,M,B>) = delete;
  template<class T,class U,std::size_t N,std::size_t M,isa<> A,isa<> B> requires(A!=B || (N!=M && (N==2 || N==3 || M==2 || M==3)))
  void operator==(simd<T,N,A>,simd<U,M,B>) = delete;
  template<class T,class U,std::size_t N,std::size_t M,isa<> A,isa<> B> requires(A!=B || (N!=M && (N==2 || N==3 || M==2 || M==3)))
  void operator!=(simd<T,N,A>,simd<U,M,B>) = delete;
  template<class T,class U,std::size_t N,std::size_t M,isa<> A,isa<> B> requires(A!=B || (N!=M && (N==2 || N==3 || M==2 || M==3)))
  void operator<(simd<T,N,A>,simd<U,M,B>) = delete;
  template<class T,class U,std::size_t N,std::size_t M,isa<> A,isa<> B> requires(A!=B || (N!=M && (N==2 || N==3 || M==2 || M==3)))
  void operator<=(simd<T,N,A>,simd<U,M,B>) = delete;
  template<class T,class U,std::size_t N,std::size_t M,isa<> A,isa<> B> requires(A!=B || (N!=M && (N==2 || N==3 || M==2 || M==3)))
  void operator>(simd<T,N,A>,simd<U,M,B>) = delete;
  template<class T,class U,std::size_t N,std::size_t M,isa<> A,isa<> B> requires(A!=B || (N!=M && (N==2 || N==3 || M==2 || M==3)))
  void operator>=(simd<T,N,A>,simd<U,M,B>) = delete;
  template<class T,class U,std::size_t N,std::size_t M,isa<> A,isa<> B> requires(A!=B || (N!=M && (N==2 || N==3 || M==2 || M==3)))
  void operator+=(simd<T,N,A> &,simd<U,M,B>) = delete;
  template<class T,class U,std::size_t N,std::size_t M,isa<> A,isa<> B> requires(A!=B || (N!=M && (N==2 || N==3 || M==2 || M==3)))
  void operator-=(simd<T,N,A> &,simd<U,M,B>) = delete;
  template<class T,class U,std::size_t N,std::size_t M,isa<> A,isa<> B> requires(A!=B || (N!=M && (N==2 || N==3 || M==2 || M==3)))
  void operator*=(simd<T,N,A> &,simd<U,M,B>) = delete;
  template<class T,class U,std::size_t N,std::size_t M,isa<> A,isa<> B> requires(A!=B || (N!=M && (N==2 || N==3 || M==2 || M==3)))
  void operator/=(simd<T,N,A> &,simd<U,M,B>) = delete;
  template<class T,class U,std::size_t N,std::size_t M,isa<> A,isa<> B> requires(A!=B || (N!=M && (N==2 || N==3 || M==2 || M==3)))
  void operator%=(simd<T,N,A> &,simd<U,M,B>) = delete;
  template<class T,class U,std::size_t N,std::size_t M,isa<> A,isa<> B> requires(A!=B || (N!=M && (N==2 || N==3 || M==2 || M==3)))
  void operator&=(simd<T,N,A> &,simd<U,M,B>) = delete;
  template<class T,class U,std::size_t N,std::size_t M,isa<> A,isa<> B> requires(A!=B || (N!=M && (N==2 || N==3 || M==2 || M==3)))
  void operator|=(simd<T,N,A> &,simd<U,M,B>) = delete;
  template<class T,class U,std::size_t N,std::size_t M,isa<> A,isa<> B> requires(A!=B || (N!=M && (N==2 || N==3 || M==2 || M==3)))
  void operator^=(simd<T,N,A> &,simd<U,M,B>) = delete;
  template<class T,class U,std::size_t N,std::size_t M,isa<> A,isa<> B> requires(A!=B || (N!=M && (N==2 || N==3 || M==2 || M==3)))
  void operator<<=(simd<T,N,A> &,simd<U,M,B>) = delete;
  template<class T,class U,std::size_t N,std::size_t M,isa<> A,isa<> B> requires(A!=B || (N!=M && (N==2 || N==3 || M==2 || M==3)))
  void operator>>=(simd<T,N,A> &,simd<U,M,B>) = delete;

  enum class simd_access { ordinary, streaming };
  template <std::size_t Alignment = 1, simd_access Access = simd_access::ordinary>
  struct simd_memory {
    static_assert(Alignment > 0 && (Alignment & (Alignment - 1)) == 0);
    static constexpr std::size_t alignment = Alignment;
    static constexpr simd_access requested_access = Access;
    // Streaming is currently an ordinary-access fallback on every backend.
    static constexpr bool non_temporal = false;
  };
 
}