त्वरण को तेज करना या SIMD को जानना, भाग 2 - AVX

पिछले भाग ने एक गर्म चर्चा का कारण बना, जिसके दौरान यह पता चला कि AVX / AVX2 वास्तव में डेस्कटॉप CPUs में है, न केवल AVX212। इसलिए, हम SIMD से परिचित होना जारी रखते हैं, लेकिन पहले से ही इसके आधुनिक भाग - AVX के साथ। और भी हम कुछ टिप्पणियों का विश्लेषण करेंगे:

• क्या _mm256_load_si256 सीधी मेमोरी एक्सेस से धीमी है?
• SSE रजिस्टरों पर AVX कमांड का उपयोग करने से गति प्रभावित होती है?
• क्या _popcnt वास्तव में बुरा है?

AVX के बारे में थोड़ा सा

AVX / AVX2 SSE का एक अधिक शक्तिशाली संस्करण है जो अधिकांश 128-बिट SSE संचालन को 256 बिट तक बढ़ाता है, साथ ही कई नए निर्देश भी लाता है।

कार्यान्वयन की सूक्ष्मताओं से, हम यह भेद कर सकते हैं कि कोडांतरक स्तर पर AVX 3 तर्कों का उपयोग करता है, जो पहले दो में डेटा को नष्ट नहीं करने देता है। SSE परिणाम को एक तर्क में संग्रहीत करता है।

यह भी ध्यान में रखा जाना चाहिए कि प्रत्यक्ष पते के साथ, डेटा को 32 बाइट्स द्वारा, एसएसई में 16 द्वारा संरेखित किया जाना चाहिए।

बेंचमार्क का संवर्धित संस्करण

परिवर्तन:

1. तत्वों की संख्या 10,000 गुना (10,240,000 तक) बढ़ाई गई है, ताकि प्रोसेसर कैश में फिट न हो।
2. AVX का समर्थन करने के लिए संरेखण 16 बाइट्स से 32 तक बदल गया।
3. SSE के समान AVX कार्यान्वयन जोड़ा गया।

 #include <benchmark/benchmark.h> #include <x86intrin.h> #include <cstring> #define ARR_SIZE 10240000 #define VAL 50 static int16_t *getRandArr() { auto res = new int16_t[ARR_SIZE]; for (int i = 0; i < ARR_SIZE; ++i) { res[i] = static_cast<int16_t>(rand() % (VAL * 2)); } return res; } static auto arr = getRandArr(); static int16_t *getAllignedArr() { auto res = aligned_alloc(32, sizeof(int16_t) * ARR_SIZE); memcpy(res, arr, sizeof(int16_t) * ARR_SIZE); return static_cast<int16_t *>(res); } static auto allignedArr = getAllignedArr(); static void BM_Count(benchmark::State &state) { for (auto _ : state) { int64_t cnt = 0; for (int i = 0; i < ARR_SIZE; ++i) if (arr[i] == VAL) ++cnt; benchmark::DoNotOptimize(cnt); } } BENCHMARK(BM_Count); static void BM_SSE_COUNT_SET_EPI(benchmark::State &state) { for (auto _ : state) { int64_t cnt = 0; auto sseVal = _mm_set1_epi16(VAL); for (int i = 0; i < ARR_SIZE; i += 8) { cnt += _popcnt32( _mm_movemask_epi8( _mm_cmpeq_epi16( sseVal, _mm_set_epi16(arr[i + 7], arr[i + 6], arr[i + 5], arr[i + 4], arr[i + 3], arr[i + 2], arr[i + 1], arr[i]) ) ) ); } benchmark::DoNotOptimize(cnt >> 1); } } BENCHMARK(BM_SSE_COUNT_SET_EPI); static void BM_SSE_COUNT_LOADU(benchmark::State &state) { for (auto _ : state) { int64_t cnt = 0; auto sseVal = _mm_set1_epi16(VAL); for (int i = 0; i < ARR_SIZE; i += 8) { cnt += _popcnt32( _mm_movemask_epi8( _mm_cmpeq_epi16( sseVal, _mm_loadu_si128((__m128i *) &arr[i]) ) ) ); } benchmark::DoNotOptimize(cnt >> 1); } } BENCHMARK(BM_SSE_COUNT_LOADU); static void BM_SSE_COUNT_DIRECT(benchmark::State &state) { for (auto _ : state) { int64_t cnt = 0; auto sseVal = _mm_set1_epi16(VAL); for (int i = 0; i < ARR_SIZE; i += 8) { cnt += _popcnt32( _mm_movemask_epi8( _mm_cmpeq_epi16( sseVal, *(__m128i *) &allignedArr[i] ) ) ); } benchmark::DoNotOptimize(cnt >> 1); } } BENCHMARK(BM_SSE_COUNT_DIRECT); #ifdef __AVX2__ static void BM_AVX_COUNT_LOADU(benchmark::State &state) { for (auto _ : state) { int64_t cnt = 0; auto avxVal = _mm256_set1_epi16(VAL); for (int i = 0; i < ARR_SIZE; i += 16) { cnt += _popcnt32( _mm256_movemask_epi8( _mm256_cmpeq_epi16( avxVal, _mm256_loadu_si256((__m256i *) &arr[i]) ) ) ); } benchmark::DoNotOptimize(cnt >> 1); } } BENCHMARK(BM_AVX_COUNT_LOADU); static void BM_AVX_COUNT_LOAD(benchmark::State &state) { for (auto _ : state) { int64_t cnt = 0; auto avxVal = _mm256_set1_epi16(VAL); for (int i = 0; i < ARR_SIZE; i += 16) { cnt += _popcnt32( _mm256_movemask_epi8( _mm256_cmpeq_epi16(avxVal, _mm256_load_si256((__m256i *) &allignedArr[i]) ) ) ); } benchmark::DoNotOptimize(cnt >> 1); } } BENCHMARK(BM_AVX_COUNT_LOAD); static void BM_AVX_COUNT_DIRECT(benchmark::State &state) { for (auto _ : state) { int64_t cnt = 0; auto avxVal = _mm256_set1_epi16(VAL); for (int i = 0; i < ARR_SIZE; i += 16) { cnt += _popcnt32( _mm256_movemask_epi8( _mm256_cmpeq_epi16( avxVal, *(__m256i *) &allignedArr[i] ) ) ); } benchmark::DoNotOptimize(cnt >> 1); } } BENCHMARK(BM_AVX_COUNT_DIRECT); #endif BENCHMARK_MAIN(); 

