Что такое sse в процессоре?

Ускоряем неускоряемое или знакомимся с SIMD

Есть класс задач, которые нельзя ускорить за счёт оптимизации алгоритмов, а ускорить надо. В этой практически тупиковой ситуации к нам на помощь приходят разработчики процессоров, которые сделали команды, позволяющие выполнять операции на большим количеством данных за одну операцию. В случае x86 процессоров это инструкции сделанные в расширениях MMX, SSE, SSE2, SSE3, SSE4, SSE4.1, SSE4.2, AVX, AVX2, AVX512.

В качестве «подопытного кролика» я взял следующую задачу:Есть неупорядоченный массив arr с числами типа uint16_t. Необходимо найти количество вхождений числа v в массив arr.

Классическое решение, работающее за линейное время выглядит так: int64_t cnt = 0;for (int i = 0; i < ARR_SIZE; ++i) if (arr[i] == v) ++cnt; В таком виде бенчмарк показывает следующие результаты: ------------------------------------------------------------Benchmark Time CPU Iterations------------------------------------------------------------BM_Count 2084 ns 2084 ns 333079 Под катом я покажу как его ускорить в 5+ раз.

Тестовое окружение

Для тестов я использовал ноутбук с процессором Intel(R) Core(TM) i7-8750H CPU @ 2.20GHz. В качестве компилятора был clang version 6.0.0. Для измерения производительности я выбрал libbenchmark от Google. Размер массива я взял 1024 элемента, чтобы не считать классическим способом остаток элементов.

Что такое SIMD

SIMD (Single Instruction, Multiple Data) — одиночный поток команд, множественный поток данных. В x86 совместимых процессорах эти команды были реализованы в нескольких поколениях SSE и AVX расширениях процессора. Команд довольно много, полный список от Intel можно посмотреть на странице software.intel.com/sites/landingpage/IntrinsicsGuide. В десктопных процессорах AVX расширения недоступны, поэтому сосредоточимся на SSE.

Для работы с SIMD в C/C++ в код надо добавить #include
Так же компилятору надо сказать, что нужно использовать расширения, иначе будут ошибки вида always_inline function '_popcnt32' requires target feature 'popcnt', but ….

Сделать это можно несколькими путями:

1. Перечислить все необходимые feature, например -mpopcnt
2. Указать целевую архитектуру процессора поддерживающего необходимые feature, например -march=corei7
3. Дать компилятору возможность использовать все расширения процессора, на котором происходит сборка: -march=native

Что же можно ускорить в коде из 3 строк?

for (int i = 0; i < ARR_SIZE; ++i) if (arr[i] == v) ++cnt;
Хорошо бы уменьшить количество итераций и проводить сравнение сразу с несколькими элементами за один цикл. Открываем сайт от Intel, выбираем только SSE расширения и категорию «Compare». Первыми в списке идёт семейство функций __m128i _mm_cmpeq_epi* (__m128i a, __m128i b).

Открываем документацию первой из них и видим:

Compare packed 16-bit integers in a and b for equality, and store the results in dst. То что надо! Осталось только превратить []int16_t в __m128i. Для этого используются функции из категорий «Set» и «Load».

Итак, функция _mm_cmpeq_epi16 сравнивает параллельно 8 int16_t чисел в «массивах» a и b, и возвращает «массив» из чисел 0xFFFF — для одинаковых элементов и 0x0000 — для разных:

Для быстрого подсчёта количества бит в числе есть функции _popcnt32 и _popcnt64, которые работают с 32 и 64 разрядными числами соответственно. Но, к сожалению, нет функции которая может привести результат _mm_cmpeq_epi16 к битовой маске, но есть функция _mm_movemask_epi8, которая делает аналогичную операцию для «массива» из 16 int8_t чисел. Но _mm_movemask_epi8 можно использовать для «массива» из 8 int16_t чисел, просто в конце результат надо будет разделить на 2.

Теперь есть всё, чтобы приступить к тестированию SIMD.

Вариант 1

