Geekly articles weekly

Accélérer l'accélération ou se familiariser avec SIMD, partie 2 - AVX

La partie précédente a provoqué une discussion animée, au cours de laquelle il s'est avéré que AVX / AVX2 existe réellement dans les processeurs de bureau, pas seulement AVX512. Par conséquent, nous continuons à nous familiariser avec SIMD, mais déjà avec sa partie moderne - AVX. Et nous analyserons également quelques commentaires:


  • _mm256_load_si256 est- _mm256_load_si256 plus lent que l'accès direct à la mémoire?
  • L'utilisation des commandes AVX sur les registres SSE affecte-t-elle la vitesse?
  • _popcnt est- _popcnt vraiment si mauvais?

Un peu sur AVX


AVX / AVX2 est une version plus puissante de SSE qui étend la plupart des opérations SSE 128 bits à 256 bits et apporte un certain nombre de nouvelles instructions.


Des subtilités de l'implémentation, on peut distinguer qu'au niveau assembleur AVX utilise 3 arguments, ce qui permet de ne pas détruire les données dans les deux premiers. SSE stocke le résultat dans l'un des arguments.


Il convient également de garder à l'esprit qu'avec l'adressage direct, les données doivent être alignées sur 32 octets, en SSE, alignement sur 16.


Version augmentée de la référence


Changements:


  1. Le nombre d'éléments a été augmenté de 10 000 fois (jusqu'à 10 240 000), afin de ne pas tenir dans le cache du processeur.
  2. L'alignement est passé de 16 octets à 32 pour prendre en charge AVX.
  3. Ajout d'implémentations AVX similaires à SSE.

Code de référence
 #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();

Les nouveaux résultats ressemblent à ceci (-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

L'accélération totale totale est de 9+ fois, AVX devrait être plus rapide que SSE de près de 2 fois.


_mm256_load_si256 est- _mm256_load_si256 que l'accès direct à la mémoire?


Il n'y a pas de réponse définitive. C -O0 plus lent que l'accès direct, mais plus rapide que _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 -O3 plus rapide que l'accès direct à la mémoire, mais devrait être plus lent _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

Dans le code de production, il est toujours préférable d'utiliser _mm256_load_si256 au lieu d'un accès direct; le compilateur peut mieux optimiser cette option.


L'utilisation des commandes AVX affecte-t-elle les registres SSE affecte-t-elle la vitesse?


La réponse courte est non . Pour l'expérience, j'ai compilé et exécuté la référence avec -mavx2 et avec -msse4.2 .


-mavx2


_popcnt32(_mm_movemask_epi8(_mm_cmpeq_epi16(...))) se transforme en


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

Résultats:


 ------------------------------------------------------------ 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(...))) se transforme en


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

Résultats:


 ------------------------------------------------------------ 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

bonus


Les commandes AVX _popcnt32(_mm256_movemask_epi8(_mm256_cmpeq_epi16(...))) transforment en


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

_popcnt est- _popcnt si mauvais?


Dans l'un des commentaires qu'Antervis a écrit:


Et pourtant, vous avez légèrement défectueux l'algorithme. Pourquoi le faire via movemask + popcnt? Pour les tableaux ne dépassant pas 2 ^ 18 éléments, vous pouvez d'abord collecter la somme élément par élément:
auto cmp = _mm_cmpeq_epi16 (sseVal, sseArr);
cmp = _mm_and_si128 (cmp, _mm_set1_epi16 (1));
sum = _mm_add_epi16 (somme, cmp);

puis, à la fin du cycle, faire un ajout horizontal (sans oublier le trop-plein).

J'ai fait une référence


 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); } }

et il s'est avéré être plus lent que c -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

et un peu plus vite avec -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

Source: https://habr.com/ru/post/fr440632/

More articles:


All Articles