Grok  9.5.0
Classes | Namespaces | Macros | Typedefs | Enumerations | Functions
rvv-inl.h File Reference
#include <riscv_vector.h>
#include <stddef.h>
#include <stdint.h>
#include "hwy/base.h"
#include "hwy/ops/shared-inl.h"

Go to the source code of this file.

Classes

struct  hwy::HWY_NAMESPACE::DFromV_t< V >
 

Namespaces

 hwy
 
 hwy::HWY_NAMESPACE
 
 hwy::HWY_NAMESPACE::detail
 

Macros

#define HWY_RVV_FOREACH_B(X_MACRO, NAME, OP)
 
#define HWY_RVV_FOREACH_08(X_MACRO, BASE, CHAR, NAME, OP)
 
#define HWY_RVV_FOREACH_16(X_MACRO, BASE, CHAR, NAME, OP)
 
#define HWY_RVV_FOREACH_32(X_MACRO, BASE, CHAR, NAME, OP)
 
#define HWY_RVV_FOREACH_64(X_MACRO, BASE, CHAR, NAME, OP)
 
#define HWY_RVV_FOREACH_U08(X_MACRO, NAME, OP)    HWY_RVV_FOREACH_08(X_MACRO, uint, u, NAME, OP)
 
#define HWY_RVV_FOREACH_U16(X_MACRO, NAME, OP)    HWY_RVV_FOREACH_16(X_MACRO, uint, u, NAME, OP)
 
#define HWY_RVV_FOREACH_U32(X_MACRO, NAME, OP)    HWY_RVV_FOREACH_32(X_MACRO, uint, u, NAME, OP)
 
#define HWY_RVV_FOREACH_U64(X_MACRO, NAME, OP)    HWY_RVV_FOREACH_64(X_MACRO, uint, u, NAME, OP)
 
#define HWY_RVV_FOREACH_I08(X_MACRO, NAME, OP)    HWY_RVV_FOREACH_08(X_MACRO, int, i, NAME, OP)
 
#define HWY_RVV_FOREACH_I16(X_MACRO, NAME, OP)    HWY_RVV_FOREACH_16(X_MACRO, int, i, NAME, OP)
 
#define HWY_RVV_FOREACH_I32(X_MACRO, NAME, OP)    HWY_RVV_FOREACH_32(X_MACRO, int, i, NAME, OP)
 
#define HWY_RVV_FOREACH_I64(X_MACRO, NAME, OP)    HWY_RVV_FOREACH_64(X_MACRO, int, i, NAME, OP)
 
#define HWY_RVV_FOREACH_F16(X_MACRO, NAME, OP)    HWY_RVV_FOREACH_16(X_MACRO, float, f, NAME, OP)
 
#define HWY_RVV_FOREACH_F32(X_MACRO, NAME, OP)    HWY_RVV_FOREACH_32(X_MACRO, float, f, NAME, OP)
 
#define HWY_RVV_FOREACH_F64(X_MACRO, NAME, OP)    HWY_RVV_FOREACH_64(X_MACRO, float, f, NAME, OP)
 
#define HWY_RVV_FOREACH_U(X_MACRO, NAME, OP)
 
#define HWY_RVV_FOREACH_I(X_MACRO, NAME, OP)
 
#define HWY_RVV_FOREACH_F(X_MACRO, NAME, OP)
 
#define HWY_RVV_FOREACH_UI16(X_MACRO, NAME, OP)
 
#define HWY_RVV_FOREACH_UI32(X_MACRO, NAME, OP)
 
#define HWY_RVV_FOREACH_UI64(X_MACRO, NAME, OP)
 
#define HWY_RVV_FOREACH_UI(X_MACRO, NAME, OP)
 
#define HWY_RVV_FOREACH(X_MACRO, NAME, OP)
 
#define HWY_RVV_T(BASE, SEW)   BASE##SEW##_t
 
#define HWY_RVV_D(CHAR, SEW, LMUL)   D##CHAR##SEW##LMUL
 
#define HWY_RVV_V(BASE, SEW, LMUL)   v##BASE##SEW##LMUL##_t
 
#define HWY_RVV_M(MLEN)   vbool##MLEN##_t
 
#define HWY_SPECIALIZE(BASE, CHAR, SEW, LMUL, X2, HALF, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_LANES(BASE, CHAR, SEW, LMUL, X2, HALF, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_AVL(SEW, SHIFT)   Lanes(Full<HWY_RVV_T(uint, SEW), SHIFT>())
 
#define HWY_RVV_RETV_ARGV(BASE, CHAR, SEW, LMUL, X2, HALF, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_RETV_ARGVS(BASE, CHAR, SEW, LMUL, X2, HALF, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_RETV_ARGVV(BASE, CHAR, SEW, LMUL, X2, HALF, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_SET(BASE, CHAR, SEW, LMUL, X2, HALF, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_UNDEFINED(BASE, CHAR, SEW, LMUL, X2, HALF, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_CAST_U8(BASE, CHAR, SEW, LMUL, X2, HALF, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_CAST_I8(BASE, CHAR, SEW, LMUL, X2, HALF, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_CAST_U(BASE, CHAR, SEW, LMUL, X2, HALF, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_CAST_IF(BASE, CHAR, SEW, LMUL, X2, HALF, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_IOTA(BASE, CHAR, SEW, LMUL, X2, HALF, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_SHIFT(BASE, CHAR, SEW, LMUL, X2, HALF, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_SHIFT_VV(BASE, CHAR, SEW, LMUL, X2, HALF, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_SHIFT_II(BASE, CHAR, SEW, LMUL, X2, HALF, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_FMA(BASE, CHAR, SEW, LMUL, X2, HALF, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_RETM_ARGVV(BASE, CHAR, SEW, LMUL, X2, HALF, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_RETM_ARGVS(BASE, CHAR, SEW, LMUL, X2, HALF, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_RETM_ARGM(SEW, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_RETM_ARGMM(SEW, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_IF_THEN_ELSE(BASE, CHAR, SEW, LMUL, X2, HALF, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_VEC_FROM_MASK(BASE, CHAR, SEW, LMUL, X2, HALF, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_FIND_FIRST_TRUE(SEW, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_ALL_TRUE(SEW, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_COUNT_TRUE(SEW, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_LOAD(BASE, CHAR, SEW, LMUL, X2, HALF, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_MASKED_LOAD(BASE, CHAR, SEW, LMUL, X2, HALF, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_RET_ARGVDP(BASE, CHAR, SEW, LMUL, X2, HALF, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_SCATTER(BASE, CHAR, SEW, LMUL, X2, HALF, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_GATHER(BASE, CHAR, SEW, LMUL, X2, HALF, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_PROMOTE(OP, BASE, CHAR, BITS, BASE_IN, BITS_IN, LMUL, LMUL_IN)
 
#define HWY_RVV_PROMOTE_X2(OP, BASE, CHAR, BITS, BASE_IN, BITS_IN)
 
#define HWY_RVV_PROMOTE_X4(OP, BASE, CHAR, BITS, BASE_IN, BITS_IN)
 
#define HWY_RVV_CONVERT(BASE, CHAR, SEW, LMUL, X2, HALF, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_SLIDE(BASE, CHAR, SEW, LMUL, X2, HALF, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_TRUNC(BASE, CHAR, SEW, LMUL, X2, HALF, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_GET_LANE(BASE, CHAR, SEW, LMUL, X2, HALF, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_TABLE(BASE, CHAR, SEW, LMUL, X2, HALF, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_COMPRESS(BASE, CHAR, SEW, LMUL, X2, HALF, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_REDUCE(BASE, CHAR, SEW, LMUL, X2, HALF, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_STORE_MASK_BITS(SEW, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_RETV_ARGV2(BASE, CHAR, SEW, LMUL, X2, HALF, SHIFT, MLEN, NAME, OP)
 