नए परिणाम इस तरह दिखते हैं (-O0):

 --------------------------------------------------------------------- Benchmark Time CPU Iterations --------------------------------------------------------------------- BM_Count 17226622 ns 17062958 ns 41 BM_SSE_COUNT_SET_EPI 8901343 ns 8814845 ns 79 BM_SSE_COUNT_LOADU 3664778 ns 3664766 ns 185 BM_SSE_COUNT_DIRECT 3468436 ns 3468423 ns 202 BM_AVX_COUNT_LOADU 2090817 ns 2090796 ns 343 BM_AVX_COUNT_LOAD 1904424 ns 1904419 ns 364 BM_AVX_COUNT_DIRECT 1814875 ns 1814854 ns 385 

कुल कुल त्वरण 9+ बार है, एवीएक्स एसएसई की तुलना में लगभग 2 गुना तेज होने की उम्मीद है।

क्या _mm256_load_si256 सीधी मेमोरी एक्सेस से _mm256_load_si256 है?

इसका कोई निश्चित उत्तर नहीं है। C -O0 सीधी पहुंच से धीमी है, लेकिन _mm256_loadu_si256 तुलना में _mm256_loadu_si256 :

 --------------------------------------------------------------------- Benchmark Time CPU Iterations --------------------------------------------------------------------- BM_AVX_COUNT_LOADU 2090817 ns 2090796 ns 343 BM_AVX_COUNT_LOAD 1904424 ns 1904419 ns 364 BM_AVX_COUNT_DIRECT 1814875 ns 1814854 ns 385 

C _mm256_loadu_si256 डायरेक्ट मेमोरी एक्सेस से तेज है, लेकिन फिर भी उम्मीद से कम है _mm256_loadu_si256 ।

 --------------------------------------------------------------------- Benchmark Time CPU Iterations --------------------------------------------------------------------- BM_AVX_COUNT_LOADU 992319 ns 992368 ns 701 BM_AVX_COUNT_LOAD 956120 ns 956166 ns 712 BM_AVX_COUNT_DIRECT 1027624 ns 1027674 ns 730 

