Grok 10.0.0
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
hwy Namespace Reference

Namespaces

namespace  detail
 
namespace  HWY_NAMESPACE
 
namespace  platform
 

Classes

class  AlignedDeleter
 
class  AlignedFreer
 
struct  bfloat16_t
 
struct  ChosenTarget
 
struct  EnableIfT
 
struct  EnableIfT< true >
 
struct  float16_t
 
struct  FunctionCache
 
class  Image
 
class  Image3
 
struct  ImageBase
 
class  InputStats
 
struct  IsSameT
 
struct  IsSameT< T, T >
 
struct  K64V64
 
struct  Params
 
class  RandomState
 
class  Rect
 
struct  RemoveConstT
 
struct  RemoveConstT< const T >
 
struct  Result
 
struct  SizeTag
 
struct  SortAscending
 
struct  SortConstants
 
struct  SortDescending
 
class  Sorter
 
class  TestWithParamTarget
 
class  TestWithParamTargetAndT
 
struct  Timestamp
 
struct  uint128_t
 
struct  WrapMirror
 
class  WrapRowMirror
 
struct  WrapRowUnchanged
 
struct  WrapUnchanged
 

Typedefs

using AllocPtr = void *(*)(void *opaque, size_t bytes)
 
using FreePtr = void(*)(void *opaque, void *memory)
 
template<typename T >
using AlignedUniquePtr = std::unique_ptr< T, AlignedDeleter >
 
template<typename T >
using AlignedFreeUniquePtr = std::unique_ptr< T, AlignedFreer >
 
using float32_t = float
 
using float64_t = double
 
template<bool Condition>
using EnableIf = typename EnableIfT< Condition >::type
 
template<class T >
using RemoveConst = typename RemoveConstT< T >::type
 
template<typename T >
using MakeUnsigned = typename detail::Relations< T >::Unsigned
 
template<typename T >
using MakeSigned = typename detail::Relations< T >::Signed
 
template<typename T >
using MakeFloat = typename detail::Relations< T >::Float
 
template<typename T >
using MakeWide = typename detail::Relations< T >::Wide
 
template<typename T >
using MakeNarrow = typename detail::Relations< T >::Narrow
 
template<size_t N>
using UnsignedFromSize = typename detail::TypeFromSize< N >::Unsigned
 
template<size_t N>
using SignedFromSize = typename detail::TypeFromSize< N >::Signed
 
template<size_t N>
using FloatFromSize = typename detail::TypeFromSize< N >::Float
 
using ImageF = Image< float >
 
using Image3F = Image3< float >
 
using FuncInput = size_t
 
using FuncOutput = uint64_t
 
using Func = FuncOutput(*)(const void *, FuncInput)
 

Enumerations

enum class  Dist { kUniform8 , kUniform16 , kUniform32 }
 
enum class  Algo { kStd , kVQSort , kHeap }
 

Functions

HWY_DLLEXPORT void * AllocateAlignedBytes (size_t payload_size, AllocPtr alloc_ptr, void *opaque_ptr)
 
HWY_DLLEXPORT void FreeAlignedBytes (const void *aligned_pointer, FreePtr free_ptr, void *opaque_ptr)
 
template<typename T , typename... Args>
AlignedUniquePtr< T > MakeUniqueAlignedWithAlloc (AllocPtr alloc, FreePtr free, void *opaque, Args &&... args)
 
template<typename T , typename... Args>
AlignedUniquePtr< T > MakeUniqueAligned (Args &&... args)
 
template<typename T , typename... Args>
AlignedUniquePtr< T[]> MakeUniqueAlignedArrayWithAlloc (size_t items, AllocPtr alloc, FreePtr free, void *opaque, Args &&... args)
 
template<typename T , typename... Args>
AlignedUniquePtr< T[]> MakeUniqueAlignedArray (size_t items, Args &&... args)
 
template<typename T >
AlignedFreeUniquePtr< T[]> AllocateAligned (const size_t items, AllocPtr alloc, FreePtr free, void *opaque)
 
