GNU Radio's BLOCKSTREAM Package
mipp Namespace Reference

Classes

struct  regx2
 
struct  AlignedAllocator
 
class  Reg
 
class  Msk
 
struct  _reduction
 
struct  _Reduction
 
struct  reduction
 
struct  Reduction
 
class  Reg_2
 
class  Regx2
 

Typedefs

using msk = uint8_t
 
using reg = uint32_t
 
using reg_2 = uint16_t
 
typedef struct mipp::regx2 regx2
 
template<class T >
using vector = std::vector< T, AlignedAllocator< T >>
 
template<typename T >
using proto_i1 = reg(*)(const reg a)
 
template<typename T >
using proto_i2 = reg(*)(const reg a, const reg b)
 
template<typename T >
using proto_i3 = reg(*)(const reg a, const reg b, const reg c)
 
template<typename T >
using proto_I1 = Reg< T >(*)(const Reg< T > a)
 
template<typename T >
using proto_I2 = Reg< T >(*)(const Reg< T > a, const Reg< T > b)
 
template<typename T >
using proto_I3 = Reg< T >(*)(const Reg< T > a, const Reg< T > b, const Reg< T > c)
 
template<typename T >
using red_op = reg(*)(const reg, const reg)
 
template<typename T >
using Red_op = Reg< T >(*)(const Reg< T >, const Reg< T >)
 
template<typename T >
using ld_op = reg(*)(const T *)
 

Functions

template<int N>
reg cvt_reg (const msk m)
 
std::vector< std::string > InstructionExtensions ()
 
template<typename T >
constexpr int32_t nElmtsPerRegister ()
 
template<typename T >
constexpr int32_t nElReg ()
 
template<typename T >
constexpr int32_t N ()
 
template<typename T >
T * malloc (uint32_t nData)
 
template<typename T >
void free (T *ptr)
 
template<class C1 , class C2 >
bool operator== (const AlignedAllocator< C1 > &ma1, const AlignedAllocator< C2 > &ma2)
 
template<class C1 , class C2 >
bool operator!= (const AlignedAllocator< C1 > &ma1, const AlignedAllocator< C2 > &ma2)
 
static std::string get_back_trace ()
 
template<typename T >
static void errorMessage (std::string instr)
 
template<typename T1 , typename T2 >
static void errorMessage (std::string instr)
 
template<typename T >
reg load (const T *)
 
template<typename T >
reg loadu (const T *)
 
template<typename T >
void store (T *, const reg)
 
template<typename T >
void storeu (T *, const reg)
 
template<typename T >
reg set (const T[nElReg< T >()])
 
template<int N>
msk set (const bool[N])
 
template<typename T >
reg set1 (const T)
 
template<int N>
msk set1 (const bool)
 
template<typename T >
reg set0 ()
 
template<int N>
msk set0 ()
 
template<typename T >
reg_2 low (const reg)
 
template<typename T >
reg_2 high (const reg)
 
template<typename T >
reg cmask (const uint32_t[nElReg< T >()])
 
template<typename T >
reg cmask2 (const uint32_t[nElReg< T >()/2])
 
template<typename T >
reg shuff (const reg, const reg)
 
template<typename T >
reg shuff2 (const reg, const reg)
 
template<typename T >
reg interleavelo (const reg, const reg)
 
template<typename T >
reg interleavehi (const reg, const reg)
 
template<typename T >
reg interleavelo2 (const reg, const reg)
 
template<typename T >
reg interleavehi2 (const reg, const reg)
 
template<typename T >
regx2 interleave (const reg, const reg)
 
template<typename T >
regx2 interleave2 (const reg, const reg)
 
template<typename T >
reg interleave (const reg)
 
template<typename T >
regx2 interleavex2 (const reg, const reg)
 
template<typename T >
reg interleavex4 (const reg)
 
template<typename T >
reg interleavex16 (const reg)
 
template<typename T >
void transpose (reg[nElReg< T >()])
 
template<typename T >
void transpose8x8 (reg[8])
 
template<typename T >
void transpose2 (reg[nElReg< T >()/2])
 
template<typename T >
void transpose28x8 (reg[8])
 
template<typename T >
reg andb (const reg, const reg)
 
template<int N>
msk andb (const msk, const msk)
 
template<typename T >
reg andnb (const reg, const reg)
 
template<int N>
msk andnb (const msk, const msk)
 
template<typename T >
reg notb (const reg)
 
template<int N>
msk notb (const msk)
 
template<typename T >
reg orb (const reg, const reg)
 
template<int N>
msk orb (const msk, const msk)
 
template<typename T >
reg xorb (const reg, const reg)
 
template<int N>
msk xorb (const msk, const msk)
 
template<typename T >
reg lshift (const reg, const uint32_t)
 
template<int N>
msk lshift (const msk, const uint32_t)
 
template<typename T >
reg rshift (const reg, const uint32_t)
 
template<int N>
msk rshift (const msk, const uint32_t)
 
template<typename T >
msk cmpeq (const reg, const reg)
 
template<typename T >
msk cmpneq (const reg, const reg)
 
template<typename T >
msk cmplt (const reg, const reg)
 
