Avx инструкции зачем нужны

From Wikipedia, the free encyclopedia

Advanced Vector Extensions (AVX, also known as Gesher New Instructions and then Sandy Bridge New Instructions) 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] microarchitecture shipping in Q1 2011 and later by AMD with the Bulldozer^[2] microarchitecture shipping in Q4 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 microarchitecture, 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.

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 still be utilized via the VEX prefix to operate on the lower 128 bits of the YMM registers.

AVX-512 register scheme as extension from the AVX (YMM0-YMM15) and SSE (XMM0-XMM15) 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]

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.

• Intel
  • Sandy Bridge processors (Q1 2011) and newer, except models branded as Celeron and Pentium.^[9]
  • Pentium and Celeron branded processors starting with Tiger Lake (Q3 2020) and newer.^[10]
• AMD:
  • Bulldozer processors (Q4 2011) and newer.^[11]

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)

• 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.^[12]
• 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). GAS supports AVX starting with binutils version 2.19.^[13]
• 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.
• NASM starting with version 2.03 and newer. There were numerous bug fixes and updates related to AVX in version 2.04.^[14]
• Other assemblers such as MASM VS2010 version, YASM,^[15] FASM and JWASM.

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,^[16] which was included in the 9.1 stable release.^[17]
• Linux: supported since kernel version 2.6.30,^[18] released on June 9, 2009.^[19]
• macOS: support added in 10.6.8 (Snow Leopard) update^{[20][unreliable source?]} released on June 23, 2011. In fact, macOS Ventura does not support x86 processors without the AVX2 instruction set.^[21]
• OpenBSD: support added on March 21, 2015.^[22]
• Solaris: supported in Solaris 10 Update 10 and Solaris 11.
• Windows: supported in Windows 7 SP1, Windows Server 2008 R2 SP1,^[23] 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
  • Windows XP and Windows Server 2003 do not support AVX in both kernel drivers and user applications.

Advanced Vector Extensions 2 (AVX2), also known as Haswell New Instructions,^[24] 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.

• Intel
  • Haswell processors (Q2 2013) and newer, except models branded as Celeron and Pentium.
  • Celeron and Pentium branded processors starting with Tiger Lake (Q3 2020) and newer.^[10]
• AMD
  • Excavator processors (Q2 2015) and newer.
• VIA:
  • Nano QuadCore
  • Eden X4

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.^[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- 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)^[25]
• AVX-512 Byte and Word Instructions (BW) – extends AVX-512 to cover 8-bit and 16-bit integer operations^[25]
• AVX-512 Doubleword and Quadword Instructions (DQ) – enhanced 32-bit and 64-bit integer operations^[25]
• AVX-512 Integer Fused Multiply Add (IFMA) – fused multiply add for 512-bit integers.^[26]: 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.^[27]
• VPCLMULQDQ – carry-less multiplication of quadwords.^[27]
• AVX-512 Vector Neural Network Instructions (VNNI) – vector instructions for deep learning.^[27]
• AVX-512 Galois Field New Instructions (GFNI) – vector instructions for calculating Galois field.^[27]
• AVX-512 Vector AES instructions (VAES) – vector instructions for AES coding.^[27]
• AVX-512 Vector Byte Manipulation Instructions 2 (VBMI2) – byte/word load, store and concatenation with shift.^[27]
• AVX-512 Bit Algorithms (BITALG) – byte/word bit manipulation instructions expanding VPOPCNTDQ.^[27]
• 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 implementations also support CD (conflict detection). All central processors with AVX-512 also support VL, DQ and BW. The ER, PF, 4VNNIW and 4FMAPS instruction set extensions are currently only implemented in Intel computing coprocessors.

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).^[26]: 23

^[28]

^Note 1 : Intel does not officially support AVX-512 family of instructions on the Alder Lake microprocessors. In early 2022, Intel began disabling in silicon (fusing off) AVX-512 in Alder Lake microprocessors to prevent customers from enabling AVX-512.^[29]
In older Alder Lake family CPUs with some legacy combinations of BIOS and microcode revisions, it was possible to execute AVX-512 family instructions when disabling all the efficiency cores which do not contain the silicon for AVX-512.^[30][31][32]

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

• FASM
• NASM 2.11 and newer^[14]

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 support of VNNI and IFMA operations even when full AVX-512 support is not implemented in the processor.

• Intel
  • Alder Lake processors (Q4 2021) and newer.
• AMD
  • Zen 5 processors (Q3 2024) and newer.^[37]