int64_t cnt = 0; // Превращаем искомое значение в «массив» из 8 одинаковых элементовauto sseVal = _mm_set1_epi16(VAL);for (int i = 0; i < ARR_SIZE; i += 8) { // Для каждого блока из 8 элементов помещаем в переменную для сравнения auto sseArr = _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]); // Получаем количество совпадений * 2 cnt += _popcnt32(_mm_movemask_epi8(_mm_cmpeq_epi16(sseVal, sseArr)));}// Делим на 2 cnt >>= 1; Бенчмарк показал следующие результаты: ————————————————————Benchmark Time CPU Iterations————————————————————BM_Count 2084 ns 2084 ns 333079BM_SSE_COUNT_SET_EPI 937 ns 937 ns 746435 Всего лишь в 2 раза быстрее, а я обещал в 5+. Для того, чтобы понять где могут быть узкие места, придётся опуститься на уровень ассемблера. ————— Копирование 8 элементов в sseArr ————— auto sseArr = _mm_set_epi16(arr[i + 7], arr[i + 6], arr[i + 5], arr[i + 4], arr[i + 3], arr[i + 2], 40133a: 48 8b 05 77 1d 20 00 mov 0x201d77(%rip),%rax # 6030b8 arr[i + 1], arr[i]); 401341: 48 63 8d 9c fe ff ff movslq -0x164(%rbp),%rcx auto sseArr = _mm_set_epi16(arr[i + 7], arr[i + 6], arr[i + 5], arr[i + 4], arr[i + 3], arr[i + 2], 401348: 66 8b 54 48 0e mov 0xe(%rax,%rcx,2),%dx 40134d: 66 8b 74 48 0c mov 0xc(%rax,%rcx,2),%si 401352: 66 8b 7c 48 0a mov 0xa(%rax,%rcx,2),%di 401357: 66 44 8b 44 48 08 mov 0x8(%rax,%rcx,2),%r8w 40135d: 66 44 8b 4c 48 06 mov 0x6(%rax,%rcx,2),%r9w 401363: 66 44 8b 54 48 04 mov 0x4(%rax,%rcx,2),%r10w arr[i + 1], arr[i]); 401369: 66 44 8b 1c 48 mov (%rax,%rcx,2),%r11w 40136e: 66 8b 5c 48 02 mov 0x2(%rax,%rcx,2),%bx auto sseArr = _mm_set_epi16(arr[i + 7], arr[i + 6], arr[i + 5], arr[i + 4], arr[i + 3], arr[i + 2], 401373: 66 89 55 ce mov %dx,-0x32(%rbp) 401377: 66 89 75 cc mov %si,-0x34(%rbp) 40137b: 66 89 7d ca mov %di,-0x36(%rbp) 40137f: 66 44 89 45 c8 mov %r8w,-0x38(%rbp) 401384: 66 44 89 4d c6 mov %r9w,-0x3a(%rbp) 401389: 66 44 89 55 c4 mov %r10w,-0x3c(%rbp) 40138e: 66 89 5d c2 mov %bx,-0x3e(%rbp) 401392: 66 44 89 5d c0 mov %r11w,-0x40(%rbp) 401397: 44 0f b7 75 c0 movzwl -0x40(%rbp),%r14d 40139c: c4 c1 79 6e c6 vmovd %r14d,%xmm0 4013a1: 44 0f b7 75 c2 movzwl -0x3e(%rbp),%r14d 4013a6: c4 c1 79 c4 c6 01 vpinsrw $0x1,%r14d,%xmm0,%xmm0 4013ac: 44 0f b7 75 c4 movzwl -0x3c(%rbp),%r14d 4013b1: c4 c1 79 c4 c6 02 vpinsrw $0x2,%r14d,%xmm0,%xmm0 4013b7: 44 0f b7 75 c6 movzwl -0x3a(%rbp),%r14d 4013bc: c4 c1 79 c4 c6 03 vpinsrw $0x3,%r14d,%xmm0,%xmm0 4013c2: 44 0f b7 75 c8 movzwl -0x38(%rbp),%r14d 4013c7: c4 c1 79 c4 c6 04 vpinsrw $0x4,%r14d,%xmm0,%xmm0 4013cd: 44 0f b7 75 ca movzwl -0x36(%rbp),%r14d 4013d2: c4 c1 79 c4 c6 05 vpinsrw $0x5,%r14d,%xmm0,%xmm0 4013d8: 44 0f b7 75 cc movzwl -0x34(%rbp),%r14d 4013dd: c4 c1 79 c4 c6 06 vpinsrw $0x6,%r14d,%xmm0,%xmm0 4013e3: 44 0f b7 75 ce movzwl -0x32(%rbp),%r14d 4013e8: c4 c1 79 c4 c6 07 vpinsrw $0x7,%r14d,%xmm0,%xmm0 4013ee: c5 f9 7f 45 b0 vmovdqa %xmm0,-0x50(%rbp) 4013f3: c5 f9 6f 45 b0 vmovdqa -0x50(%rbp),%xmm0 4013f8: c5 f9 7f 85 80 fe ff vmovdqa %xmm0,-0x180(%rbp) 4013ff: ff ————— Подсчёт совпавших элементов ————— cnt += _popcnt32(_mm_movemask_epi8(_mm_cmpeq_epi16(sseVal, sseArr))); 401400: c5 f9 6f 85 a0 fe ff vmovdqa -0x160(%rbp),%xmm0 401407: ff 401408: c5 f9 6f 8d 80 fe ff vmovdqa -0x180(%rbp),%xmm1 40140f: ff 401410: c5 f9 7f 45 a0 vmovdqa %xmm0,-0x60(%rbp) 401415: c5 f9 7f 4d 90 vmovdqa %xmm1,-0x70(%rbp) 40141a: c5 f9 6f 45 a0 vmovdqa -0x60(%rbp),%xmm0 40141f: c5 f9 6f 4d 90 vmovdqa -0x70(%rbp),%xmm1 401424: c5 f9 75 c1 vpcmpeqw %xmm1,%xmm0,%xmm0 401428: c5 f9 7f 45 80 vmovdqa %xmm0,-0x80(%rbp) 40142d: c5 f9 6f 45 80 vmovdqa -0x80(%rbp),%xmm0 401432: c5 79 d7 f0 vpmovmskb %xmm0,%r14d 401436: 44 89 b5 7c ff ff ff mov %r14d,-0x84(%rbp) 40143d: 44 8b b5 7c ff ff ff mov -0x84(%rbp),%r14d 401444: f3 45 0f b8 f6 popcnt %r14d,%r14d 401449: 49 63 c6 movslq %r14d,%rax 40144c: 48 03 85 b8 fe ff ff add -0x148(%rbp),%rax 401453: 48 89 85 b8 fe ff ff mov %rax,-0x148(%rbp)
Видно, что очень много команд процессора занимает копирование элементов массива в sseArr.