template<typename T >
msk cmple (const reg, const reg)
 
template<typename T >
msk cmpgt (const reg, const reg)
 
template<typename T >
msk cmpge (const reg, const reg)
 
template<typename T >
reg add (const reg, const reg)
 
template<typename T >
reg sub (const reg, const reg)
 
template<typename T >
reg mul (const reg, const reg)
 
template<typename T >
reg div (const reg, const reg)
 
template<typename T >
reg min (const reg, const reg)
 
template<typename T >
reg max (const reg, const reg)
 
template<typename T >
reg msb (const reg)
 
template<typename T >
reg msb (const reg, const reg)
 
template<typename T >
msk sign (const reg)
 
template<typename T >
reg neg (const reg, const reg)
 
template<typename T >
reg neg (const reg, const msk)
 
template<typename T >
reg abs (const reg)
 
template<typename T >
reg sqrt (const reg)
 
template<typename T >
reg rsqrt (const reg)
 
template<typename T >
reg log (const reg)
 
template<typename T >
reg exp (const reg)
 
template<typename T >
reg sin (const reg)
 
template<typename T >
reg cos (const reg)
 
template<typename T >
void sincos (const reg, reg &, reg &)
 
template<typename T >
reg fmadd (const reg, const reg, const reg)
 
template<typename T >
reg fnmadd (const reg, const reg, const reg)
 
template<typename T >
reg fmsub (const reg, const reg, const reg)
 
template<typename T >
reg fnmsub (const reg, const reg, const reg)
 
template<typename T >
reg blend (const reg, const reg, const msk)
 
template<typename T >
reg lrot (const reg)
 
template<typename T >
reg rrot (const reg)
 
template<typename T >
reg div2 (const reg)
 
template<typename T >
reg div4 (const reg)
 
template<typename T >
reg sat (const reg, T, T)
 
template<typename T >
reg round (const reg)
 
template<typename T1 , typename T2 >
reg cvt (const reg)
 
template<typename T1 , typename T2 >
reg cvt (const reg_2)
 
template<typename T1 , typename T2 >
reg pack (const reg, const reg)
 
template<typename T >
reg copysign (const reg r1, const reg r2)
 
template<typename T >
reg copysign (const reg r1, const msk r2)
 
template<typename T , proto_i1< T > I1>
reg mask (const msk m, const reg src, const reg a)
 
template<typename T , proto_i2< T > I2>
reg mask (const msk m, const reg src, const reg a, const reg b)
 
template<typename T , proto_i3< T > I3>
reg mask (const msk m, const reg src, const reg a, const reg b, const reg c)
 
template<typename T , proto_i1< T > I1>
reg maskz (const msk m, const reg a)
 
template<typename T , proto_i2< T > I2>
reg maskz (const msk m, const reg a, const reg b)
 
template<typename T , proto_i3< T > I3>
reg maskz (const msk m, const reg a, const reg b, const reg c)
 
template<typename T >
Reg< T > blend (const Reg< T > v1, const Reg< T > v2, const Msk< N< T >()> m)
 
template<typename T >
Reg< T > andb (const Reg< T > v1, const Reg< T > v2)
 
template<typename T , proto_I1< T > I1>
Reg< T > mask (const Msk< N< T >()> m, const Reg< T > src, const Reg< T > a)
 
template<typename T , proto_I2< T > I2>
Reg< T > mask (const Msk< N< T >()> m, const Reg< T > src, const Reg< T > a, const Reg< T > b)
 
template<typename T , proto_I3< T > I3>
Reg< T > mask (const Msk< N< T >()> m, const Reg< T > src, const Reg< T > a, const Reg< T > b, const Reg< T > c)
 
template<typename T , proto_I1< T > I1>
Reg< T > maskz (const Msk< N< T >()> m, const Reg< T > a)
 
template<typename T , proto_I2< T > I2>
Reg< T > maskz (const Msk< N< T >()> m, const Reg< T > a, const Reg< T > b)
 
template<typename T , proto_I3< T > I3>
Reg< T > maskz (const Msk< N< T >()> m, const Reg< T > a, const Reg< T > b, const Reg< T > c)
 
template<typename T >
void dump (const mipp::reg r, std::ostream &stream=std::cout, const uint32_t elmtWidth=6)
 
template<int N>
void dump (const mipp::msk m, std::ostream &stream=std::cout, const uint32_t elmtWidth=6)
 
template<typename T >
sum (const reg v)
 
template<typename T >
hadd (const reg v)
 
template<typename T >
hmul (const reg v)
 
template<typename T >
hmin (const reg v)
 
template<typename T >
hmax (const reg v)
 
template<typename T >
Reg< T > add (const Reg< T > v1, const Reg< T > v2)
 
template<typename T >
Reg< T > sub (const Reg< T > v1, const Reg< T > v2)
 
template<typename T >
Reg< T > mul (const Reg< T > v1, const Reg< T > v2)
 
template<typename T >
Reg< T > div (const Reg< T > v1, const Reg< T > v2)
 
template<typename T >
Reg< T > min (const Reg< T > v1, const Reg< T > v2)
 