#define HWY_RVV_SLIDE1(BASE, CHAR, SEW, LMUL, X2, HALF, SHIFT, MLEN, NAME, OP)
 

Typedefs

template<class D >
using hwy::HWY_NAMESPACE::MFromD = decltype(MaskFromVec(Zero(D())))
 

Enumerations

enum  hwy::HWY_NAMESPACE::detail::RoundingModes { hwy::HWY_NAMESPACE::detail::kNear , hwy::HWY_NAMESPACE::detail::kTrunc , hwy::HWY_NAMESPACE::detail::kDown , hwy::HWY_NAMESPACE::detail::kUp }
 

Functions

 HWY_BEFORE_NAMESPACE ()
 
template<typename T , size_t N>
constexpr HWY_INLINE size_t hwy::HWY_NAMESPACE::MLenFromD (Simd< T, N >)
 
template<size_t N>
HWY_API size_t hwy::HWY_NAMESPACE::Lanes (Simd< bfloat16_t, N >)
 
template<size_t N>
decltype(Set(Simd< uint16_t, N >(), 0)) hwy::HWY_NAMESPACE::Set (Simd< bfloat16_t, N > d, bfloat16_t arg)
 
template<typename T , size_t N, HWY_IF_LE128(T, N) >
HWY_API VFromD< Simd< T, N > > hwy::HWY_NAMESPACE::Set (Simd< T, N >, T arg)
 
template<typename T , size_t N>
HWY_API VFromD< Simd< T, N > > hwy::HWY_NAMESPACE::Zero (Simd< T, N > d)
 
template<class D >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::Undefined (D d)
 
template<size_t N>
HWY_INLINE VFromD< Simd< uint16_t, N > > hwy::HWY_NAMESPACE::detail::BitCastFromByte (Simd< bfloat16_t, N >, VFromD< Simd< uint8_t, N *2 >> v)
 
template<class D , class FromV >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::BitCast (D d, FromV v)
 
template<typename T , size_t N, class FromV , HWY_IF_LE128(T, N) >
HWY_API VFromD< Simd< T, N > > hwy::HWY_NAMESPACE::BitCast (Simd< T, N >, FromV v)
 
template<class V , class DU = RebindToUnsigned<DFromV<V>>>
HWY_INLINE VFromD< DU > hwy::HWY_NAMESPACE::detail::BitCastToUnsigned (V v)
 
template<class D , class DU = RebindToUnsigned<D>>
HWY_INLINE VFromD< DU > hwy::HWY_NAMESPACE::detail::Iota0 (const D)
 
template<typename T , size_t N, HWY_IF_LE128(T, N) >
HWY_INLINE VFromD< Simd< T, N > > hwy::HWY_NAMESPACE::detail::Iota0 (Simd< T, N >)
 
template<class V , HWY_IF_FLOAT_V(V) >
HWY_APIhwy::HWY_NAMESPACE::Not (const V v)
 
template<class V , HWY_IF_FLOAT_V(V) >
HWY_APIhwy::HWY_NAMESPACE::And (const V a, const V b)
 
template<class V , HWY_IF_FLOAT_V(V) >
HWY_APIhwy::HWY_NAMESPACE::Or (const V a, const V b)
 
template<class V , HWY_IF_FLOAT_V(V) >
HWY_APIhwy::HWY_NAMESPACE::Xor (const V a, const V b)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::AndNot (const V not_a, const V b)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::CopySignToAbs (const V abs, const V sign)
 
template<class V >
HWY_API auto hwy::HWY_NAMESPACE::Ge (V a, V b) -> decltype(a==b)
 
template<class V >
HWY_API auto hwy::HWY_NAMESPACE::Gt (V a, V b) -> decltype(a==b)
 
template<class V >
HWY_API auto hwy::HWY_NAMESPACE::TestBit (const V a, const V bit) -> decltype(Eq(a, bit))
 
template<class M , class V >
HWY_APIhwy::HWY_NAMESPACE::IfThenElseZero (const M mask, const V yes)
 
template<class M , class V >
HWY_APIhwy::HWY_NAMESPACE::IfThenZeroElse (const M mask, const V no)
 
template<class V >
HWY_API auto hwy::HWY_NAMESPACE::MaskFromVec (const V v) -> decltype(Eq(v, v))
 
template<class D , typename MFrom >
HWY_API MFromD< D > hwy::HWY_NAMESPACE::RebindMask (const D, const MFrom mask)
 
template<class D , HWY_IF_NOT_FLOAT_D(D) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::VecFromMask (const D d, MFromD< D > mask)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::ZeroIfNegative (const V v)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::BroadcastSignBit (const V v)
 
template<class D >
HWY_API bool hwy::HWY_NAMESPACE::AllFalse (D d, MFromD< D > m)
 
template<typename T , size_t N, HWY_IF_LE128(T, N) >
HWY_API VFromD< Simd< T, N > > hwy::HWY_NAMESPACE::Load (Simd< T, N > d, const T *HWY_RESTRICT p)
 
template<size_t N>
HWY_API VFromD< Simd< uint16_t, N > > hwy::HWY_NAMESPACE::Load (Simd< bfloat16_t, N > d, const bfloat16_t *HWY_RESTRICT p)
 
template<size_t N>
HWY_API void hwy::HWY_NAMESPACE::Store (VFromD< Simd< uint16_t, N >> v, Simd< bfloat16_t, N > d, bfloat16_t *HWY_RESTRICT p)
 
template<class D >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::LoadU (D d, const TFromD< D > *HWY_RESTRICT p)
 
template<typename T , size_t N, HWY_IF_LE128(T, N) >
HWY_API void hwy::HWY_NAMESPACE::Store (VFromD< Simd< T, N >> v, Simd< T, N >, T *HWY_RESTRICT p)
 
template<class V , class D >
HWY_API void hwy::HWY_NAMESPACE::StoreU (const V v, D d, TFromD< D > *HWY_RESTRICT p)
 
template<class V , class D , typename T >
HWY_API void hwy::HWY_NAMESPACE::Stream (const V v, D d, T *HWY_RESTRICT aligned)
 
template<typename T , size_t N, HWY_IF_LE128(T, N) >
HWY_API void hwy::HWY_NAMESPACE::ScatterOffset (VFromD< Simd< T, N >> v, Simd< T, N >, T *HWY_RESTRICT base, VFromD< Simd< MakeSigned< T >, N >> offset)
 
template<class D , HWY_IF_LANE_SIZE_D(D, 4) >
HWY_API void hwy::HWY_NAMESPACE::ScatterIndex (VFromD< D > v, D d, TFromD< D > *HWY_RESTRICT base, const VFromD< RebindToSigned< D >> index)
 
template<typename T , size_t N, HWY_IF_LE128(T, N) >
HWY_API VFromD< Simd< T, N > > hwy::HWY_NAMESPACE::GatherOffset (Simd< T, N >, const T *HWY_RESTRICT base, VFromD< Simd< MakeSigned< T >, N >> offset)
 
template<class D , HWY_IF_LANE_SIZE_D(D, 4) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::GatherIndex (D d, const TFromD< D > *HWY_RESTRICT base, const VFromD< RebindToSigned< D >> index)
 
template<size_t N>
HWY_API auto hwy::HWY_NAMESPACE::PromoteTo (Simd< int16_t, N > d, VFromD< Simd< uint8_t, N >> v) -> VFromD< decltype(d)>
 
template<size_t N>
HWY_API auto hwy::HWY_NAMESPACE::PromoteTo (Simd< int32_t, N > d, VFromD< Simd< uint8_t, N >> v) -> VFromD< decltype(d)>
 
template<size_t N>
HWY_API auto hwy::HWY_NAMESPACE::PromoteTo (Simd< int32_t, N > d, VFromD< Simd< uint16_t, N >> v) -> VFromD< decltype(d)>
 