• Intel
  • Sierra Forest E-core-only Xeon processors (Q2 2024) and newer.
  • Grand Ridge special-purpose processors and newer.
  • Meteor Lake mobile processors (Q4 2023) and newer.
  • Arrow Lake desktop processors (Q4 2024) and newer.

AVX10, announced in July 2023,^[38] is a new, «converged» AVX instruction set. It addresses several issues of AVX-512, in particular that it is split into too many parts^[39] (20 feature flags). The initial technical paper also made 512-bit vectors optional to support, but as of revision 3.0 vector length enumeration is removed and 512-bit vectors are mandatory.^[40]

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).^[41] For example, AVX10.2 indicates that a CPU is capable of the second version of AVX10.^[42] Initial revisions of the AVX10 technical specifications also included maximum supported vector length as part of the ISA extension name, e.g. AVX10.2/256 would mean a second version of AVX10 with vector length up to 256 bits, but later revisions made that unnecessary.

The first version of AVX10, notated AVX10.1, does not introduce any instructions or encoding features beyond what is already in AVX-512 (specifically, in Intel Sapphire Rapids: AVX-512F, CD, VL, DQ, BW, IFMA, VBMI, VBMI2, BITALG, VNNI, GFNI, VPOPCNTDQ, VPCLMULQDQ, VAES, BF16, FP16). 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.^[42]

AVX10.1 was first released in Intel Granite Rapids^[42] (Q3 2024) and AVX10.2 will be available in Diamond Rapids.^[43]

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.^[44][45]

• 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 (requires AVX2, AVX is not sufficient)^[46]

• Cryptography
  • BSAFE C toolkits uses AVX and AVX2 where appropriate to accelerate various cryptographic algorithms.^[47]
  • OpenSSL uses AVX- and AVX2-optimized cryptographic functions since version 1.0.2.^[48] Support for AVX-512 was added in version 3.0.0.^[49] Some of these optimizations are also present in various clones and forks, like LibreSSL.

• Multimedia
  • Blender uses AVX, AVX2 and AVX-512 in the Cycles render engine.^[50]
  • Native Instruments’ Massive X softsynth requires AVX.^[51]
  • dav1d AV1 decoder can use AVX2 and AVX-512 on supported CPUs.^[52][53]
  • SVT-AV1 AV1 encoder can use AVX2 and AVX-512 to accelerate video encoding.^[54]

• Science, engineering an others
  • Esri ArcGIS Data Store uses AVX2 for graph storage.^[55]
  • 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.^[56]
  • Einstein@Home uses AVX in some of their distributed applications that search for gravitational waves.^[57]
  • TensorFlow since version 1.6 and tensorflow above versions requires CPU supporting at least AVX.^[58]
  • EmEditor 19.0 and above uses AVX2 to speed up processing.^[59]
  • Microsoft Teams uses AVX2 instructions to create a blurred or custom background behind video chat participants,^[60] and for background noise suppression.^[61]
  • simdjson, a JSON parsing library, uses AVX2 and AVX-512 to achieve improved decoding speed.^[62][63]
  • 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.^[64]
  • Tesseract OCR engine uses AVX, AVX2 and AVX-512 to accelerate character recognition.^[65]

Since AVX instructions are wider, they consume more power and generate more heat. Executing heavy AVX instructions at high CPU clock frequencies may affect CPU stability due to excessive voltage droop during load transients. Some Intel processors have provisions to reduce the Turbo Boost frequency limit when such instructions are being executed. This reduction happens even if the CPU hasn’t reached its thermal and power consumption limits.

On Skylake and its derivatives, the throttling is divided into three levels:^[66][67]

• 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.^[66]

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

• 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.^[68] 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 instructions, making it a sensible default for mixed loads.^[69]

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

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

• Intel Intrinsics Guide
• x86 Assembly Language Reference Manual

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

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

Предыдущая часть вызвала бурную дискуссию, в ходе которой выяснилось, что AVX/AVX2 на самом деле есть в десктопных CPU, нет только AVX512. Поэтому продолжаем знакомиться с SIMD, но уже с современной его частью — AVX. А так же разберём некоторые комментарии:

• медленнее ли _mm256_load_si256, чем прямое обращение к памяти?
• влияет ли на скорость использование AVX команд над SSE регистрами?
• действительно ли так плохо использовать _popcnt?

Немного про AVX

AVX/AVX2 — это более мощная версия SSE, которая расширяет большинство 128 битных SSE операций до 256 бит, плюс приносит ряд новых инструкций.

