Для чего нужны avx инструкции

В новой линейке процессоров Ryzen 7000 компания AMD обещает полную поддержку инструкций AVX-512. Тех самых, которые недавно заблокировала в своих процессорах для массовых платформ компания Intel. Для чего нужны эти инструкции, какую реальную пользу они несут, и будет ли поддержка AVX-512 реальным преимуществом AMD перед конкурентом? 

Что такое AVX-512

Инструкции семейства Advanced Vector Extensions (AVX) являются дальнейшим развитием инструкций семейства Streaming SIMD Extensions (SSE). Прародителем последних, в свою очередь, являются инструкции MultiMedia eXtensions (MMX), впервые появившиеся в 1997 году в процессорах Pentium MMX. За четверть века эволюции этого семейства инструкций их основное предназначение оставалось неизменным: ускорение работы программного обеспечения, работающего с мультимедийным контентом, к которому относится фото, видео или 3D-модели.

MMX использует 64-битные регистры, семейство SSE удваивает этот параметр до 128 бит. AVX первого и второго поколения работает с 256-битными регистрами, а последний в линейке — AVX-512 (как следует из названия, с 512-битными).

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

Почему Intel отказалась от AVX-512

Первой ранняя реализация 512-битных инструкций была применена в ускорителях вычислений Intel семейства Xeon Phi. Но по-настоящему массовое распространение уже стандартизированный AVX-512 получил в серверных процессорах Xeon на архитектуре Skylake. В десктоп новые инструкции впервые попали в 2017 году, вместе с HEDT-платформой Intel на базе чипсета X299 и процессоров Core i7-X 7000 серии, использующих архитектуру серверных моделей. Позже в линейку процессоров, которые поддерживают AVX-512, добавились Core-X 9000 и 10000 серии, работающие на той же платформе.

Несмотря на то, что массовые платформы тех лет тоже полагались на архитектуру Skylake, поддержки 512-битных инструкций в них не было. Дебют AVX-512 в массовых десктопных и мобильных платформах состоялся с 11 поколением процессоров Core архитектур Rocket Lake и Ice Lake в 2021 году.

При выходе процессоров 12 поколения на новой гибридной архитектуре Intel уточнила, что для задействования AVX-512 нужно будет отключить малые ядра, так как у них поддержки данных инструкций нет. Но позже компания решила вообще отказаться от AVX-512 на процессорах данного поколения в новых ревизиях процессоров. А чтобы ее не было и в старых, обязала производителей материнских плат выпустить обновления BIOS, отключающие данную технологию.

Почему? Причин на это несколько. Во-первых, при использовании новых инструкций и так не холодные процессоры Alder Lake потребляют намного больше энергии и еще сильнее разогреваются — температуры под нагрузкой увеличиваются на десяток-полтора градусов. При таком использовании приемлемые результаты охлаждения начинают показывать только дорогие кулеры и водяные СО. То же самое было и в предыдущем поколении Rocket Lake при задействовании AVX-512.  

Во-вторых, в линейке этих процессоров есть младшие модели без малых ядер. По этой причине AVX-512 у них должен быть активен по умолчанию, в отличие от «танцев с бубнами» с отключением малых ядер в BIOS для работы технологии у старших моделей. Это представляет последние в невыгодном свете.

В-третьих, Intel считает наличие 512-битной версии AVX в данный момент необязательным в массовых платформах по причине их малой распространенности в пользовательском программном обеспечении, в отличие от серверного.

Вернет ли Intel AVX-512 в массовые платформы? Да, но точно не в этом году. В новом 13 поколении процессоров Core малые ядра архитектуру не сменят, и AVX-512 в них не появится. Скорее всего, 512-битные мультимедийные расширения вернутся в 14 поколении процессоров Core, малые ядра которого получат новую процессорную архитектуру, то есть — не раньше конца следующего года.

Почему AMD пришла к AVX-512 только сейчас

Серверные процессоры AMD, в отличие от продукции конкурента, до сих пор не поддерживают AVX-512. AMD вводит поддержку нового набора инструкций только в этом году на десктопных Ryzen 7000, сердцем которых стала архитектура Zen 4. Позже будут выпущены серверные и HEDT-процессоры на той же архитектуре, которые унаследуют поддержку инструкций от младших собратьев.

При этом возникают два вопроса: почему AMD не добавила поддержку AVX-512 в серверы раньше? И почему, в отличие от конкурента, ее десктопные процессоры получат поддержку инструкций раньше серверных и HEDT? Ответ прост: все дело в унификации.

Все процессоры AMD собираются из одних и тех же чиплетов — как десктопные, так и серверные. Именно поэтому сначала представляются десктопные процессоры на новой архитектуре с малым количеством чиплетов, а позже — серверные и HEDT с большим количеством тех же самых базовых «кирпичиков».

Intel разрабатывает разные кристаллы для десктопных и серверных процессоров, поэтому ненужные блоки в десктопные кристаллы она может просто не включать еще на стадии их проектирования, как это было сделано с процессорами на архитектуре Skylake.

Смысла же добавлять инструкции AVX-512 у AMD до этого года было немного. Пользовательское программное обеспечение до сих пор умеет задействовать их с видимой пользой лишь в достаточно редких случаях. Серверное — немного чаще, но тоже не всегда. При этом в серверах процессоры AMD и так зачастую быстрее продукции конкурента даже без новых инструкций — просто за счет большего количества ядер.

Однако, рано или поздно новые инструкции должны были попасть и в процессоры AMD. Ryzen 7000 серии помимо новой архитектуры получили и новый техпроцесс производства — 5 нм, который положительно скажется на энергопотреблении в работе с энергоемким AVX-512. К тому же, серверное ПО все активнее разрабатывается с учетом AVX-512, а чиплеты архитектуры Zen 4 в следующем году попадут и в серверные процессоры. Поэтому компания решила, что время и для ее реализации AVX-512 уже пришло.

Для чего нужен AVX-512

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

С массовым распространением AVX-512 многие из этих алгоритмов в течение нескольких лет получат и его поддержку. За счет более широких регистров новых инструкций, при должной оптимизации ПО, его работу можно будет заметно ускорить. Уже сегодня есть некоторое программное обеспечение, которое получает значительное ускорение от AVX-512, но пока его крайне мало. Например, эмулятор Play Station 3 под названием RPCS3 при его задействовании получает дополнительные 30% производительности.   

Заметного ускорения за счет новых инструкций уже сегодня можно добиться и при кодировании видео формата HEVC. Представители AMD говорят о том, что данные инструкции в первую очередь пригодятся для программного обеспечения, которое задействует глубокое обучение и искусственный интеллект, а также различные техники масштабирования изображений.

AVX-512 сегодня

При всех преимуществах AVX-512 стоит помнить, что в основной массе программного обеспечения поддержка новых инструкций всегда внедряется достаточно медленно. В том числе потому, что практически вся работа, которую позволяют ускорить инструкции, может быть сделана либо без них, либо на старых версиях вроде SSE4.2. Именно поэтому большая часть возможностей современного ПО полагается на мультимедийные инструкции старых версий. Взять в пример те же игры — до сих пор много случаев, когда на выходе игры разработчик заявляет об обязательных требованиях в виде процессора с AVX, а через некоторое время игра получает патч, который делает ее запуск возможным и на процессорах без него.

Почему так происходит? Дело в том, что для реального ускорения работы за счет мультимедийных инструкций нужно хорошо оптимизировать код программы под их определенную версию. Если этой оптимизации нет, то что с AVX, что с SSE4.2 та же игра покажет почти одинаковую производительность, и тогда требовать для запуска проекта процессора с AVX будет просто бессмысленно.

Такое до сих пор сплошь и рядом даже с AVX2, которому в этом году исполнилось 9 лет, не говоря уже о AVX-512, который пока не использует ни одна игра. Так что любителям компьютерных игр насчет отсутствия у их процессоров новых инструкций еще как минимум несколько лет беспокоиться не стоит.

Даже когда первые проекты получат поддержку новых инструкций, не стоит ждать от этих реализаций значительного буста производительности. Примером может служить выпущенная через два года после появления инструкций AVX игра GRID 2, которая имела два исполняемых файла, работающих с AVX и SSE. В итоге обе версии на одном и том же «железе» показывают практически идентичную производительность.

Долгий путь AVX-512 еще только начинается. Сейчас эти инструкции востребованы в основном в узкоспециализированном ПО. Через некоторое время они станут несколько более распространенными, но только через десяток лет станут использоваться повсеместно. Поэтому переживать о том, что ваш процессор их не поддерживает, пока смысла нет.

Время на прочтение
19 мин

Количество просмотров 70K

Введение

Новый набор SIMD инструкций для x86-процессоров Intel AVX был представлен публике ещё в марте 2008 года. И хотя реализации этих инструкций в железе ждать ещё полгода, спецификацию AVX уже можно считать устоявшейся, а поддержка набора инструкций AVX добавлена в новые версии компиляторов и ассемблеров. В данной статье рассмотрены практические вопросы оптимизации для Intel AVX подпрограмм на языках C/C++ и ассемблер.

Набор команд AVX

Все команды AVX, а также некоторые другие команды, описаны в справочнике, который можно найти на сайте Intel, посвященному AVX. В некотором смысле, набор команд AVX представляет собой расширение наборов команд SSE, которые уже поддерживаются всеми современными процессорами. В частности, AVX расширяет изначально 128-битные регистры SSE до 256 бит. Новые 256-битные регистры обозначаются как ymm0-ymm15 (для 32-битной программы доступны только ymm0-ymm7); при этом 128-битные SSE регистры xmm0-xmm15 ссылаются на младшие 128 бит соответствующего AVX регистра.