template<typename T >
Reg< T > max (const Reg< T > v1, const Reg< T > v2)
 
template<typename T >
std::ostream & operator<< (std::ostream &os, const Reg< T > &r)
 
template<int N>
std::ostream & operator<< (std::ostream &os, const Msk< N > &m)
 
template<typename T >
Reg< T > shuff (const Reg< T > v1, const Reg< T > v2)
 
template<typename T >
Reg< T > shuff2 (const Reg< T > v1, const Reg< T > v2)
 
template<typename T >
Reg< T > interleavelo (const Reg< T > v1, const Reg< T > v2)
 
template<typename T >
Reg< T > interleavehi (const Reg< T > v1, const Reg< T > v2)
 
template<typename T >
Reg< T > interleavelo2 (const Reg< T > v1, const Reg< T > v2)
 
template<typename T >
Reg< T > interleavehi2 (const Reg< T > v1, const Reg< T > v2)
 
template<typename T >
Regx2< T > interleave (const Reg< T > v1, const Reg< T > v2)
 
template<typename T >
Regx2< T > interleave2 (const Reg< T > v1, const Reg< T > v2)
 
template<typename T >
Reg< T > interleave (const Reg< T > v)
 
template<typename T >
Regx2< T > interleavex2 (const Reg< T > v1, const Reg< T > v2)
 
template<typename T >
Reg< T > interleavex4 (const Reg< T > v)
 
template<typename T >
Reg< T > interleavex16 (const Reg< T > v)
 
template<int N>
Msk< Nandb (const Msk< N > v1, const Msk< N > v2)
 
template<typename T >
Reg< T > andb (const Reg< T > v1, const Msk< N< T >()> v2)
 
template<typename T >
Reg< T > andb (const Msk< N< T >()> v1, const Reg< T > v2)
 
template<typename T >
Reg< T > andnb (const Reg< T > v1, const Reg< T >v2)
 
template<int N>
Msk< Nandnb (const Msk< N > v1, const Msk< N >v2)
 
template<typename T >
Reg< T > andnb (const Reg< T > v1, const Msk< N< T >()> v2)
 
template<typename T >
Reg< T > andnb (const Msk< N< T >()> v1, const Reg< T > v2)
 
template<typename T >
Reg< T > notb (const Reg< T > v)
 
template<int N>
Msk< Nnotb (const Msk< N > v)
 
template<typename T >
Reg< T > orb (const Reg< T > v1, const Reg< T > v2)
 
template<int N>
Msk< Norb (const Msk< N > v1, const Msk< N > v2)
 
template<typename T >
Reg< T > orb (const Reg< T > v1, const Msk< N< T >()> v2)
 
template<typename T >
Reg< T > orb (const Msk< N< T >()> v1, const Reg< T > v2)
 
template<typename T >
Reg< T > xorb (const Reg< T > v1, const Reg< T > v2)
 
template<int N>
Msk< Nxorb (const Msk< N > v1, const Msk< N > v2)
 
template<typename T >
Reg< T > xorb (const Reg< T > v1, const Msk< N< T >()> v2)
 
template<typename T >
Reg< T > xorb (const Msk< N< T >()> v1, const Reg< T > v2)
 
template<typename T >
Reg< T > lshift (const Reg< T > v, const uint32_t n)
 
template<int N>
Msk< Nlshift (const Msk< N > v, const uint32_t n)
 
template<typename T >
Reg< T > rshift (const Reg< T > v, const uint32_t n)
 
template<int N>
Msk< Nrshift (const Msk< N > v, const uint32_t n)
 
template<typename T >
Msk< N< T >)> cmpeq (const Reg< T > v1, const Reg< T > v2)
 
template<typename T >
Msk< N< T >)> cmpneq (const Reg< T > v1, const Reg< T > v2)
 
template<typename T >
Msk< N< T >)> cmplt (const Reg< T > v1, const Reg< T > v2)
 
template<typename T >
Msk< N< T >)> cmple (const Reg< T > v1, const Reg< T > v2)
 
template<typename T >
Msk< N< T >)> cmpgt (const Reg< T > v1, const Reg< T > v2)
 
template<typename T >
Msk< N< T >)> cmpge (const Reg< T > v1, const Reg< T > v2)
 
template<typename T >
Reg< T > msb (const Reg< T > v)
 
template<typename T >
Reg< T > msb (const Reg< T > v1, const Reg< T > v2)
 
template<typename T >
Msk< N< T >)> sign (const Reg< T > v)
 
template<typename T >
Reg< T > neg (const Reg< T > v1, const Reg< T > v2)
 
template<typename T >
Reg< T > neg (const Reg< T > v1, const Msk< N< T >()> v2)
 
template<typename T >
Reg< T > copysign (const Reg< T > v1, const Reg< T > v2)
 
template<typename T >
Reg< T > copysign (const Reg< T > v1, const Msk< N< T >()> v2)
 
template<typename T >
Reg< T > abs (const Reg< T > v)
 
template<typename T >
Reg< T > sqrt (const Reg< T > v)
 
template<typename T >
Reg< T > rsqrt (const Reg< T > v)
 