Вариант 2

Вместо функции _mm_set_epi16, можно использовать _mm_loadu_si128. Описание функции:
Load 128-bits of integer data from unaligned memory into dst На вход ожидается указатель на память, что намекает на более оптимальное копирование данных в переменную.

Проверим: int64_t cnt = 0; auto sseVal = _mm_set1_epi16(VAL); for (int i = 0; i < ARR_SIZE; i += 8) { auto sseArr = _mm_loadu_si128((__m128i *) &arr[i]); cnt += _popcnt32(_mm_movemask_epi8(_mm_cmpeq_epi16(sseVal, sseArr))); } Бенчмарк показал улучшение в ~2 раза: ------------------------------------------------------------Benchmark Time CPU Iterations------------------------------------------------------------BM_Count 2084 ns 2084 ns 333079BM_SSE_COUNT_SET_EPI 937 ns 937 ns 746435BM_SSE_COUNT_LOADU 454 ns 454 ns 1548455 Машинный код выглядит так: auto sseArr = _mm_loadu_si128((__m128i *) &arr[i]); 401695: 48 8b 05 1c 1a 20 00 mov 0x201a1c(%rip),%rax # 6030b8 40169c: 48 63 8d bc fe ff ff movslq -0x144(%rbp),%rcx 4016a3: 48 8d 04 48 lea (%rax,%rcx,2),%rax 4016a7: 48 89 45 d8 mov %rax,-0x28(%rbp) 4016ab: 48 8b 45 d8 mov -0x28(%rbp),%rax 4016af: c5 fa 6f 00 vmovdqu (%rax),%xmm0 4016b3: c5 f9 7f 85 a0 fe ff vmovdqa %xmm0,-0x160(%rbp) 4016ba: ff cnt += _popcnt32(_mm_movemask_epi8(_mm_cmpeq_epi16(sseVal, sseArr))); 4016bb: c5 f9 6f 85 c0 fe ff vmovdqa -0x140(%rbp),%xmm0 4016c2: ff 4016c3: c5 f9 6f 8d a0 fe ff vmovdqa -0x160(%rbp),%xmm1 4016ca: ff 4016cb: c5 f9 7f 45 c0 vmovdqa %xmm0,-0x40(%rbp) 4016d0: c5 f9 7f 4d b0 vmovdqa %xmm1,-0x50(%rbp) 4016d5: c5 f9 6f 45 c0 vmovdqa -0x40(%rbp),%xmm0 4016da: c5 f9 6f 4d b0 vmovdqa -0x50(%rbp),%xmm1 4016df: c5 f9 75 c1 vpcmpeqw %xmm1,%xmm0,%xmm0 4016e3: c5 f9 7f 45 a0 vmovdqa %xmm0,-0x60(%rbp) 4016e8: c5 f9 6f 45 a0 vmovdqa -0x60(%rbp),%xmm0 4016ed: c5 f9 d7 d0 vpmovmskb %xmm0,%edx 4016f1: 89 55 9c mov %edx,-0x64(%rbp) 4016f4: 8b 55 9c mov -0x64(%rbp),%edx 4016f7: f3 0f b8 d2 popcnt %edx,%edx 4016: 48 63 c2 movslq %edx,%rax 4016fe: 48 03 85 d8 fe ff ff add -0x128(%rbp),%rax 401705: 48 89 85 d8 fe ff ff mov %rax,-0x128(%rbp)