उत्पादन कोड में, प्रत्यक्ष पहुंच के बजाय _mm256_load_si256 का उपयोग करना अभी भी बेहतर है; संकलक इस विकल्प को बेहतर ढंग से अनुकूलित कर सकता है।

क्या AVX कमांड का उपयोग SSE रजिस्टरों की गति को प्रभावित करता है?

संक्षिप्त उत्तर नहीं है । प्रयोग के लिए, मैंने -mavx2 और -mavx2 साथ बेंचमार्क संकलित और चलाया।

-mavx2

_popcnt32(_mm_movemask_epi8(_mm_cmpeq_epi16(...))) बदल जाता है

 vpcmpeqw %xmm1,%xmm0,%xmm0 vpmovmskb %xmm0,%edx popcnt %edx,%edx 

परिणाम:

 ------------------------------------------------------------ Benchmark Time CPU Iterations ------------------------------------------------------------ BM_SSE_COUNT_SET_EPI 9376699 ns 9376767 ns 75 BM_SSE_COUNT_LOADU 4425510 ns 4425560 ns 159 BM_SSE_COUNT_DIRECT 3938604 ns 3938648 ns 177 

-msse4.2

_popcnt32(_mm_movemask_epi8(_mm_cmpeq_epi16(...))) बदल जाता है

 pcmpeqw %xmm1,%xmm0 pmovmskb %xmm0,%edx popcnt %edx,%edx 

परिणाम:

 ------------------------------------------------------------ Benchmark Time CPU Iterations ------------------------------------------------------------ BM_SSE_COUNT_SET_EPI 9309352 ns 9309375 ns 76 BM_SSE_COUNT_LOADU 4382183 ns 4382195 ns 159 BM_SSE_COUNT_DIRECT 3944579 ns 3944590 ns 176 

बोनस

AVX कमांड _popcnt32(_mm256_movemask_epi8(_mm256_cmpeq_epi16(...))) बदल जाती है

 vpcmpeqw %ymm1,%ymm0,%ymm0 vpmovmskb %ymm0,%edx popcnt %edx,%edx 

क्या _popcnt इतना बुरा है?

टिप्पणियों में से एक में Antervis ने लिखा है:

और फिर भी, आपने एल्गोरिथ्म को थोड़ा दोष दिया है। इसे मूवमस्क + पॉपकंट के माध्यम से क्यों करते हैं? 2 ^ 18 तत्वों से अधिक के सरणियों के लिए, आप पहले तत्व-बाय-एलीमेंट राशि एकत्र कर सकते हैं:
ऑटो cmp = _mm_cmpeq_epi16 (sseVal, sseArr);
cmp = _mm_and_si128 (cmp, _mm_set1_epi16 (1));
sum = _mm_add_epi16 (sum, cmp);

और फिर, चक्र के अंत में, एक क्षैतिज जोड़ बनाएं (अतिप्रवाह नहीं भूलना)।

मैंने एक बेंचमार्क बनाया

 static void BM_AVX_COUNT_DIRECT_WO_POPCNT(benchmark::State &state) { auto avxVal1 = _mm256_set1_epi16(1); for (auto _ : state) { auto sum = _mm256_set1_epi16(0); auto avxVal = _mm256_set1_epi16(VAL); for (int i = 0; i < ARR_SIZE; i += 16) { sum = _mm256_add_epi16( sum, _mm256_and_si256( avxVal1, _mm256_cmpeq_epi16( avxVal, *(__m256i *) &allignedArr[i]) ) ); } auto arrSum = (uint16_t *) &sum; size_t cnt = 0; for (int j = 0; j < 16; ++j) cnt += arrSum[j]; benchmark::DoNotOptimize(cnt >> 1); } } 

और यह c -O0 की तुलना में धीमा -O0 :

 --------------------------------------------------------------------- Benchmark Time CPU Iterations --------------------------------------------------------------------- BM_AVX_COUNT_DIRECT 1814821 ns 1814785 ns 392 BM_AVX_COUNT_DIRECT_WO_POPCNT 2386289 ns 2386227 ns 287 

और -O3 साथ थोड़ा तेज:

 --------------------------------------------------------------------- Benchmark Time CPU Iterations --------------------------------------------------------------------- BM_AVX_COUNT_DIRECT 960941 ns 960924 ns 722 BM_AVX_COUNT_DIRECT_WO_POPCNT 948611 ns 948596 ns 732