Чтобы эффективно работать с новыми 256-битными регистрами, в AVX было добавлено несметное количество инструкций. Однако, большинство из них представляет собой лишь немного изменённые версии уже знакомых нам инструкций SSE.
Так, каждая инструкция из SSE (а также SSE2, SSE3, SSSE3, SSE4.1, SSE4.2 и AES-NI) имеет в AVX свой аналог с префиксом v. Кроме префикса, такие AVX-инстукции отличаются от своих SSE-собратьев тем, что могут иметь три операнда: первый операнд указывает, куда писать результат, а остальные два — откуда брать данные. Трёхоперандные инструкции хороши тем, что во-первых позволяют избавиться от лишних операций копирования регистров в коде, а во-вторых упрощают написание хороших оптимизирующих компиляторов. SSE2-код
movdqa xmm2, xmm0
punpcklbw xmm0, xmm1
punpckhbw xmm2, xmm1
может быть переписан с AVX как
vpunpckhbw xmm2, xmm0, xmm1
vpunpcklbw xmm0, xmm0, xmm1.
При этом команды с префиксом v зануляют старшие 128 бит того AVX регистра, в который они пишут. Например, инструкция vpaddw xmm0, xmm1, xmm2 занулит старшие 128-бит регистра ymm0.
Кроме того, некоторые SSE-инструкции были расширены в AVX для работы с 256-битными регистрами. К таким инструкциям относятся все команды, работающие с числами с плавающей точкой (как одинарной, так и двойной точности). Например следующий AVX код
vmovapd ymm0, [esi]
vmulpd ymm0, ymm0, [edx]
vmovapd [edi], ymm0
обрабатывает сразу 4 double.
Вдобавок, AVX включает в себя некоторые новые инструкции

• vbroadcastss/vbroadcastsd/vbroadcastf128 — заполнение всего AVX регистра одним и тем же загруженным значением
• vmaskmovps/vmaskmovpd — условная загрузка/сохранение float/double чисел в AVX регистр в зависимости от знака чисел в другом AVX регистре
• vzeroupper — обнуление старших 128 бит всех AVX регистров
• vzeroall — полное обнуление всех AVX регистров
• vinsertf128/vextractf128 — вставка/получение любой 128-битной части 256-битного AVX регистра
• vperm2f128 — перестановка 128-битных частей 256-битного AVX регистра. Параметр перестановки задаётся статически.
• vpermilps/vpermilpd — перестановка float/double чисел внутри 128-битных частей 256-битного AVX регистра. При этом параметры перестановки берутся из другого AVX регистра.
• vldmxcsr/vstmxcsr — загрузка/сохранение управляющих параметров AVX (куда ж без этого!)
• xsaveopt — получение подсказки о том, какие AVX-регистры содержат данные. Эта команда сделана для разработчиков ОС и помогает им ускорить переключение контекста.

Использование AVX в ассемблерном коде

На сегодня AVX поддерживается всеми популярными ассемблерами для x86:

• GAS (GNU Assembler) — начиная с версии binutils 2.19.50.0.1, но лучше использовать 2.19.51.0.1, которая поддерживает более позднюю спецификацию AVX
• MASM — начиная с версии 10 (входит в Visual Studio 2010)
• NASM — начиная с версии 2.03, но лучше использовать последнюю версию
• YASM — начиная с версии 0.70, но лучше использовать последнюю версию

Определение поддержки AVX системой

Первое, что нужно сделать перед использованием AVX — убедиться, что система его поддерживает. В отличие от разных версий SSE, для использования AVX требуется его поддержка не только процессором, но и операционной системой (ведь она должна теперь сохранять верхние 128-бит AVX регистров при переключении контекста). К счастью, разработчики AVX предусмотрели способ узнать о поддержке этого набора инструкций операционной системой. ОС сохраняет/восстанавливает контекст AVX с помощью специальных инструкций XSAVE/XRSTOR, а конфигурируются эти команды с помощью расширенных контрольных регистров (extended control register). На сегодня есть только один такой регистр — XCR0, он же XFEATURE_ENABLED_MASK. Получить его значение можно, записав в ecx номер регистра (для XCR0 это, естественно, 0) и вызвав команду XGETBV. 64-битное значение регистра будет сохранено в паре регистров edx:eax. Выставленный нулевой бит регистра XFEATURE_ENABLED_MASK означает, что команда XSAVE сохраняет состояние FPU-регистров (впрочем, этот бит всегда выставлен), выставленный первый бит — сохранение SSE-регистров (младшие 128 бит AVX регистра), а выставленный второй бит — сохранение старших 128 бит AVX регистра. Т.о. чтобы быть уверенным, что система сохраняет состояние AVX регистров при переключении контекстов, нужно убедиться, что в регистре XFEATURE_ENABLED_MASK выставлены биты 1 и 2. Однако, это ещё не всё: прежде, чем вызывать команду XGETBV, нужно убедиться, что ОС действительно использует инструкции XSAVE/XRSTOR для управления контекстами. Делается это с помощью вызова инструкции CPUID с параметром eax = 1: если ОС включила управление сохранением/восстановлением контекста с помощью инструкций XSAVE/XRSTOR, то после выполениния CPUID в 27-ом бите регистра ecx будет единица. Вдобавок, неплохо бы проверить, что сам процессор поддерживает набор инструкций AVX. Делается это аналогично: вызвать CPUID с eax = 1 и убедиться, что после этого в 28-ом бите регистра ecx находится единица. Всё вышесказанное можно выразить следующим кодом (скопированном, с небольшими изменениями, из Intel AVX Reference):
; extern "C" int isAvxSupported()
_isAvxSupported:
    xor eax, eax
    cpuid
    cmp eax, 1 ; Поддерживает ли CPUID параметр eax = 1?
    jb not_supported
    mov eax, 1
    cpuid
    and ecx, 018000000h ; Проверяем, что установлены биты 27 (ОС использует XSAVE/XRSTOR)
    cmp ecx, 018000000h ; и 28 (поддержка AVX процессором)
    jne not_supported
    xor ecx, ecx ; Номер регистра XFEATURE_ENABLED_MASK/XCR0 есть 0
    xgetbv ; Регистр XFEATURE_ENABLED_MASK теперь в edx:eax
    and eax, 110b
    cmp eax, 110b ; Убеждаемся, что ОС сохраняет AVX регистры при переключении контекста
    jne not_supported
    mov eax, 1
    ret
not_supported:
    xor eax, eax
    ret


Использование AVX-инструкций

Теперь, когда вы знаете, когда можно использовать AVX-инструкции, самое время перейти к их использованию. Программирование под AVX мало отличается от программирования под другие наборы инструкций, но нужно учесть следующие особенности:

• Крайне нежелательно смешивать SSE- и AVX-инструкции (в том числе AVX-аналоги SSE-инструкций). Чтобы перейти от выполнения AVX-инструкций к SSE-инструкциям процессор сохраняет в специальном кэше верхние 128 бит AVX регистров, на что может уйти полсотни тактов. Когда после SSE-инструкций процессор снова вернётся к выполнению AVX-инструкций, он восстановит верхние 128 бит AVX регистров, на что уйдёт ещё полсотни тактов. Поэтому смешивание SSE и AVX инструкций приведёт к заметному снижению производительности. Если вам нужна какая-то команда из SSE в AVX-коде, воспользуйтесь её AVX-аналогом с префиксом v.
• Сохранения верхней части AVX регистров при переходе к SSE-коду можно избежать, если занулить верхние 128 бит AVX регистров с помощью команды vzeroupper или vzeroall. Несмотря на то, что эти команды зануляют все AVX регистры, они работают очень быстро. Правилом хорошего тона будет использовать одну из этих команд перед выходом из подпрограммы, использующей AVX.
• Команды загрузки/сохранения выровненных данных vmovaps/vmovapd/vmovdqa требуют, чтобы данные были выровнены на 16 байт, даже если сама команда загружает 32 байта.
• На Windows x64 подпрограмма не должна изменять регистры xmm6-xmm15. Т.о., если вы используете эти регистры (или соответствующие им регистры ymm6-ymm15), вы должны сохранить их в стеке в начале подпрограммы и восстановить из стека перед выходом из подпрограммы.
• Ядро Sandy Bridge будет способно запускать на выполнение две 256-битные AVX-команды с плавающей точкой каждый такт (одно умножение и одно сложение) благодаря расширению исполнительных устройств до 256 бит. Ядро Bulldozer будет иметь два универсальных 128-битных исполнительных устройства для команд с плавающей точкой, что позволит ему выполнять одну 256-битную AVX-команду за такт (умножение, сложение либо совмещённое умножение и сложение (fused multiply-add); при использовании последней операции можно надеяться на такую же производительность, как и у Sandy Bridge).

Теперь вы знаете всё, чтобы писать код с использованием AVX. Например, такой:
; extern "C" double _vec4_dot_avx( double a[4], double b[4] )
_vec4_dot_avx:
%ifdef X86
    mov eax, [esp + 8 + 0] ; eax = a
    mov edx, [esp + 8 + 8] ; edx = b
    vmovupd ymm0, [eax] ; ymm0 = *a
    vmovupd ymm1, [edx] ; ymm1 = *b
%else
    vmovupd ymm0, [rcx] ; ymm0 = *a
    vmovupd ymm1, [rdx] ; ymm1 = *b
%endif
    vmulpd ymm0, ymm0, ymm1 ; ymm0 = ( a3 * b3, a2 * b2, a1 * b1, a0 * b0 )
    vperm2f128 ymm1, ymm0, ymm0, 010000001b ; ymm1 = ( +0.0, +0.0, a3 * b3, a2 * b2 )
    vaddpd xmm0, xmm0, xmm1 ; ymm0 = ( +0.0, +0.0, a1 * b1 + a3 * b3, a0 * b0 + a2 * b2 )
    vxorpd xmm1, xmm1, xmm1 ; ymm1 = ( +0.0, +0.0, +0.0, +0.0 )
    vhaddpd xmm0, xmm0, xmm1 ; ymm0 = ( +0.0, +0.0, +0.0, a0 * b0 + a1 * b1 + a2 * b2 + a3 * b3 )
%ifdef X86 ; На 32-битной архитектуре возвращаемые числа с плавающей точкой должны быть в st(0)
    sub esp, 8
    vmovsd [esp], xmm0
    vzeroall ; Содержимое SSE-регистров не важно: зануляем полностью
    fld qword [esp]
    add esp, 8
%else
    vzeroupper ; В xmm0 содержится возвращаемое значение, поэтому зануляем только верхние 128 бит
%endif
    ret


Тестирование AVX кода