Вариант 3

SSE инструкции работают с выровненной памятью по 16 байт.

Функция _mm_loadu_si128 позволяет избежать это ограничение, но если выделять память под массив с помощью функции aligned_alloc(16, SZ), то можно будет напрямую передавать адрес в SSE инструкцию: int64_t cnt = 0; auto sseVal = _mm_set1_epi16(VAL);for (int i = 0; i < ARR_SIZE; i += 8) { auto sseArr = *(__m128i *) &allignedArr[i]; cnt += _popcnt32(_mm_movemask_epi8(_mm_cmpeq_epi16(sseVal, sseArr)));} Такая оптимизация даёт ещё немного прироста производительности: ------------------------------------------------------------Benchmark Time CPU Iterations------------------------------------------------------------BM_Count 2084 ns 2084 ns 333079BM_SSE_COUNT_SET_EPI 937 ns 937 ns 746435BM_SSE_COUNT_LOADU 454 ns 454 ns 1548455BM_SSE_COUNT_DIRECT 395 ns 395 ns 1770803 Это произошло благодаря экономии 3 инструкций: auto sseArr = *(__m128i *) &allignedArr[i]; 40193c: 48 8b 05 7d 17 20 00 mov 0x20177d(%rip),%rax # 6030c0 401943: 48 63 8d cc fe ff ff movslq -0x134(%rbp),%rcx 40194a: c5 f9 6f 04 48 vmovdqa (%rax,%rcx,2),%xmm0 40194f: c5 f9 7f 85 b0 fe ff vmovdqa %xmm0,-0x150(%rbp) 401956: ff cnt += _popcnt32(_mm_movemask_epi8(_mm_cmpeq_epi16(sseVal, sseArr))); 401957: c5 f9 6f 85 d0 fe ff vmovdqa -0x130(%rbp),%xmm0 40195e: ff 40195f: c5 f9 6f 8d b0 fe ff vmovdqa -0x150(%rbp),%xmm1 401966: ff 401967: c5 f9 7f 45 d0 vmovdqa %xmm0,-0x30(%rbp) 40196c: c5 f9 7f 4d c0 vmovdqa %xmm1,-0x40(%rbp) 401971: c5 f9 6f 45 d0 vmovdqa -0x30(%rbp),%xmm0 401976: c5 f9 6f 4d c0 vmovdqa -0x40(%rbp),%xmm1 40197b: c5 f9 75 c1 vpcmpeqw %xmm1,%xmm0,%xmm0 40197f: c5 f9 7f 45 b0 vmovdqa %xmm0,-0x50(%rbp) 401984: c5 f9 6f 45 b0 vmovdqa -0x50(%rbp),%xmm0 401989: c5 f9 d7 d0 vpmovmskb %xmm0,%edx 40198d: 89 55 ac mov %edx,-0x54(%rbp) 401990: 8b 55 ac mov -0x54(%rbp),%edx 401993: f3 0f b8 d2 popcnt %edx,%edx 401997: 48 63 c2 movslq %edx,%rax 40199a: 48 03 85 e8 fe ff ff add -0x118(%rbp),%rax 4019a1: 48 89 85 e8 fe ff ff mov %rax,-0x118(%rbp)