template<typename T >
Reg< T > log (const Reg< T > v)
 
template<typename T >
Reg< T > exp (const Reg< T > v)
 
template<typename T >
Reg< T > sin (const Reg< T > v)
 
template<typename T >
Reg< T > cos (const Reg< T > v)
 
template<typename T >
void sincos (const Reg< T > x, Reg< T > &s, Reg< T > &c)
 
template<typename T >
Reg< T > fmadd (const Reg< T > v1, const Reg< T > v2, const Reg< T > v3)
 
template<typename T >
Reg< T > fnmadd (const Reg< T > v1, const Reg< T > v2, const Reg< T > v3)
 
template<typename T >
Reg< T > fmsub (const Reg< T > v1, const Reg< T > v2, const Reg< T > v3)
 
template<typename T >
Reg< T > fnmsub (const Reg< T > v1, const Reg< T > v2, const Reg< T > v3)
 
template<typename T >
Reg< T > lrot (const Reg< T > v)
 
template<typename T >
Reg< T > rrot (const Reg< T > v)
 
template<typename T >
Reg< T > div2 (const Reg< T > v)
 
template<typename T >
Reg< T > div4 (const Reg< T > v)
 
template<typename T >
Reg< T > sat (const Reg< T > v, T min, T max)
 
template<typename T >
Reg< T > round (const Reg< T > v)
 
template<typename T >
sum (const Reg< T > v)
 
template<typename T >
hadd (const Reg< T > v)
 
template<typename T >
hmul (const Reg< T > v)
 
template<typename T >
hmin (const Reg< T > v)
 
template<typename T >
hmax (const Reg< T > v)
 
template<typename T >
Reg< T > cvt_reg (const Msk< N< T >()> m)
 
template<typename T1 , typename T2 >
Reg< T2 > cvt (const Reg< T1 > v)
 
template<typename T1 , typename T2 >
Reg< T2 > cvt (const Reg_2< T1 > v)
 
template<typename T1 , typename T2 >
Reg< T2 > pack (const Reg< T1 > v1, const Reg< T1 > v2)
 
template<typename T1 , typename T2 >
Reg< T2 > cast (const Reg< T1 > v)
 

Variables

const std::string InstructionType = "NO"
 
const std::string InstructionFullType = "NO_INTRINSICS"
 
const std::string InstructionVersion = "1"
 
constexpr uint32_t RequiredAlignment = MIPP_REQUIRED_ALIGNMENT
 
constexpr uint32_t RegisterSizeBit = MIPP_REGISTER_SIZE
 
constexpr uint32_t Lanes = MIPP_LANES
 
const bool Support64Bit = false
 
const bool SupportByteWord = true
 

Typedef Documentation

template<typename T >
using mipp::ld_op = typedef reg (*)(const T*)
using mipp::msk = typedef uint8_t
template<typename T >
using mipp::proto_i1 = typedef reg (*)(const reg a)
template<typename T >
using mipp::proto_I1 = typedef Reg<T> (*)(const Reg<T> a)
template<typename T >
using mipp::proto_i2 = typedef reg (*)(const reg a, const reg b)
template<typename T >
using mipp::proto_I2 = typedef Reg<T> (*)(const Reg<T> a, const Reg<T> b)
template<typename T >
using mipp::proto_i3 = typedef reg (*)(const reg a, const reg b, const reg c)
template<typename T >
using mipp::proto_I3 = typedef Reg<T> (*)(const Reg<T> a, const Reg<T> b, const Reg<T> c)
template<typename T >
using mipp::red_op = typedef reg (*)(const reg, const reg)
template<typename T >
using mipp::Red_op = typedef Reg<T> (*)(const Reg<T>, const Reg<T>)
using mipp::reg = typedef uint32_t
using mipp::reg_2 = typedef uint16_t
typedef struct mipp::regx2 mipp::regx2
template<class T >
using mipp::vector = typedef std::vector<T, AlignedAllocator<T>>

Function Documentation

