如何使用 Altivec 将向量存储到内存中未对齐的位置

Posted 2023-02-16

【中文标题】如何使用 Altivec 将向量存储到内存中未对齐的位置

【英文标题】：How to store a vector to an unaligned location in memory with Altivec

【发布时间】：2016-02-10 14:04:45

【问题描述】：

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

//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 倍。 由于我无法控制输入和输出内存的对齐，所以我必须实现这两个版本。 如何最大程度地减少未对齐大小写的性能损失？

【参考方案1】：

首先我想提一下，如果您多次将 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%。 这当然令人不快，但可以容忍。

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