Заключение

Все приведённые ассемблерные листинги были получены после компиляции с -O0.

Если включить -O3, то компилятор довольно хорошо оптимизирует код и такого разделения по времени уже не будет: ————————————————————Benchmark Time CPU Iterations————————————————————BM_Count 129 ns 129 ns 5359145BM_SSE_COUNT_SET_EPI 70 ns 70 ns 9936200BM_SSE_COUNT_LOADU 49 ns 49 ns 14187659BM_SSE_COUNT_DIRECT 53 ns 53 ns 13401612
Код бенчмарка#include #include #include #define ARR_SIZE 1024#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(rand() % (VAL * 2)); } return res;} static auto arr = getRandArr(); static int16_t *getAllignedArr() { auto res = aligned_alloc(16, sizeof(int16_t) * ARR_SIZE); memcpy(res, arr, sizeof(int16_t) * ARR_SIZE); return static_cast(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) { auto sseArr = _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]); cnt += _popcnt32(_mm_movemask_epi8(_mm_cmpeq_epi16(sseVal, sseArr))); } 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) { auto sseArr = _mm_loadu_si128((__m128i *) &arr[i]); cnt += _popcnt32(_mm_movemask_epi8(_mm_cmpeq_epi16(sseVal, sseArr))); } 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) { auto sseArr = *(__m128i *) &allignedArr[i]; cnt += _popcnt32(_mm_movemask_epi8(_mm_cmpeq_epi16(sseVal, sseArr))); } benchmark::DoNotOptimize(cnt >> 1); }} BENCHMARK(BM_SSE_COUNT_DIRECT); BENCHMARK_MAIN();

Часть 2

Хабы:

• Высокая производительность
• C++
• Assembler
• C
• Процессоры

Источник: https://habr.com/ru/post/440566/

Как проверить инструкции sse процессора

SSE2 это набор инструкций, который определяет возможности того или иного процессора. Был разработан компанией Intel в 2000 году и включен в состав процессоров Pentium 4. Пришел на смену набору SSE, расширив список команд с 70 до 144.

C тех далеких времен вышло несколько более свежих версий этого набора инструкций.

На компьютер без поддержки SSE2 невозможно установить Windows 8 и более поздние версии этой операционной системы, Microsoft Office 2013 также требует поддержку SSE2 и практически все современные браузеры, включая Google Chrome и Mozilla Firefox.

Все больше программ обновляется до версий, которым необходимо наличие этого набора команд в процессоре компьютера.

Какие процессоры имеют поддержку SSE2?

У Intel данный набор инструкций впервые был внедрен на семейство процессоров Pentium 4 в 2000 году. Следовательно все процессоры, выпущенные позже, а это Pentium 4, Xeon, Celeron, Celeron D, Pentium M, Celeron M, Pentium D, Intel Atom, Core i3, i5, i7 поддерживают данный набор инструкций.

AMD внедрила SSE2 на свои процессоры впервые в 2003 году, когда была представлена архитектура AMD K8. Сюда входят все Athlon 64, Athlon 64 X2, Sempron 64, Turion 64. Поэтому если ваш AMD процессор выпущен в 2003 и позднее, то с 99% вероятностью он поддерживает SSE2.

Как узнать поддерживает ли процессор SSE2?

Во первых, при попытке установить на компьютер с процессором без поддержки SSE2 последнюю версию браузера Chrome или Mozilla Firefox будет появляться ошибка с текстом «This program requires a computer that supports SSE2 instructions». В ней говорится, что для данной программы нужен процессор с поддержкой SSE2.

Эту ошибку можно будет наблюдать при попытке установить или запустить любую другую игру или программу, для которой необходима поддержка данного набора команд.

Также вы можете скачать бесплатную программу CPU-Z, запустив которую можно посмотреть какие наборы команд доступны для использования на вашем процессоре.