Чтобы убедиться в работоспособности AVX кода лучше написать к нему Unit-тесты. Однако встаёт вопрос: как запустить эти Unit-тесты, если ни один ныне продаваемый процессор не поддерживает AVX? В этом вам поможет специальная утилита от Intel — Software Development Emulator (SDE). Всё, что умеет SDE — это запускать программы, на лету эмулируя новые наборы инструкций. Разумеется, производительность при этом будет далека от таковой на реальном железе, но проверить корректность работы программы таким образом можно. Использовать SDE проще простого: если у вас есть unit-тест для AVX кода в файле avx-unit-test.exe и его нужно запускать с параметром «Hello, AVX!», то вам просто нужно запустить SDE с параметрами
sde -- avx-unit-test.exe "Hello, AVX!"
При запуске программы SDE сэмулирует не только AVX инструкции, но также и инструкции XGETBV и CPUID, так что если вы используете предложенный ранее метод для детектирования поддержки AVX, запущенная под SDE программа решит, что AVX действительно поддерживается. Кроме AVX, SDE (вернее, JIT-компилятор pin, на котором SDE построен) умеет эмулировать SSE3, SSSE3, SSE4.1, SSE4.2, SSE4a, AES-NI, XSAVE, POPCNT и PCLMULQDQ инструкции, так что даже очень старый процессор не помешает вам разрабатывать софт под новые наборы инструкций.

Оценка производительности AVX кода

Некоторое представление о производительности AVX кода можно получить с помощью другой утилиты от Intel — Intel Architecture Code Analyzer (IACA). IACA позволяет оценить время выполнения линейного участка кода (если встречаются команды условных переходов, IACA считает, что переход не происходит). Чтобы использовать IACA, нужно сначала пометить специальными маркерами участки кода, которые вы хотите проанализировать. Маркеры выглядят следующим образом:
; Начало участка кода, который надо проанализировать
%macro IACA_START 0
    mov ebx, 111
    db 0x64, 0x67, 0x90
%endmacro

Теперь следует окружить этими макросами тот участок кода, который вы хотите проанализировать
IACA_START
vmovups ymm0, [ecx]
vbroadcastss ymm1, [edx]
vmulps ymm0, ymm0, ymm1
vmovups [ecx], ymm0
vzeroupper
IACA_END
Скомпилированный с этими макросами объектный файл нужно скормить IACA:
iaca -32 -arch AVX -cp DATA_DEPENDENCY -mark 0 -o avx-sample.txt avx-sample.obj
Параметры для IACA нужно понимать так

• -32 — означает, что входной объектный файл (MS COFF) содержит 32-битный код. Для 64-битного кода нужно указывать -64. Если на вход IACA подаётся не объектный файл (.obj), а исполняемый модуль (.exe или .dll), то этот аргумент можно не указывать.
• -arch AVX — показывает IACA, что нужно анализировать производительность этого кода на будущем процессоре Intel с поддержкой AVX (т.е. Sandy Bridge). Другие возможные значения: -arch nehalem и -arch westmere.
• -cp DATA_DEPENDENCY просит IACA показать, какие инструкции находятся на критическом путе для данных (т.е. какие инструкции нужно соптимизировать, чтобы результат работы этого кода вычислялся быстрее). Другое возможное значение: -cp PERFORMANCE просит IACA показать, какие инструкции «затыкают» конвеер процессора.
• -mark 0 говорит IACA проанализировать все помеченные маркерами участки кода. Если задать -mark n, IACA будет анализировать только n-ый размеченный участок кода.
• -o avx-sample задаёт имя файла, в который будут записаны результаты анализа. Можно опустить этот параметр, тогда результаты анализа будут выведены в консоль.

Результат запуска IACA приведён ниже:
Intel(R) Architecture Code Analyzer Version - 1.1.3
Analyzed File - avx-sample.obj
Binary Format - 32Bit
Architecture  - Intel(R) AVX

Самыми важными метриками здесь являются Total Throughput и Data Dependency Latency. Если код, который вы оптимизируете, это небольшая подпрограмма, и в программе есть зависимость по данным от её результата, то вам нужно стараться сделать Data Dependency Latency как можно меньше. В качестве примера может служить приведённый выше листинг подпрограммы vec4_dot_avx. Если же оптимизируемый код — это часть цикла, обрабатывающего большой массив элементов, то ваша задача — уменьшать Total Throughput (вообще-то эта метрика должна была бы называться Reciprocal Throughput, ну да ладно).

Использование AVX в коде на C/C++

Поддержка AVX реализована в следующих популярных компиляторах:

• Microsoft C/C++ Compiler начиная с версии 16 (входит в Visual Studio 2010)
• Intel C++ Compiler начиная с версии 11.1
• GCC начиная с версии 4.4

Для использования 256-битных инструкций AVX в дистрибутив этих компиляторов включен новый заголовочный файл immintrin.h с описанием соответствующих intrinsic-функций. Включение этого заголовочного файла автоматически влечёт за собой включение заголовочных файлов всех SSE-intrinsic’ов. Что касается 128-битных инструкций AVX, то для них нет ни только отдельных хидеров, но и отдельных intrinsics-функций. Вместо этого для них используются intrinsic-функции для SSEx-инструкций, а тип инструкций (SSE или AVX), в которые будут компилироваться вызовы этих intrinsic-функций задаётся в параметрах компилятора. Это означает, что смешать SSE и AVX формы 128-битных инструкций в одном компилируемом файле не получится, и если вы хотите иметь и SSE, и AVX версии функций, то вам придётся писать их в разных компилируемых файлах (и компилировать эти файлы с разными параметрами). Параметры компиляции, которые включают компиляцию SSEx intrinsic-функций в AVX инструкции следующие:

• /arch:AVX — для Microsoft C/C++ Compiler и Intel C++ Compiler под Windows
• -mavx — для GCC и Intel C++ Compiler под Linux
• /QxAVX — для Intel C++ Compiler
• /QaxAVX — для Intel C++ Compiler

Следует иметь в виду, что данные команды не только изменяют поведение SSEx intrinsic-функций, но и разрешают компилятору генерировать AVX инструкции при компиляции обычного C/C++ кода (/QaxAVX говорит Интеловскому компилятору сгенерировать две версии кода — с AVX инструкциями и с базовыми x86 инструкциями).
Чтобы со всеми этими intrinsic’ами было проще разобраться, Intel сделал интерактивный справочник — Intel Intrinsic Guide, который включает в себя описание всех intrinsic-функций, которые поддерживаются интеловскими процессорами. Для тех инструкций, которые уже реализованы в железе, указаны также latency и throughput. Скачать этот справочник можно с сайта Intel AVX (есть версии для Windows, Linux и Mac OS X).

Определение поддержки AVX системой

В принципе, для распознавания поддержки AVX системой можно использовать приведённый ранее ассемблерный код, переписав его на inline-ассемблере, либо просто прилинковав собранный ассемблером объектный файл. Однако, если использование inline-ассемблера невозможно (например, из-за coding guidelines, либо потому, что компилятор его не поддерживает, как в случае Microsoft C/C++ Compiler’а для Windows x64), то you are in deep shit. Проблема в том, что intrinsic-функции для инструкции xgetbv не существует! Таким образом, задача разбивается на две части: проверить, что процессор поддерживает AVX (это можно сделать кроссплатформенно) и проверить, что ОС поддерживает AVX (тут уж придётся писать свой код для каждой ОС).
Проверить, что процессор поддерживает AVX можно используя всё ту же инструкцию CPUID, для которой есть intrinsic-функция void __cpuid( int cpuInfo[4], int infoType ). Параметр infoType задаёт значение регистра eax перед вызовом CPUID, а cpuInfo после выполнения функции будет содежать регистры eax, ebx, ecx, edx (именно в таком порядке). Т.о. получаем следующий код:
int isAvxSupportedByCpu() {
    int cpuInfo[4];
    __cpuid( cpuInfo, 0 );
    if( cpuInfo[0] != 0 ) {
        __cpuid( cpuInfo, 1 );
        return cpuInfo[3] & 0x10000000; // Возвращаем ноль, если 28-ой бит в ecx сброшен
    } else {
        return 0; // Процессор не поддерживает получение информации о поддерживаемых наборах инструкций
    }
}
С поддержкой со стороны ОС сложнее. AVX на сегодня поддерживается следующими ОС:

• Windows 7
• Windows Server 2008 R2
• Linux с ядром 2.6.30 и выше

В Windows была добавлена возможность узнать о поддержке операционкой новых наборов инструкций в виде функции GetEnabledExtendedFeatures из kernel32.dll. К сожалению, эта функция документирована чуть менее, чем никак. Но кое-какую информацию о ней раздобыть всё же можно. Эта функция описана в файле WinBase.h из Platform SDK:
WINBASEAPI
DWORD64
WINAPI
GetEnabledExtendedFeatures(
    __in DWORD64 FeatureMask
    );
Значения для параметра FeatureMask можно найти в хидере WinNT.h:
//
// Known extended CPU state feature IDs
//

Нетрудно заметить, что маски XSTATE_MASK_* соответствуют аналогичным битам регистра XFEATURE_ENABLED_MASK.
В дополнение к этому, в Windows DDK есть описание функции RtlGetEnabledExtendedFeatures и констант XSTATE_MASK_XXX, как две капли воды похожих на GetEnabledExtendedFeatures и XSTATE_MASK_* из WinNT.h. Т.о. для определения поддержки AVX со стороны Windows можно воспользоваться следующим кодом:
int isAvxSupportedByWindows() {
    const DWORD64 avxFeatureMask = XSTATE_MASK_LEGACY_SSE | XSTATE_MASK_GSSE;
    return GetEnabledExtendedFeatures( avxFeatureMask ) == avxFeatureMask;
}
Если ваша программа должна работать не только в Windows 7 и Windows 2008 R2, то функцию GetEnabledExtendedFeatures нужно подгружать динамически из kernel32.dll, т.к. в других версиях Windows этой функции нет.

В Linux, насколько мне известно, нет отдельной функции, чтобы узнать о поддержке AVX со стороны ОС. Но вы можете воспользоваться тем фактом, что поддержка AVX было добавлена в ядро 2.6.30. Тогда остаётся только проверить, что версия ядра не меньше этого значения. Узнать версию ядра можно с помощью функции uname.

Использование AVX-инструкций