template<size_t N>
HWY_API auto hwy::HWY_NAMESPACE::PromoteTo (Simd< float32_t, N > d, VFromD< Simd< bfloat16_t, N >> v) -> VFromD< decltype(d)>
 
HWY_INLINE Vu16m1 hwy::HWY_NAMESPACE::detail::DemoteTo (Du16m1 d, const Vu32m2 v)
 
HWY_INLINE Vu16m2 hwy::HWY_NAMESPACE::detail::DemoteTo (Du16m2 d, const Vu32m4 v)
 
HWY_INLINE Vu16m4 hwy::HWY_NAMESPACE::detail::DemoteTo (Du16m4 d, const Vu32m8 v)
 
HWY_INLINE Vu8m1 hwy::HWY_NAMESPACE::detail::DemoteTo (Du8m1 d, const Vu16m2 v)
 
HWY_INLINE Vu8m2 hwy::HWY_NAMESPACE::detail::DemoteTo (Du8m2 d, const Vu16m4 v)
 
HWY_INLINE Vu8m4 hwy::HWY_NAMESPACE::detail::DemoteTo (Du8m4 d, const Vu16m8 v)
 
HWY_API Vu16m1 hwy::HWY_NAMESPACE::DemoteTo (Du16m1 d, const Vi32m2 v)
 
HWY_API Vu16m2 hwy::HWY_NAMESPACE::DemoteTo (Du16m2 d, const Vi32m4 v)
 
HWY_API Vu16m4 hwy::HWY_NAMESPACE::DemoteTo (Du16m4 d, const Vi32m8 v)
 
HWY_API Vu8m1 hwy::HWY_NAMESPACE::DemoteTo (Du8m1 d, const Vi32m4 v)
 
HWY_API Vu8m2 hwy::HWY_NAMESPACE::DemoteTo (Du8m2 d, const Vi32m8 v)
 
HWY_API Vu8m1 hwy::HWY_NAMESPACE::DemoteTo (Du8m1 d, const Vi16m2 v)
 
HWY_API Vu8m2 hwy::HWY_NAMESPACE::DemoteTo (Du8m2 d, const Vi16m4 v)
 
HWY_API Vu8m4 hwy::HWY_NAMESPACE::DemoteTo (Du8m4 d, const Vi16m8 v)
 
HWY_API Vu8m1 hwy::HWY_NAMESPACE::U8FromU32 (const Vu32m4 v)
 
HWY_API Vu8m2 hwy::HWY_NAMESPACE::U8FromU32 (const Vu32m8 v)
 
HWY_API Vi8m1 hwy::HWY_NAMESPACE::DemoteTo (Di8m1 d, const Vi16m2 v)
 
HWY_API Vi8m2 hwy::HWY_NAMESPACE::DemoteTo (Di8m2 d, const Vi16m4 v)
 
HWY_API Vi8m4 hwy::HWY_NAMESPACE::DemoteTo (Di8m4 d, const Vi16m8 v)
 
HWY_API Vi16m1 hwy::HWY_NAMESPACE::DemoteTo (Di16m1 d, const Vi32m2 v)
 
HWY_API Vi16m2 hwy::HWY_NAMESPACE::DemoteTo (Di16m2 d, const Vi32m4 v)
 
HWY_API Vi16m4 hwy::HWY_NAMESPACE::DemoteTo (Di16m4 d, const Vi32m8 v)
 
HWY_API Vi8m1 hwy::HWY_NAMESPACE::DemoteTo (Di8m1 d, const Vi32m4 v)
 
HWY_API Vi8m2 hwy::HWY_NAMESPACE::DemoteTo (Di8m2 d, const Vi32m8 v)
 
HWY_API Vf32m1 hwy::HWY_NAMESPACE::DemoteTo (Df32m1 d, const Vf64m2 v)
 
HWY_API Vf32m2 hwy::HWY_NAMESPACE::DemoteTo (Df32m2 d, const Vf64m4 v)
 
HWY_API Vf32m4 hwy::HWY_NAMESPACE::DemoteTo (Df32m4 d, const Vf64m8 v)
 
HWY_API Vi32m1 hwy::HWY_NAMESPACE::DemoteTo (Di32m1 d, const Vf64m2 v)
 
HWY_API Vi32m2 hwy::HWY_NAMESPACE::DemoteTo (Di32m2 d, const Vf64m4 v)
 
HWY_API Vi32m4 hwy::HWY_NAMESPACE::DemoteTo (Di32m4 d, const Vf64m8 v)
 
template<size_t N>
HWY_API VFromD< Simd< uint16_t, N > > hwy::HWY_NAMESPACE::DemoteTo (Simd< bfloat16_t, N > d, VFromD< Simd< float, N >> v)
 
template<typename T , size_t N, class FromV , HWY_IF_LE128(T, N) >
HWY_API VFromD< Simd< T, N > > hwy::HWY_NAMESPACE::ConvertTo (Simd< T, N >, FromV v)
 
template<typename T , size_t N>
constexpr size_t hwy::HWY_NAMESPACE::detail::LanesPerBlock (Simd< T, N >)
 
template<class D , class V >
HWY_INLINEhwy::HWY_NAMESPACE::detail::OffsetsOf128BitBlocks (const D d, const V iota0)
 
template<size_t kLanes, class D >
HWY_INLINE MFromD< D > hwy::HWY_NAMESPACE::detail::FirstNPerBlock (D)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::ConcatUpperLower (const V hi, const V lo)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::ConcatLowerLower (const V hi, const V lo)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::ConcatUpperUpper (const V hi, const V lo)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::ConcatLowerUpper (const V hi, const V lo)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::ZeroExtendVector (const V lo)
 
template<class D , HWY_IF_NOT_LANE_SIZE_D(D, 8) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::LowerHalf (const D, const VFromD< D > v)
 
template<class D , HWY_IF_NOT_LANE_SIZE_D(D, 8) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::UpperHalf (const D d, const VFromD< D > v)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::OddEven (const V odd, const V even)
 
template<class D , class DU = RebindToUnsigned<D>>
HWY_API VFromD< DU > hwy::HWY_NAMESPACE::SetTableIndices (D d, const TFromD< DU > *idx)
 
template<class D >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::Reverse (D, VFromD< D > v)
 
template<class V , class M , class D >
HWY_API size_t hwy::HWY_NAMESPACE::CompressStore (const V v, const M mask, const D d, TFromD< D > *HWY_RESTRICT unaligned)
 
template<size_t kBytes, class D , class V = VFromD<D>>
HWY_APIhwy::HWY_NAMESPACE::CombineShiftRightBytes (const D d, const V hi, const V lo)
 
template<size_t kLanes, class D , class V = VFromD<D>>
HWY_APIhwy::HWY_NAMESPACE::CombineShiftRightLanes (const D d, const V hi, V lo)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::Shuffle2301 (const V v)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::Shuffle2103 (const V v)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::Shuffle0321 (const V v)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::Shuffle1032 (const V v)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::Shuffle01 (const V v)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::Shuffle0123 (const V v)
 
template<class V , class VI >
HWY_API VI hwy::HWY_NAMESPACE::TableLookupBytes (const V v, const VI idx)
 
template<class V , class VI >
HWY_APIhwy::HWY_NAMESPACE::TableLookupBytesOr0 (const VI v, const V idx)
 
template<int kLane, class V >
HWY_APIhwy::HWY_NAMESPACE::Broadcast (const V v)
 
template<size_t kLanes, class D , class V = VFromD<D>>
HWY_APIhwy::HWY_NAMESPACE::ShiftLeftLanes (D d, const V v)
 
template<size_t kLanes, class V >
HWY_APIhwy::HWY_NAMESPACE::ShiftLeftLanes (const V v)
 
template<int kBytes, class V >
HWY_APIhwy::HWY_NAMESPACE::ShiftLeftBytes (DFromV< V > d, const V v)
 