Просмотр поддерживаемых инструкций процессором в программе CPU-Z

Что делать, если SSE2 не поддерживается?

Самый правильный вариант — обновлять компьютер (установить процессор с поддержкой SSE2, если это возможно) или приобрести новый.

Также можно попробовать поискать более ранние версии той программы, которая требует поддержку этого набора команд.

Является ли следующий код действительным для проверки того, поддерживает ли процессор набор инструкций SSE3?

Я создал GitHub-реестр, который обнаружит поддержку ЦП и ОС для всех основных расширений ISA x86: https://github.com/Mysticial/FeatureDetector

Здесь короче версия:

Сначала вам нужно получить доступ к инструкции CPUID:

Затем вы можете запустить следующий код:

Обратите внимание, что это только определяет, поддерживает ли процессор инструкции. Чтобы запустить их, вам также потребуется поддержка операционной системы.

В частности, поддержка операционной системы требуется для:

• x64. (Вам нужна 64-разрядная ОС.)
• Инструкции, которые используют (AVX) 256-битные ymm регистры. См. ответ Энди Лутомирски о том, как это обнаружить.
• Инструкции, в которых используются 512-битные регистры zmm и маска (AVX512). Обнаружение поддержки ОС для AVX512 такое же, как у AVX, но с использованием флага 0xe6 вместо 0x6 .

Мистический ответ немного опасен – в нем объясняется, как определить поддержку ЦП, но не поддерживать ОС. Вам нужно использовать _xgetbv, чтобы проверить, активировала ли ОС требуемое расширенное состояние CPU. См. здесь для другого источника. Даже gcc совершил ту же ошибку. Мяч кода:

После недолгих поисков я также нашел решения от Intel:

Также обратите внимание, что в GCC есть некоторые специальные встроенные функции, которые вы можете использовать (см.: https://gcc.gnu.org/onlinedocs/gcc-4.9.2/gcc/X86-Built-in-Functions.html):

Если вы сложите это вместе с информацией выше, все будет хорошо.

На Mac OS это работает:

В моей машине это выводит это:

machdep.cpu.features: ФПУ УМЭ ДЕ ПСЭ ТСК МСР РАЙ МОК CX8 APIC сентябрь MTRR ПГЕ MCA CMOV РАТ PSE36 CLFSH DS ACPI МОГО FXSR SSE, SSE2, СС НТТ ТМ РВЕ SSE3 PCLMULQDQ DTES64 ПН DSCPL VMX EST ТМ2 SSSE3 ФМА CX16 Т PDCM SSE4.1SSE4.2 x2APIC MOVBE POPCNT AES PCID XSAVE OSXSAVE SEGLIM64 TSCTMR AVX1.0 RDRAND F16C

Как вы можете видеть из инструкций, написанных жирным шрифтом, SSE3 и куча других инструкций SIMD поддерживаются.

Чтобы добавить в Abhiroop ответ: В linux вы можете запустить эту команду оболочки, чтобы узнать функции, поддерживаемые вашим процессором.

cat/proc/cpuinfo | grep flags | uniq

На моей машине это печатает

флаги: FPU VME-де-псевдоэфедрин TSC MSR пае MCE CX8 APIC SEP MTRR PGE MCA CMOV погладить pse36 clflush MMX fxsr ссе sse2 ХТ системный вызов пх pdpe1gb rdtscp лм constant_tsc rep_good nopl xtopology nonstop_tsc aperfmperf eagerfpu ПНИ PCLMULQDQ SSSE3 FMA CX16 PCID sse4_1 sse4_2 x2APIC movbe POPCNT tsc_deadline_timer АЕС xsave avx f16c гипервизор rdrand lahf_lm abm 3dnowprefetch invpcid_single retpoline kaiser fsgsbase bmi1 hle avx2 smep bmi2 erms invpcid rtm rdseed adx xsaveopt

Люди обычно оценивают процессор по количеству ядер, тактовой частоте, объему кэша и других показателях, редко обращая внимание на поддерживаемые им технологии.

Отдельные из этих технологий нужны только для решения специфических заданий и в «домашнем» компьютере вряд ли когда-нибудь понадобятся. Наличие же других является непременным условием работы программ, необходимых для повседневного использования.

Источник: https://hd01.ru/info/kak-proverit-instrukcii-sse-processora/