Написание AVX-кода с использованием intrinsic-функций не вызовет у вас затруднений, если вы когда-либо использовали MMX или SSE посредством intrinsic’ов. Единственное, о чём нужно позаботиться дополнительно, это вызвать функцию _mm256_zeroupper() в конце подпрограммы (как нетрудно догадаться, эта intrinsic-функция генерирует инструкцию vzeroupper). Например, приведённая выше ассемблерная подпрограмма vec4_dot_avx может быть переписана на intrinsic’ах так:
double vec4_dot_avx( double a[4], double b[4] ) {
    // mmA = a
    const __m256d mmA = _mm256_loadu_pd( a );
    // mmB = b
    const __m256d mmB = _mm256_loadu_pd( b );
    // mmAB = ( a3 * b3, a2 * b2, a1 * b1, a0 * b0 )
    const __m256d mmAB = _mm256_mul_pd( mmA, mmB );
    // mmABHigh = ( +0.0, +0.0, a3 * b3, a2 * b2 )
    const __m256d mmABHigh = _mm256_permute2f128_pd( mmAB, mmAB, 0x81 );
    // mmSubSum = ( +0.0, +0.0, a1 * b1 + a3 * b3, a0 * b0 + a2 * b2 )
    const __m128d mmSubSum = _mm_add_pd(
        _mm256_castpd256_pd128( mmAB ),
        _mm256_castpd256_pd128( mmABHigh )
    );
    // mmSum = ( +0.0, +0.0, +0.0, a0 * b0 + a1 * b1 + a2 * b2 + a3 * b3 )
    const __m128d mmSum = _mm_hadd_pd( mmSubSum, _mm_setzero_pd() );
    const double result = _mm_cvtsd_f64( mmSum );
    _mm256_zeroupper();
    return result;
}

Тестирование AVX кода

Если вы используете набор инструкций AVX посредством intrinsic-функций, то, кроме запуска этого кода под эмулятором SDE, у вас есть ещё одна возможность — использовать специальный заголовочный файл, эмулирующий 256-битные AVX intrinsic-функции через intrinsic-функции SSE1-SSE4.2. В этом случае у вас получится исполняемый файл, который можно запустить на процессорах Nehalem и Westmere, что, конечно, быстрее эмулятора. Однако учтите, что таким методом не получиться обнаружить ошибки генерации AVX-кода компилятором (а они вполне могут быть).

Оценка производительности AVX кода

Использование IACA для анализа производительности AVX кода, созданного C/C++ компилятором из intrinsic-функций почти ничем не отличается от анализа ассемблерного кода. В дистрибутиве IACA можно найти заголовочный файл iacaMarks.h, в котором описаны макросы-маркеры IACA_START и IACA_END. Ими нужно пометить анализируемые участки кода. В коде подпрограммы маркер IACA_END должен находиться до оператора return, иначе компилятор «соптимизирует», выкинув код маркера. Макросы IACA_START/IACA_END используют inline-ассемблер, который не поддерживается Microsoft C/C++ Compiler для Windows x64, поэтому если для него нужно использовать специальные варианты макросов — IACA_VC64_START и IACA_VC64_END.

Заключение

В этой статье было продемонстрировано, как разрабатывать программы с использованием набора инструкций AVX. Надеюсь, что это знание поможет вам радовать своих пользователей программами, которые используют возможности компьютера на все сто процентов!

Упражнение

Приведённый код подпрограммы vec4_dot_avx не является оптимальным с точки зрения производительности. Попробуйте переписать её более оптимально. Какая у вас получалась Data Dependency Latency?

From Wikipedia, the free encyclopedia

Advanced Vector Extensions (AVX) are SIMD extensions to the x86 instruction set architecture for microprocessors from Intel and Advanced Micro Devices (AMD). They were proposed by Intel in March 2008 and first supported by Intel with the Sandy Bridge^[1] processor shipping in Q1 2011 and later by AMD with the Bulldozer^[2] processor shipping in Q3 2011. AVX provides new features, new instructions, and a new coding scheme.

AVX2 (also known as Haswell New Instructions) expands most integer commands to 256 bits and introduces new instructions. They were first supported by Intel with the Haswell processor, which shipped in 2013.

AVX-512 expands AVX to 512-bit support using a new EVEX prefix encoding proposed by Intel in July 2013 and first supported by Intel with the Knights Landing co-processor, which shipped in 2016.^[3][4] In conventional processors, AVX-512 was introduced with Skylake server and HEDT processors in 2017.

Advanced Vector Extensions[edit]

AVX uses sixteen YMM registers to perform a single instruction on multiple pieces of data (see SIMD). Each YMM register can hold and do simultaneous operations (math) on:

• eight 32-bit single-precision floating point numbers or
• four 64-bit double-precision floating point numbers.

The width of the SIMD registers is increased from 128 bits to 256 bits, and renamed from XMM0–XMM7 to YMM0–YMM7 (in x86-64 mode, from XMM0–XMM15 to YMM0–YMM15). The legacy SSE instructions can be still utilized via the VEX prefix to operate on the lower 128 bits of the YMM registers.

AVX introduces a three-operand SIMD instruction format called VEX coding scheme, where the destination register is distinct from the two source operands. For example, an SSE instruction using the conventional two-operand form a ← a + b can now use a non-destructive three-operand form c ← a + b, preserving both source operands. Originally, AVX’s three-operand format was limited to the instructions with SIMD operands (YMM), and did not include instructions with general purpose registers (e.g. EAX). It was later used for coding new instructions on general purpose registers in later extensions, such as BMI. VEX coding is also used for instructions operating on the k0-k7 mask registers that were introduced with AVX-512.

The alignment requirement of SIMD memory operands is relaxed.^[5] Unlike their non-VEX coded counterparts, most VEX coded vector instructions no longer require their memory operands to be aligned to the vector size. Notably, the VMOVDQA instruction still requires its memory operand to be aligned.

The new VEX coding scheme introduces a new set of code prefixes that extends the opcode space, allows instructions to have more than two operands, and allows SIMD vector registers to be longer than 128 bits. The VEX prefix can also be used on the legacy SSE instructions giving them a three-operand form, and making them interact more efficiently with AVX instructions without the need for VZEROUPPER and VZEROALL.

The AVX instructions support both 128-bit and 256-bit SIMD. The 128-bit versions can be useful to improve old code without needing to widen the vectorization, and avoid the penalty of going from SSE to AVX, they are also faster on some early AMD implementations of AVX. This mode is sometimes known as AVX-128.^[6]

New instructions[edit]

These AVX instructions are in addition to the ones that are 256-bit extensions of the legacy 128-bit SSE instructions; most are usable on both 128-bit and 256-bit operands.

CPUs with AVX[edit]

• Intel
  • Sandy Bridge processors, Q1 2011^[9]
  • Sandy Bridge E processors, Q4 2011^[10]
  • Ivy Bridge processors, Q1 2012
  • Ivy Bridge E processors, Q3 2013
  • Haswell processors, Q2 2013
  • Haswell E processors, Q3 2014
  • Broadwell processors, Q4 2014
  • Skylake processors, Q3 2015
  • Broadwell E processors, Q2 2016
  • Kaby Lake processors, Q3 2016 (ULV mobile)/Q1 2017 (desktop/mobile)
  • Skylake-X processors, Q2 2017
  • Coffee Lake processors, Q4 2017
  • Cannon Lake processors, Q2 2018
  • Whiskey Lake processors, Q3 2018
  • Cascade Lake processors, Q4 2018
  • Ice Lake processors, Q3 2019
  • Comet Lake processors (only Core and Xeon branded), Q3 2019
  • Tiger Lake (Core, Pentium and Celeron branded^[11]) processors, Q3 2020
  • Rocket Lake processors, Q1 2021
  • Alder Lake (Xeon, Core, Pentium and Celeron branded) processors, Q4 2021. Supported both in Golden Cove P-cores and Gracemont E-cores.
  • Raptor Lake processors, Q4 2022
  • Sapphire Rapids processors, Q1 2023
  • Meteor Lake processors
  • Arrow Lake processors
  • Lunar Lake processors

Not all CPUs from the listed families support AVX. Generally, CPUs with the commercial denomination Core i3/i5/i7/i9 support them, whereas Pentium and Celeron CPUs before Tiger Lake^[12] do not.

• AMD:
  • Jaguar-based processors and newer
  • Puma-based processors and newer
  • «Heavy Equipment» processors
    • Bulldozer-based processors, Q4 2011^[13]
    • Piledriver-based processors, Q4 2012^[14]
    • Steamroller-based processors, Q1 2014
    • Excavator-based processors and newer, 2015
  • Zen-based processors, Q1 2017
  • Zen+-based processors, Q2 2018
  • Zen 2-based processors, Q3 2019
  • Zen 3 processors, Q4 2020
  • Zen 4 processors, Q4 2022

Issues regarding compatibility between future Intel and AMD processors are discussed under XOP instruction set.

• VIA:
  • Nano QuadCore
  • Eden X4
• Zhaoxin:
  • WuDaoKou-based processors (KX-5000 and KH-20000)

Compiler and assembler support[edit]

• Absoft supports with -mavx flag.
• The Free Pascal compiler supports AVX and AVX2 with the -CfAVX and -CfAVX2 switches from version 2.7.1.
• RAD studio (v11.0 Alexandria) supports AVX2 and AVX512.^[15]
• The GNU Assembler (GAS) inline assembly functions support these instructions (accessible via GCC), as do Intel primitives and the Intel inline assembler (closely compatible to GAS, although more general in its handling of local references within inline code).
• GCC starting with version 4.6 (although there was a 4.3 branch with certain support) and the Intel Compiler Suite starting with version 11.1 support AVX.
• The Open64 compiler version 4.5.1 supports AVX with -mavx flag.
• PathScale supports via the -mavx flag.
• The Vector Pascal compiler supports AVX via the -cpuAVX32 flag.
• The Visual Studio 2010/2012 compiler supports AVX via intrinsic and /arch:AVX switch.
• Other assemblers such as MASM VS2010 version, YASM,^[16] FASM, NASM and JWASM.

Operating system support[edit]

AVX adds new register-state through the 256-bit wide YMM register file, so explicit operating system support is required to properly save and restore AVX’s expanded registers between context switches. The following operating system versions support AVX:

• DragonFly BSD: support added in early 2013.
• FreeBSD: support added in a patch submitted on January 21, 2012,^[17] which was included in the 9.1 stable release^[18]
• Linux: supported since kernel version 2.6.30,^[19] released on June 9, 2009.^[20]
• macOS: support added in 10.6.8 (Snow Leopard) update^{[21][unreliable source?]} released on June 23, 2011. In fact, macOS Ventura does not support processors without the AVX2 instruction set. ^[22]
• OpenBSD: support added on March 21, 2015.^[23]
• Solaris: supported in Solaris 10 Update 10 and Solaris 11
• Windows: supported in Windows 7 SP1, Windows Server 2008 R2 SP1,^[24] Windows 8, Windows 10
  • Windows Server 2008 R2 SP1 with Hyper-V requires a hotfix to support AMD AVX (Opteron 6200 and 4200 series) processors, KB2568088

Advanced Vector Extensions 2[edit]

Advanced Vector Extensions 2 (AVX2), also known as Haswell New Instructions,^[25] is an expansion of the AVX instruction set introduced in Intel’s Haswell microarchitecture. AVX2 makes the following additions:

• expansion of most vector integer SSE and AVX instructions to 256 bits
• Gather support, enabling vector elements to be loaded from non-contiguous memory locations
• DWORD- and QWORD-granularity any-to-any permutes
• vector shifts.

Sometimes three-operand fused multiply-accumulate (FMA3) extension is considered part of AVX2, as it was introduced by Intel in the same processor microarchitecture. This is a separate extension using its own CPUID flag and is described on its own page and not below.

New instructions[edit]

CPUs with AVX2[edit]

• Intel
  • Haswell processors (only Core and Xeon branded), Q2 2013
  • Haswell E processors, Q3 2014
  • Broadwell processors, Q4 2014
  • Broadwell E processors, Q3 2016
  • Skylake processors, Q3 2015
  • Kaby Lake processors, Q3 2016 (ULV mobile)/Q1 2017 (desktop/mobile)
  • Skylake-X processors, Q2 2017
  • Coffee Lake processors, Q4 2017
  • Cannon Lake processors, Q2 2018
  • Cascade Lake processors, Q2 2019
  • Ice Lake processors, Q3 2019
  • Comet Lake processors, Q3 2019
  • Tiger Lake (Core, Pentium and Celeron branded^[11]) processors, Q3 2020
  • Rocket Lake processors, Q1 2021
  • Alder Lake (Xeon, Core, Pentium and Celeron branded^[11]) processors, Q4 2021. Supported both in Golden Cove P-cores and Gracemont E-cores.
  • Raptor Lake processors, Q4 2022
  • Sapphire Rapids processors, Q1 2023
  • Meteor Lake processors
  • Arrow Lake processors
  • Lunar Lake processors
• AMD
  • Excavator processor and newer, Q2 2015
  • Zen processors, Q1 2017
  • Zen+ processors, Q2 2018
  • Zen 2 processors, Q3 2019
  • Zen 3 processors, Q4 2020
  • Zen 4 processors, Q4 2022
• VIA:
  • Nano QuadCore
  • Eden X4

AVX-512[edit]

AVX-512 are 512-bit extensions to the 256-bit Advanced Vector Extensions SIMD instructions for x86 instruction set architecture proposed by Intel in July 2013, and are supported with Intel’s Knights Landing processor.^[3]

AVX-512 instructions are encoded with the new EVEX prefix. It allows 4 operands, 8 new 64-bit opmask registers, scalar memory mode with automatic broadcast, explicit rounding control, and compressed displacement memory addressing mode. The width of the register file is increased to 512 bits and total register count increased to 32 (registers ZMM0-ZMM31) in x86-64 mode.

AVX-512 consists of multiple instruction subsets, not all of which are meant to be supported by all processors implementing them. The instruction set consists of the following:

• AVX-512 Foundation (F) – adds several new instructions and expands most 32-bit and 64-bit floating point SSE-SSE4.1 and AVX/AVX2 instructions with EVEX coding scheme to support the 512-bit registers, operation masks, parameter broadcasting, and embedded rounding and exception control
• AVX-512 Conflict Detection Instructions (CD) – efficient conflict detection to allow more loops to be vectorized, supported by Knights Landing^[3]
• AVX-512 Exponential and Reciprocal Instructions (ER) – exponential and reciprocal operations designed to help implement transcendental operations, supported by Knights Landing^[3]
• AVX-512 Prefetch Instructions (PF) – new prefetch capabilities, supported by Knights Landing^[3]
• AVX-512 Vector Length Extensions (VL) – extends most AVX-512 operations to also operate on XMM (128-bit) and YMM (256-bit) registers (including XMM16-XMM31 and YMM16-YMM31 in x86-64 mode)^[26]
• AVX-512 Byte and Word Instructions (BW) – extends AVX-512 to cover 8-bit and 16-bit integer operations^[26]
• AVX-512 Doubleword and Quadword Instructions (DQ) – enhanced 32-bit and 64-bit integer operations^[26]
• AVX-512 Integer Fused Multiply Add (IFMA) – fused multiply add for 512-bit integers.^[27]: 746
• AVX-512 Vector Byte Manipulation Instructions (VBMI) adds vector byte permutation instructions which are not present in AVX-512BW.
• AVX-512 Vector Neural Network Instructions Word variable precision (4VNNIW) – vector instructions for deep learning.
• AVX-512 Fused Multiply Accumulation Packed Single precision (4FMAPS) – vector instructions for deep learning.
• VPOPCNTDQ – count of bits set to 1.^[28]
• VPCLMULQDQ – carry-less multiplication of quadwords.^[28]
• AVX-512 Vector Neural Network Instructions (VNNI) – vector instructions for deep learning.^[28]
• AVX-512 Galois Field New Instructions (GFNI) – vector instructions for calculating Galois field.^[28]
• AVX-512 Vector AES instructions (VAES) – vector instructions for AES coding.^[28]
• AVX-512 Vector Byte Manipulation Instructions 2 (VBMI2) – byte/word load, store and concatenation with shift.^[28]
• AVX-512 Bit Algorithms (BITALG) – byte/word bit manipulation instructions expanding VPOPCNTDQ.^[28]
• AVX-512 Bfloat16 Floating-Point Instructions (BF16) – vector instructions for AI acceleration.
• AVX-512 Half-Precision Floating-Point Instructions (FP16) – vector instructions for operating on floating-point and complex numbers with reduced precision.

Only the core extension AVX-512F (AVX-512 Foundation) is required by all implementations, though all current processors also support CD (conflict detection); computing coprocessors will additionally support ER, PF, 4VNNIW, 4FMAPS, and VPOPCNTDQ, while central processors will support VL, DQ, BW, IFMA, VBMI, VPOPCNTDQ, VPCLMULQDQ etc.

The updated SSE/AVX instructions in AVX-512F use the same mnemonics as AVX versions; they can operate on 512-bit ZMM registers, and will also support 128/256 bit XMM/YMM registers (with AVX-512VL) and byte, word, doubleword and quadword integer operands (with AVX-512BW/DQ and VBMI).^[27]: 23

CPUs with AVX-512[edit]

^[29]

^Note 1 : AVX-512 is disabled by default in Alder Lake processors. On some motherboards with some BIOS versions, AVX-512 can be enabled in the BIOS, but this requires disabling E-cores.^[30] However, Intel has begun fusing AVX-512 off on newer Alder Lake processors.^[31]

Compilers supporting AVX-512[edit]

• GCC 4.9 and newer^[32]
• Clang 3.9 and newer^[33]
• ICC 15.0.1 and newer^[34]
• Microsoft Visual Studio 2017 C++ Compiler^[35]

AVX-VNNI, AVX-IFMA[edit]

AVX-VNNI is a VEX-coded variant of the AVX512-VNNI instruction set extension. Similarly, AVX-IFMA is a VEX-coded variant of AVX512-IFMA. These extensions provide the same sets of operations as their AVX-512 counterparts, but are limited to 256-bit vectors and do not support any additional features of EVEX encoding, such as broadcasting, opmask registers or accessing more than 16 vector registers. These extensions allow to support VNNI and IFMA operations even when full AVX-512 support is not implemented in the processor.

CPUs with AVX-VNNI[edit]

• Intel
  • Alder Lake processors, Q4 2021
  • Raptor Lake processors, Q4 2022
  • Sapphire Rapids processors, Q1 2023
  • Meteor Lake processors
  • Emerald Rapids processors
  • Arrow Lake processors
  • Lunar Lake processors

CPUs with AVX-IFMA[edit]

• Intel
  • Sierra Forest processors
  • Grand Ridge processors
  • Meteor Lake processors

AVX10[edit]

AVX10, announced in August 2023, is a new, «converged» AVX instruction set. It addresses several issues of AVX-512, in particular that it is split into too many parts^[36] (20 feature flags) and that it makes 512-bit vectors mandatory to support. AVX10 presents a simplified CPUID interface to test for instruction support, consisting of the AVX10 version number (indicating the set of instructions supported, with later versions always being a superset of an earlier one) and the available maximum vector length (256 or 512 bits).^[37] A combined notation is used to indicate the version and vector length: for example, AVX10.2/256 indicates that a CPU is capable of the second version of AVX10 with a maximum vector width of 256 bits.^[38]

The first and «early» version of AVX10, notated AVX10.1, will not introduce any instructions or encoding features beyond what is already in AVX-512 (F, CD, VL, DQ, BW, IFMA, VBMI, VBMI2, BITALG, VNNI, GFNI, VPOPCNTDQ, VPCLMULQDQ, VAES, BF16, FP16). The second and «fully-featured» version, AVX10.2, introduces new features such as YMM embedded rounding and Suppress All Exception. For CPUs supporting AVX10 and 512-bit vectors, all legacy AVX-512 feature flags will remain set to facilitate applications supporting AVX-512 to continue using AVX-512 instructions.^[38]

AVX10.1/512 will be available on Granite Rapids.^[38]

APX[edit]

APX is a new extension. It is not focused on vector computation, but provides RISC-like extensions to the x86-64 architecture by doubling the number of general purpose registers to 32 and introducing three-operand instruction formats. AVX is only tangentially affected as APX introduces extended operands.^[39][40]

Applications[edit]