template<int kBytes, class V >
HWY_APIhwy::HWY_NAMESPACE::ShiftLeftBytes (const V v)
 
template<size_t kLanes, typename T , size_t N, class V = VFromD<Simd<T, N>>>
HWY_APIhwy::HWY_NAMESPACE::ShiftRightLanes (Simd< T, N > d, V v)
 
template<int kBytes, class D , class V = VFromD<D>>
HWY_APIhwy::HWY_NAMESPACE::ShiftRightBytes (const D d, const V v)
 
template<class D , class V >
HWY_APIhwy::HWY_NAMESPACE::InterleaveLower (D d, const V a, const V b)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::InterleaveLower (const V a, const V b)
 
template<class D , class V >
HWY_APIhwy::HWY_NAMESPACE::InterleaveUpper (const D d, const V a, const V b)
 
template<class V , class DW = RepartitionToWide<DFromV<V>>>
HWY_API VFromD< DW > hwy::HWY_NAMESPACE::ZipLower (DW dw, V a, V b)
 
template<class V , class DW = RepartitionToWide<DFromV<V>>>
HWY_API VFromD< DW > hwy::HWY_NAMESPACE::ZipLower (V a, V b)
 
template<class V , class DW = RepartitionToWide<DFromV<V>>>
HWY_API VFromD< DW > hwy::HWY_NAMESPACE::ZipUpper (DW dw, V a, V b)
 
template<class D >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::SumOfLanes (D, const VFromD< D > v)
 
template<class D >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::MinOfLanes (D, const VFromD< D > v)
 
template<class D >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::MaxOfLanes (D, const VFromD< D > v)
 
template<class D >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::LoadDup128 (D d, const TFromD< D > *const HWY_RESTRICT p)
 
template<class D , HWY_IF_NOT_LANE_SIZE_D(D, 1) >
HWY_API MFromD< D > hwy::HWY_NAMESPACE::FirstN (const D d, const size_t n)
 
template<class V , HWY_IF_SIGNED_V(V) >
HWY_APIhwy::HWY_NAMESPACE::Neg (const V v)
 
template<class V , HWY_IF_SIGNED_V(V) >
HWY_APIhwy::HWY_NAMESPACE::Abs (const V v)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::AbsDiff (const V a, const V b)
 
template<class V >
HWY_INLINE auto hwy::HWY_NAMESPACE::detail::UseInt (const V v) -> decltype(MaskFromVec(v))
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::Round (const V v)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::Trunc (const V v)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::Ceil (const V v)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::Floor (const V v)
 
template<class D , HWY_IF_FLOAT_D(D) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::Iota (const D d, TFromD< D > first)
 
template<class V , HWY_IF_LANE_SIZE_V(V, 4) >
HWY_API VFromD< RepartitionToWide< DFromV< V > > > hwy::HWY_NAMESPACE::MulEven (const V a, const V b)
 
template<class V , HWY_IF_LANE_SIZE_V(V, 8) >
HWY_INLINEhwy::HWY_NAMESPACE::MulEven (const V a, const V b)
 
template<class V , HWY_IF_LANE_SIZE_V(V, 8) >
HWY_INLINEhwy::HWY_NAMESPACE::MulOdd (const V a, const V b)
 
template<size_t N, class DF = Simd<float, N / 2>>
HWY_API VFromD< Simd< uint16_t, N > > hwy::HWY_NAMESPACE::ReorderDemote2To (Simd< bfloat16_t, N > dbf16, VFromD< DF > a, VFromD< DF > b)
 
template<size_t N, class DU16 = Simd<uint16_t, N * 2>>
HWY_API auto hwy::HWY_NAMESPACE::ReorderWidenMulAccumulate (Simd< float, N > df32, VFromD< DU16 > a, VFromD< DU16 > b, const VFromD< decltype(df32)> sum0, VFromD< decltype(df32)> &sum1) -> VFromD< decltype(df32)>
 
 HWY_AFTER_NAMESPACE ()
 

Macro Definition Documentation

◆ HWY_RVV_ALL_TRUE

#define HWY_RVV_ALL_TRUE (   SEW,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
template <class D> \
HWY_API bool AllTrue(D d, HWY_RVV_M(MLEN) m) { \
static_assert(MLenFromD(d) == MLEN, "Type mismatch"); \
return AllFalse(d, vmnot_m_b##MLEN(m, Lanes(d))); \
}
HWY_API size_t Lanes(Simd< bfloat16_t, N >)
Definition: rvv-inl.h:216
HWY_API bool AllTrue(const Simd< T, N > d, const Mask128< T, N > m)
Definition: arm_neon-inl.h:4557
constexpr HWY_INLINE size_t MLenFromD(Simd< T, N >)
Definition: rvv-inl.h:38
HWY_API bool AllFalse(D d, MFromD< D > m)
Definition: rvv-inl.h:859
#define HWY_RVV_M(MLEN)
Definition: rvv-inl.h:173

◆ HWY_RVV_AVL

#define HWY_RVV_AVL (   SEW,
  SHIFT 
)    Lanes(Full<HWY_RVV_T(uint, SEW), SHIFT>())

◆ HWY_RVV_CAST_I8

#define HWY_RVV_CAST_I8 (   BASE,
  CHAR,
  SEW,
  LMUL,
  X2,
  HALF,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API vuint8##LMUL##_t BitCastToByte(vint8##LMUL##_t v) { \
return vreinterpret_v_i8##LMUL##_u8##LMUL(v); \
} \
HWY_API vint8##LMUL##_t BitCastFromByte(HWY_RVV_D(CHAR, SEW, LMUL) /* d */, \
vuint8##LMUL##_t v) { \
return vreinterpret_v_u8##LMUL##_i8##LMUL(v); \
}
#define HWY_API
Definition: base.h:117
HWY_INLINE VFromD< Simd< uint16_t, N > > BitCastFromByte(Simd< bfloat16_t, N >, VFromD< Simd< uint8_t, N *2 >> v)
Definition: rvv-inl.h:372
HWY_INLINE Vec128< uint8_t, N > BitCastToByte(Vec128< uint8_t, N > v)
Definition: arm_neon-inl.h:551
#define HWY_RVV_D(CHAR, SEW, LMUL)
Definition: rvv-inl.h:171

◆ HWY_RVV_CAST_IF

#define HWY_RVV_CAST_IF (   BASE,
  CHAR,
  SEW,
  LMUL,
  X2,
  HALF,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API vuint8##LMUL##_t BitCastToByte(HWY_RVV_V(BASE, SEW, LMUL) v) { \
return v##OP##_v_u##SEW##LMUL##_u8##LMUL( \
v##OP##_v_##CHAR##SEW##LMUL##_u##SEW##LMUL(v)); \
} \
HWY_API HWY_RVV_V(BASE, SEW, LMUL) BitCastFromByte( \
HWY_RVV_D(CHAR, SEW, LMUL) /* d */, vuint8##LMUL##_t v) { \
return v##OP##_v_u##SEW##LMUL##_##CHAR##SEW##LMUL( \
v##OP##_v_u8##LMUL##_u##SEW##LMUL(v)); \
}
#define HWY_RVV_V(BASE, SEW, LMUL)
Definition: rvv-inl.h:172

◆ HWY_RVV_CAST_U

#define HWY_RVV_CAST_U (   BASE,
  CHAR,
  SEW,
  LMUL,
  X2,
  HALF,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API vuint8##LMUL##_t BitCastToByte(HWY_RVV_V(BASE, SEW, LMUL) v) { \
return v##OP##_v_##CHAR##SEW##LMUL##_u8##LMUL(v); \
} \
HWY_API HWY_RVV_V(BASE, SEW, LMUL) BitCastFromByte( \
HWY_RVV_D(CHAR, SEW, LMUL) /* d */, vuint8##LMUL##_t v) { \
return v##OP##_v_u8##LMUL##_##CHAR##SEW##LMUL(v); \
}

