GNU Radio's BLOCKSTREAM Package
mipp.h File Reference
#include "mipp_scalar_op.h"
#include <unordered_map>
#include <typeindex>
#include <stdexcept>
#include <typeinfo>
#include <iomanip>
#include <cstddef>
#include <cassert>
#include <string>
#include <vector>
#include <cmath>
#include <map>
#include "mipp_object.hxx"

Go to the source code of this file.

Classes

struct  mipp::regx2
 
struct  mipp::AlignedAllocator< T >
 
class  mipp::Reg< T >
 
class  mipp::Msk< N >
 
struct  mipp::_reduction< T, OP >
 
struct  mipp::_Reduction< T, OP >
 
struct  mipp::reduction< T, OP >
 
struct  mipp::Reduction< T, OP >
 
class  mipp::Reg< T >
 
class  mipp::Reg_2< T >
 
class  mipp::Regx2< T >
 
class  mipp::Msk< N >
 
class  mipp::Reg< T >
 
class  mipp::Msk< N >
 
class  mipp::Reg_2< T >
 
class  mipp::Regx2< T >
 

Namespaces

 mipp
 

Macros

#define MIPP_NO
 
#define MIPP_NO_INTRINSICS
 
#define MIPP_REQUIRED_ALIGNMENT   1
 
#define MIPP_BW
 
#define MIPP_INSTR_VERSION   1
 
#define MIPP_REGISTER_SIZE   0
 
#define MIPP_LANES   1
 

Typedefs

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

Functions

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

Variables

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

Macro Definition Documentation

#define MIPP_BW
#define MIPP_INSTR_VERSION   1
#define MIPP_LANES   1
#define MIPP_NO
#define MIPP_NO_INTRINSICS
#define MIPP_REGISTER_SIZE   0
#define MIPP_REQUIRED_ALIGNMENT   1