Из тонкостей реализации можно выделить то, что на уровне ассемблера AVX использует 3 аргумента, что позволяет не разрушать данные в первых двух. SSE сохраняет результат в одном из аргументов.

Так же нужно учитывать, что при прямой адресации данные должны быть выровнены по 32 байта, в SSE выравнивание по 16.

Дополненная версия бенчмарка

Изменения:

1. Количество элементов увеличено в 10 000 раз (до 10 240 000), чтобы гарантированно не вместиться в кэш процессора.
2. Выравнивание изменено с 16 байт на 32 для поддержки AVX.
3. Добавлены AVX реализации аналогичные SSE.

#include <benchmark/benchmark.h>
#include <x86intrin.h>
#include <cstring>

#define ARR_SIZE 10240000
#define VAL 50

static int16_t *getRandArr() {
    auto res = new int16_t[ARR_SIZE];
    for (int i = 0; i < ARR_SIZE; ++i) {
        res[i] = static_cast<int16_t>(rand() % (VAL * 2));
    }
    return res;
}
static auto arr = getRandArr();

static int16_t *getAllignedArr() {
    auto res = aligned_alloc(32, sizeof(int16_t) * ARR_SIZE);
    memcpy(res, arr, sizeof(int16_t) * ARR_SIZE);
    return static_cast<int16_t *>(res);
}
static auto allignedArr = getAllignedArr();

static void BM_Count(benchmark::State &state) {
    for (auto _ : state) {
        int64_t cnt = 0;
        for (int i = 0; i < ARR_SIZE; ++i)
            if (arr[i] == VAL)
                ++cnt;
        benchmark::DoNotOptimize(cnt);
    }
}

BENCHMARK(BM_Count);

static void BM_SSE_COUNT_SET_EPI(benchmark::State &state) {
    for (auto _ : state) {
        int64_t cnt = 0;

        auto sseVal = _mm_set1_epi16(VAL);
        for (int i = 0; i < ARR_SIZE; i += 8) {
            cnt += _popcnt32(
                    _mm_movemask_epi8(
                            _mm_cmpeq_epi16(
                                    sseVal,
                                    _mm_set_epi16(arr[i + 7], arr[i + 6], arr[i + 5], arr[i + 4],
                                                  arr[i + 3], arr[i + 2], arr[i + 1], arr[i])
                            )
                    )
            );
        }
        benchmark::DoNotOptimize(cnt >> 1);
    }
}

BENCHMARK(BM_SSE_COUNT_SET_EPI);

static void BM_SSE_COUNT_LOADU(benchmark::State &state) {
    for (auto _ : state) {
        int64_t cnt = 0;

        auto sseVal = _mm_set1_epi16(VAL);
        for (int i = 0; i < ARR_SIZE; i += 8) {
            cnt += _popcnt32(
                    _mm_movemask_epi8(
                            _mm_cmpeq_epi16(
                                    sseVal,
                                    _mm_loadu_si128((__m128i *) &arr[i])
                            )
                    )
            );
        }
        benchmark::DoNotOptimize(cnt >> 1);
    }
}

BENCHMARK(BM_SSE_COUNT_LOADU);

static void BM_SSE_COUNT_DIRECT(benchmark::State &state) {
    for (auto _ : state) {
        int64_t cnt = 0;

        auto sseVal = _mm_set1_epi16(VAL);
        for (int i = 0; i < ARR_SIZE; i += 8) {
            cnt += _popcnt32(
                    _mm_movemask_epi8(
                            _mm_cmpeq_epi16(
                                    sseVal,
                                    *(__m128i *) &allignedArr[i]
                            )
                    )
            );
        }
        benchmark::DoNotOptimize(cnt >> 1);
    }
}

BENCHMARK(BM_SSE_COUNT_DIRECT);

#ifdef __AVX2__

static void BM_AVX_COUNT_LOADU(benchmark::State &state) {
    for (auto _ : state) {
        int64_t cnt = 0;

        auto avxVal = _mm256_set1_epi16(VAL);
        for (int i = 0; i < ARR_SIZE; i += 16) {
            cnt += _popcnt32(
                    _mm256_movemask_epi8(
                            _mm256_cmpeq_epi16(
                                    avxVal,
                                    _mm256_loadu_si256((__m256i *) &arr[i])
                            )
                    )
            );
        }
        benchmark::DoNotOptimize(cnt >> 1);
    }
}

BENCHMARK(BM_AVX_COUNT_LOADU);