◆ HWY_RVV_CAST_U8

#define HWY_RVV_CAST_U8 (   BASE,
  CHAR,
  SEW,
  LMUL,
  X2,
  HALF,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API vuint8##LMUL##_t BitCastToByte(vuint8##LMUL##_t v) { return v; } \
HWY_API vuint8##LMUL##_t BitCastFromByte(HWY_RVV_D(CHAR, SEW, LMUL) /* d */, \
vuint8##LMUL##_t v) { \
return v; \
}

◆ HWY_RVV_COMPRESS

#define HWY_RVV_COMPRESS (   BASE,
  CHAR,
  SEW,
  LMUL,
  X2,
  HALF,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_V(BASE, SEW, LMUL) v, HWY_RVV_M(MLEN) mask) { \
return v##OP##_vm_##CHAR##SEW##LMUL(mask, v, v, HWY_RVV_AVL(SEW, SHIFT)); \
}
#define HWY_RVV_AVL(SEW, SHIFT)
Definition: rvv-inl.h:223

◆ HWY_RVV_CONVERT

#define HWY_RVV_CONVERT (   BASE,
  CHAR,
  SEW,
  LMUL,
  X2,
  HALF,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
ConvertTo(HWY_RVV_D(CHAR, SEW, LMUL) d, HWY_RVV_V(int, SEW, LMUL) v) { \
return vfcvt_f_x_v_f##SEW##LMUL(v, Lanes(d)); \
} \
/* Truncates (rounds toward zero). */ \
HWY_API HWY_RVV_V(int, SEW, LMUL) \
ConvertTo(HWY_RVV_D(i, SEW, LMUL) d, HWY_RVV_V(BASE, SEW, LMUL) v) { \
return vfcvt_rtz_x_f_v_i##SEW##LMUL(v, Lanes(d)); \
} \
/* Uses default rounding mode. */ \
HWY_API HWY_RVV_V(int, SEW, LMUL) NearestInt(HWY_RVV_V(BASE, SEW, LMUL) v) { \
return vfcvt_x_f_v_i##SEW##LMUL(v, HWY_RVV_AVL(SEW, SHIFT)); \
}
HWY_API Vec128< int32_t, N > NearestInt(const Vec128< float, N > v)
Definition: arm_neon-inl.h:2890

◆ HWY_RVV_COUNT_TRUE

#define HWY_RVV_COUNT_TRUE (   SEW,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
template <class D> \
HWY_API size_t CountTrue(D d, HWY_RVV_M(MLEN) m) { \
static_assert(MLenFromD(d) == MLEN, "Type mismatch"); \
return vpopc_m_b##MLEN(m, Lanes(d)); \
}
HWY_INLINE size_t CountTrue(hwy::SizeTag< 1 >, const Mask128< T > mask)
Definition: arm_neon-inl.h:4447

◆ HWY_RVV_D

#define HWY_RVV_D (   CHAR,
  SEW,
  LMUL 
)    D##CHAR##SEW##LMUL

◆ HWY_RVV_FIND_FIRST_TRUE

#define HWY_RVV_FIND_FIRST_TRUE (   SEW,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
template <class D> \
HWY_API intptr_t FindFirstTrue(D d, HWY_RVV_M(MLEN) m) { \
static_assert(MLenFromD(d) == MLEN, "Type mismatch"); \
return vfirst_m_b##MLEN(m, Lanes(d)); \
}
HWY_API intptr_t FindFirstTrue(const Simd< T, N >, const Mask128< T, N > mask)
Definition: arm_neon-inl.h:4520

◆ HWY_RVV_FMA

#define HWY_RVV_FMA (   BASE,
  CHAR,
  SEW,
  LMUL,
  X2,
  HALF,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_V(BASE, SEW, LMUL) mul, HWY_RVV_V(BASE, SEW, LMUL) x, \
HWY_RVV_V(BASE, SEW, LMUL) add) { \
return v##OP##_vv_##CHAR##SEW##LMUL(add, mul, x, HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ HWY_RVV_FOREACH

#define HWY_RVV_FOREACH (   X_MACRO,
  NAME,
  OP 
)
Value:
HWY_RVV_FOREACH_U(X_MACRO, NAME, OP) \
HWY_RVV_FOREACH_I(X_MACRO, NAME, OP) \
HWY_RVV_FOREACH_F(X_MACRO, NAME, OP)
#define HWY_RVV_FOREACH_U(X_MACRO, NAME, OP)
Definition: rvv-inl.h:123

◆ HWY_RVV_FOREACH_08

#define HWY_RVV_FOREACH_08 (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)
Value:
X_MACRO(BASE, CHAR, 8, m1, m2, mf2, /*kShift=*/0, /*MLEN=*/8, NAME, OP) \
X_MACRO(BASE, CHAR, 8, m2, m4, m1, /*kShift=*/1, /*MLEN=*/4, NAME, OP) \
X_MACRO(BASE, CHAR, 8, m4, m8, m2, /*kShift=*/2, /*MLEN=*/2, NAME, OP) \
X_MACRO(BASE, CHAR, 8, m8, __, m4, /*kShift=*/3, /*MLEN=*/1, NAME, OP)

◆ HWY_RVV_FOREACH_16

#define HWY_RVV_FOREACH_16 (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)
Value:
X_MACRO(BASE, CHAR, 16, m1, m2, mf2, /*kShift=*/0, /*MLEN=*/16, NAME, OP) \
X_MACRO(BASE, CHAR, 16, m2, m4, m1, /*kShift=*/1, /*MLEN=*/8, NAME, OP) \
X_MACRO(BASE, CHAR, 16, m4, m8, m2, /*kShift=*/2, /*MLEN=*/4, NAME, OP) \
X_MACRO(BASE, CHAR, 16, m8, __, m4, /*kShift=*/3, /*MLEN=*/2, NAME, OP)

◆ HWY_RVV_FOREACH_32

#define HWY_RVV_FOREACH_32 (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)
Value:
X_MACRO(BASE, CHAR, 32, m1, m2, mf2, /*kShift=*/0, /*MLEN=*/32, NAME, OP) \
X_MACRO(BASE, CHAR, 32, m2, m4, m1, /*kShift=*/1, /*MLEN=*/16, NAME, OP) \
X_MACRO(BASE, CHAR, 32, m4, m8, m2, /*kShift=*/2, /*MLEN=*/8, NAME, OP) \
X_MACRO(BASE, CHAR, 32, m8, __, m4, /*kShift=*/3, /*MLEN=*/4, NAME, OP)

◆ HWY_RVV_FOREACH_64

#define HWY_RVV_FOREACH_64 (   X_MACRO,
  BASE,
  CHAR,
  NAME,
  OP 
)
Value:
X_MACRO(BASE, CHAR, 64, m1, m2, mf2, /*kShift=*/0, /*MLEN=*/64, NAME, OP) \
X_MACRO(BASE, CHAR, 64, m2, m4, m1, /*kShift=*/1, /*MLEN=*/32, NAME, OP) \
X_MACRO(BASE, CHAR, 64, m4, m8, m2, /*kShift=*/2, /*MLEN=*/16, NAME, OP) \
X_MACRO(BASE, CHAR, 64, m8, __, m4, /*kShift=*/3, /*MLEN=*/8, NAME, OP)

◆ HWY_RVV_FOREACH_B

#define HWY_RVV_FOREACH_B (   X_MACRO,
  NAME,
  OP 
)
Value:
X_MACRO(64, 0, 64, NAME, OP) \
X_MACRO(32, 0, 32, NAME, OP) \
X_MACRO(16, 0, 16, NAME, OP) \
X_MACRO(8, 0, 8, NAME, OP) \
X_MACRO(8, 1, 4, NAME, OP) \
X_MACRO(8, 2, 2, NAME, OP) \
X_MACRO(8, 3, 1, NAME, OP)

