_mm_alignr_epi8 (PALIGNR) AVX2 में बराबर

Question

SSE3 में, PALIGNR अनुदेश निम्नलिखित प्रदर्शन 128 बिट। नैवली, मुझे विश्वास था कि अंतर्निहित कार्य _mm256_alignr_epi8 (VPALIGNR) उसी ऑपरेशन को _mm_alignr_epi8 केवल 256 बिट रजिस्टरों पर करता है। अफसोस की बात है, हालांकि, यह बिल्कुल मामला नहीं है। वास्तव में, _mm256_alignr_epi8 256 बिट रजिस्टर को 2 128 बिट रजिस्ट्रार के रूप में मानता है और दो पड़ोसी 128 बिट रजिस्टरों पर 2 "संरेखण" संचालन करता है। _mm_alignr_epi8 के रूप में एक ही ऑपरेशन को प्रभावी ढंग से प्रदर्शन करना, लेकिन एक बार में 2 रजिस्टरों पर। यह सबसे स्पष्ट रूप से यहाँ सचित्र है: _mm256_alignr_epi8

वर्तमान में मेरे समाधान है _mm_alignr_epi8 का उपयोग कर रखने के लिए YMM (256 बिट) पंजीकृत करता विभाजित करके दो XMM (128 बिट) रजिस्टरों (हाई और लो) में है, इसलिए जैसे:

__m128i xmm_ymm1_hi = _mm256_extractf128_si256(ymm1, 0); 
__m128i xmm_ymm1_lo = _mm256_extractf128_si256(ymm1, 1); 
__m128i xmm_ymm2_hi = _mm256_extractf128_si256(ymm2, 0); 
__m128i xmm_ymm_aligned_lo = _mm_alignr_epi8(xmm_ymm1_lo, xmm_ymm1_hi, 1); 
__m128i xmm_ymm_aligned_hi = _mm_alignr_epi8(xmm_ymm2_hi, xmm_ymm1_lo, 1); 
__m256i xmm_ymm_aligned = _mm256_set_m128i(xmm_ymm_aligned_lo, xmm_ymm_aligned_hi); 

यह काम करता है, लेकिन एक बेहतर तरीका होना चाहिए, है ना? क्या कोई और अधिक "सामान्य" AVX2 निर्देश है जिसका उपयोग एक ही परिणाम प्राप्त करने के लिए किया जाना चाहिए?

Answer 1

एकमात्र समाधान मैं के लिए यह है साथ आने के लिए सक्षम था:

static inline __m256i _mm256_alignr_epi8(const __m256i v0, const __m256i v1, const int n) 
{ 
    if (n < 16) 
    { 
    __m128i v0h = _mm256_extractf128_si256(v0, 0); 
    __m128i v0l = _mm256_extractf128_si256(v0, 1); 
    __m128i v1h = _mm256_extractf128_si256(v1, 0); 
    __m128i vouth = _mm_alignr_epi8(v0l, v0h, n); 
    __m128i voutl = _mm_alignr_epi8(v1h, v0l, n); 
    __m256i vout = _mm256_set_m128i(voutl, vouth); 
    return vout; 
    } 
    else 
    { 
    __m128i v0h = _mm256_extractf128_si256(v0, 1); 
    __m128i v0l = _mm256_extractf128_si256(v1, 0); 
    __m128i v1h = _mm256_extractf128_si256(v1, 1); 
    __m128i vouth = _mm_alignr_epi8(v0l, v0h, n - 16); 
    __m128i voutl = _mm_alignr_epi8(v1h, v0l, n - 16); 
    __m256i vout = _mm256_set_m128i(voutl, vouth); 
    return vout; 
    } 
} 

जो मुझे लगता है कि काफी अपने समाधान के समान को छोड़कर यह भी> = 16 बाइट्स की पाली संभालती है।

Answer 2

आप palignr का उपयोग कर रहे हैं? यदि यह केवल डेटा मिसाइलमेंट को संभालने के लिए है, तो इसके बजाय गलत तरीके से लोड किए गए लोड का उपयोग करें; वे आम तौर पर आधुनिक इंटेल μ-architectures पर "तेज़ पर्याप्त" होते हैं (और आपको बहुत सारे कोड आकार को बचाएंगे)।

यदि आपको किसी अन्य कारण के लिए palignr जैसा व्यवहार की आवश्यकता है, तो आप इसे शाखा-मुक्त तरीके से करने के लिए असाइन किए गए लोड समर्थन का लाभ उठा सकते हैं। जब तक कि आप पूरी तरह से लोड-स्टोर बाध्य न हों, यह शायद पसंदीदा मुहावरे है।

static inline __m256i _mm256_alignr_epi8(const __m256i v0, const __m256i v1, const int n) 
{ 
    // Do whatever your compiler needs to make this buffer 64-byte aligned. 
    // You want to avoid the possibility of a page-boundary crossing load. 
    char buffer[64]; 

    // Two aligned stores to fill the buffer. 
    _mm256_store_si256((__m256i *)&buffer[0], v0); 
    _mm256_store_si256((__m256i *)&buffer[32], v1); 

    // Misaligned load to get the data we want. 
    return _mm256_loadu_si256((__m256i *)&buffer[n]); 
} 

आप बारे में अधिक जानकारी प्रदान कर सकते हैं कि कैसे वास्तव में आप palignr उपयोग कर रहे हैं, मैं शायद और अधिक उपयोगी हो सकता है।

Answer 3

हमें 256 बिट्स पर "palignr" का विस्तार करने के लिए "vperm2i128" और "vpalignr" की आवश्यकता है।

देखें: https://software.intel.com/en-us/blogs/2015/01/13/programming-using-avx2-permutations