static void BM_AVX_COUNT_LOAD(benchmark::State &state) {
    for (auto _ : state) {
        int64_t cnt = 0;

        auto avxVal = _mm256_set1_epi16(VAL);
        for (int i = 0; i < ARR_SIZE; i += 16) {
            cnt += _popcnt32(
                    _mm256_movemask_epi8(
                            _mm256_cmpeq_epi16(avxVal,
                                               _mm256_load_si256((__m256i *) &allignedArr[i])
                            )
                    )
            );
        }
        benchmark::DoNotOptimize(cnt >> 1);
    }
}

BENCHMARK(BM_AVX_COUNT_LOAD);

static void BM_AVX_COUNT_DIRECT(benchmark::State &state) {
    for (auto _ : state) {
        int64_t cnt = 0;

        auto avxVal = _mm256_set1_epi16(VAL);
        for (int i = 0; i < ARR_SIZE; i += 16) {
            cnt += _popcnt32(
                    _mm256_movemask_epi8(
                            _mm256_cmpeq_epi16(
                                    avxVal,
                                    *(__m256i *) &allignedArr[i]
                            )
                    )
            );
        }
        benchmark::DoNotOptimize(cnt >> 1);
    }
}

BENCHMARK(BM_AVX_COUNT_DIRECT);

#endif

BENCHMARK_MAIN();

Новые результаты выглядят так (-O0):

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

Итого суммарное ускорение в 9+ раз, AVX ожидаемо быстрей SSE почти в 2 раза.

Медленнее ли _mm256_load_si256, чем прямое обращение к памяти?

Однозначного ответа нет. С -O0 медленнее прямого обращения, но быстрее _mm256_loadu_si256:

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

С -O3 быстрее, чем прямое обращение к памяти, но всё ещё ожидаемо медленней _mm256_loadu_si256.

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

В продакшн коде всё-таки лучше использовать _mm256_load_si256 вместо прямого обращения, этот вариант компилятор умеет лучше оптимизировать.

Влияет ли на скорость использование AVX команд над SSE регистрами?

Короткий ответ — нет. Для эксперимента я собрал и запустил бенчмарк с -mavx2 и с -msse4.2.

-mavx2

_popcnt32(_mm_movemask_epi8(_mm_cmpeq_epi16(...))) превращается в

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

Результаты:

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

-msse4.2

_popcnt32(_mm_movemask_epi8(_mm_cmpeq_epi16(...))) превращается в

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

Результаты:

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

bonus

AVX команды _popcnt32(_mm256_movemask_epi8(_mm256_cmpeq_epi16(...)))превращаются в

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

Действительно ли так плохо использовать _popcnt?

В одном из комментариев Antervis написал:

А еще, ты несколько недоработал алгоритм. Зачем делать через movemask + popcnt? Для массивов не более 2^18 элементов можно сначала собирать поэлементную сумму:
auto cmp = _mm_cmpeq_epi16(sseVal, sseArr);
cmp = _mm_and_si128(cmp, _mm_set1_epi16(1));
sum = _mm_add_epi16(sum, cmp);

а потом, в конце цикла, сделать одно горизонтальное сложение (не забывая про переполнение).

Я сделал бенчмарк

static void BM_AVX_COUNT_DIRECT_WO_POPCNT(benchmark::State &state) {
    auto avxVal1 = _mm256_set1_epi16(1);
    for (auto _ : state) {
        auto sum = _mm256_set1_epi16(0);

        auto avxVal = _mm256_set1_epi16(VAL);
        for (int i = 0; i < ARR_SIZE; i += 16) {
            sum = _mm256_add_epi16(
                    sum,
                    _mm256_and_si256(
                            avxVal1,
                            _mm256_cmpeq_epi16(
                                    avxVal,
                                    *(__m256i *) &allignedArr[i])
                    )
            );
        }

        auto arrSum = (uint16_t *) &sum;
        size_t cnt = 0;
        for (int j = 0; j < 16; ++j)
            cnt += arrSum[j];

        benchmark::DoNotOptimize(cnt >> 1);
    }
}

и он оказался медленней c -O0:

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

и немного быстрее с -O3:

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

Если эта публикация вас вдохновила и вы хотите поддержать автора — не стесняйтесь нажать на кнопку

В мире компьютерных технологий нет ничего странного в обилии всевозможных аббревиатур: 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 наборов инструкций – для каждого числа из этой группы по отдельности. По-другому процессоры тех лет складывать ещё не умели.

Картинка с сайта: i2hard.ru

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

Картинка с сайта: i2hard.ru

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, или для смешивания видеопотоков при работе с хромакеем или альфа-композитингом.

Картинка с сайта: i2hard.ru