◆ HWY_RVV_FOREACH_F

#define HWY_RVV_FOREACH_F (   X_MACRO,
  NAME,
  OP 
)
Value:
HWY_RVV_FOREACH_F32(X_MACRO, NAME, OP) \
HWY_RVV_FOREACH_F64(X_MACRO, NAME, OP)
#define HWY_RVV_FOREACH_F32(X_MACRO, NAME, OP)
Definition: rvv-inl.h:117

◆ HWY_RVV_FOREACH_F16

#define HWY_RVV_FOREACH_F16 (   X_MACRO,
  NAME,
  OP 
)     HWY_RVV_FOREACH_16(X_MACRO, float, f, NAME, OP)

◆ HWY_RVV_FOREACH_F32

#define HWY_RVV_FOREACH_F32 (   X_MACRO,
  NAME,
  OP 
)     HWY_RVV_FOREACH_32(X_MACRO, float, f, NAME, OP)

◆ HWY_RVV_FOREACH_F64

#define HWY_RVV_FOREACH_F64 (   X_MACRO,
  NAME,
  OP 
)     HWY_RVV_FOREACH_64(X_MACRO, float, f, NAME, OP)

◆ HWY_RVV_FOREACH_I

#define HWY_RVV_FOREACH_I (   X_MACRO,
  NAME,
  OP 
)
Value:
HWY_RVV_FOREACH_I08(X_MACRO, NAME, OP) \
HWY_RVV_FOREACH_I16(X_MACRO, NAME, OP) \
HWY_RVV_FOREACH_I32(X_MACRO, NAME, OP) \
HWY_RVV_FOREACH_I64(X_MACRO, NAME, OP)
#define HWY_RVV_FOREACH_I08(X_MACRO, NAME, OP)
Definition: rvv-inl.h:105

◆ HWY_RVV_FOREACH_I08

#define HWY_RVV_FOREACH_I08 (   X_MACRO,
  NAME,
  OP 
)     HWY_RVV_FOREACH_08(X_MACRO, int, i, NAME, OP)

◆ HWY_RVV_FOREACH_I16

#define HWY_RVV_FOREACH_I16 (   X_MACRO,
  NAME,
  OP 
)     HWY_RVV_FOREACH_16(X_MACRO, int, i, NAME, OP)

◆ HWY_RVV_FOREACH_I32

#define HWY_RVV_FOREACH_I32 (   X_MACRO,
  NAME,
  OP 
)     HWY_RVV_FOREACH_32(X_MACRO, int, i, NAME, OP)

◆ HWY_RVV_FOREACH_I64

#define HWY_RVV_FOREACH_I64 (   X_MACRO,
  NAME,
  OP 
)     HWY_RVV_FOREACH_64(X_MACRO, int, i, NAME, OP)

◆ HWY_RVV_FOREACH_U

#define HWY_RVV_FOREACH_U (   X_MACRO,
  NAME,
  OP 
)
Value:
HWY_RVV_FOREACH_U08(X_MACRO, NAME, OP) \
HWY_RVV_FOREACH_U16(X_MACRO, NAME, OP) \
HWY_RVV_FOREACH_U32(X_MACRO, NAME, OP) \
HWY_RVV_FOREACH_U64(X_MACRO, NAME, OP)
#define HWY_RVV_FOREACH_U08(X_MACRO, NAME, OP)
Definition: rvv-inl.h:95

◆ HWY_RVV_FOREACH_U08

#define HWY_RVV_FOREACH_U08 (   X_MACRO,
  NAME,
  OP 
)     HWY_RVV_FOREACH_08(X_MACRO, uint, u, NAME, OP)

◆ HWY_RVV_FOREACH_U16

#define HWY_RVV_FOREACH_U16 (   X_MACRO,
  NAME,
  OP 
)     HWY_RVV_FOREACH_16(X_MACRO, uint, u, NAME, OP)

◆ HWY_RVV_FOREACH_U32

#define HWY_RVV_FOREACH_U32 (   X_MACRO,
  NAME,
  OP 
)     HWY_RVV_FOREACH_32(X_MACRO, uint, u, NAME, OP)

◆ HWY_RVV_FOREACH_U64

#define HWY_RVV_FOREACH_U64 (   X_MACRO,
  NAME,
  OP 
)     HWY_RVV_FOREACH_64(X_MACRO, uint, u, NAME, OP)

◆ HWY_RVV_FOREACH_UI

#define HWY_RVV_FOREACH_UI (   X_MACRO,
  NAME,
  OP 
)
Value:
HWY_RVV_FOREACH_U(X_MACRO, NAME, OP) \
HWY_RVV_FOREACH_I(X_MACRO, NAME, OP)

◆ HWY_RVV_FOREACH_UI16

#define HWY_RVV_FOREACH_UI16 (   X_MACRO,
  NAME,
  OP 
)
Value:
HWY_RVV_FOREACH_U16(X_MACRO, NAME, OP) \
HWY_RVV_FOREACH_I16(X_MACRO, NAME, OP)
#define HWY_RVV_FOREACH_U16(X_MACRO, NAME, OP)
Definition: rvv-inl.h:97

◆ HWY_RVV_FOREACH_UI32

#define HWY_RVV_FOREACH_UI32 (   X_MACRO,
  NAME,
  OP 
)
Value:
HWY_RVV_FOREACH_U32(X_MACRO, NAME, OP) \
HWY_RVV_FOREACH_I32(X_MACRO, NAME, OP)
#define HWY_RVV_FOREACH_U32(X_MACRO, NAME, OP)
Definition: rvv-inl.h:99

◆ HWY_RVV_FOREACH_UI64

#define HWY_RVV_FOREACH_UI64 (   X_MACRO,
  NAME,
  OP 
)
Value:
HWY_RVV_FOREACH_U64(X_MACRO, NAME, OP) \
HWY_RVV_FOREACH_I64(X_MACRO, NAME, OP)
#define HWY_RVV_FOREACH_U64(X_MACRO, NAME, OP)
Definition: rvv-inl.h:101

◆ HWY_RVV_GATHER

#define HWY_RVV_GATHER (   BASE,
  CHAR,
  SEW,
  LMUL,
  X2,
  HALF,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_D(CHAR, SEW, LMUL) d, \
const HWY_RVV_T(BASE, SEW) * HWY_RESTRICT base, \
HWY_RVV_V(int, SEW, LMUL) offset) { \
return v##OP##ei##SEW##_v_##CHAR##SEW##LMUL( \
base, detail::BitCastToUnsigned(offset), Lanes(d)); \
}
#define HWY_RESTRICT
Definition: base.h:58
HWY_INLINE VFromD< DU > BitCastToUnsigned(V v)
Definition: rvv-inl.h:393
#define HWY_RVV_T(BASE, SEW)
Definition: rvv-inl.h:170

◆ HWY_RVV_GET_LANE

#define HWY_RVV_GET_LANE (   BASE,
  CHAR,
  SEW,
  LMUL,
  X2,
  HALF,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_T(BASE, SEW) NAME(HWY_RVV_V(BASE, SEW, LMUL) v) { \
return v##OP##_s_##CHAR##SEW##LMUL##_##CHAR##SEW(v); /* no AVL */ \
}

◆ HWY_RVV_IF_THEN_ELSE

#define HWY_RVV_IF_THEN_ELSE (   BASE,
  CHAR,
  SEW,
  LMUL,
  X2,
  HALF,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_M(MLEN) m, HWY_RVV_V(BASE, SEW, LMUL) yes, \