• Suitable for floating point-intensive calculations in multimedia, scientific and financial applications (AVX2 adds support for integer operations).
• Increases parallelism and throughput in floating point SIMD calculations.
• Reduces register load due to the non-destructive instructions.
• Improves Linux RAID software performance (required AVX2, AVX is not sufficient)^[41]

Software[edit]

• Blender uses AVX, AVX2 and AVX-512 in the Cycles render engine.^[42]
• Bloombase uses AVX, AVX2 and AVX-512 in their Bloombase Cryptographic Module (BCM).
• Botan uses both AVX and AVX2 when available to accelerate some algorithms, like ChaCha.
• BSAFE C toolkits uses AVX and AVX2 where appropriate to accelerate various cryptographic algorithms.^[43]
• Crypto++ uses both AVX and AVX2 when available to accelerate some algorithms, like Salsa and ChaCha.
• OpenSSL uses AVX- and AVX2-optimized cryptographic functions since version 1.0.2.^[44] Support for AVX-512 was added in version 3.0.0.^[45] Some of these optimizations are also present in various clones and forks, like LibreSSL.
• Prime95/MPrime, the software used for GIMPS, started using the AVX instructions since version 27.1, AVX2 since 28.6 and AVX-512 since 29.1.^[46]
• dav1d AV1 decoder can use AVX2 and AVX-512 on supported CPUs.^[47][48]
• SVT-AV1 AV1 encoder can use AVX2 and AVX-512 to accelerate video encoding.^[49]
• dnetc, the software used by distributed.net, has an AVX2 core available for its RC5 project and will soon release one for its OGR-28 project.
• Einstein@Home uses AVX in some of their distributed applications that search for gravitational waves.^[50]
• Folding@home uses AVX on calculation cores implemented with GROMACS library.
• Helios uses AVX and AVX2 hardware acceleration on 64-bit x86 hardware.^[51]
• Horizon: Zero Dawn uses AVX in its Decima game engine.
• RPCS3, an open source PlayStation 3 emulator, uses AVX2 and AVX-512 instructions to emulate PS3 games.
• Network Device Interface, an IP video/audio protocol developed by NewTek for live broadcast production, uses AVX and AVX2 for increased performance.
• TensorFlow since version 1.6 and tensorflow above versions requires CPU supporting at least AVX.^[52]
• x264, x265 and VTM video encoders can use AVX2 or AVX-512 to speed up encoding.
• Various CPU-based cryptocurrency miners (like pooler’s cpuminer for Bitcoin and Litecoin) use AVX and AVX2 for various cryptography-related routines, including SHA-256 and scrypt.
• libsodium uses AVX in the implementation of scalar multiplication for Curve25519 and Ed25519 algorithms, AVX2 for BLAKE2b, Salsa20, ChaCha20, and AVX2 and AVX-512 in implementation of Argon2 algorithm.
• libvpx open source reference implementation of VP8/VP9 encoder/decoder, uses AVX2 or AVX-512 when available.
• libjpeg-turbo uses AVX2 to accelerate image processing.
• FFTW can utilize AVX, AVX2 and AVX-512 when available.
• LLVMpipe, a software OpenGL renderer in Mesa using Gallium and LLVM infrastructure, uses AVX2 when available.
• glibc uses AVX2 (with FMA) and AVX-512 for optimized implementation of various mathematical (i.e. expf, sinf, powf, atanf, atan2f) and string (memmove, memcpy, etc.) functions in libc.
• Linux kernel can use AVX or AVX2, together with AES-NI as optimized implementation of AES-GCM cryptographic algorithm.
• Linux kernel uses AVX or AVX2 when available, in optimized implementation of multiple other cryptographic ciphers: Camellia, CAST5, CAST6, Serpent, Twofish, MORUS-1280, and other primitives: Poly1305, SHA-1, SHA-256, SHA-512, ChaCha20.
• POCL, a portable Computing Language, that provides implementation of OpenCL, makes use of AVX, AVX2 and AVX-512 when possible.
• .NET and .NET Framework can utilize AVX, AVX2 through the generic System.Numerics.Vectors namespace.
• .NET Core, starting from version 2.1 and more extensively after version 3.0 can directly use all AVX, AVX2 intrinsics through the System.Runtime.Intrinsics.X86 namespace.
• EmEditor 19.0 and above uses AVX2 to speed up processing.^[53]
• Native Instruments’ Massive X softsynth requires AVX.^[54]
• Microsoft Teams uses AVX2 instructions to create a blurred or custom background behind video chat participants,^[55] and for background noise suppression.^[56]
• Pale Moon custom Windows builds greatly increase browsing speed due to the use of AVX2.
• simdjson, a JSON parsing library, uses AVX2 and AVX-512 to achieve improved decoding speed.^[57][58]
• x86-simd-sort, a library with sorting algorithms for 16, 32 and 64-bit numeric data types, uses AVX2 and AVX-512. The library is used in NumPy and OpenJDK to accelerate sorting algorithms.^[59]
• zlib-ng, an optimized version of zlib, contains AVX2 and AVX-512 versions of some data compression algorithms.
• Tesseract OCR engine uses AVX, AVX2 and AVX-512 to accelerate character recognition.^[60]

Downclocking[edit]

Since AVX instructions are wider and generate more heat, some Intel processors have provisions to reduce the Turbo Boost frequency limit when such instructions are being executed. On Skylake and its derivatives, the throttling is divided into three levels:^[61][62]

• L0 (100%): The normal turbo boost limit.
• L1 (~85%): The «AVX boost» limit. Soft-triggered by 256-bit «heavy» (floating-point unit: FP math and integer multiplication) instructions. Hard-triggered by «light» (all other) 512-bit instructions.
• L2 (~60%):^{[dubious – discuss]} The «AVX-512 boost» limit. Soft-triggered by 512-bit heavy instructions.

The frequency transition can be soft or hard. Hard transition means the frequency is reduced as soon as such an instruction is spotted; soft transition means that the frequency is reduced only after reaching a threshold number of matching instructions. The limit is per-thread.^[61]

In Ice Lake, only two levels persist:^[63]

• L0 (100%): The normal turbo boost limit.
• L1 (~97%): Triggered by any 512-bit instructions, but only when single-core boost is active; not triggered when multiple cores are loaded.

Rocket Lake processors do not trigger frequency reduction upon executing any kind of vector instructions regardless of the vector size.^[63] However, downclocking can still happen due to other reasons, such as reaching thermal and power limits.

Downclocking means that using AVX in a mixed workload with an Intel processor can incur a frequency penalty. Avoiding the use of wide and heavy instructions help minimize the impact in these cases. AVX-512VL allows for using 256-bit or 128-bit operands in AVX-512, making it a sensible default for mixed loads.^[64]

On supported and unlocked variants of processors that down-clock, the ratios are adjustable and may be turned off (set to 0x) entirely via Intel’s Overclocking / Tuning utility or in BIOS if supported there.^[65]

See also[edit]

• F16C instruction set extension
• Memory Protection Extensions
• Scalable Vector Extension for ARM — a new vector instruction set (supplementing VFP and NEON) similar to AVX-512, with some additional features.

References[edit]

External links[edit]

• Intel Intrinsics Guide
• x86 Assembly Language Reference Manual

При использовании TensorFlow, особенно после первоначальной установки, может возникнуть ситуация, когда при попытке запуска кода появляется следующее

При использовании TensorFlow, особенно после первоначальной установки, может возникнуть ситуация, когда при попытке запуска кода появляется следующее сообщение:

Your CPU supports instructions that this TensorFlow binary was not compiled to use: AVX AVX2

Это сообщение хоть и звучит сложно, на самом деле не является ошибкой. AVX (Advanced Vector Extensions) и AVX2 — это расширения набора инструкций процессора, которые позволяют увеличить производительность при выполнении операций с векторами и матрицами.

Однако, бинарные файлы TensorFlow, которые можно скачать и установить, обычно не поддерживают эти инструкции. Это сделано для обеспечения совместимости с большим количеством процессоров, включая те, которые не поддерживают AVX и AVX2.

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

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

Однако, важно отметить, что использование AVX и AVX2 может привести к незначительному увеличению производительности. В большинстве случаев разница в скорости работы не будет заметна. Поэтому, если не требуется максимальная производительность, можно просто игнорировать это сообщение.

В мире компьютерных технологий нет ничего странного в обилии всевозможных аббревиатур: CPU, GPU, RAM, SSD, BIOS, CD-ROM, и многих других. И почти каждый день появляются всё новые и новые сокращения названий каких-то технологий, что является неизбежным следствием бесконечного стремления инженеров улучшить функции и возможности наших вычислительных устройств.

Сегодня речь пойдёт о таких расширениях набора команд процессоров, как MMX, SSE и AVX. Многим знакомы эти сокращения, и мы выясним, действительно ли это какие-то интересные разработки, или же это не более чем бессмысленные маркетинговые уловки.

Ну о-о-очень первые дни

Середина 80-х прошлого столетия. Рынок процессоров был очень похож на сегодняшний. Intel бесспорно преобладала, но столкнулась с жесткой конкуренцией со стороны AMD. Домашние компьютеры, такие как Commodore 64, использовали базовые 8-битные процессоры, тогда как настольные ПК начинали переходить с 16-битных на 32-битные чипы.

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

Такие процессоры являются также скалярными и целочисленными. Что это означает? Скаляр – это когда над одним элементом данных выполняется только одна любая математическая операция. Обычно это обозначается как SISD (single instruction, single data, «одиночный поток команд – одиночный поток данных»).

Таким образом, инструкция по сложению двух значений данных просто обрабатывается для этих двух чисел. А если вам, например, нужно прибавить одно и то же значение к группе из 16 чисел, то для этого потребуется выполнить все 16 наборов инструкций – для каждого числа из этой группы по отдельности. По-другому процессоры тех лет складывать ещё не умели.

Intel 80386DX с частотой 16МГц (1985).

Целое (Integer) – в математике, это такое число, которое не имеет дробной части. Например, 8 или -12. Процессоры типа интеловского 80386SX не имели врожденной способности сложить, скажем, 3.80 и 7.26 – такие дробные числа называются числами с плавающей точкой (или запятой, в русском языке это без разницы) – по-английски FP, floating point или просто floats. Чтобы справиться с ними, нужен был другой процессор, например 80387SX, и отдельный набор инструкций – список команд, который сообщает процессору, что делать.