template<typename T >
Reg<T> mipp::abs ( const Reg< T >  v)
inline
template<typename T >
reg mipp::abs ( const reg  )
inline
template<typename T >
Reg< T > mipp::add ( const Reg< T >  v1,
const Reg< T >  v2 
)
inline
template<typename T >
reg mipp::add ( const reg  ,
const reg   
)
inline
template<int N>
Msk<N> mipp::andb ( const Msk< N >  v1,
const Msk< N >  v2 
)
inline
template<typename T >
Reg<T> mipp::andb ( const Reg< T >  v1,
const Msk< N< T >()>  v2 
)
inline
template<typename T >
Reg<T> mipp::andb ( const Msk< N< T >()>  v1,
const Reg< T >  v2 
)
inline
template<typename T >
reg mipp::andb ( const reg  ,
const reg   
)
inline
template<int N>
msk mipp::andb ( const msk  ,
const msk   
)
inline
template<typename T >
Reg< T > mipp::andb ( const Reg< T >  v1,
const Reg< T >  v2 
)
inline
template<typename T >
Reg<T> mipp::andnb ( const Reg< T >  v1,
const Reg< T >  v2 
)
inline
template<int N>
Msk<N> mipp::andnb ( const Msk< N >  v1,
const Msk< N >  v2 
)
inline
template<typename T >
Reg<T> mipp::andnb ( const Reg< T >  v1,
const Msk< N< T >()>  v2 
)
inline
template<typename T >
Reg<T> mipp::andnb ( const Msk< N< T >()>  v1,
const Reg< T >  v2 
)
inline
template<typename T >
reg mipp::andnb ( const reg  ,
const reg   
)
inline
template<int N>
msk mipp::andnb ( const msk  ,
const msk   
)
inline
template<typename T >
reg mipp::blend ( const reg  ,
const reg  ,
const msk   
)
inline
template<typename T >
Reg< T > mipp::blend ( const Reg< T >  v1,
const Reg< T >  v2,
const Msk< N< T >()>  m 
)
inline
template<typename T1 , typename T2 >
Reg<T2> mipp::cast ( const Reg< T1 >  v)
inline
template<typename T >
reg mipp::cmask ( const uint32_t  [nElReg< T >()])
inline
template<typename T >
reg mipp::cmask2 ( const uint32_t  [nElReg< T >()/2])
inline
template<typename T >
Msk<N<T>)> mipp::cmpeq ( const Reg< T >  v1,
const Reg< T >  v2 
)
inline
template<typename T >
msk mipp::cmpeq ( const reg  ,
const reg   
)
inline
template<typename T >
Msk<N<T>)> mipp::cmpge ( const Reg< T >  v1,
const Reg< T >  v2 
)
inline
template<typename T >
msk mipp::cmpge ( const reg  ,
const reg   
)
inline
template<typename T >
Msk<N<T>)> mipp::cmpgt ( const Reg< T >  v1,
const Reg< T >  v2 
)
inline
template<typename T >
msk mipp::cmpgt ( const reg  ,
const reg   
)
inline
template<typename T >
Msk<N<T>)> mipp::cmple ( const Reg< T >  v1,
const Reg< T >  v2 
)
inline
template<typename T >
msk mipp::cmple ( const reg  ,
const reg   
)
inline
template<typename T >
Msk<N<T>)> mipp::cmplt ( const Reg< T >  v1,
const Reg< T >  v2 
)
inline
template<typename T >
msk mipp::cmplt ( const reg  ,
const reg   
)
inline
template<typename T >
Msk<N<T>)> mipp::cmpneq ( const Reg< T >  v1,
const Reg< T >  v2 
)
inline
template<typename T >
msk mipp::cmpneq ( const reg  ,
const reg   
)
inline
template<typename T >
Reg<T> mipp::copysign ( const Reg< T >  v1,
const Reg< T >  v2 
)
inline
template<typename T >
Reg<T> mipp::copysign ( const Reg< T >  v1,
const Msk< N< T >()>  v2 
)
inline
template<typename T >
reg mipp::copysign ( const reg  r1,
const reg  r2 
)
inline
template<typename T >
reg mipp::copysign ( const reg  r1,
const msk  r2 
)
inline
template<typename T >
Reg<T> mipp::cos ( const Reg< T >  v)
inline
template<typename T >
reg mipp::cos ( const reg  )
inline
template<typename T1 , typename T2 >
Reg<T2> mipp::cvt ( const Reg< T1 >  v)
inline
template<typename T1 , typename T2 >
Reg<T2> mipp::cvt ( const Reg_2< T1 >  v)
inline
template<typename T1 , typename T2 >
reg mipp::cvt ( const reg  )
inline
template<typename T1 , typename T2 >
reg mipp::cvt ( const reg_2  )
inline
template<int N>
reg mipp::cvt_reg ( const msk  m)
inline
template<typename T >
Reg<T> mipp::cvt_reg ( const Msk< N< T >()>  m)
inline
template<typename T >
Reg< T > mipp::div ( const Reg< T >  v1,
const Reg< T >  v2 
)
inline
template<typename T >
reg mipp::div ( const reg  ,
const reg   
)
inline
template<typename T >
Reg<T> mipp::div2 ( const Reg< T >  v)
inline
template<typename T >
reg mipp::div2 ( const reg  )
inline
template<typename T >
Reg<T> mipp::div4 ( const Reg< T >  v)
inline
template<typename T >
reg mipp::div4 ( const reg  )
inline
template<typename T >
void mipp::dump ( const mipp::reg  r,
std::ostream &  stream = std::cout,
const uint32_t  elmtWidth = 6 
)

References Lanes.

template<int N>
void mipp::dump ( const mipp::msk  m,
std::ostream &  stream = std::cout,
const uint32_t  elmtWidth = 6 
)

References Lanes, N(), and RegisterSizeBit.