HWY_RVV_V(BASE, SEW, LMUL) no) { \
return v##OP##_vvm_##CHAR##SEW##LMUL(m, no, yes, HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ HWY_RVV_IOTA

#define HWY_RVV_IOTA (   BASE,
  CHAR,
  SEW,
  LMUL,
  X2,
  HALF,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) NAME(HWY_RVV_D(CHAR, SEW, LMUL) d) { \
return v##OP##_##CHAR##SEW##LMUL(Lanes(d)); \
}

◆ HWY_RVV_LANES

#define HWY_RVV_LANES (   BASE,
  CHAR,
  SEW,
  LMUL,
  X2,
  HALF,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API size_t NAME(HWY_RVV_D(CHAR, SEW, LMUL) /* d */) { \
return v##OP##SEW##LMUL(); \
}

◆ HWY_RVV_LOAD

#define HWY_RVV_LOAD (   BASE,
  CHAR,
  SEW,
  LMUL,
  X2,
  HALF,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_D(CHAR, SEW, LMUL) d, \
const HWY_RVV_T(BASE, SEW) * HWY_RESTRICT p) { \
return v##OP##SEW##_v_##CHAR##SEW##LMUL(p, Lanes(d)); \
}

◆ HWY_RVV_M

#define HWY_RVV_M (   MLEN)    vbool##MLEN##_t

◆ HWY_RVV_MASKED_LOAD

#define HWY_RVV_MASKED_LOAD (   BASE,
  CHAR,
  SEW,
  LMUL,
  X2,
  HALF,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_M(MLEN) m, HWY_RVV_D(CHAR, SEW, LMUL) d, \
const HWY_RVV_T(BASE, SEW) * HWY_RESTRICT p) { \
return v##OP##SEW##_v_##CHAR##SEW##LMUL##_m(m, Zero(d), p, Lanes(d)); \
}
HWY_API VFromD< Simd< T, N > > Zero(Simd< T, N > d)
Definition: rvv-inl.h:282

◆ HWY_RVV_PROMOTE

#define HWY_RVV_PROMOTE (   OP,
  BASE,
  CHAR,
  BITS,
  BASE_IN,
  BITS_IN,
  LMUL,
  LMUL_IN 
)
Value:
HWY_API HWY_RVV_V(BASE, BITS, LMUL) PromoteTo( \
HWY_RVV_D(CHAR, BITS, LMUL) d, HWY_RVV_V(BASE_IN, BITS_IN, LMUL_IN) v) { \
return OP##CHAR##BITS##LMUL(v, Lanes(d)); \
}
HWY_API auto PromoteTo(Simd< float32_t, N > d, VFromD< Simd< bfloat16_t, N >> v) -> VFromD< decltype(d)>
Definition: rvv-inl.h:1164

◆ HWY_RVV_PROMOTE_X2

#define HWY_RVV_PROMOTE_X2 (   OP,
  BASE,
  CHAR,
  BITS,
  BASE_IN,
  BITS_IN 
)
Value:
HWY_RVV_PROMOTE(OP, BASE, CHAR, BITS, BASE_IN, BITS_IN, m1, mf2) \
HWY_RVV_PROMOTE(OP, BASE, CHAR, BITS, BASE_IN, BITS_IN, m2, m1) \
HWY_RVV_PROMOTE(OP, BASE, CHAR, BITS, BASE_IN, BITS_IN, m4, m2) \
HWY_RVV_PROMOTE(OP, BASE, CHAR, BITS, BASE_IN, BITS_IN, m8, m4)
#define HWY_RVV_PROMOTE(OP, BASE, CHAR, BITS, BASE_IN, BITS_IN, LMUL, LMUL_IN)
Definition: rvv-inl.h:1103

◆ HWY_RVV_PROMOTE_X4

#define HWY_RVV_PROMOTE_X4 (   OP,
  BASE,
  CHAR,
  BITS,
  BASE_IN,
  BITS_IN 
)
Value:
HWY_RVV_PROMOTE(OP, BASE, CHAR, BITS, BASE_IN, BITS_IN, m1, mf4) \
HWY_RVV_PROMOTE(OP, BASE, CHAR, BITS, BASE_IN, BITS_IN, m2, mf2) \
HWY_RVV_PROMOTE(OP, BASE, CHAR, BITS, BASE_IN, BITS_IN, m4, m1) \
HWY_RVV_PROMOTE(OP, BASE, CHAR, BITS, BASE_IN, BITS_IN, m8, m2)

◆ HWY_RVV_REDUCE

#define HWY_RVV_REDUCE (   BASE,
  CHAR,
  SEW,
  LMUL,
  X2,
  HALF,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_V(BASE, SEW, LMUL) v, HWY_RVV_V(BASE, SEW, m1) v0) { \
return Set(HWY_RVV_D(CHAR, SEW, LMUL)(), \
GetLane(v##OP##_vs_##CHAR##SEW##LMUL##_##CHAR##SEW##m1( \
v0, v, v0, HWY_RVV_AVL(SEW, SHIFT)))); \
}
HWY_API uint8_t GetLane(const Vec128< uint8_t, 16 > v)
Definition: arm_neon-inl.h:744
HWY_API VFromD< Simd< T, N > > Set(Simd< T, N >, T arg)
Definition: rvv-inl.h:275

◆ HWY_RVV_RET_ARGVDP

#define HWY_RVV_RET_ARGVDP (   BASE,
  CHAR,
  SEW,
  LMUL,
  X2,
  HALF,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API void NAME(HWY_RVV_V(BASE, SEW, LMUL) v, \
HWY_RVV_D(CHAR, SEW, LMUL) d, \
HWY_RVV_T(BASE, SEW) * HWY_RESTRICT p) { \
return v##OP##SEW##_v_##CHAR##SEW##LMUL(p, v, Lanes(d)); \
}

◆ HWY_RVV_RETM_ARGM

#define HWY_RVV_RETM_ARGM (   SEW,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_M(MLEN) NAME(HWY_RVV_M(MLEN) m) { \
return vm##OP##_m_b##MLEN(m, ~0ull); \
}

◆ HWY_RVV_RETM_ARGMM

#define HWY_RVV_RETM_ARGMM (   SEW,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_M(MLEN) NAME(HWY_RVV_M(MLEN) a, HWY_RVV_M(MLEN) b) { \
return vm##OP##_mm_b##MLEN(b, a, HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ HWY_RVV_RETM_ARGVS

#define HWY_RVV_RETM_ARGVS (   BASE,
  CHAR,
  SEW,
  LMUL,
  X2,
  HALF,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
