5

我从教程中知道，未对齐的加载和存储可能如下所示：

//Load a vector from an unaligned location in memory
__vector unsigned char LoadUnaligned(const unsigned char * src )
{
    __vector unsigned char permuteVector = vec_lvsl(0, src);
    __vector unsigned char low = vec_ld( 0, src);
    __vector unsigned char high = vec_ld( 16, src);
    return vec_perm( low, high, permuteVector);
}

//Store a vector to an unaligned location in memory
void StoreUnaligned(__vector unsigned char v, __vector unsigned char * dst)
{
    //Load the surrounding area
    __vector unsigned char low = vec_ld( 0, dst);
    __vector unsigned char high = vec_ld( 16, dst);
    //Prepare the constants that we need
    __vector unsigned char permuteVector = vec_lvsr( 0, (int*) dst);
    __vector signed char oxFF = vec_splat_s8( -1 );
    __vector signed char ox00 = vec_splat_s8( 0 );
    //Make a mask for which parts of the vectors to swap out
    __vector unsigned char mask = vec_perm( ox00, oxFF, permuteVector );
    //Right rotate our input data
    v = vec_perm( v, v, permuteVector );
    //Insert our data into the low and high vectors
    low = vec_sel( v, low, mask );
    high = vec_sel( high, v, mask );
    //Store the two aligned result vectors
    vec_st( low, 0, dst);
    vec_st( high, 16, dst);
}

看起来很可怕。为了存储一个向量需要做大量的工作！并且有适当的性能损失。

void SomeFuncA(const unsigned char * src, size_t size, unsigned char * dst)
{
    for(size_t i = 0; i < size; i += 16)
    {
        __vector unsigned char a = vec_ld(0, src + i);
        //simple work
        vec_st(a, 0, dst + i);
    }    
}

void SomeFuncU(const unsigned char * src, size_t size, unsigned char * dst)
{
    for(size_t i = 0; i < size; i += 16)
    {
        __vector unsigned char a = LoadUnaligned(src + i);
        //simple work
        StoreUnaligned(dst + i, a);
    }    
}

第二个功能的工作速度比第一个慢 3-4 倍。由于我无法控制输入和输出内存的对齐，所以我必须实现这两个版本。如何最大程度地减少未对齐案例的性能损失？

4

1 回答 1

4

首先我想提一下，如果您多次将 Altivec 向量保存到未对齐的内存中，则不需要仅在开始和结束时将先前的内存状态保存在数组中间。所以Simd Library中有一个有用的函数和类，它实现了这个功能：

typedef __vector uint8_t v128_u8;
const v128_u8 K8_00 = vec_splat_u8(0x00);
const v128_u8 K8_FF = vec_splat_u8(0xFF);

template <bool align> inline v128_u8 Load(const uint8_t * p);

template <> inline v128_u8 Load<false>(const uint8_t * p)
{
    v128_u8 lo = vec_ld(0, p);
    v128_u8 hi = vec_ld(16, p);
    return vec_perm(lo, hi, vec_lvsl(0, p));        
}        

template <> inline v128_u8 Load<true>(const uint8_t * p)
{
    return vec_ld(0, p); 
}

template <bool align> struct Storer;

template <> struct Storer<true>
{
    template <class T> Storer(T * ptr)
        :_ptr((uint8_t*)ptr)
    {
    }

    template <class T> inline void First(T value)
    {
        vec_st((v128_u8)value, 0, _ptr);
    }

    template <class T> inline void Next(T value)
    {
        _ptr += 16;
        vec_st((v128_u8)value, 0, _ptr);
    }

    inline void Flush()
    {
    }
private:
    uint8_t * _ptr;
};

template <> struct Storer<false>
{
    template <class T> inline Storer(T * ptr)
        :_ptr((uint8_t*)ptr)
    {
        _perm = vec_lvsr(0, _ptr);
        _mask = vec_perm(K8_00, K8_FF, _perm);
    }

    template <class T> inline void First(T value)
    {
        _last = (v128_u8)value;
        v128_u8 background = vec_ld(0, _ptr);
        v128_u8 foreground = vec_perm(_last, _last, _perm);
        vec_st(vec_sel(background, foreground, _mask), 0, _ptr);
    }

    template <class T> inline void Next(T value)
    {
        _ptr += 16;
        vec_st(vec_perm(_last, (v128_u8)value, _perm), 0, _ptr);
        _last = (v128_u8)value;
    }

    inline void Flush()
    {
        v128_u8 background = vec_ld(16, _ptr);
        v128_u8 foreground = vec_perm(_last, _last, _perm); 
        vec_st(vec_sel(foreground, background, _mask), 16, _ptr);
    }
private:
    uint8_t * _ptr;
    v128_u8 _perm;
    v128_u8 _mask;
    v128_u8 _last;
};

它的使用将如下所示：

template<bool align> void SomeFunc(const unsigned char * src, size_t size, unsigned char * dst)
{
    Storer<align> _dst(dst);
    __vector unsigned char a = Load<align>(src);
    //simple work
    _dst.First(a);// save first block 
    for(size_t i = 16; i < size; i += 16)
    {
        __vector unsigned char a = Load<align>(src + i);
        //simple work
        _dst.Next(a);// save body 
    }
    _dst.Flush();  // save tail      
}

与对齐版本相比，性能损失将是 30-40%。这当然令人不快，但可以容忍。

另一个优点是减少了代码 - 所有函数（对齐和未对齐）都具有相同的实现。

于 2016-02-10T14:30:17.573 回答