template<typename T >
AlignedFreeUniquePtr< T[]> AllocateAligned (const size_t items)
 
static HWY_MAYBE_UNUSED bool operator< (const uint128_t &a, const uint128_t &b)
 
static HWY_MAYBE_UNUSED bool operator> (const uint128_t &a, const uint128_t &b)
 
static HWY_MAYBE_UNUSED bool operator< (const K64V64 &a, const K64V64 &b)
 
static HWY_MAYBE_UNUSED bool operator> (const K64V64 &a, const K64V64 &b)
 
template<typename T , typename U >
HWY_API constexpr bool IsSame ()
 
template<typename T >
HWY_API constexpr bool IsFloat ()
 
template<typename T >
HWY_API constexpr bool IsSigned ()
 
template<>
constexpr bool IsSigned< float16_t > ()
 
template<>
constexpr bool IsSigned< bfloat16_t > ()
 
template<typename T >
HWY_API constexpr T LimitsMax ()
 
template<typename T >
HWY_API constexpr T LimitsMin ()
 
template<typename T >
HWY_API constexpr T LowestValue ()
 
template<>
constexpr float LowestValue< float > ()
 
template<>
constexpr double LowestValue< double > ()
 
template<typename T >
HWY_API constexpr T HighestValue ()
 
template<>
constexpr float HighestValue< float > ()
 
template<>
constexpr double HighestValue< double > ()
 
template<typename T >
constexpr int MantissaBits ()
 
template<>
constexpr int MantissaBits< float > ()
 
template<>
constexpr int MantissaBits< double > ()
 
template<typename T >
constexpr MakeSigned< T > MaxExponentTimes2 ()
 
template<typename T >
constexpr MakeUnsigned< T > SignMask ()
 
template<typename T >
constexpr MakeUnsigned< T > ExponentMask ()
 
template<typename T >
constexpr MakeUnsigned< T > MantissaMask ()
 
template<typename T >
constexpr T MantissaEnd ()
 
template<>
constexpr float MantissaEnd< float > ()
 
template<>
constexpr double MantissaEnd< double > ()
 
template<typename T >
constexpr int ExponentBits ()
 
template<typename T >
constexpr MakeSigned< T > MaxExponentField ()
 
template<typename T1 , typename T2 >
constexpr T1 DivCeil (T1 a, T2 b)
 
constexpr size_t RoundUpTo (size_t what, size_t align)
 
HWY_API size_t Num0BitsBelowLS1Bit_Nonzero32 (const uint32_t x)
 
HWY_API size_t Num0BitsBelowLS1Bit_Nonzero64 (const uint64_t x)
 
HWY_API size_t Num0BitsAboveMS1Bit_Nonzero32 (const uint32_t x)
 
HWY_API size_t Num0BitsAboveMS1Bit_Nonzero64 (const uint64_t x)
 
HWY_API size_t PopCount (uint64_t x)
 
template<typename TI >
constexpr size_t FloorLog2 (TI x)
 
template<typename TI >
constexpr size_t CeilLog2 (TI x)
 
HWY_API uint64_t Mul128 (uint64_t a, uint64_t b, uint64_t *HWY_RESTRICT upper)
 
template<size_t kBytes, typename From , typename To >
HWY_API void CopyBytes (const From *from, To *to)
 
template<size_t kBytes, typename To >
HWY_API void ZeroBytes (To *to)
 
HWY_API float F32FromBF16 (bfloat16_t bf)
 
HWY_API bfloat16_t BF16FromF32 (float f)
 