template<typename T >
static void mipp::errorMessage ( std::string  instr)
inlinestatic
template<typename T1 , typename T2 >
static void mipp::errorMessage ( std::string  instr)
inlinestatic
template<typename T >
Reg<T> mipp::exp ( const Reg< T >  v)
inline
template<typename T >
reg mipp::exp ( const reg  )
inline
template<typename T >
Reg<T> mipp::fmadd ( const Reg< T >  v1,
const Reg< T >  v2,
const Reg< T >  v3 
)
inline
template<typename T >
reg mipp::fmadd ( const reg  ,
const reg  ,
const reg   
)
inline
template<typename T >
Reg<T> mipp::fmsub ( const Reg< T >  v1,
const Reg< T >  v2,
const Reg< T >  v3 
)
inline
template<typename T >
reg mipp::fmsub ( const reg  ,
const reg  ,
const reg   
)
inline
template<typename T >
Reg<T> mipp::fnmadd ( const Reg< T >  v1,
const Reg< T >  v2,
const Reg< T >  v3 
)
inline
template<typename T >
reg mipp::fnmadd ( const reg  ,
const reg  ,
const reg   
)
inline
template<typename T >
Reg<T> mipp::fnmsub ( const Reg< T >  v1,
const Reg< T >  v2,
const Reg< T >  v3 
)
inline
template<typename T >
reg mipp::fnmsub ( const reg  ,
const reg  ,
const reg   
)
inline
template<typename T >
void mipp::free ( T *  ptr)
static std::string mipp::get_back_trace ( )
inlinestatic
template<typename T >
T mipp::hadd ( const Reg< T >  v)
inline
template<typename T >
T mipp::hadd ( const reg  v)
inline
template<typename T >
reg_2 mipp::high ( const reg  )
inline
template<typename T >
T mipp::hmax ( const Reg< T >  v)
inline
template<typename T >
T mipp::hmax ( const reg  v)
inline
template<typename T >
T mipp::hmin ( const Reg< T >  v)
inline
template<typename T >
T mipp::hmin ( const reg  v)
inline
template<typename T >
T mipp::hmul ( const Reg< T >  v)
inline
template<typename T >
T mipp::hmul ( const reg  v)
inline
std::vector<std::string> mipp::InstructionExtensions ( )
inline
template<typename T >
Regx2<T> mipp::interleave ( const Reg< T >  v1,
const Reg< T >  v2 
)
inline
template<typename T >
Reg<T> mipp::interleave ( const Reg< T >  v)
inline
template<typename T >
regx2 mipp::interleave ( const reg  ,
const reg   
)
inline
template<typename T >
reg mipp::interleave ( const reg  )
inline
template<typename T >
Regx2<T> mipp::interleave2 ( const Reg< T >  v1,
const Reg< T >  v2 
)
inline
template<typename T >
regx2 mipp::interleave2 ( const reg  ,
const reg   
)
inline
template<typename T >
Reg<T> mipp::interleavehi ( const Reg< T >  v1,
const Reg< T >  v2 
)
inline
template<typename T >
reg mipp::interleavehi ( const reg  ,
const reg   
)
inline
template<typename T >
Reg<T> mipp::interleavehi2 ( const Reg< T >  v1,
const Reg< T >  v2 
)
inline
template<typename T >
reg mipp::interleavehi2 ( const reg  ,
const reg   
)
inline
template<typename T >
Reg<T> mipp::interleavelo ( const Reg< T >  v1,
const Reg< T >  v2 
)
inline
template<typename T >
reg mipp::interleavelo ( const reg  ,
const reg   
)
inline
template<typename T >
Reg<T> mipp::interleavelo2 ( const Reg< T >  v1,
const Reg< T >  v2 
)
inline
template<typename T >
reg mipp::interleavelo2 ( const reg  ,
const reg   
)
inline
template<typename T >
Reg<T> mipp::interleavex16 ( const Reg< T >  v)
inline
template<typename T >
reg mipp::interleavex16 ( const reg  )
inline
template<typename T >
Regx2<T> mipp::interleavex2 ( const Reg< T >  v1,
const Reg< T >  v2 
)
inline
template<typename T >
regx2 mipp::interleavex2 ( const reg  ,
const reg   
)
inline
template<typename T >
Reg<T> mipp::interleavex4 ( const Reg< T >  v)
inline
template<typename T >
reg mipp::interleavex4 ( const reg  )
inline
template<typename T >
reg mipp::load ( const T *  )
inline
template<typename T >
reg mipp::loadu ( const T *  )
inline
template<typename T >
Reg<T> mipp::log ( const Reg< T >  v)
inline
template<typename T >
reg mipp::log ( const reg  )
inline
template<typename T >
reg_2 mipp::low ( const reg  )
inline
template<typename T >
Reg<T> mipp::lrot ( const Reg< T >  v)
inline
template<typename T >
reg mipp::lrot ( const reg  )
inline
template<typename T >
Reg<T> mipp::lshift ( const Reg< T >  v,
const uint32_t  n 
)
inline
template<int N>
Msk<N> mipp::lshift ( const Msk< N >  v,
const uint32_t  n 
)
inline
template<typename T >
reg mipp::lshift ( const reg  ,
const uint32_t   
)
inline
template<int N>
msk mipp::lshift ( const msk  ,
const uint32_t   
)
inline
template<typename T >
T* mipp::malloc ( uint32_t  nData)
template<typename T , proto_i1< T > I1>
reg mipp::mask ( const msk  m,
const reg  src,
const reg  a 
)
inline
template<typename T , proto_i2< T > I2>
reg mipp::mask ( const msk  m,
const reg  src,
const reg  a,
const reg  b 
)
inline
template<typename T , proto_i3< T > I3>
reg mipp::mask ( const msk  m,
const reg  src,
const reg  a,
const reg  b,
const reg  c 
)
inline
template<typename T , proto_I1< T > I1>
Reg<T> mipp::mask ( const Msk< N< T >()>  m,
const Reg< T >  src,
const Reg< T >  a 
)
inline
template<typename T , proto_I2< T > I2>
Reg<T> mipp::mask ( const Msk< N< T >()>  m,
const Reg< T >  src,
const Reg< T >  a,
const Reg< T >  b 
)
inline
template<typename T , proto_I3< T > I3>
Reg<T> mipp::mask ( const Msk< N< T >()>  m,
const Reg< T >  src,
const Reg< T >  a,
const Reg< T >  b,
const Reg< T >  c 
)
inline
template<typename T , proto_i1< T > I1>
reg mipp::maskz ( const msk  m,
const reg  a 
)
inline
template<typename T , proto_i2< T > I2>
reg mipp::maskz ( const msk  m,
const reg  a,
const reg  b 
)
inline
template<typename T , proto_i3< T > I3>
reg mipp::maskz ( const msk  m,
const reg  a,
const reg  b,
const reg  c 
)
inline
template<typename T , proto_I1< T > I1>
Reg<T> mipp::maskz ( const Msk< N< T >()>  m,
const Reg< T >  a 
)
inline
template<typename T , proto_I2< T > I2>
Reg<T> mipp::maskz ( const Msk< N< T >()>  m,
const Reg< T >  a,
const Reg< T >  b 
)
inline
template<typename T , proto_I3< T > I3>
Reg<T> mipp::maskz ( const Msk< N< T >()>  m,
const Reg< T >  a,
const Reg< T >  b,
const Reg< T >  c 
)
inline
template<typename T >
Reg< T > mipp::max ( const Reg< T >  v1,
const Reg< T >  v2 
)
inline
template<typename T >
reg mipp::max ( const reg  ,
const reg   
)
inline