NAME(HWY_RVV_V(BASE, SEW, LMUL) a, HWY_RVV_T(BASE, SEW) b) { \
return v##OP##_vx_##CHAR##SEW##LMUL##_b##MLEN(a, b, \
HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ HWY_RVV_RETM_ARGVV

#define HWY_RVV_RETM_ARGVV (   BASE,
  CHAR,
  SEW,
  LMUL,
  X2,
  HALF,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
NAME(HWY_RVV_V(BASE, SEW, LMUL) a, HWY_RVV_V(BASE, SEW, LMUL) b) { \
return v##OP##_vv_##CHAR##SEW##LMUL##_b##MLEN(a, b, \
HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ HWY_RVV_RETV_ARGV

#define HWY_RVV_RETV_ARGV (   BASE,
  CHAR,
  SEW,
  LMUL,
  X2,
  HALF,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) NAME(HWY_RVV_V(BASE, SEW, LMUL) v) { \
return v##OP##_v_##CHAR##SEW##LMUL(v, HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ HWY_RVV_RETV_ARGV2

#define HWY_RVV_RETV_ARGV2 (   BASE,
  CHAR,
  SEW,
  LMUL,
  X2,
  HALF,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) NAME(HWY_RVV_V(BASE, SEW, LMUL) v) { \
return v##OP##_vv_##CHAR##SEW##LMUL(v, v, HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ HWY_RVV_RETV_ARGVS

#define HWY_RVV_RETV_ARGVS (   BASE,
  CHAR,
  SEW,
  LMUL,
  X2,
  HALF,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_V(BASE, SEW, LMUL) a, HWY_RVV_T(BASE, SEW) b) { \
return v##OP##_##CHAR##SEW##LMUL(a, b, HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ HWY_RVV_RETV_ARGVV

#define HWY_RVV_RETV_ARGVV (   BASE,
  CHAR,
  SEW,
  LMUL,
  X2,
  HALF,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_V(BASE, SEW, LMUL) a, HWY_RVV_V(BASE, SEW, LMUL) b) { \
return v##OP##_vv_##CHAR##SEW##LMUL(a, b, HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ HWY_RVV_SCATTER

#define HWY_RVV_SCATTER (   BASE,
  CHAR,
  SEW,
  LMUL,
  X2,
  HALF,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API void NAME(HWY_RVV_V(BASE, SEW, LMUL) v, \
HWY_RVV_D(CHAR, SEW, LMUL) d, \
HWY_RVV_T(BASE, SEW) * HWY_RESTRICT base, \
HWY_RVV_V(int, SEW, LMUL) offset) { \
return v##OP##ei##SEW##_v_##CHAR##SEW##LMUL( \
base, detail::BitCastToUnsigned(offset), v, Lanes(d)); \
}

◆ HWY_RVV_SET

#define HWY_RVV_SET (   BASE,
  CHAR,
  SEW,
  LMUL,
  X2,
  HALF,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_D(CHAR, SEW, LMUL) d, HWY_RVV_T(BASE, SEW) arg) { \
return v##OP##_##CHAR##SEW##LMUL(arg, Lanes(d)); \
}

◆ HWY_RVV_SHIFT

#define HWY_RVV_SHIFT (   BASE,
  CHAR,
  SEW,
  LMUL,
  X2,
  HALF,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
template <int kBits> \
HWY_API HWY_RVV_V(BASE, SEW, LMUL) NAME(HWY_RVV_V(BASE, SEW, LMUL) v) { \
return v##OP##_vx_##CHAR##SEW##LMUL(v, kBits, HWY_RVV_AVL(SEW, SHIFT)); \
} \
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME##Same(HWY_RVV_V(BASE, SEW, LMUL) v, int bits) { \
return v##OP##_vx_##CHAR##SEW##LMUL(v, static_cast<uint8_t>(bits), \
HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ HWY_RVV_SHIFT_II

#define HWY_RVV_SHIFT_II (   BASE,
  CHAR,
  SEW,
  LMUL,
  X2,
  HALF,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_V(BASE, SEW, LMUL) v, HWY_RVV_V(BASE, SEW, LMUL) bits) { \
return v##OP##_vv_##CHAR##SEW##LMUL(v, detail::BitCastToUnsigned(bits), \
HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ HWY_RVV_SHIFT_VV

#define HWY_RVV_SHIFT_VV (   BASE,
  CHAR,
  SEW,
  LMUL,
  X2,
  HALF,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_V(BASE, SEW, LMUL) v, HWY_RVV_V(BASE, SEW, LMUL) bits) { \
return v##OP##_vv_##CHAR##SEW##LMUL(v, bits, HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ HWY_RVV_SLIDE

#define HWY_RVV_SLIDE (   BASE,
  CHAR,
  SEW,
  LMUL,
  X2,
  HALF,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_V(BASE, SEW, LMUL) dst, HWY_RVV_V(BASE, SEW, LMUL) src, \
size_t lanes) { \
return v##OP##_vx_##CHAR##SEW##LMUL(dst, src, lanes, \
HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ HWY_RVV_SLIDE1

#define HWY_RVV_SLIDE1 (   BASE,
  CHAR,
  SEW,
  LMUL,
  X2,
  HALF,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) NAME(HWY_RVV_V(BASE, SEW, LMUL) v) { \
return v##OP##_vx_##CHAR##SEW##LMUL(v, 0, HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ HWY_RVV_STORE_MASK_BITS

#define HWY_RVV_STORE_MASK_BITS (   SEW,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
/* DEPRECATED */ \
HWY_API size_t StoreMaskBits(HWY_RVV_M(MLEN) m, uint8_t* bits) { \
/* LMUL=1 is always enough */ \
Full<uint8_t> d8; \
const size_t num_bytes = (Lanes(d8) + MLEN - 1) / MLEN; \
/* TODO(janwas): how to convert vbool* to vuint?*/ \
/*Store(m, d8, bits);*/ \
(void)m; \
(void)bits; \
return num_bytes; \
} \
template <class D> \
HWY_API size_t StoreMaskBits(D /* tag */, HWY_RVV_M(MLEN) m, \
uint8_t* bits) { \
return StoreMaskBits(m, bits); \
}
HWY_API size_t StoreMaskBits(Simd< T, N >, const Mask128< T, N > mask, uint8_t *bits)
Definition: arm_neon-inl.h:4528

◆ HWY_RVV_T

#define HWY_RVV_T (   BASE,
  SEW 
)    BASE##SEW##_t

◆ HWY_RVV_TABLE

#define HWY_RVV_TABLE (   BASE,
  CHAR,
  SEW,
  LMUL,
  X2,
  HALF,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_V(BASE, SEW, LMUL) v, HWY_RVV_V(uint, SEW, LMUL) idx) { \
return v##OP##_vv_##CHAR##SEW##LMUL(v, idx, HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ HWY_RVV_TRUNC

#define HWY_RVV_TRUNC (   BASE,
  CHAR,
  SEW,
  LMUL,
  X2,
  HALF,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_V(BASE, SEW, HALF) NAME(HWY_RVV_V(BASE, SEW, LMUL) v) { \
return v##OP##_v_##CHAR##SEW##LMUL##_##CHAR##SEW##HALF(v); /* no AVL */ \
}

◆ HWY_RVV_UNDEFINED

#define HWY_RVV_UNDEFINED (   BASE,
  CHAR,
  SEW,
  LMUL,
  X2,
  HALF,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_D(CHAR, SEW, LMUL) /* tag */) { \
return v##OP##_##CHAR##SEW##LMUL(); /* no AVL */ \
}

◆ HWY_RVV_V

#define HWY_RVV_V (   BASE,
  SEW,
  LMUL 
)    v##BASE##SEW##LMUL##_t

◆ HWY_RVV_VEC_FROM_MASK

#define HWY_RVV_VEC_FROM_MASK (   BASE,
  CHAR,
  SEW,
  LMUL,
  X2,
  HALF,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
HWY_API HWY_RVV_V(BASE, SEW, LMUL) \
NAME(HWY_RVV_V(BASE, SEW, LMUL) v0, HWY_RVV_M(MLEN) m) { \
return v##OP##_##CHAR##SEW##LMUL##_m(m, v0, v0, 1, \
HWY_RVV_AVL(SEW, SHIFT)); \
}

◆ HWY_SPECIALIZE

#define HWY_SPECIALIZE (   BASE,
  CHAR,
  SEW,
  LMUL,
  X2,
  HALF,
  SHIFT,
  MLEN,
  NAME,
  OP 
)
Value:
using HWY_RVV_D(CHAR, SEW, LMUL) = Full<HWY_RVV_T(BASE, SEW), SHIFT>; \
using V##CHAR##SEW##LMUL = HWY_RVV_V(BASE, SEW, LMUL); \
template <> \
struct DFromV_t<HWY_RVV_V(BASE, SEW, LMUL)> { \
using Lane = HWY_RVV_T(BASE, SEW); \
using type = Full<Lane, SHIFT>; \
};
Simd< T,(kShift<=0) ?(HWY_LANES(T) > >(-kShift)) :0 > Full
Definition: arm_sve-inl.h:36

Function Documentation

◆ HWY_AFTER_NAMESPACE()

HWY_AFTER_NAMESPACE ( )

◆ HWY_BEFORE_NAMESPACE()

HWY_BEFORE_NAMESPACE ( )