В те времена под инструкциями x86 понимали наборы команд для целочисленных (integer) операций, а под инструкциями x87 – для чисел с плавающей точкой (float). В наши дни все операции умеет выполнять один процессор, поэтому мы используем термин x86 для обозначения набора инструкций обоих типов данных.

Использование отдельных сопроцессоров для обработки разных типов данных было нормой, пока Intel не представила 80486: их первый CPU для персоналок со встроенным математическим сопроцессором для обработки вещественных данных (FPU, Floating Point Unit).

Intel 80486: Жёлтым цветом выделен блок FPU для обработки чисел с плавающей точкой.

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

Но в целом принцип работы оставался скалярным, и таким он перешел и к преемнику 486-го: оригинальному Intel Pentium.

И пройдёт ещё три года после релиза этого первого Пентиума, прежде чем Intel представит миру Pentium MMX. Это произошло в октябре 1996 года.

V – значит «векторный». А MMX что значит?

В мире математики числа можно группировать в наборы различных видов и размеров – одна такая упорядоченная совокупность называется арифметическим вектором. Проще всего представить его себе в виде списка значений, расположенных горизонтально или вертикально. Технология MMX привнесла в мир процессоров возможность выполнять векторные математические вычисления.

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

Знаменитая реклама технологии Intel MMX (1997).

FPU Pentium имел 64-битные регистры, и в операциях MMX каждый из них мог вместить два 32-битных, четыре 16-битных или восемь 8-битных целых числа. Именно эти группы чисел и являются векторами, и каждая инструкция, предназначенная для них, будет выполняться сразу над всеми значениями в группе.

Такой принцип получил название SIMD (single instruction, multiple data, «одиночный поток команд, множественный поток данных») и знаменует собой большой шаг вперед в развитии возможностей процессоров для персональных компьютеров.

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

Например, MMX можно применить для ускорения умножения матриц при обработке вершин в 3D, или для смешивания видеопотоков при работе с хромакеем или альфа-композитингом.

Процессор AMD K6-2 – где-то там есть 3DNow!

К сожалению, внедрение MMX продвигалось  довольно медленными темпами из-за негативного влияния этой технологии на производительность операций с плавающей точкой. AMD частично решила эту проблему, создав свою собственную версию под названием 3DNow! примерно через два года после появления MMX. Технология от AMD предлагала больше инструкций SIMD и умела обрабатывать числа с плавающей точкой, но также страдала от недостатка понимания программистами.

Ах, да! Как же официально расшифровывается аббревиатура MMX? Согласно Intel – никак!

Проще пареной SSE

Ситуация переломилась в лучшую сторону с приходом в 1999 году процессора Intel Pentium III. Он принёс с собой блестящую реализацию векторной функции под названием SSE (Streaming SIMD Extensions, «потоковые расширения SIMD»). На этот раз это был дополнительный набор из восьми 128-битных регистров, отдельных от регистров в FPU, и стек дополнительных инструкций для обработки чисел с плавающей точкой.

Использование независимых регистров означает, что больше нет такой сильной зависимости от FPU, хотя Pentium III не мог выполнять инструкции SSE одновременно с инструкциями FP. А также, новая функция поддерживает только один тип данных в регистрах: четыре 32-битных FP-числа.

Но переход к использованию FP-инструкций SIMD позволил значительно увеличить производительность в таких приложениях, как кодирование/декодирование видео, обработка изображений и звука, сжатие файлов и многих других.

Pentium IV: желтым цветом выделен блок регистров SSE2.

Усовершенствованная версия SSE2 появилась в 2001 году вместе с Pentium 4, и на этот раз поддержка типов данных была намного лучше: четыре 32-битных или два 64-битных FP-числа, а также шестнадцать 8-битных, восемь 16-битных, четыре 32-битных или два 64-битных целых числа. Регистры MMX остались в процессоре, но все операции MMX и SSE могли выполняться с использованием независимых 128-битных регистров SSE.

Модификация SSE3 появилась на свет в 2003 году, имея больше инструкций и возможность выполнять некоторые математические вычисления между значениями внутри одного регистра.

Ещё через 3 года мы познакомились с архитектурой Intel Core, принёсшей ещё одну ревизию технологии SIMD (SSSE3 – Supplemental SSE, «расширенные SSE»), и чуть позже в том же году – финальную версию, SSE4.

В 2007 году AMD применила собственную версию расширений CPU-инструкций SSE4 в своей архитектуре Barcelona. С названием в AMD париться не стали, и назвали свою версию просто SSE4a.

С линейкой Nehalem Core в 2008 году было выпущено незначительное обновление этой версии, которую Intel обозначила как SSE4.2 (а под SSE4.1 стали понимать исходную версию этого обновления). Обновления не затронули регистры, а лишь добавили больше инструкций в таблицу, расширив диапазон возможных математических и логических операций.

AMD, со своей стороны, сперва предложила новую версию SSE5, но позже решила разделить ее на три отдельных расширения, одно из которых довольно проблемное – подробнее об этом чуть позже.

К концу 2008 года и Intel, и AMD поставляли процессоры, которые уже могли обрабатывать все версии наборов инструкций от MMX до SSE4.2, и многие приложения (в основном игры) начали требовать этих функций для работы.

Время для новых букв

2008 год также был годом, когда Intel объявила о том, что они работают над значительным апгрейдом своей системы SIMD, и в 2011 году выкатила линейку процессоров Sandy Bridge с поддержкой набора инструкций AVX (Advanced Vector Extensions, «продвинутые векторные расширения»).

Всё удвоилось: вдвое больше векторных регистров и вдвое больше их размер.

Шестнадцать 256-битных регистров вмещают только восемь 32-битных или четыре 64-битных вещественных числа, поэтому в плане форматов данных, этот набор инструкций более ограничен в сравнении с SSE, но ведь и SSE никто не отменял. К тому времени программная поддержка векторных операций для CPU была уже хорошо отлажена, начиная с фундаментального мира компиляторов, заканчивая сложными приложениями.

И не даром: Core i7-2600K (или подобный ему), работающий на частоте 3,8ГГц, потенциально может выдавать более 230 GFLOPS (миллиардов операций с плавающей точкой в секунду) при выполнении инструкций AVX – неплохо для дополнения, относительно немного места занимающего на кристалле процессора.

Или могло бы быть неплохо, если бы он действительно работал на частоте 3,8ГГц. Частично проблема AVX заключалась в том, что нагрузка на чип получалась настолько высокой, что Intel пришлось заставить процессор автоматически снижать тактовую частоту в этом режиме примерно на 20%, чтобы уменьшить энергопотребление и не допустить перегрева. К сожалению, такова цена за выполнение любой работы SIMD в современном процессоре.

Еще одно усовершенствование, предлагаемое в AVX – это возможность работать одновременно с тремя значениями. Во всех версиях SSE операции выполнялись между двумя значениями, после чего результат заменял одно из них в регистре. При выполнении инструкций SIMD AVX не трогает исходные значения, сохраняя результирующее значение в отдельный регистр.

AVX2 был выпущен вместе с архитектурой Haswell для процессоров Core 4-го поколения в 2013 году, и представлял собой довольно значительный апгрейд, благодаря добавлению нового расширения: FMA (Fused Multiply-Add, «умножение-сложение с однократным округлением»).

Эта независимая функция в составе AVX2 была крайне востребована для приложений, работающих с векторной и матричной математикой, поскольку давала возможность выполнять две операции с помощью одной инструкции. Функция поддерживала и скалярные операции также.

Проблема оказалась в том, что FMA от Intel отличался от аналогичного расширения AMD настолько, что они были совершенно несовместимы. Причина в том, что Intel FMA представляет собой систему с тремя операндами, то есть работает с тремя отдельными значениями: два слагаемых и сумма, либо три слагаемых и сумма, замещающая одно из слагаемых.

У версии от AMD четыре операнда, поэтому она может вычислить 3 числа и записать ответ в отдельный регистр, не трогая исходные значения. Математически FMA4 лучше, чем FMA3, но его реализация немного сложнее, как с точки зрения программирования, так и с точки зрения интеграции функции в процессор.

AVX-512: а не многовато-ли?

AVX2 ещё только начал появляться на рынке процессоров, а Intel уже плела маниакальные планы относительно его преемника, AVX-512, и общий настрой среди разработчиков был такой: «больше регистров богу регистров!». Мало того, что этих самых регистров снова вдвое больше, и они снова вдвое увеличились в размере, так ещё и появился стек новых инструкций и поддержка устаревших.

Первой партией чипов, на которых поднялся в воздух набор функций AVX-512, стала серия Xeon Phi 7200 – второе поколение громоздких и очень многоядерных процессоров Intel, ориентированных на рынок суперкомпьютеров.

72-ядерный 288-потоковый Knights Landing Xeon Phi.

В отличие от всех предыдущих реализаций, новый набор векторных инструкций состоял из 19-и компонентов: базового – AVX-512F, – необходимого для обеспечения совместимости, и множества весьма специфических. Эти дополнительные наборы охватывают такие области операций, как обратная математика, целочисленные FMA и алгоритмы свёрточной (конволюционной) нейронной сети (CNN-алгоритмы).

Первоначально AVX-512 был только прерогативой крупнейших чипов Intel, предназначенных для рабочих станций и серверов, но теперь их недавние архитектуры Ice Lake и Tiger Lake также поддерживают его. Да, не удивляйтесь: вы можете купить легкий ноутбук с процессором, имеющим 512-битные векторные блоки.

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

2-ядерный Intel Skylake

Желтым прямоугольником выделен файл векторных регистров, красный прямоугольник – это наиболее вероятное расположение файла целочисленного регистра. Обратите внимание, насколько файл векторного регистра больше integer-регистра. В Skylake используются 256-битные регистры AVX2, следовательно аналогичный векторный регистровый файл AVX-512 занял бы на таком же кристалле в четыре раза больше места: вдвое больше, потому что вдвое больше их размер, и ещё вдвое – потому что самих регистров вдвое больше.

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