Процессор 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 позволил значительно увеличить производительность в таких приложениях, как кодирование/декодирование видео, обработка изображений и звука, сжатие файлов и многих других.

Картинка с сайта: i2hard.ru

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.

Картинка с сайта: i2hard.ru

В 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 была уже хорошо отлажена, начиная с фундаментального мира компиляторов, заканчивая сложными приложениями.

Картинка с сайта: i2hard.ru

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

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

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

Картинка с сайта: i2hard.ru

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, ориентированных на рынок суперкомпьютеров.

Картинка с сайта: i2hard.ru

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

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

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

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

Картинка с сайта: i2hard.ru

2-ядерный Intel Skylake

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

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

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

Картинка с сайта: i2hard.ru

И проблема 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, скорее это полезное дополнение к его арсеналу.

Картинка с сайта: i2hard.ru

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

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

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

Картинка с сайта: i2hard.ru

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

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

Регистрация

Пожалуйста, введите Ваш e-mail, чтобы зарегистрироваться.
Регистрируясь на нашем сайте вы соглашаетесь с правилами и политикой конфиденциальности.

Получать новости

Восстановление доступа к аккаунту

Пожалуйста, введите Ваш e-mail, чтобы начать процедуру восстановления.

Изменение почты

Пожалуйста, введите Ваш e-mail, чтобы начать процедуру восстановления.

Код подтверждения

Письмо с проверочным кодом было отправлено на ваш e-mail: . Введите код в поле ниже.

По мере роста требований к вычислениям — от обучения моделей ИИ до высокопроизводительной аналитики — системе нужна соответствующая мощность. Intel® AVX-512 (Advanced Vector Extensions 512) — это расширение набора инструкций x86, созданное для эффективной обработки ресурсоёмких задач.

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

Разберёмся, почему AVX-512 важно для современных вычислений в 2025 году.

Что такое AVX-512?

Intel® AVX-512 (Advanced Vector Extensions 512) — это набор инструкций, встроенный во все процессоры Intel® Xeon® Scalable. Он предназначен для ускорения ресурсоёмких вычислений и поддерживает современные задачи: ИИ, аналитика, HPC и сетевые приложения, чувствительные к производительности.

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

AVX-512 входит в состав аппаратных ускорителей Intel AI Engines и HPC Engines, доступных в современных процессорах Xeon:

• Intel Xeon Scalable — Granite Rapids
• Intel Xeon Scalable — Skylake-SP
• Intel Xeon Scalable — Cascade Lake-SP
• Intel Xeon Scalable — Ice Lake-SP

AVX-512 разработан для гибридной архитектуры Intel, где производительные ядра (P-core) решают основные вычислительные задачи, а энергоэффективные (E-core) разгружают систему и снижают энергопотребление.

Инструкции AVX-512 позволяют полностью использовать возможности CPU в задачах с высокой нагрузкой.

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

Картинка с сайта: kvan.tech

Как работает AVX-512?

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

Набор регистров AVX-512 поддерживает следующие типы данных:

• 8 целых чисел по 64 бита
• 16 целых чисел по 32 бита
• 4 операции с плавающей точкой (32-бит) и 32 — с двойной точностью (64-бит)

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

Кроме того, AVX-512 поддерживает два блока FMA (fused-multiply add) по 512 бит. Это вдвое увеличивает пропускную способность при матричных операциях, что особенно важно в ИИ и научных моделированиях.

Что такое Advanced Vector Extensions (AVX)?

AVX (Advanced Vector Extensions) — это расширения SIMD (Single Instruction, Multiple Data) для архитектуры x86. Они также известны как Gesher New Instructions.

Первой значимой реализацией стала AVX2, представленная в 2013 году. Она расширила большинство целочисленных инструкций до 256 бит.

AVX-512 — следующий шаг в развитии AVX. Он увеличивает ширину регистров до 512 бит. Впервые технология появилась в сопроцессорах Intel Knights Landing (2016), а с 2017 года начала применяться в серверных и HEDT-процессорах Skylake, став доступной для более широкого круга задач.

Картинка с сайта: kvan.tech

Будущее AVX 512: эволюция или завершение пути?

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

Несмотря на сложности, AVX-512 продолжает ускорять вычисления в дата-центрах, задачах ИИ и научных симуляциях. В 2025 году технология остаётся актуальной в высоконагруженных системах.

Ближайшие годы станут решающими для AVX-512 — именно они определят, станет ли он этапом эволюции или уступит место новым подходам.

Картинка с сайта: kvan.tech

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

Источник: Servermania