Referenced by aff3ct::tools::saturate().

template<typename T >
Reg< T > mipp::min ( const Reg< T >  v1,
const Reg< T >  v2 
)
inline
template<typename T >
reg mipp::min ( const reg  ,
const reg   
)
inline
template<typename T >
Reg<T> mipp::msb ( const Reg< T >  v)
inline
template<typename T >
Reg<T> mipp::msb ( const Reg< T >  v1,
const Reg< T >  v2 
)
inline
template<typename T >
reg mipp::msb ( const reg  )
inline
template<typename T >
reg mipp::msb ( const reg  ,
const reg   
)
inline
template<typename T >
Reg< T > mipp::mul ( const Reg< T >  v1,
const Reg< T >  v2 
)
inline
template<typename T >
reg mipp::mul ( const reg  ,
const reg   
)
inline
template<typename T >
constexpr int32_t mipp::N ( )

Referenced by dump().

template<typename T >
Reg<T> mipp::neg ( const Reg< T >  v1,
const Reg< T >  v2 
)
inline
template<typename T >
Reg<T> mipp::neg ( const Reg< T >  v1,
const Msk< N< T >()>  v2 
)
inline
template<typename T >
reg mipp::neg ( const reg  ,
const reg   
)
inline
template<typename T >
reg mipp::neg ( const reg  ,
const msk   
)
inline
template<typename T >
constexpr int32_t mipp::nElmtsPerRegister ( )

References RegisterSizeBit.