И учитывая, что использование AVX в любом виде приводит к автоматическому уменьшению тактовой частоты, использование AVX-512 на таких платформах скорее всего приведет к ещё более сомнительным издержкам по сравнению с любым из своих предшественников, поскольку при работе он потребляет еще больше энергии.

И проблема AVX-512 не только в применении к небольшим мобильным процессорам. Разработчикам, пишущим код для работы на рабочих станциях и серверах, и для которых увеличение возможностей векторных расширений действительно важный вопрос, потребуется создавать несколько версий кода. Это связано с тем, что не все процессоры с AVX-512 работают с одинаковым набором команд.

Например, набор IFMA (Integer Fused Multiply Add, «целочисленное умножение-сложение с однократным округлением») доступен только на процессорах Cannon, Ice и Tiger Lake. В то время как процессоры на архитектуре Cooper и Cascade Lake его не поддерживают, несмотря на то, что они относятся к сегменту процессоров для серверов и рабочих станций.

Стоит отметить, что AMD не предлагает поддержку AVX-512, и не собирается. По их мнению, обработка массивных векторных вычислений – это прерогатива GPU. С AMD полностью солидарна Nvidia, и обе компании уже выпустили продукты специально для таких нужд.

И дальше что?

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

Что касается последних двух типов данных, то CPU теперь напрямую конкурируют с GPU: ведь мир 3D-графики – это как раз всё, что связано с SIMD, векторами, плавающими точками и т.д. И производители GPU не спали – разработка графических ускорителей велась стремительными темпами. В начале 2010-х годов купить видеокарту, процессор которой способен выполнять почти 800 миллиардов инструкций SIMD в секунду, вы уже могли менее чем за 500 долларов.

Это больше, чем то, на что сейчас способны лучшие из десктопных CPU. Но они и не предназначены для рекордов в какой-то конкретной области – их задача обрабатывать очень обобщенный код, который зачастую не повторяется или легко распараллеливается. Поэтому, не стоит думать, что возможности SIMD столь жизненно-важны для CPU, скорее это полезное дополнение к его арсеналу.

Вас интересует производительность SIMD в чистом виде? Ваш выбор – видеокарта, а не материнка!

Стремительное развитие графических процессоров недвусмысленно намекает, что для CPU нет нужды иметь чересчур большие векторные блоки, и почти наверняка именно поэтому AMD даже не пыталась разрабатывать своего собственного преемника для AVX2 (расширение, которое они используют в своих чипах с 2015 года). Давайте также не будем забывать, что процессоры следующего поколения могут больше походить на мобильные однокристальные (SoC, System-on-a-Chip), где под каждый тип задач выделена площадь на кристалле. Intel, в свою очередь, похоже, стремится внедрить AVX-512 в как можно большее количество продуктов.

Ждёт ли нас ещё и AVX-1024? Вряд ли, либо очень нескоро. Скорее всего, Intel займётся расширением AVX-512 с помощью дополнительных компонентов с инструкциями, чтобы повысить гибкость, а чистую SIMD-производительность переложит на плечи своей недавно разработанной линейки графических процессоров Xe.

Библиотеки SSE и AVX теперь являются неотъемлемой частью программного обеспечения: Adobe Photoshop требует, чтобы процессоры поддерживали как минимум SSE4.2; API машинного обучения TensorFlow требует поддержки AVX; Microsoft Teams может выполнять фоновые видеоэффекты, только если доступен AVX2.

Это говорит только об одном: несмотря на то, что в плане обработки SIMD графическим процессорам нет равных, этот функционал ещё долго будет в арсенале CPU. Так что будем ждать нового поколения векторных расширений и надеюсь, реклама нас впечатлит.

Он делает процессоры быстрее, так почему Intel его удаляет?

Центральный процессор вашего устройства выполняет миллионы вычислений каждую секунду и отвечает за работу вашего компьютера. Вместе с процессором работает блок арифметической обработки (ALU), который отвечает за математические задачи и управляется микрокодом процессора

Микрокод процессора не статичен и может быть улучшен, и одним из таких улучшений стал набор инструкций AVX-512 от Intel. Однако Intel намерена уничтожить AVX-512, навсегда удалив его функциональность из своих процессоров. Но почему? Почему Intel отказывается от AVX-512?

Как работает АЛУ?

Прежде чем знакомиться с набором инструкций AVX-512, необходимо понять, как работает АЛУ

Как следует из названия, блок арифметической обработки используется для выполнения математических задач. Эти задачи включают такие операции, как сложение, умножение и вычисления с плавающей точкой. Для выполнения этих задач ALU использует цифровые схемы, специфичные для конкретного приложения, которые приводятся в действие тактовым сигналом центрального процессора

Таким образом, тактовая частота процессора определяет скорость обработки инструкций в АЛУ. Так, если ваш процессор работает на тактовой частоте 5 ГГц, АЛУ может обработать 5 миллиардов инструкций за одну секунду. По этой причине производительность процессора повышается по мере увеличения тактовой частоты

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

Как же процессор нового поколения обеспечивает более высокую производительность по сравнению со старыми версиями? Для повышения производительности производители процессоров используют концепцию параллелизма. Параллелизм может быть достигнут за счет использования многоядерной архитектуры, когда несколько различных вычислительных ядер используются для повышения вычислительной мощности процессора

Другим способом повышения производительности является использование набора инструкций SIMD. Проще говоря, инструкция Single Instruction Multiple Data позволяет АЛУ выполнять одну и ту же инструкцию в разных точках данных. Такой тип параллелизма повышает производительность процессора, а AVX-512 – это SIMD-инструкция, используемая для повышения производительности процессора при выполнении определенных задач

Как данные попадают в АЛУ?

Теперь, когда у нас есть базовое понимание того, как работает АЛУ, нам нужно понять, как данные попадают в АЛУ

Чтобы попасть в АЛУ, данные должны пройти через различные системы хранения. Это путешествие данных основано на иерархии памяти вычислительной системы. Краткий обзор этой иерархии приведен ниже:

• Вторичная память: Вторичная память вычислительного устройства состоит из постоянного запоминающего устройства. Это устройство может хранить данные постоянно, но оно не такое быстрое, как центральный процессор. Из-за этого ЦП не может получить прямой доступ к данным из вторичной системы хранения.
• Первичная память: Первичная система хранения данных состоит из памяти с произвольным доступом (RAM). Эта система хранения данных быстрее, чем вторичная, но не может хранить данные постоянно. Поэтому, когда вы открываете файл в системе, он перемещается с жесткого диска в оперативную память. При этом даже оперативная память недостаточно быстра для центрального процессора.
• Кэш-память: Кэш-память встроена в процессор и является самой быстрой системой памяти на компьютере. Эта система памяти разделена на три части, а именно кэш-память L1, L2 и L3. Любые данные, которые должны быть обработаны АЛУ, перемещаются с жесткого диска в оперативную память, а затем в кэш-память. При этом АЛУ не может получить доступ к данным непосредственно из кэш-памяти.
• Регистры ЦП: Регистр ЦП на вычислительном устройстве имеет очень маленький размер, и в зависимости от архитектуры компьютера эти регистры могут содержать 32 или 64 бита данных. Как только данные перемещаются в эти регистры, АЛУ может получить к ним доступ и выполнить поставленную задачу.

Набор инструкций AVX 512 является второй итерацией AVX и появился в процессорах Intel в 2013 году. Сокращение от Advanced Vector Extensions (Расширенные векторные расширения), набор инструкций AVX был впервые представлен в архитектуре Intel Xeon Phi (Knights Landing), а затем попал в серверные процессоры Intel в CPU Skylake-X

Кроме того, набор инструкций AVX-512 попал в потребительские системы с архитектурой Cannon Lake, а затем был поддержан архитектурами Ice Lake и Tiger Lake

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

Итак, как Intel удвоила производительность своих процессоров, использующих архитектуру AVX-512?

Как объяснялось ранее, ALU может обращаться только к данным, находящимся в регистрах процессора. Набор инструкций Advanced Vector Extensions увеличивает размер этих регистров

Благодаря такому увеличению размера ALU может обрабатывать несколько точек данных в одной инструкции, увеличивая производительность системы

Что касается размера регистра, набор инструкций AVX-512 предлагает тридцать два 512-битных регистра, что вдвое больше по сравнению со старым набором инструкций AVX

Почему Intel прекращает использование AVX-512?

Как объяснялось ранее, набор инструкций AVX-512 обеспечивает ряд вычислительных преимуществ. Фактически, популярные библиотеки, такие как TensorFlow, используют этот набор инструкций для обеспечения более быстрых вычислений на процессорах, поддерживающих этот набор инструкций

Итак, почему Intel отключает AVX-512 в своих последних процессорах Alder Lake?

Процессоры Alder Lake отличаются от более старых моделей, выпускаемых Intel. Если в старых системах использовались ядра, работающие на одной архитектуре, то в процессорах Alder Lake используются два разных ядра. Эти ядра в процессорах Alder Lake известны как P- и E-ядра и работают на разных архитектурах

В то время как ядра P используют микроархитектуру Golden Cove, ядра E используют микроархитектуру Gracemont. Эта разница в архитектурах препятствует корректной работе планировщика, когда определенные инструкции могут выполняться на одной архитектуре, но не на другой

В случае процессоров Alder Lake набор инструкций AVX-512 является одним из таких примеров, поскольку ядра P имеют аппаратное обеспечение для обработки этой инструкции, а ядра E – нет

По этой причине процессоры Alder Lake не поддерживают набор инструкций AVX-512

Тем не менее, инструкции AVX-512 могут работать на некоторых процессорах Alder Lake, где Intel физически не отключила их. Для этого пользователям необходимо отключить ядра E в BIOS

Нужен ли AVX-512 в потребительских чипсетах?

Набор инструкций AVX-512 увеличивает размер регистра процессора для повышения его производительности. Этот прирост производительности позволяет процессорам быстрее обрабатывать числа, что позволяет пользователям запускать алгоритмы сжатия видео/аудио на более высоких скоростях

Тем не менее, этот прирост производительности может наблюдаться только в том случае, если инструкции, определенные в программе, оптимизированы для работы с набором инструкций AVX-512

По этой причине архитектуры наборов инструкций, подобные AVX-512, больше подходят для серверных рабочих нагрузок, а чипсеты потребительского класса могут работать без сложных наборов инструкций, подобных AVX-512