HWY_DLLEXPORT HWY_NORETURN void HWY_FORMAT (3, 4) Abort(const char *file
 
HWY_INLINE HWY_ATTR_CACHE void LoadFence ()
 
HWY_INLINE HWY_ATTR_CACHE void FlushStream ()
 
template<typename T >
HWY_INLINE HWY_ATTR_CACHE void Prefetch (const T *p)
 
HWY_INLINE HWY_ATTR_CACHE void FlushCacheline (const void *p)
 
HWY_INLINE HWY_ATTR_CACHE void Pause ()
 
template<class Image1 , class Image2 >
HWY_MAYBE_UNUSED bool SameSize (const Image1 &image1, const Image2 &image2)
 
static HWY_INLINE HWY_MAYBE_UNUSED size_t Mirror (int64_t x, const int64_t xsize)
 
static std::vector< DistAllDist ()
 
static const char * DistName (Dist dist)
 
const char * AlgoName (Algo algo)
 
static double SecondsSince (const Timestamp &t0)
 
static double SummarizeMeasurements (std::vector< double > &seconds)
 
template<typename RetType , typename... Args>
FunctionCache< RetType, Args... > FunctionCacheFactory (RetType(*)(Args...))
 
HWY_DLLEXPORT int Unpredictable1 ()
 
HWY_DLLEXPORT size_t Measure (const Func func, const uint8_t *arg, const FuncInput *inputs, const size_t num_inputs, Result *results, const Params &p=Params())
 
template<class Closure >
static FuncOutput CallClosure (const Closure *f, const FuncInput input)
 
template<class Closure >
static size_t MeasureClosure (const Closure &closure, const FuncInput *inputs, const size_t num_inputs, Result *results, const Params &p=Params())
 
size_t VectorBytes ()
 
template<typename T >
HWY_NOINLINE void PrintValue (T value)
 
template<typename T >
HWY_NOINLINE void PrintArray (const T *value, size_t count)
 
HWY_DLLEXPORT uint32_t SupportedTargets ()
 
HWY_DLLEXPORT void DisableTargets (uint32_t disabled_targets)
 
HWY_DLLEXPORT void SetSupportedTargetsForTest (uint32_t targets)
 
HWY_INLINE std::vector< uint32_t > SupportedAndGeneratedTargets ()
 
static HWY_MAYBE_UNUSED const char * TargetName (uint32_t target)
 
HWY_DLLEXPORT ChosenTargetGetChosenTarget ()
 
static std::string TestParamTargetName (const testing::TestParamInfo< uint32_t > &info)
 
template<typename T >
std::string TestParamTargetNameAndT (const testing::TestParamInfo< std::tuple< uint32_t, T > > &info)
 
static HWY_INLINE uint32_t Random32 (RandomState *rng)
 
static HWY_INLINE uint64_t Random64 (RandomState *rng)
 
template<class T >
void PreventElision (T &&output)
 
HWY_TEST_DLLEXPORT bool BytesEqual (const void *p1, const void *p2, const size_t size, size_t *pos=nullptr)
 
void AssertStringEqual (const char *expected, const char *actual, const char *target_name, const char *filename, int line)
 
template<typename T >
std::string TypeName (T, size_t N)
 
template<typename T >
HWY_INLINE bool IsEqual (const T expected, const T actual)
 
template<typename T >
HWY_INLINE void AssertEqual (const T expected, const T actual, const char *target_name, const char *filename, int line, size_t lane=0)
 
template<typename T >
HWY_INLINE void AssertArrayEqual (const T *expected, const T *actual, size_t count, const char *target_name, const char *filename, int line)
 

Variables

static constexpr HWY_MAYBE_UNUSED size_t kMaxVectorSize = 16
 
HWY_DLLEXPORT HWY_NORETURN void int line
 
HWY_DLLEXPORT HWY_NORETURN void int const char * format
 
constexpr size_t kTestMaxVectorSize = 64
 

Typedef Documentation

◆ AlignedFreeUniquePtr

template<typename T >
using hwy::AlignedFreeUniquePtr = typedef std::unique_ptr<T, AlignedFreer>

◆ AlignedUniquePtr

template<typename T >
using hwy::AlignedUniquePtr = typedef std::unique_ptr<T, AlignedDeleter>

◆ AllocPtr

using hwy::AllocPtr = typedef void* (*)(void* opaque, size_t bytes)

◆ EnableIf

template<bool Condition>
using hwy::EnableIf = typedef typename EnableIfT<Condition>::type

◆ float32_t

using hwy::float32_t = typedef float

◆ float64_t

using hwy::float64_t = typedef double

◆ FloatFromSize

template<size_t N>
using hwy::FloatFromSize = typedef typename detail::TypeFromSize<N>::Float

◆ FreePtr

using hwy::FreePtr = typedef void (*)(void* opaque, void* memory)

◆ Func

using hwy::Func = typedef FuncOutput (*)(const void*, FuncInput)

◆ FuncInput

using hwy::FuncInput = typedef size_t

◆ FuncOutput

using hwy::FuncOutput = typedef uint64_t

◆ Image3F

using hwy::Image3F = typedef Image3<float>

◆ ImageF

using hwy::ImageF = typedef Image<float>

◆ MakeFloat

template<typename T >
using hwy::MakeFloat = typedef typename detail::Relations<T>::Float

◆ MakeNarrow

template<typename T >
using hwy::MakeNarrow = typedef typename detail::Relations<T>::Narrow

◆ MakeSigned

template<typename T >
using hwy::MakeSigned = typedef typename detail::Relations<T>::Signed

◆ MakeUnsigned

template<typename T >
using hwy::MakeUnsigned = typedef typename detail::Relations<T>::Unsigned

◆ MakeWide

template<typename T >
using hwy::MakeWide = typedef typename detail::Relations<T>::Wide

◆ RemoveConst

template<class T >
using hwy::RemoveConst = typedef typename RemoveConstT<T>::type

◆ SignedFromSize

template<size_t N>
using hwy::SignedFromSize = typedef typename detail::TypeFromSize<N>::Signed

◆ UnsignedFromSize

template<size_t N>
using hwy::UnsignedFromSize = typedef typename detail::TypeFromSize<N>::Unsigned

Enumeration Type Documentation

◆ Algo

enum class hwy::Algo
strong
Enumerator
kStd 
kVQSort 
kHeap 

◆ Dist

enum class hwy::Dist
strong
Enumerator
kUniform8 
kUniform16 
kUniform32 

Function Documentation

◆ AlgoName()

const char * hwy::AlgoName ( Algo  algo)

References kHeap, kStd, and kVQSort.

Referenced by hwy::HWY_NAMESPACE::Result::Print().

◆ AllDist()

static std::vector< Dist > hwy::AllDist ( )
inlinestatic

References kUniform32.

◆ AllocateAligned() [1/2]

template<typename T >
AlignedFreeUniquePtr< T[]> hwy::AllocateAligned ( const size_t  items)

◆ AllocateAligned() [2/2]

template<typename T >
AlignedFreeUniquePtr< T[]> hwy::AllocateAligned ( const size_t  items,
AllocPtr  alloc,
FreePtr  free,
void *  opaque 
)

◆ AllocateAlignedBytes()

HWY_DLLEXPORT void * hwy::AllocateAlignedBytes ( size_t  payload_size,
AllocPtr  alloc_ptr,
void *  opaque_ptr 
)

◆ AssertArrayEqual()

template<typename T >
HWY_INLINE void hwy::AssertArrayEqual ( const T *  expected,
const T *  actual,
size_t  count,
const char *  target_name,
const char *  filename,
int  line 
)

◆ AssertEqual()

template<typename T >
HWY_INLINE void hwy::AssertEqual ( const T  expected,
const T  actual,
const char *  target_name,
const char *  filename,
int  line,
size_t  lane = 0 
)

◆ AssertStringEqual()

void hwy::AssertStringEqual ( const char *  expected,
const char *  actual,
const char *  target_name,
const char *  filename,
int  line 
)

◆ BF16FromF32()

HWY_API bfloat16_t hwy::BF16FromF32 ( float  f)

◆ BytesEqual()

HWY_TEST_DLLEXPORT bool hwy::BytesEqual ( const void *  p1,
const void *  p2,
const size_t  size,
size_t *  pos = nullptr 
)

◆ CallClosure()

template<class Closure >
static FuncOutput hwy::CallClosure ( const Closure *  f,
const FuncInput  input 
)
static

◆ CeilLog2()

template<typename TI >
constexpr size_t hwy::CeilLog2 ( TI  x)
constexpr

◆ CopyBytes()

template<size_t kBytes, typename From , typename To >
HWY_API void hwy::CopyBytes ( const From *  from,
To *  to 
)

◆ DisableTargets()

HWY_DLLEXPORT void hwy::DisableTargets ( uint32_t  disabled_targets)

◆ DistName()

static const char * hwy::DistName ( Dist  dist)
inlinestatic

◆ DivCeil()

template<typename T1 , typename T2 >
constexpr T1 hwy::DivCeil ( T1  a,
T2  b 
)
inlineconstexpr

Referenced by RoundUpTo().

◆ ExponentBits()

template<typename T >
constexpr int hwy::ExponentBits ( )
constexpr

◆ ExponentMask()

template<typename T >
constexpr MakeUnsigned< T > hwy::ExponentMask ( )
constexpr

◆ F32FromBF16()

HWY_API float hwy::F32FromBF16 ( bfloat16_t  bf)

◆ FloorLog2()

template<typename TI >
constexpr size_t hwy::FloorLog2 ( TI  x)
constexpr

References FloorLog2().

Referenced by CeilLog2(), and FloorLog2().

◆ FlushCacheline()

HWY_INLINE HWY_ATTR_CACHE void hwy::FlushCacheline ( const void *  p)

◆ FlushStream()

HWY_INLINE HWY_ATTR_CACHE void hwy::FlushStream ( )

◆ FreeAlignedBytes()

HWY_DLLEXPORT void hwy::FreeAlignedBytes ( const void *  aligned_pointer,
FreePtr  free_ptr,
void *  opaque_ptr 
)

◆ FunctionCacheFactory()

template<typename RetType , typename... Args>
FunctionCache< RetType, Args... > hwy::FunctionCacheFactory ( RetType(*)(Args...)  )

◆ GetChosenTarget()

HWY_DLLEXPORT ChosenTarget & hwy::GetChosenTarget ( )

◆ HighestValue()

template<typename T >
HWY_API constexpr T hwy::HighestValue ( )
constexpr

◆ HighestValue< double >()

template<>
constexpr double hwy::HighestValue< double > ( )
constexpr

◆ HighestValue< float >()

template<>
constexpr float hwy::HighestValue< float > ( )
constexpr

◆ HWY_FORMAT()

HWY_DLLEXPORT HWY_NORETURN void hwy::HWY_FORMAT ( ,
 
) const

◆ IsEqual()

template<typename T >
HWY_INLINE bool hwy::IsEqual ( const T  expected,
const T  actual 
)

◆ IsFloat()

template<typename T >
HWY_API constexpr bool hwy::IsFloat ( )
constexpr

◆ IsSame()

template<typename T , typename U >
HWY_API constexpr bool hwy::IsSame ( )
constexpr

◆ IsSigned()

template<typename T >
HWY_API constexpr bool hwy::IsSigned ( )
constexpr

◆ IsSigned< bfloat16_t >()

template<>
constexpr bool hwy::IsSigned< bfloat16_t > ( )
constexpr

◆ IsSigned< float16_t >()

template<>
constexpr bool hwy::IsSigned< float16_t > ( )
constexpr

◆ LimitsMax()

template<typename T >
HWY_API constexpr T hwy::LimitsMax ( )
constexpr

Referenced by hwy::HWY_NAMESPACE::NaN().

◆ LimitsMin()

template<typename T >
HWY_API constexpr T hwy::LimitsMin ( )
constexpr

◆ LoadFence()

HWY_INLINE HWY_ATTR_CACHE void hwy::LoadFence ( )

◆ LowestValue()

template<typename T >
HWY_API constexpr T hwy::LowestValue ( )
constexpr

◆ LowestValue< double >()

template<>
constexpr double hwy::LowestValue< double > ( )
constexpr

◆ LowestValue< float >()

template<>
constexpr float hwy::LowestValue< float > ( )
constexpr

◆ MakeUniqueAligned()

template<typename T , typename... Args>
AlignedUniquePtr< T > hwy::MakeUniqueAligned ( Args &&...  args)

◆ MakeUniqueAlignedArray()

template<typename T , typename... Args>
AlignedUniquePtr< T[]> hwy::MakeUniqueAlignedArray ( size_t  items,
Args &&...  args 
)

◆ MakeUniqueAlignedArrayWithAlloc()

template<typename T , typename... Args>
AlignedUniquePtr< T[]> hwy::MakeUniqueAlignedArrayWithAlloc ( size_t  items,
AllocPtr  alloc,
FreePtr  free,
void *  opaque,
Args &&...  args 
)

Referenced by MakeUniqueAlignedArray().

◆ MakeUniqueAlignedWithAlloc()

template<typename T , typename... Args>
AlignedUniquePtr< T > hwy::MakeUniqueAlignedWithAlloc ( AllocPtr  alloc,
FreePtr  free,
void *  opaque,
Args &&...  args 
)

◆ MantissaBits()

template<typename T >
constexpr int hwy::MantissaBits ( )
constexpr

◆ MantissaBits< double >()

template<>
constexpr int hwy::MantissaBits< double > ( )
constexpr

◆ MantissaBits< float >()

template<>
constexpr int hwy::MantissaBits< float > ( )
constexpr

◆ MantissaEnd()

template<typename T >
constexpr T hwy::MantissaEnd ( )
constexpr

◆ MantissaEnd< double >()

template<>
constexpr double hwy::MantissaEnd< double > ( )
constexpr

◆ MantissaEnd< float >()

template<>
constexpr float hwy::MantissaEnd< float > ( )
constexpr

◆ MantissaMask()

template<typename T >
constexpr MakeUnsigned< T > hwy::MantissaMask ( )
constexpr

◆ MaxExponentField()

template<typename T >
constexpr MakeSigned< T > hwy::MaxExponentField ( )
constexpr

◆ MaxExponentTimes2()

template<typename T >
constexpr MakeSigned< T > hwy::MaxExponentTimes2 ( )
constexpr

◆ Measure()

HWY_DLLEXPORT size_t hwy::Measure ( const Func  func,
const uint8_t *  arg,
const FuncInput inputs,
const size_t  num_inputs,
Result results,
const Params p = Params() 
)

Referenced by MeasureClosure().

◆ MeasureClosure()

template<class Closure >
static size_t hwy::MeasureClosure ( const Closure &  closure,
const FuncInput inputs,
const size_t  num_inputs,
Result results,
const Params p = Params() 
)
inlinestatic

References Measure().

◆ Mirror()

static HWY_INLINE HWY_MAYBE_UNUSED size_t hwy::Mirror ( int64_t  x,
const int64_t  xsize 
)
static

References HWY_DASSERT.

Referenced by hwy::WrapMirror::operator()().

◆ Mul128()

HWY_API uint64_t hwy::Mul128 ( uint64_t  a,
uint64_t  b,
uint64_t *HWY_RESTRICT  upper 
)

◆ Num0BitsAboveMS1Bit_Nonzero32()

HWY_API size_t hwy::Num0BitsAboveMS1Bit_Nonzero32 ( const uint32_t  x)

◆ Num0BitsAboveMS1Bit_Nonzero64()

HWY_API size_t hwy::Num0BitsAboveMS1Bit_Nonzero64 ( const uint64_t  x)

◆ Num0BitsBelowLS1Bit_Nonzero32()

HWY_API size_t hwy::Num0BitsBelowLS1Bit_Nonzero32 ( const uint32_t  x)

◆ Num0BitsBelowLS1Bit_Nonzero64()

HWY_API size_t hwy::Num0BitsBelowLS1Bit_Nonzero64 ( const uint64_t  x)

◆ operator<() [1/2]

static HWY_MAYBE_UNUSED bool hwy::operator< ( const K64V64 a,
const K64V64 b 
)
inlinestatic

References hwy::K64V64::key.

◆ operator<() [2/2]

static HWY_MAYBE_UNUSED bool hwy::operator< ( const uint128_t a,
const uint128_t b 
)
inlinestatic

◆ operator>() [1/2]

static HWY_MAYBE_UNUSED bool hwy::operator> ( const K64V64 a,
const K64V64 b 
)
inlinestatic

◆ operator>() [2/2]

static HWY_MAYBE_UNUSED bool hwy::operator> ( const uint128_t a,
const uint128_t b 
)
inlinestatic

◆ Pause()

HWY_INLINE HWY_ATTR_CACHE void hwy::Pause ( )

◆ PopCount()

HWY_API size_t hwy::PopCount ( uint64_t  x)

◆ Prefetch()

template<typename T >
HWY_INLINE HWY_ATTR_CACHE void hwy::Prefetch ( const T *  p)

◆ PreventElision()

template<class T >
void hwy::PreventElision ( T &&  output)
inline

◆ PrintArray()

template<typename T >
HWY_NOINLINE void hwy::PrintArray ( const T *  value,
size_t  count 
)

◆ PrintValue()

template<typename T >
HWY_NOINLINE void hwy::PrintValue ( value)

◆ Random32()

static HWY_INLINE uint32_t hwy::Random32 ( RandomState rng)
static

◆ Random64()

static HWY_INLINE uint64_t hwy::Random64 ( RandomState rng)
static

◆ RoundUpTo()

constexpr size_t hwy::RoundUpTo ( size_t  what,
size_t  align 
)
inlineconstexpr

References DivCeil().

◆ SameSize()

template<class Image1 , class Image2 >
HWY_MAYBE_UNUSED bool hwy::SameSize ( const Image1 &  image1,
const Image2 &  image2 
)

◆ SecondsSince()

static double hwy::SecondsSince ( const Timestamp t0)
inlinestatic

References hwy::Timestamp::t.

◆ SetSupportedTargetsForTest()

HWY_DLLEXPORT void hwy::SetSupportedTargetsForTest ( uint32_t  targets)

◆ SignMask()

template<typename T >
constexpr MakeUnsigned< T > hwy::SignMask ( )
constexpr

◆ SummarizeMeasurements()

static double hwy::SummarizeMeasurements ( std::vector< double > &  seconds)
inlinestatic

◆ SupportedAndGeneratedTargets()

HWY_INLINE std::vector< uint32_t > hwy::SupportedAndGeneratedTargets ( )

References HWY_TARGETS, and SupportedTargets().

◆ SupportedTargets()

HWY_DLLEXPORT uint32_t hwy::SupportedTargets ( )

◆ TargetName()

static HWY_MAYBE_UNUSED const char * hwy::TargetName ( uint32_t  target)
inlinestatic

◆ TestParamTargetName()

static std::string hwy::TestParamTargetName ( const testing::TestParamInfo< uint32_t > &  info)
inlinestatic

References TargetName().

◆ TestParamTargetNameAndT()

template<typename T >
std::string hwy::TestParamTargetNameAndT ( const testing::TestParamInfo< std::tuple< uint32_t, T > > &  info)

References TargetName().

◆ TypeName()

template<typename T >
std::string hwy::TypeName ( ,
size_t  N 
)

◆ Unpredictable1()

HWY_DLLEXPORT int hwy::Unpredictable1 ( )

◆ VectorBytes()

size_t hwy::VectorBytes ( )

◆ ZeroBytes()

template<size_t kBytes, typename To >
HWY_API void hwy::ZeroBytes ( To *  to)

Variable Documentation

◆ format

HWY_DLLEXPORT HWY_NORETURN void int const char* hwy::format

◆ kMaxVectorSize

constexpr HWY_MAYBE_UNUSED size_t hwy::kMaxVectorSize = 16
staticconstexpr

◆ kTestMaxVectorSize

constexpr size_t hwy::kTestMaxVectorSize = 64
constexpr

◆ line

HWY_DLLEXPORT HWY_NORETURN void int hwy::line