template<typename T >
constexpr int32_t mipp::nElReg ( )
template<typename T >
Reg<T> mipp::notb ( const Reg< T >  v)
inline
template<int N>
Msk<N> mipp::notb ( const Msk< N >  v)
inline
template<typename T >
reg mipp::notb ( const reg  )
inline
template<int N>
msk mipp::notb ( const msk  )
inline
template<class C1 , class C2 >
bool mipp::operator!= ( const AlignedAllocator< C1 > &  ma1,
const AlignedAllocator< C2 > &  ma2 
)
template<typename T >
std::ostream& mipp::operator<< ( std::ostream &  os,
const Reg< T > &  r 
)
template<int N>
std::ostream& mipp::operator<< ( std::ostream &  os,
const Msk< N > &  m 
)
template<class C1 , class C2 >
bool mipp::operator== ( const AlignedAllocator< C1 > &  ma1,
const AlignedAllocator< C2 > &  ma2 
)
template<typename T >
Reg<T> mipp::orb ( const Reg< T >  v1,
const Reg< T >  v2 
)
inline
template<int N>
Msk<N> mipp::orb ( const Msk< N >  v1,
const Msk< N >  v2 
)
inline
template<typename T >
Reg<T> mipp::orb ( const Reg< T >  v1,
const Msk< N< T >()>  v2 
)
inline
template<typename T >
Reg<T> mipp::orb ( const Msk< N< T >()>  v1,
const Reg< T >  v2 
)
inline
template<typename T >
reg mipp::orb ( const reg  ,
const reg   
)
inline
template<int N>
msk mipp::orb ( const msk  ,
const msk   
)
inline
template<typename T1 , typename T2 >
Reg<T2> mipp::pack ( const Reg< T1 >  v1,
const Reg< T1 >  v2 
)
inline
template<typename T1 , typename T2 >
reg mipp::pack ( const reg  ,
const reg   
)
inline
template<typename T >
Reg<T> mipp::round ( const Reg< T >  v)
inline
template<typename T >
reg mipp::round ( const reg  )
inline
template<typename T >
Reg<T> mipp::rrot ( const Reg< T >  v)
inline
template<typename T >
reg mipp::rrot ( const reg  )
inline
template<typename T >
Reg<T> mipp::rshift ( const Reg< T >  v,
const uint32_t  n 
)
inline
template<int N>
Msk<N> mipp::rshift ( const Msk< N >  v,
const uint32_t  n 
)
inline
template<typename T >
reg mipp::rshift ( const reg  ,
const uint32_t   
)
inline
template<int N>
msk mipp::rshift ( const msk  ,
const uint32_t   
)
inline
template<typename T >
Reg<T> mipp::rsqrt ( const Reg< T >  v)
inline
template<typename T >
reg mipp::rsqrt ( const reg  )
inline
template<typename T >
Reg<T> mipp::sat ( const Reg< T >  v,
min,
max 
)
inline
template<typename T >
reg mipp::sat ( const reg  ,
,
 
)
inline
template<typename T >
reg mipp::set ( const T  [nElReg< T >()])
inline
template<int N>
msk mipp::set ( const bool  [N])
inline
template<typename T >
reg mipp::set0 ( )
inline
template<int N>
msk mipp::set0 ( )
inline
template<typename T >
reg mipp::set1 ( const T  )
inline
template<int N>
msk mipp::set1 ( const bool  )
inline
template<typename T >
Reg<T> mipp::shuff ( const Reg< T >  v1,
const Reg< T >  v2 
)
inline
template<typename T >
reg mipp::shuff ( const reg  ,
const reg   
)
inline
template<typename T >
Reg<T> mipp::shuff2 ( const Reg< T >  v1,
const Reg< T >  v2 
)
inline
template<typename T >
reg mipp::shuff2 ( const reg  ,
const reg   
)
inline
template<typename T >
Msk<N<T>)> mipp::sign ( const Reg< T >  v)
inline
template<typename T >
msk mipp::sign ( const reg  )
inline
template<typename T >
Reg<T> mipp::sin ( const Reg< T >  v)
inline
template<typename T >
reg mipp::sin ( const reg  )
inline
template<typename T >
void mipp::sincos ( const Reg< T >  x,
Reg< T > &  s,
Reg< T > &  c 
)
inline
template<typename T >
void mipp::sincos ( const reg  ,
reg &  ,
reg &   
)
inline
template<typename T >
Reg<T> mipp::sqrt ( const Reg< T >  v)
inline
template<typename T >
reg mipp::sqrt ( const reg  )
inline
template<typename T >
void mipp::store ( T *  ,
const reg   
)
inline
template<typename T >
void mipp::storeu ( T *  ,
const reg   
)
inline
template<typename T >
Reg< T > mipp::sub ( const Reg< T >  v1,
const Reg< T >  v2 
)
inline
template<typename T >
reg mipp::sub ( const reg  ,
const reg   
)
inline
template<typename T >
T mipp::sum ( const Reg< T >  v)
inline
template<typename T >
T mipp::sum ( const reg  v)
inline
template<typename T >
void mipp::transpose ( reg  [nElReg< T >()])
inline
template<typename T >
void mipp::transpose2 ( reg  [nElReg< T >()/2])
inline
template<typename T >
void mipp::transpose28x8 ( reg  [8])
inline
template<typename T >
void mipp::transpose8x8 ( reg  [8])
inline
template<typename T >
Reg<T> mipp::xorb ( const Reg< T >  v1,
const Reg< T >  v2 
)
inline
template<int N>
Msk<N> mipp::xorb ( const Msk< N >  v1,
const Msk< N >  v2 
)
inline
template<typename T >
Reg<T> mipp::xorb ( const Reg< T >  v1,
const Msk< N< T >()>  v2 
)
inline
template<typename T >
Reg<T> mipp::xorb ( const Msk< N< T >()>  v1,
const Reg< T >  v2 
)
inline
template<typename T >
reg mipp::xorb ( const reg  ,
const reg   
)
inline
template<int N>
msk mipp::xorb ( const msk  ,
const msk   
)
inline

Variable Documentation

const std::string mipp::InstructionFullType = "NO_INTRINSICS"
const std::string mipp::InstructionType = "NO"
const std::string mipp::InstructionVersion = "1"
constexpr uint32_t mipp::Lanes = MIPP_LANES

Referenced by dump().

constexpr uint32_t mipp::RegisterSizeBit = MIPP_REGISTER_SIZE

Referenced by dump(), and nElmtsPerRegister().

constexpr uint32_t mipp::RequiredAlignment = MIPP_REQUIRED_ALIGNMENT
const bool mipp::Support64Bit = false
const bool mipp::SupportByteWord = true