View source for AVX-512

{{Short description|Instruction set extension developed by Intel}}
'''AVX-512''' are 512-bit extensions to the 256-bit [[Advanced Vector Extensions]] [[SIMD]] instructions for [[X86|x86]] [[Instruction set architecture|instruction set architecture]] (ISA) proposed by Intel in July 2013, and first implemented in the 2016 Intel [[Engineering:Xeon Phi#Knights Landing|Xeon Phi x200]] (Knights Landing),<ref name="reinders512">{{cite web|url=https://software.intel.com/en-us/articles/intel-avx-512-instructions|title=AVX-512 Instructions|author=James Reinders|date=23 July 2013|publisher=[[Company:Intel|Intel]]|access-date=20 August 2013}}</ref> and then later in a number of [[Engineering:AMD|AMD]] and other Intel CPUs (see list below). AVX-512 consists of multiple extensions that may be implemented independently.{{sfn|Kusswurm|2022|p=223}} This policy is a departure from the historical requirement of implementing the entire instruction block. Only the core extension AVX-512F (AVX-512 Foundation) is required by all AVX-512 implementations.

Besides widening most 256-bit instructions, the extensions introduce various new operations, such as new data conversions, scatter operations, and permutations.{{sfn|Kusswurm|2022|p=223}} The number of AVX registers is increased from 16 to 32, and eight new "mask registers" are added, which allow for variable selection and blending of the results of instructions. In CPUs with the vector length (VL) extension—included in most AVX-512-capable processors (see {{section link||CPUs with AVX-512}})—these instructions may also be used on the 128-bit and 256-bit vector sizes. AVX-512 is not the first 512-bit SIMD instruction set that Intel has introduced in processors: the earlier 512-bit SIMD instructions used in the first generation [[Engineering:Xeon Phi|Xeon Phi]] coprocessors, derived from Intel's [[Engineering:Larrabee (microarchitecture)|Larrabee]] project, are similar but not binary compatible and only partially source compatible.<ref name="reinders512" />

==Instruction set==
The AVX-512 instruction set consists of several separate sets each having their own unique CPUID feature bit; however, they are typically grouped by the processor generation that implements them.

; F, CD, ER, PF: Introduced with [[Engineering:Xeon Phi#Knights Landing|Xeon Phi x200 (Knights Landing)]] and Xeon Gold/Platinum ([[Skylake (microarchitecture)#Skylake-SP (14 nm) Scalable Performance|Skylake SP]] "Purley"), with the last two (ER and PF) being specific to Knights Landing.
:* ''AVX-512 Foundation (F)''{{snd}} expands most 32-bit and 64-bit based [[Advanced Vector Extensions|AVX]] instructions with the [[EVEX prefix|EVEX]] coding scheme to support 512-bit registers, operation masks, parameter broadcasting, and embedded rounding and exception control, implemented by Knights Landing and Skylake Xeon
:* ''AVX-512 Conflict Detection Instructions (CD)''{{snd}} efficient conflict detection to allow more loops to be [[Array programming|vectorized]], implemented by Knights Landing<ref name="reinders512"/> and Skylake X
:* ''AVX-512 [[Exponential function|Exponential]] and [[Multiplicative inverse|Reciprocal]] Instructions (ER){{snd}}'' exponential and reciprocal operations designed to help implement [[Transcendental function|transcendental]] operations, implemented by Knights Landing<ref name="reinders512"/> 
:* ''AVX-512 Prefetch Instructions (PF)''{{snd}} new prefetch capabilities, implemented by Knights Landing<ref name="reinders512"/>
; VL, DQ, BW: Introduced with Skylake X and Cannon Lake.
:* ''AVX-512 Vector Length Extensions (VL)''{{snd}} extends most AVX-512 operations to also operate on XMM (128-bit) and YMM (256-bit) registers<ref name="reinders512b"/>
:* ''AVX-512 Doubleword and Quadword Instructions (DQ)''{{snd}} adds new 32-bit and 64-bit AVX-512 instructions<ref name="reinders512b"/>
:* ''AVX-512 Byte and Word Instructions (BW)''{{snd}} extends AVX-512 to cover 8-bit and 16-bit integer operations<ref name="reinders512b">{{cite web|url=https://software.intel.com/en-us/articles/additional-intel-avx-512-instructions|title=Additional AVX-512 instructions|author=James Reinders|date=17 July 2014|publisher=[[Company:Intel|Intel]]|access-date=3 August 2014}}</ref>
; IFMA, VBMI: Introduced with Cannon Lake.<ref>{{cite web|url=https://www.kitguru.net/components/cpu/anton-shilov/intel-skylake-processors-for-pcs-will-not-support-avx-512-instructions/|title=Intel 'Skylake' processors for PCs will not support AVX-512 instructions|author=Anton Shilov|website=Kitguru.net| access-date=2015-03-17}}</ref>
:* ''AVX-512 Integer Fused Multiply Add (IFMA)'' – fused multiply add of integers using 52-bit precision.
:* ''AVX-512 Vector Byte Manipulation Instructions (VBMI)'' adds vector byte permutation instructions which were not present in AVX-512BW.
; 4VNNIW, 4FMAPS:Introduced with [[Engineering:Xeon Phi#Knights Mill|Knights Mill]].<ref>{{cite web|url=https://lemire.me/blog/2016/10/14/intel-will-add-deep-learning-instructions-to-its-processors/|title = Intel will add deep-learning instructions to its processors| date=14 October 2016 }}</ref><ref name="newisa"/>
:* ''AVX-512 Vector Neural Network Instructions Word variable precision (4VNNIW)'' – vector instructions for deep learning, enhanced word, variable precision.
:* ''AVX-512 Fused Multiply Accumulation Packed Single precision (4FMAPS)'' – vector instructions for deep learning, floating point, single precision.
; VPOPCNTDQ: Vector [[Hamming weight|population count]] instruction. Introduced with Knights Mill and [[Ice Lake (microarchitecture)|Ice Lake]].<ref name="iaiseaffpr"/>
; VNNI, VBMI2, BITALG:Introduced with Ice Lake.<ref name="iaiseaffpr"/>
:* ''AVX-512 Vector Neural Network Instructions (VNNI)'' – vector instructions for deep learning.
:* ''AVX-512 Vector Byte Manipulation Instructions 2 (VBMI2)'' – byte/word load, store and concatenation with shift.
:* ''AVX-512 Bit Algorithms (BITALG)'' – byte/word [[Bit manipulation|bit manipulation]] instructions expanding VPOPCNTDQ.
; VP2INTERSECT: Introduced with Tiger Lake.
:* ''AVX-512 Vector Pair Intersection to a Pair of Mask Registers (VP2INTERSECT)''.
; GFNI, VPCLMULQDQ, VAES:Introduced with Ice Lake.<ref name="iaiseaffpr"/>
:* These are not AVX-512 features per se. Together with AVX-512, they enable EVEX encoded versions of GFNI, [[CLMUL instruction set|PCLMULQDQ]] and AES instructions.

==Encoding and features==
The [[VEX prefix]] used by AVX and AVX2, while flexible, did not leave enough room for the features Intel wanted to add to AVX-512. This has led them to define a new prefix called [[EVEX prefix|EVEX]].

Compared to VEX, EVEX adds the following benefits:<ref name="newisa">{{cite web|url=https://software.intel.com/en-us/intel-architecture-instruction-set-extensions-programming-reference|title=Intel Architecture Instruction Set Extensions Programming Reference|publisher=[[Company:Intel|Intel]]|format=PDF|access-date=2014-01-29}}</ref>
* Expanded register encoding allowing 32 512-bit registers.
* Adds 8 new opmask registers for masking most AVX-512 instructions.
* Adds a new scalar memory mode that automatically performs a broadcast.
* Adds room for explicit rounding control in each instruction.
* Adds a new compressed displacement memory [[Addressing mode|addressing mode]].

The extended registers, SIMD width bit, and opmask registers of AVX-512 are mandatory and all require support from the OS.

===SIMD modes===
The AVX-512 instructions are designed to mix with 128/256-bit AVX/AVX2 instructions without a performance penalty. However, AVX-512VL extensions allows the use of AVX-512 instructions on 128/256-bit registers XMM/YMM, so most SSE and AVX/AVX2 instructions have new AVX-512 versions encoded with the EVEX prefix which allow access to new features such as opmask and additional registers. Unlike AVX-256, the new instructions do not have new mnemonics but share namespace with AVX, making the distinction between VEX and EVEX encoded versions of an instruction ambiguous in the source code. Since AVX-512F only works on 32- and 64-bit values, SSE and AVX/AVX2 instructions that operate on bytes or words are available only with the AVX-512BW extension (byte & word support).<ref name="newisa"/>

{| class="wikitable plainrowheaders"
|-
! scope="col" | Name
! scope="col" | Extension sets
! scope="col" | Registers
! scope="col" | Types
|-
! scope="row" | Legacy SSE 
| SSE–SSE4.2 
| xmm0–xmm15
| single floats. From SSE2: bytes, words, doublewords, quadwords and double floats.
|-
! scope="row" | AVX-128 (VEX)
| AVX, AVX2
| xmm0–xmm15
| bytes, words, doublewords, quadwords, single floats and double floats. 
|-
! scope="row" | AVX-256 (VEX)
| AVX, AVX2
| ymm0–ymm15
| single float and double float. From AVX2: bytes, words, doublewords, quadwords.
|-
! scope="row" | AVX-128 (EVEX)
| AVX-512VL
| xmm0–xmm31 (k0–k7)
| doublewords, quadwords, single float and double float. With AVX512BW: bytes and words. With AVX512-FP16: half float.
|-
! scope="row" | AVX-256 (EVEX)
| AVX-512VL
| ymm0–ymm31 (k0–k7)
| doublewords, quadwords, single float and double float. With AVX512BW: bytes and words. With AVX512-FP16: half float.
|-
! scope="row" | AVX-512 (EVEX)
| AVX-512F
| zmm0–zmm31 (k0–k7)
| doublewords, quadwords, single float and double float. With AVX512BW: bytes and words. With AVX512-FP16: half float.
|}

===Extended registers===
{| class="wikitable floatright" style="margin-left: 1rem; text-align: center; line-height: normal"
|+ style="margin-bottom: 0.2em; font-size: small;" | x64 AVX-512 register scheme as extension from the x64 AVX (YMM0–YMM15) and x64 SSE (XMM0–XMM15) registers
|- style="font-size: xx-small;" 
| style="width: 50%; border: none; " | <span style="float: left">511</span> <span style="float: right">256</span>
| style="width: 25%; border: none; " | <span style="float: left">255</span> <span style="float: right">128</span>
| style="width: 25%; border: none; " | <span style="float: left">127</span> <span style="float: right">0</span>
|-
| style="border-top: none" |
| style="border-top: none" |
| style="border-top: none" |
|-
| style="padding: 0" | &nbsp;&nbsp;ZMM0&nbsp;&nbsp;
| style="padding: 0; background: #ddd" | &nbsp;&nbsp;YMM0&nbsp;&nbsp;
| style="padding: 0; background: #ccc" | &nbsp;&nbsp;XMM0&nbsp;&nbsp;
|-
| style="padding: 0" | ZMM1
| style="padding: 0; background: #ddd" | YMM1
| style="padding: 0; background: #ccc" | XMM1
|-
| style="padding: 0" | ZMM2
| style="padding: 0; background: #ddd" | YMM2
| style="padding: 0; background: #ccc" | XMM2
|-
| style="padding: 0" | ZMM3
| style="padding: 0; background: #ddd" | YMM3
| style="padding: 0; background: #ccc" | XMM3
|-
| style="padding: 0" | ZMM4
| style="padding: 0; background: #ddd" | YMM4
| style="padding: 0; background: #ccc" | XMM4
|-
| style="padding: 0" | ZMM5
| style="padding: 0; background: #ddd" | YMM5
| style="padding: 0; background: #ccc" | XMM5
|-
| style="padding: 0" | ZMM6
| style="padding: 0; background: #ddd" | YMM6
| style="padding: 0; background: #ccc" | XMM6
|-
| style="padding: 0" | ZMM7
| style="padding: 0; background: #ddd" | YMM7
| style="padding: 0; background: #ccc" | XMM7
|-
| style="padding: 0" | ZMM8
| style="padding: 0; background: #ddd" | YMM8
| style="padding: 0; background: #ccc" | XMM8
|-
| style="padding: 0" | ZMM9
| style="padding: 0; background: #ddd" | YMM9
| style="padding: 0; background: #ccc" | XMM9
|-
| style="padding: 0" | ZMM10
| style="padding: 0; background: #ddd" | YMM10
| style="padding: 0; background: #ccc" | XMM10
|-
| style="padding: 0" | ZMM11
| style="padding: 0; background: #ddd" | YMM11
| style="padding: 0; background: #ccc" | XMM11
|-
| style="padding: 0" | ZMM12
| style="padding: 0; background: #ddd" | YMM12
| style="padding: 0; background: #ccc" | XMM12
|-
| style="padding: 0" | ZMM13
| style="padding: 0; background: #ddd" | YMM13
| style="padding: 0; background: #ccc" | XMM13
|-
| style="padding: 0" | ZMM14
| style="padding: 0; background: #ddd" | YMM14
| style="padding: 0; background: #ccc" | XMM14
|-
| style="padding: 0" | ZMM15
| style="padding: 0; background: #ddd" | YMM15
| style="padding: 0; background: #ccc" | XMM15
|-
| style="padding: 0" | ZMM16
| style="padding: 0" | YMM16
| style="padding: 0" | XMM16
|-
| style="padding: 0" | ZMM17
| style="padding: 0" | YMM17
| style="padding: 0" | XMM17
|-
| style="padding: 0" | ZMM18
| style="padding: 0" | YMM18
| style="padding: 0" | XMM18
|-
| style="padding: 0" | ZMM19
| style="padding: 0" | YMM19
| style="padding: 0" | XMM19
|-
| style="padding: 0" | ZMM20
| style="padding: 0" | YMM20
| style="padding: 0" | XMM20
|-
| style="padding: 0" | ZMM21
| style="padding: 0" | YMM21
| style="padding: 0" | XMM21
|-
| style="padding: 0" | ZMM22
| style="padding: 0" | YMM22
| style="padding: 0" | XMM22
|-
| style="padding: 0" | ZMM23
| style="padding: 0" | YMM23
| style="padding: 0" | XMM23
|-
| style="padding: 0" | ZMM24
| style="padding: 0" | YMM24
| style="padding: 0" | XMM24
|-
| style="padding: 0" | ZMM25
| style="padding: 0" | YMM25
| style="padding: 0" | XMM25
|-
| style="padding: 0" | ZMM26
| style="padding: 0" | YMM26
| style="padding: 0" | XMM26
|-
| style="padding: 0" | ZMM27
| style="padding: 0" | YMM27
| style="padding: 0" | XMM27
|-
| style="padding: 0" | ZMM28
| style="padding: 0" | YMM28
| style="padding: 0" | XMM28
|-
| style="padding: 0" | ZMM29
| style="padding: 0" | YMM29
| style="padding: 0" | XMM29
|-
| style="padding: 0" | ZMM30
| style="padding: 0" | YMM30
| style="padding: 0" | XMM30
|-
| style="padding: 0" | ZMM31
| style="padding: 0" | YMM31
| style="padding: 0" | XMM31
|}

The width of the [[SIMD]] register file is increased from 256 bits to 512 bits, and expanded from 16 to a total of 32 registers ZMM0–ZMM31. These registers can be addressed as 256 bit YMM registers from AVX extensions and 128-bit XMM registers from [[Streaming SIMD Extensions]], and legacy AVX and SSE instructions can be extended to operate on the 16 additional registers XMM16-XMM31 and YMM16-YMM31 when using EVEX encoded form.

==Opmask registers==
Most AVX-512 instructions may indicate one of 8 opmask registers (k0&ndash;k7). For instructions which use a mask register as an opmask, register 'k0' is special: a hardcoded constant used to indicate unmasked operations. For other operations, such as those that write to an opmask register or perform arithmetic or logical operations, 'k0' is a functioning, valid register. In most instructions, the opmask is used to control which values are written to the destination. A flag controls the opmask behavior, which can either be "zero", which zeros everything not selected by the mask, or "merge", which leaves everything not selected untouched. The merge behavior is identical to the blend instructions.

The opmask registers are normally 16 bits wide, but can be up to 64 bits with the AVX-512BW extension.<ref name="newisa"/> How many of the bits are actually used, though, depends on the vector type of the instructions masked. For the 32-bit single float or double words, 16 bits are used to mask the 16 elements in a 512-bit register. For double float and quad words, at most 8 mask bits are used.

The opmask register is the reason why several bitwise instructions which naturally have no element widths had them added in AVX-512. For instance, bitwise AND, OR or 128-bit shuffle now exist in both double-word and quad-word variants with the only difference being in the final masking.

===New opmask instructions===
The opmask registers have a new mini extension of instructions operating directly on them. Unlike the rest of the AVX-512 instructions, these instructions are all VEX encoded. The initial opmask instructions are all 16-bit (Word) versions. With AVX-512DQ 8-bit (Byte) versions were added to better match the needs of masking 8 64-bit values, and with AVX-512BW 32-bit (Double) and 64-bit (Quad) versions were added so they can mask up to 64 8-bit values. The instructions KORTEST and KTEST can be used to set the x86 flags based on mask registers, so that they may be used together with non-SIMD x86 branch and conditional instructions.

{| class="wikitable plainrowheaders"
|-
! scope="col" | Instruction
! scope="col" | Extension set
! scope="col" | Description
|-
! scope="row" | <code>KAND</code>
| F
| Bitwise logical AND Masks
|-
! scope="row" | <code>KANDN</code>
| F
| Bitwise logical AND NOT Masks
|-
! scope="row" | <code>KMOV</code>
| F
| Move from and to Mask Registers or General Purpose Registers
|-
! scope="row" | <code>KUNPCK</code>
| F
| Unpack for Mask Registers
|-
! scope="row" | <code>KNOT</code>
| F
| NOT Mask Register
|-
! scope="row" | <code>KOR</code>
| F
| Bitwise logical OR Masks
|-
! scope="row" | <code>KORTEST</code>
| F
| OR Masks And Set Flags
|-
! scope="row" | <code>KSHIFTL</code>
| F
| Shift Left Mask Registers
|-
! scope="row" | <code>KSHIFTR</code>
| F
| Shift Right Mask Registers
|-
! scope="row" | <code>KXNOR</code>
| F
| Bitwise logical XNOR Masks
|-
! scope="row" | <code>KXOR</code>
| F
| Bitwise logical XOR Masks
|-
! scope="row" | <code>KADD</code>
| BW/DQ
| Add Two Masks
|-
! scope="row" | <code>KTEST</code>
| BW/DQ
| Bitwise comparison and set flags
|}

==New instructions in AVX-512 foundation==
Many AVX-512 instructions are simply EVEX versions of old SSE or AVX instructions. There are, however, several new instructions, and old instructions that have been replaced with new AVX-512 versions. The new or heavily reworked instructions are listed below. These ''foundation'' instructions also include the extensions from AVX-512VL and AVX-512BW since those extensions merely add new versions of these instructions instead of new instructions.

===Blend using mask===
There are no EVEX-prefixed versions of the blend instructions from [[SSE4]]; instead, AVX-512 has a new set of blending instructions using mask registers as selectors. Together with the general compare into mask instructions below, these may be used to implement generic ternary operations or cmov, similar to [[XOP instruction set|XOP]]'s VPCMOV.

Since blending is an integral part of the EVEX encoding, these instructions may also be considered basic move instructions. Using the zeroing blend mode, they can also be used as masking instructions.

{| class="wikitable plainrowheaders"
|-
! scope="col" | Instruction
! scope="col" | Extension set
! scope="col" | Description
|-
! scope="row" | <code>VBLENDMPD</code>
| F
| Blend float64 vectors using opmask control
|-
! scope="row" | <code>VBLENDMPS</code>
| F
| Blend float32 vectors using opmask control
|-
! scope="row" | <code>VPBLENDMD</code>
| F
| Blend int32 vectors using opmask control
|-
! scope="row" | <code>VPBLENDMQ</code>
| F
| Blend int64 vectors using opmask control
|-
! scope="row" | <code>VPBLENDMB</code>
| BW
| Blend byte integer vectors using opmask control
|-
! scope="row" | <code>VPBLENDMW</code>
| BW
| Blend word integer vectors using opmask control
|}

===Compare into mask===
AVX-512F has four new compare instructions. Like their [[XOP instruction set|XOP]] counterparts they use the immediate field to select between 8 different comparisons. Unlike their XOP inspiration, however, they save the result to a mask register and initially only support doubleword and quadword comparisons. The AVX-512BW extension provides the byte and word versions. Note that two mask registers may be specified for the instructions, one to write to and one to declare regular masking.<ref name="newisa"/>

{| class="wikitable floatright" style="margin-left: 1rem; text-align: center; line-height: normal"
|-
! scope="col" | Immediate
! scope="col" | Comparison
! scope="col" | Description
|-
| 0
| EQ
| Equal
|-
| 1
| LT
| Less than
|-
| 2
| LE
| Less than or equal
|-
| 3
| FALSE
| Set to zero
|-
| 4
| NEQ
| Not equal
|-
| 5
| NLT
| Greater than or equal
|-
| 6
| NLE
| Greater than
|-
| 7
| TRUE
| Set to one
|}

{| class="wikitable plainrowheaders"
|-
! scope="col" | Instruction
! scope="col" | Extension set
! scope="col" | Description
|-
| <code>VPCMPD</code>, <code>VPCMPUD</code>
| F
| Compare signed/unsigned doublewords into mask
|-
| <code>VPCMPQ</code>, <code>VPCMPUQ</code>
| F
| Compare signed/unsigned quadwords into mask
|-
| <code>VPCMPB</code>, <code>VPCMPUB</code>
| BW
| Compare signed/unsigned bytes into mask
|-
| <code>VPCMPW</code>, <code>VPCMPUW</code>
| BW
| Compare signed/unsigned words into mask
|}

===Logical set mask===
The final way to set masks is using Logical Set Mask. These instructions perform either AND or NAND, and then set the destination opmask based on the result values being zero or non-zero. Note that like the comparison instructions, these take two opmask registers, one as destination and one a regular opmask.

{| class="wikitable"
|-
! scope="col" | Instruction
! scope="col" | Extension set
! scope="col" | Description
|-
| <code>VPTESTMD</code>, <code>VPTESTMQ</code>
| F
| Logical AND and set mask for 32 or 64 bit integers.
|-
| <code>VPTESTNMD</code>, <code>VPTESTNMQ</code>
| F
| Logical NAND and set mask for 32 or 64 bit integers.
|-
| <code>VPTESTMB</code>, <code>VPTESTMW</code>
| BW
| Logical AND and set mask for 8 or 16 bit integers.
|-
| <code>VPTESTNMB</code>, <code>VPTESTNMW</code>
| BW
| Logical NAND and set mask for 8 or 16 bit integers.
|}

===Compress and expand===
The compress and expand instructions match the [[APL (programming language)|APL]] operations of the same name. They use the opmask in a slightly different way from other AVX-512 instructions. Compress only saves the values marked in the mask, but saves them compacted by skipping and not reserving space for unmarked values. Expand operates in the opposite way, by loading as many values as indicated in the mask and then spreading them to the selected positions.

{| class="wikitable"
|-
! scope="col" | Instruction
! scope="col" | Description
|-
| <code>VCOMPRESSPD</code>, <code>VCOMPRESSPS</code>
| Store sparse packed double/single-precision floating-point values into dense memory
|-
| <code>VPCOMPRESSD</code>, <code>VPCOMPRESSQ</code>
| Store sparse packed doubleword/quadword integer values into dense memory/register
|-
| <code>VEXPANDPD</code>, <code>VEXPANDPS</code>
| Load sparse packed double/single-precision floating-point values from dense memory
|-
| <code>VPEXPANDD</code>, <code>VPEXPANDQ</code>
| Load sparse packed doubleword/quadword integer values from dense memory/register
|}

===Permute===
A new set of [[Permute instruction|permute instruction]]s have been added for full two input permutations. They all take three arguments, two source registers and one index; the result is output by either overwriting the first source register or the index register. AVX-512BW extends the instructions to also include 16-bit (word) versions, and the AVX-512_VBMI extension defines the byte versions of the instructions.

{| class="wikitable"
|-
! scope="col" | Instruction
! scope="col" | Extension set
! scope="col" | Description
|-
| <code>VPERMB</code>
| VBMI
| Permute packed bytes elements.
|-
| <code>VPERMW</code>
| BW
| Permute packed words elements.
|-
| <code>VPERMT2B</code>
| VBMI
| Full byte permute overwriting first source.
|-
| <code>VPERMT2W</code>
| BW
| Full word permute overwriting first source.
|-
| <code>VPERMI2PD</code>, <code>VPERMI2PS</code>
| F
| Full single/double floating-point permute overwriting the index.
|-
| <code>VPERMI2D</code>, <code>VPERMI2Q</code>
| F
| Full doubleword/quadword permute overwriting the index.
|-
| <code>VPERMI2B</code>
| VBMI
| Full byte permute overwriting the index.
|-
| <code>VPERMI2W</code>
| BW
| Full word permute overwriting the index.
|-
| <code>VPERMT2PS</code>, <code>VPERMT2PD</code>
| F
| Full single/double floating-point permute overwriting first source.
|-
| <code>VPERMT2D</code>, <code>VPERMT2Q</code>
| F
| Full doubleword/quadword permute overwriting first source.
|-
| <code>VSHUFF32x4</code>, <code>VSHUFF64x2</code>, <code>VSHUFI32x4</code>, <code>VSHUFI64x2</code>
| F
| Shuffle four packed 128-bit lines.
|-
| <code>VPMULTISHIFTQB</code>
| VBMI
| Select packed unaligned bytes from quadword sources.
|}

===Bitwise ternary logic===
Two new instructions added can logically implement all possible bitwise operations between three inputs. They take three registers as input and an 8-bit immediate field. Each bit in the output is generated using a lookup of the three corresponding bits in the inputs to select one of the 8 positions in the 8-bit immediate. Since only 8 combinations are possible using three bits, this allow all possible 3 input bitwise operations to be performed.<ref name="newisa"/>
These are the only bitwise vector instructions in AVX-512F; EVEX versions of the two source SSE and AVX bitwise vector instructions AND, ANDN, OR and XOR were added in AVX-512DQ.

The difference in the doubleword and quadword versions is only the application of the opmask.

{| class="wikitable"
|-
! scope="col" | Instruction
! scope="col" | Description
|-
| <code>VPTERNLOGD</code>, <code>VPTERNLOGQ</code>
| Bitwise Ternary Logic
|}

{| class="wikitable"
|+ Bitwise Ternary Logic [[Truth table]]
|-
! scope="col" | A0
! scope="col" | A1
! scope="col" | A2
! scope="col" | Double AND<br/>(0x80)
! scope="col" | Double OR<br/>(0xFE)
! scope="col" | Bitwise blend<br/>(0xCA)
|-
| 0 || 0 || 0 || 0 || 0 || 0
|-
| 0 || 0 || 1 || 0 || 1 || 1
|-
| 0 || 1 || 0 || 0 || 1 || 0
|-
| 0 || 1 || 1 || 0 || 1 || 1
|-
| 1 || 0 || 0 || 0 || 1 || 0
|-
| 1 || 0 || 1 || 0 || 1 || 0
|-
| 1 || 1 || 0 || 0 || 1 || 1
|-
| 1 || 1 || 1 || 1 || 1 || 1
|}

===Conversions===
A number of conversion or move instructions were added; these complete the set of conversion instructions available from SSE2.
{| class="wikitable"
|-
! scope="col" | Instruction
! scope="col" | Extension set
! scope="col" | Description
|-
|
<code>VPMOVQD</code>, <code>VPMOVSQD</code>, <code>VPMOVUSQD</code>, <code>VPMOVQW</code>, <code>VPMOVSQW</code>, <code>VPMOVUSQW</code>, <code>VPMOVQB</code>, <code>VPMOVSQB</code>, <code>VPMOVUSQB</code>, <code>VPMOVDW</code>, <code>VPMOVSDW</code>, <code>VPMOVUSDW</code>, <code>VPMOVDB</code>, <code>VPMOVSDB</code>, <code>VPMOVUSDB</code>
| F
| Down convert quadword or doubleword to doubleword, word or byte; unsaturated, saturated or saturated unsigned. The reverse of the sign/zero extend instructions from SSE4.1.
|-
| <code>VPMOVWB</code>, <code>VPMOVSWB</code>, <code>VPMOVUSWB</code>
| BW
| Down convert word to byte; unsaturated, saturated or saturated unsigned.
|-
| <code>VCVTPS2UDQ</code>, <code>VCVTPD2UDQ</code>, <code>VCVTTPS2UDQ</code>, <code>VCVTTPD2UDQ</code>
| F
| Convert with or without truncation, packed single or double-precision floating point to packed unsigned doubleword integers.
|-
| <code>VCVTSS2USI</code>, <code>VCVTSD2USI</code>, <code>VCVTTSS2USI</code>, <code>VCVTTSD2USI</code>
| F
| Convert with or without truncation, scalar single or double-precision floating point to unsigned doubleword integer.
|-
| <code>VCVTPS2QQ</code>, <code>VCVTPD2QQ</code>, <code>VCVTPS2UQQ</code>, <code>VCVTPD2UQQ</code>, <code>VCVTTPS2QQ</code>, <code>VCVTTPD2QQ</code>, <code>VCVTTPS2UQQ</code>, <code>VCVTTPD2UQQ</code>
| DQ
| Convert with or without truncation, packed single or double-precision floating point to packed signed or unsigned quadword integers.
|-
| <code>VCVTUDQ2PS</code>, <code>VCVTUDQ2PD</code>
| F
| Convert packed unsigned doubleword integers to packed single or double-precision floating point.
|-
| <code>VCVTUSI2PS</code>, <code>VCVTUSI2PD</code>
| F
| Convert scalar unsigned doubleword integers to single or double-precision floating point.
|-
| <code>VCVTUSI2SD</code>, <code>VCVTUSI2SS</code>
| F
| Convert scalar unsigned integers to single or double-precision floating point.
|-
| <code>VCVTUQQ2PS</code>, <code>VCVTUQQ2PD</code>
| DQ
| Convert packed unsigned quadword integers to packed single or double-precision floating point.
|-
| <code>VCVTQQ2PD</code>, <code>VCVTQQ2PS</code>
| F
| Convert packed quadword integers to packed single or double-precision floating point.
|}

===Floating-point decomposition===
Among the unique new features in AVX-512F are instructions to decompose floating-point values and handle special floating-point values. Since these methods are completely new, they also exist in scalar versions.

{| class="wikitable"
|-
! scope="col" | Instruction
! scope="col" | Description
|-
| <code>VGETEXPPD</code>, <code>VGETEXPPS</code>
| Convert exponents of packed fp values into fp values
|-
| <code>VGETEXPSD</code>, <code>VGETEXPSS</code>
| Convert exponent of scalar fp value into fp value
|-
| <code>VGETMANTPD</code>, <code>VGETMANTPS</code>
| Extract vector of normalized mantissas from float32/float64 vector
|-
| <code>VGETMANTSD</code>, <code>VGETMANTSS</code>
| Extract float32/float64 of normalized [[Significand|mantissa]] from float32/float64 scalar
|-
| <code>VFIXUPIMMPD</code>, <code>VFIXUPIMMPS</code>
| Fix up special packed float32/float64 values
|-
| <code>VFIXUPIMMSD</code>, <code>VFIXUPIMMSS</code>
| Fix up special scalar float32/float64 value
|}

===Floating-point arithmetic===
This is the second set of new floating-point methods, which includes new scaling and approximate calculation of reciprocal, and reciprocal of square root. The approximate reciprocal instructions guarantee to have at most a relative error of 2<sup>−14</sup>.<ref name="newisa"/>

{| class="wikitable"
|-
! scope="col" | Instruction
! scope="col" | Description
|-
| <code>VRCP14PD</code>, <code>VRCP14PS</code>
| Compute approximate reciprocals of packed float32/float64 values
|-
| <code>VRCP14SD</code>, <code>VRCP14SS</code>
| Compute approximate reciprocals of scalar float32/float64 value
|-
| <code>VRNDSCALEPS</code>, <code>VRNDSCALEPD</code>
| Round packed float32/float64 values to include a given number of fraction bits
|-
| <code>VRNDSCALESS</code>, <code>VRNDSCALESD</code>
| Round scalar float32/float64 value to include a given number of fraction bits
|-
| <code>VRSQRT14PD</code>, <code>VRSQRT14PS</code>
| Compute approximate reciprocals of square roots of packed float32/float64 values
|-
| <code>VRSQRT14SD</code>, <code>VRSQRT14SS</code>
| Compute approximate reciprocal of square root of scalar float32/float64 value
|-
| <code>VSCALEFPS</code>, <code>VSCALEFPD</code>
| Scale packed float32/float64 values with float32/float64 values
|-
| <code>VSCALEFSS</code>, <code>VSCALEFSD</code>
| Scale scalar float32/float64 value with float32/float64 value
|}

===Broadcast===
{| class="wikitable"
|-
! scope="col" | Instruction
! scope="col" | Extension set
! scope="col" | Description
|-
| <code>VBROADCASTSS</code>, <code>VBROADCASTSD</code>
| F, VL
| Broadcast single/double floating-point value
|-
| <code>VPBROADCASTB</code>, <code>VPBROADCASTW</code>, <code>VPBROADCASTD</code>, <code>VPBROADCASTQ</code>
| F, VL, DQ, BW
|Broadcast a byte/word/doubleword/quadword integer value 
|-
|<code>VBROADCASTI32X2</code>, <code>VBROADCASTI64X2</code>, <code>VBROADCASTI32X4</code>, <code>VBROADCASTI32X8</code>, <code>VBROADCASTI64X4</code>
| F, VL, DQ, BW
|Broadcast two or four doubleword/quadword integer values 
|}

===Miscellaneous===
{| class="wikitable"
|-
! scope="col" | Instruction
! scope="col" | Extension set
! scope="col" | Description
|-
| <code>VALIGND</code>, <code>VALIGNQ</code>
| F, VL
| Align doubleword or quadword vectors
|-
| <code>VDBPSADBW</code>
| BW
| Double block packed sum-absolute-differences (SAD) on unsigned bytes
|-
| <code>VPABSQ</code>
| F
| Packed absolute value quadword
|-
| <code>VPMAXSQ</code>, <code>VPMAXUQ</code>
| F
| Maximum of packed signed/unsigned quadword
|-
| <code>VPMINSQ</code>, <code>VPMINUQ</code>
| F
| Minimum of packed signed/unsigned quadword
|-
| <code>VPROLD</code>, <code>VPROLVD</code>, <code>VPROLQ</code>, <code>VPROLVQ</code>, <code>VPRORD</code>, <code>VPRORVD</code>, <code>VPRORQ</code>, <code>VPRORVQ</code> 
| F
| Bit rotate left or right
|-
| <code>VPSCATTERDD</code>, <code>VPSCATTERDQ</code>, <code>VPSCATTERQD</code>, <code>VPSCATTERQQ</code>
| F
| Scatter packed doubleword/quadword with signed doubleword and quadword indices
|-
| <code>VSCATTERDPS</code>, <code>VSCATTERDPD</code>, <code>VSCATTERQPS</code>, <code>VSCATTERQPD</code>
| F
| Scatter packed float32/float64 with signed doubleword and quadword indices
|}

==New instructions by sets==
===Conflict detection===
The instructions in AVX-512 conflict detection (AVX-512CD) are designed to help efficiently calculate conflict-free subsets of elements in loops that normally could not be safely vectorized.<ref>{{cite web|url=https://llvm.org/devmtg/2013-11/slides/Demikhovsky-Poster.pdf|title=AVX-512 Architecture/Demikhovsky Poster |publisher= [[Company:Intel|Intel]] |access-date= 25 February 2014}}</ref>

{| class="wikitable"
|-
! scope="col" | Instruction
! scope="col" | Name 
! scope="col" | Description
|-
| <code>VPCONFLICTD</code>, <code>VPCONFLICTQ</code>
| Detect conflicts within vector of packed double- or quadwords values
| Compares each element in the first source, to all elements on same or earlier places in the second source and forms a bit vector of the results
|-
| <code>VPLZCNTD</code>, <code>VPLZCNTQ</code>
| Count the number of leading zero bits for packed double- or quadword values
| Vectorized <code>LZCNT</code> instruction
|-
| <code>VPBROADCASTMB2Q</code>, <code>VPBROADCASTMW2D</code>
| Broadcast mask to vector register
| Either 8-bit mask to quadword vector, or 16-bit mask to doubleword vector
|}

===Exponential and reciprocal===
AVX-512 exponential and reciprocal (AVX-512ER) instructions contain more accurate approximate reciprocal instructions than those in the AVX-512 foundation; relative error is at most 2<sup>−28</sup>. They also contain two new exponential functions that have a relative error of at most 2<sup>−23</sup>.<ref name="newisa"/>

{| class="wikitable"
|-
! scope="col" | Instruction
! scope="col" | Description
|-
| <code>VEXP2PD</code>, <code>VEXP2PS</code>
| Compute approximate exponential 2^x of packed single or double-precision floating-point values
|-
| <code>VRCP28PD</code>, <code>VRCP28PS</code>
| Compute approximate reciprocals of packed single or double-precision floating-point values
|-
| <code>VRCP28SD</code>, <code>VRCP28SS</code>
| Compute approximate reciprocal of scalar single or double-precision floating-point value
|-
| <code>VRSQRT28PD</code>, <code>VRSQRT28PS</code>
| Compute approximate reciprocals of square roots of packed single or double-precision floating-point values
|-
| <code>VRSQRT28SD</code>, <code>VRSQRT28SS</code>
| Compute approximate reciprocal of square root of scalar single or double-precision floating-point value
|}

===Prefetch===
AVX-512 prefetch (AVX-512PF) instructions contain new prefetch operations for the new scatter and gather functionality introduced in AVX2 and AVX-512. <code>T0</code> prefetch means prefetching into level 1 cache and <code>T1</code> means prefetching into level 2 cache.

{| class="wikitable"
|-
! scope="col" | Instruction
! scope="col" | Description
|-
| <code>VGATHERPF0DPS</code>, <code>VGATHERPF0QPS</code>, <code>VGATHERPF0DPD</code>, <code>VGATHERPF0QPD</code>
| Using signed dword/qword indices, prefetch sparse byte memory locations containing single/double-precision data using opmask k1 and T0 hint.
|-
| <code>VGATHERPF1DPS</code>, <code>VGATHERPF1QPS</code>, <code>VGATHERPF1DPD</code>, <code>VGATHERPF1QPD</code>
| Using signed dword/qword indices, prefetch sparse byte memory locations containing single/double-precision data using opmask k1 and T1 hint.
|-
| <code>VSCATTERPF0DPS</code>, <code>VSCATTERPF0QPS</code>, <code>VSCATTERPF0DPD</code>, <code>VSCATTERPF0QPD</code>
| Using signed dword/qword indices, prefetch sparse byte memory locations containing single/double-precision data using writemask k1 and T0 hint with intent to write.
|-
| <code>VSCATTERPF1DPS</code>, <code>VSCATTERPF1QPS</code>, <code>VSCATTERPF1DPD</code>, <code>VSCATTERPF1QPD</code>
| Using signed dword/qword indices, prefetch sparse byte memory locations containing single/double precision data using writemask k1 and T1 hint with intent to write.
|}

===4FMAPS and 4VNNIW===
The two sets of instructions perform multiple iterations of processing. They are generally only found in Xeon Phi products.

{| class="wikitable"
|-
! scope="col" | Instruction
! scope="col" | Extension set
! scope="col" | Description
|-
| <code>V4FMADDPS</code>, <code>V4FMADDSS</code>
| 4FMAPS
| Packed/scalar single-precision floating-point fused multiply-add (4-iterations)
|-
| <code>V4FNMADDPS</code>, <code>V4FNMADDSS</code>
| 4FMAPS
| Packed/scalar single-precision floating-point fused multiply-add and negate (4-iterations)
|-
| <code>VP4DPWSSD</code>
| 4VNNIW
| Dot product of signed words with double word accumulation (4-iterations)
|-
| <code>VP4DPWSSDS</code>
| 4VNNIW
| Dot product of signed words with double word accumulation and saturation (4-iterations)
|}

===BW, DQ and VBMI===
AVX-512DQ adds new doubleword and quadword instructions. AVX-512BW adds byte and words versions of the same instructions, and adds byte and word version of doubleword/quadword instructions in AVX-512F. A few instructions which get only word forms with AVX-512BW acquire byte forms with the AVX-512_VBMI extension (<code>VPERMB</code>, <code>VPERMI2B</code>, <code>VPERMT2B</code>, <code>VPMULTISHIFTQB</code>).

Two new instructions were added to the mask instructions set: <code>KADD</code> and <code>KTEST</code> (B and W forms with AVX-512DQ, D and Q with AVX-512BW). The rest of mask instructions, which had only word forms, got byte forms with AVX-512DQ and doubleword/quadword forms with AVX-512BW. <code>KUNPCKBW</code> was extended to <code>KUNPCKWD</code> and <code>KUNPCKDQ</code> by AVX-512BW.

Among the instructions added by AVX-512DQ are several SSE and AVX instructions that didn't get AVX-512 versions with AVX-512F, among those are all the two input bitwise instructions and extract/insert integer instructions.

Instructions that are completely new are covered below.

====Floating-point instructions====
Three new floating-point operations are introduced. Since they are not only new to AVX-512 they have both packed/SIMD and scalar versions.

The <code>VFPCLASS</code> instructions tests if the floating-point value is one of eight special floating-point values, which of the eight values will trigger a bit in the output mask register is controlled by the immediate field. The <code>VRANGE</code> instructions perform minimum or maximum operations depending on the value of the immediate field, which can also control if the operation is done absolute or not and separately how the sign is handled. The <code>VREDUCE</code> instructions operate on a single source, and subtract from that the integer part of the source value plus a number of bits specified in the immediate field of its fraction.

{| class="wikitable"
|-
! scope="col" | Instruction
! scope="col" | Extension set
! scope="col" | Description
|-
| <code>VFPCLASSPS</code>, <code>VFPCLASSPD</code>
| DQ
| Test types of packed single and double precision floating-point values.
|-
| <code>VFPCLASSSS</code>, <code>VFPCLASSSD</code>
| DQ
| Test types of scalar single and double precision floating-point values.
|-
| <code>VRANGEPS</code>, <code>VRANGEPD</code>
| DQ
| Range restriction calculation for packed floating-point values.
|-
| <code>VRANGESS</code>, <code>VRANGESD</code>
| DQ
| Range restriction calculation for scalar floating-point values.
|-
| <code>VREDUCEPS</code>, <code>VREDUCEPD</code>
| DQ
| Perform reduction transformation on packed floating-point values.
|-
| <code>VREDUCESS</code>, <code>VREDUCESD</code>
| DQ
| Perform reduction transformation on scalar floating-point values.
|}

====Other instructions====
{| class="wikitable"
|-
! scope="col" | Instruction
! scope="col" | Extension set
! scope="col" | Description
|-
| <code>VPMOVM2D</code>, <code>VPMOVM2Q</code>
| DQ
| Convert mask register to double- or quad-word vector register.
|-
| <code>VPMOVM2B</code>, <code>VPMOVM2W</code>
| BW
| Convert mask register to byte or word vector register.
|-
| <code>VPMOVD2M</code>, <code>VPMOVQ2M</code>
| DQ
| Convert double- or quad-word vector register to mask register.
|-
| <code>VPMOVB2M</code>, <code>VPMOVW2M</code>
| BW
| Convert byte or word vector register to mask register.
|-
| <code>VPMULLQ</code>
| DQ
| Multiply packed quadword store low result. A quadword version of VPMULLD.
|}

===VBMI2===
Extend VPCOMPRESS and VPEXPAND with byte and word variants. Shift instructions are new.

{| class="wikitable"
|-
! scope="col" | Instruction
! scope="col" | Description
|-
| <code>VPCOMPRESSB</code>, <code>VPCOMPRESSW</code>
| Store sparse packed byte/word integer values into dense memory/register
|-
| <code>VPEXPANDB</code>, <code>VPEXPANDW</code>
| Load sparse packed byte/word integer values from dense memory/register
|-
| <code>VPSHLD</code>
| Concatenate and shift packed data left logical
|-
| <code>VPSHLDV</code>
| Concatenate and variable shift packed data left logical
|-
| <code>VPSHRD</code>
| Concatenate and shift packed data right logical
|-
| <code>VPSHRDV</code>
| Concatenate and variable shift packed data right logical
|}

===VNNI===
Vector Neural Network Instructions:<ref>{{cite web |url=https://www.intel.com/content/dam/www/public/us/en/documents/product-overviews/dl-boost-product-overview.pdf|title=Intel® Deep Learning Boost|publisher=Intel|access-date=2021-10-11}}</ref> AVX512-VNNI adds [[EVEX prefix|EVEX]]-coded instructions described below. With AVX-512F, these instructions can operate on 512-bit vectors, and AVX-512VL further adds support for 128- and 256-bit vectors.

A later [[Advanced Vector Extensions#AVX-VNNI|AVX-VNNI]] extension adds [[VEX prefix|VEX]] encodings of these instructions which can only operate on 128- or 256-bit vectors. AVX-VNNI is not part of the AVX-512 suite, it does not require AVX-512F and can be implemented independently.

{| class="wikitable"
|-
! scope="col" | Instruction
! scope="col" | Description
|-
| <code>VPDPBUSD</code>
| Multiply and add unsigned and signed bytes
|-
| <code>VPDPBUSDS</code>
| Multiply and add unsigned and signed bytes with saturation
|-
| <code>VPDPWSSD</code>
| Multiply and add signed word integers
|-
| <code>VPDPWSSDS</code>
| Multiply and add word integers with saturation
|}

===IFMA===
Integer fused multiply-add instructions. AVX512-IFMA adds [[EVEX prefix|EVEX]]-coded instructions described below.

A separate [[Advanced Vector Extensions#AVX-IFMA|AVX-IFMA]] instruction set extension defines [[VEX prefix|VEX]] encoding of these instructions. This extension is not part of the AVX-512 suite and can be implemented independently.

{| class="wikitable"
|-
! scope="col" | Instruction
! scope="col" | Extension set
! scope="col" | Description
|-
| <code>VPMADD52LUQ</code>
| IFMA
| Packed multiply of unsigned 52-bit integers and add the low 52-bit products to 64-bit accumulators
|-
| <code>VPMADD52HUQ</code>
| IFMA
| Packed multiply of unsigned 52-bit integers and add the high 52-bit products to 64-bit accumulators
|}

===VPOPCNTDQ and BITALG===
{| class="wikitable"
|-
! scope="col" | Instruction
! scope="col" | Extension set
! scope="col" | Description
|-
| <code>VPOPCNTD</code>, <code>VPOPCNTQ</code>
| VPOPCNTDQ
| Return the number of bits set to 1 in doubleword/quadword
|-
| <code>VPOPCNTB</code>, <code>VPOPCNTW</code>
| BITALG
| Return the number of bits set to 1 in byte/word
|-
| <code>VPSHUFBITQMB</code>
| BITALG
| Shuffle bits from quadword elements using byte indexes into mask
|}

===VP2INTERSECT===
{| class="wikitable"
|-
! scope="col" | Instruction
! scope="col" | Extension set
! scope="col" | Description
|-
| <code>VP2INTERSECTD</code>, <code>VP2INTERSECTQ</code>
| VP2INTERSECT
| Compute intersection between doublewords/quadwords to a pair of mask registers
|}

===GFNI===
Galois field new instructions are useful for cryptography,<ref name=gfni>{{cite web |title=Galois Field New Instructions (GFNI) Technology Guide |url=https://networkbuilders.intel.com/solutionslibrary/galois-field-new-instructions-gfni-technology-guide |website=networkbuilders.intel.com |language=en}}</ref> as they can be used to implement [[Rijndael S-box|Rijndael-style S-boxes]] such as those used in AES, Camellia, and SM4.<ref>{{cite web |last1=Kivilinna |first1=Jussi |title=camellia-simd-aesni |website=[[GitHub]] |url=https://github.com/jkivilin/camellia-simd-aesni |date=19 April 2023 |quote=Newer x86-64 processors also support Galois Field New Instructions (GFNI) which allow implementing Camellia s-box more straightforward manner and yield even better performance.}}</ref> These instructions may also be used for bit manipulation in networking and signal processing.<ref name=gfni/>

GFNI is a standalone instruction set extension and can be enabled separately from AVX or AVX-512. Depending on whether AVX and AVX-512F support is indicated by the CPU, GFNI support enables legacy (SSE), VEX or EVEX-coded instructions operating on 128, 256 or 512-bit vectors.

{| class="wikitable"
|-
! scope="col" | Instruction
! scope="col" | Description
|-
| <code>VGF2P8AFFINEINVQB</code>
| Galois field affine transformation inverse
|-
| <code>VGF2P8AFFINEQB</code>
| Galois field affine transformation
|-
| <code>VGF2P8MULB</code>
| Galois field multiply bytes
|}

===VPCLMULQDQ===
VPCLMULQDQ with AVX-512F adds an EVEX-encoded 512-bit version of the PCLMULQDQ instruction. With AVX-512VL, it adds EVEX-encoded 256- and 128-bit versions. VPCLMULQDQ alone (that is, on non-AVX512 CPUs) adds only VEX-encoded 256-bit version. (Availability of the VEX-encoded 128-bit version is indicated by different CPUID bits: PCLMULQDQ and AVX.) The wider than 128-bit variations of the instruction perform the same operation on each 128-bit portion of input registers, but they do not extend it to select quadwords from different 128-bit fields (the meaning of imm8 operand is the same: either low or high quadword of the 128-bit field is selected).

{| class="wikitable"
|-
! scope="col" | Instruction
! scope="col" | Description
|-
| <code>VPCLMULQDQ</code>
| Carry-less multiplication quadword
|}

===VAES===
VEX- and EVEX-encoded [[Advanced Encryption Standard|AES]] instructions. The wider than 128-bit variations of the instruction perform the same operation on each 128-bit portion of input registers. The VEX versions can be used without AVX-512 support.

{| class="wikitable"
|-
! scope="col" | Instruction
! scope="col" | Description
|-
| <code>VAESDEC</code>
| Perform one round of an AES decryption flow
|-
| <code>VAESDECLAST</code>
| Perform last round of an AES decryption flow
|-
| <code>VAESENC</code>
| Perform one round of an AES encryption flow
|-
| <code>VAESENCLAST</code>
| Perform last round of an AES encryption flow
|}

===BF16===
AI acceleration instructions operating on the [[Bfloat16 floating-point format|Bfloat16]] numbers.

{| class="wikitable"
|-
! scope="col" | Instruction
! scope="col" | Description
|-
| <code>VCVTNE2PS2BF16</code>
| Convert two vectors of packed single precision numbers into one vector of packed Bfloat16 numbers
|-
| <code>VCVTNEPS2BF16</code>
| Convert one vector of packed single precision numbers to one vector of packed Bfloat16 numbers
|-
| <code>VDPBF16PS</code>
| Calculate dot product of two Bfloat16 pairs and accumulate the result into one packed single precision number
|}

===FP16===
An extension of the earlier [[F16C]] instruction set, adding comprehensive support for the [[Half-precision floating-point format|binary16]] floating-point numbers (also known as FP16, float16 or half-precision floating-point numbers). The new instructions implement most operations that were previously available for [[Single-precision floating-point format|single]] and [[Double-precision floating-point format|double]]-precision floating-point numbers and also introduce new [[Complex number|complex number]] instructions and conversion instructions. Scalar and packed operations are supported.

Unlike the single and double-precision format instructions, the half-precision operands are neither conditionally flushed to zero ([[Subnormal number#Disabling subnormal floats at the code level|FTZ]]) nor conditionally treated as zero ([[Subnormal number#Disabling subnormal floats at the code level|DAZ]]) based on <code>MXCSR</code> settings. [[Subnormal number|Subnormal]] values are processed at full speed by hardware to facilitate using the full dynamic range of the FP16 numbers. Instructions that create FP32 and FP64 numbers still respect the <code>MXCSR.FTZ</code> bit.<ref name="intel-avx512-fp16-arch">{{cite web |url=https://software.intel.com/content/dam/develop/external/us/en/documents-tps/intel-avx512-fp16.pdf|title=Intel® AVX512-FP16 Architecture Specification, June 2021, Revision 1.0, Ref. 347407-001US|publisher=Intel|date=2021-06-30|access-date=2021-07-04}}</ref>

====Arithmetic instructions====
{| class="wikitable"
|-
! scope="col" | Instruction
! scope="col" | Description
|-
| <code>VADDPH</code>, <code>VADDSH</code>
| Add packed/scalar FP16 numbers.
|-
| <code>VSUBPH</code>, <code>VSUBSH</code>
| Subtract packed/scalar FP16 numbers.
|-
| <code>VMULPH</code>, <code>VMULSH</code>
| Multiply packed/scalar FP16 numbers.
|-
| <code>VDIVPH</code>, <code>VDIVSH</code>
| Divide packed/scalar FP16 numbers.
|-
| <code>VSQRTPH</code>, <code>VSQRTSH</code>
| Compute square root of packed/scalar FP16 numbers.
|-
| <code>VFMADD{132, 213, 231}PH</code>, <code>VFMADD{132, 213, 231}SH</code>
| Multiply-add packed/scalar FP16 numbers.
|-
| <code>VFNMADD{132, 213, 231}PH</code>, <code>VFNMADD{132, 213, 231}SH</code>
| Negated multiply-add packed/scalar FP16 numbers.
|-
| <code>VFMSUB{132, 213, 231}PH</code>, <code>VFMSUB{132, 213, 231}SH</code>
| Multiply-subtract packed/scalar FP16 numbers.
|-
| <code>VFNMSUB{132, 213, 231}PH</code>, <code>VFNMSUB{132, 213, 231}SH</code>
| Negated multiply-subtract packed/scalar FP16 numbers.
|-
| <code>VFMADDSUB{132, 213, 231}PH</code>
| Multiply-add (odd vector elements) or multiply-subtract (even vector elements) packed FP16 numbers.
|-
| <code>VFMSUBADD{132, 213, 231}PH</code>
| Multiply-subtract (odd vector elements) or multiply-add (even vector elements) packed FP16 numbers.
|-
| <code>VREDUCEPH</code>, <code>VREDUCESH</code>
| Perform reduction transformation of the packed/scalar FP16 numbers.
|-
| <code>VRNDSCALEPH</code>, <code>VRNDSCALESH</code>
| Round packed/scalar FP16 numbers to a given number of fraction bits.
|-
| <code>VSCALEFPH</code>, <code>VSCALEFSH</code>
| Scale packed/scalar FP16 numbers by multiplying it by a power of two.
|}

====Complex arithmetic instructions====
{| class="wikitable"
|-
! scope="col" | Instruction
! scope="col" | Description
|-
| <code>VFMULCPH</code>, <code>VFMULCSH</code>
| Multiply packed/scalar complex FP16 numbers.
|-
| <code>VFCMULCPH</code>, <code>VFCMULCSH</code>
| Multiply packed/scalar complex FP16 numbers. Complex conjugate form of the operation.
|-
| <code>VFMADDCPH</code>, <code>VFMADDCSH</code>
| Multiply-add packed/scalar complex FP16 numbers.
|-
| <code>VFCMADDCPH</code>, <code>VFCMADDCSH</code>
| Multiply-add packed/scalar complex FP16 numbers. Complex conjugate form of the operation.
|}

====Approximate reciprocal instructions====
{| class="wikitable"
|-
! scope="col" | Instruction
! scope="col" | Description
|-
| <code>VRCPPH</code>, <code>VRCPSH</code>
| Compute approximate reciprocal of the packed/scalar FP16 numbers. The maximum relative error of the approximation is less than 2<sup>−11</sup>+2<sup>−14</sup>.
|-
| <code>VRSQRTPH</code>, <code>VRSQRTSH</code>
| Compute approximate reciprocal square root of the packed/scalar FP16 numbers. The maximum relative error of the approximation is less than 2<sup>−14</sup>.
|}

====Comparison instructions====
{| class="wikitable"
|-
! scope="col" | Instruction
! scope="col" | Description
|-
| <code>VCMPPH</code>, <code>VCMPSH</code>
| Compare the packed/scalar FP16 numbers and store the result in a mask register.
|-
| <code>VCOMISH</code>
| Compare the scalar FP16 numbers and store the result in the flags register. Signals an exception if a source operand is QNaN or SNaN.
|-
| <code>VUCOMISH</code>
| Compare the scalar FP16 numbers and store the result in the flags register. Signals an exception only if a source operand is SNaN.
|-
| <code>VMAXPH</code>, <code>VMAXSH</code>
| Select the maximum of each vertical pair of the source packed/scalar FP16 numbers.
|-
| <code>VMINPH</code>, <code>VMINSH</code>
| Select the minimum of each vertical pair of the source packed/scalar FP16 numbers.
|-
| <code>VFPCLASSPH</code>, <code>VFPCLASSSH</code>
| Test packed/scalar FP16 numbers for special categories (NaN, infinity, negative zero, etc.) and store the result in a mask register.
|}

====Conversion instructions====
{| class="wikitable"
|-
! scope="col" | Instruction
! scope="col" | Description
|-
| <code>VCVTW2PH</code>
| Convert packed signed 16-bit integers to FP16 numbers.
|-
| <code>VCVTUW2PH</code>
| Convert packed unsigned 16-bit integers to FP16 numbers.
|-
| <code>VCVTDQ2PH</code>
| Convert packed signed 32-bit integers to FP16 numbers.
|-
| <code>VCVTUDQ2PH</code>
| Convert packed unsigned 32-bit integers to FP16 numbers.
|-
| <code>VCVTQQ2PH</code>
| Convert packed signed 64-bit integers to FP16 numbers.
|-
| <code>VCVTUQQ2PH</code>
| Convert packed unsigned 64-bit integers to FP16 numbers.
|-
| <code>VCVTPS2PHX</code>
| Convert packed FP32 numbers to FP16 numbers. Unlike <code>VCVTPS2PH</code> from [[F16C]], <code>VCVTPS2PHX</code> has a different encoding that also supports broadcasting.
|-
| <code>VCVTPD2PH</code>
| Convert packed FP64 numbers to FP16 numbers.
|-
| <code>VCVTSI2SH</code>
| Convert a scalar signed 32-bit or 64-bit integer to FP16 number.
|-
| <code>VCVTUSI2SH</code>
| Convert a scalar unsigned 32-bit or 64-bit integer to FP16 number.
|-
| <code>VCVTSS2SH</code>
| Convert a scalar FP32 number to FP16 number.
|-
| <code>VCVTSD2SH</code>
| Convert a scalar FP64 number to FP16 number.
|-
| <code>VCVTPH2W</code>, <code>VCVTTPH2W</code>
| Convert packed FP16 numbers to signed 16-bit integers. <code>VCVTPH2W</code> rounds the value according to the <code>MXCSR</code> register. <code>VCVTTPH2W</code> rounds toward zero.
|-
| <code>VCVTPH2UW</code>, <code>VCVTTPH2UW</code>
| Convert packed FP16 numbers to unsigned 16-bit integers. <code>VCVTPH2UW</code> rounds the value according to the <code>MXCSR</code> register. <code>VCVTTPH2UW</code> rounds toward zero.
|-
| <code>VCVTPH2DQ</code>, <code>VCVTTPH2DQ</code>
| Convert packed FP16 numbers to signed 32-bit integers. <code>VCVTPH2DQ</code> rounds the value according to the <code>MXCSR</code> register. <code>VCVTTPH2DQ</code> rounds toward zero.
|-
| <code>VCVTPH2UDQ</code>, <code>VCVTTPH2UDQ</code>
| Convert packed FP16 numbers to unsigned 32-bit integers. <code>VCVTPH2UDQ</code> rounds the value according to the <code>MXCSR</code> register. <code>VCVTTPH2UDQ</code> rounds toward zero.
|-
| <code>VCVTPH2QQ</code>, <code>VCVTTPH2QQ</code>
| Convert packed FP16 numbers to signed 64-bit integers. <code>VCVTPH2QQ</code> rounds the value according to the <code>MXCSR</code> register. <code>VCVTTPH2QQ</code> rounds toward zero.
|-
| <code>VCVTPH2UQQ</code>, <code>VCVTTPH2UQQ</code>
| Convert packed FP16 numbers to unsigned 64-bit integers. <code>VCVTPH2UQQ</code> rounds the value according to the <code>MXCSR</code> register. <code>VCVTTPH2UQQ</code> rounds toward zero.
|-
| <code>VCVTPH2PSX</code>
| Convert packed FP16 numbers to FP32 numbers. Unlike <code>VCVTPH2PS</code> from [[F16C]], <code>VCVTPH2PSX</code> has a different encoding that also supports broadcasting.
|-
| <code>VCVTPH2PD</code>
| Convert packed FP16 numbers to FP64 numbers.
|-
| <code>VCVTSH2SI</code>, <code>VCVTTSH2SI</code>
| Convert a scalar FP16 number to signed 32-bit or 64-bit integer. <code>VCVTSH2SI</code> rounds the value according to the <code>MXCSR</code> register. <code>VCVTTSH2SI</code> rounds toward zero.
|-
| <code>VCVTSH2USI</code>, <code>VCVTTSH2USI</code>
| Convert a scalar FP16 number to unsigned 32-bit or 64-bit integer. <code>VCVTSH2USI</code> rounds the value according to the <code>MXCSR</code> register. <code>VCVTTSH2USI</code> rounds toward zero.
|-
| <code>VCVTSH2SS</code>
| Convert a scalar FP16 number to FP32 number.
|-
| <code>VCVTSH2SD</code>
| Convert a scalar FP16 number to FP64 number.
|}

====Decomposition instructions====
{| class="wikitable"
|-
! scope="col" | Instruction
! scope="col" | Description
|-
| <code>VGETEXPPH</code>, <code>VGETEXPSH</code>
| Extract exponent components of packed/scalar FP16 numbers as FP16 numbers.
|-
| <code>VGETMANTPH</code>, <code>VGETMANTSH</code>
| Extract [[Significand|mantissa]] components of packed/scalar FP16 numbers as FP16 numbers.
|}

====Move instructions====
{| class="wikitable"
|-
! scope="col" | Instruction
! scope="col" | Description
|-
| <code>VMOVSH</code>
| Move scalar FP16 number to/from memory or between vector registers.
|-
| <code>VMOVW</code>
| Move scalar FP16 number to/from memory or general purpose register.
|}

==Legacy instructions with EVEX-encoded versions==
{| class="wikitable sortable plainrowheaders"
|-
! scope="col" rowspan="3" | Group
! scope="col" colspan="3" | Legacy encoding
! scope="col" rowspan="3" class="unsortable" | Instructions
! scope="col" colspan="4" | AVX-512<br />extensions
|-
! scope="col" | SSE<br />SSE2 <br />MMX
! scope="col" | AVX<br />SSE3<br />SSE4
! scope="col" | AVX2<br />[[FMA instruction set|FMA]]
! scope="col" | F
! scope="col" | VL
! scope="col" | BW
! scope="col" | DQ
|-
! scope="row" | VADD
| rowspan="16" {{yes}}
| rowspan="16" {{yes}}
| rowspan="16" {{no}}
| <code>VADDPD</code>, <code>VADDPS</code>, <code>VADDSD</code>, <code>VADDSS</code>
| {{yes|Y}} || rowspan=2 {{yes|Y}} || rowspan=8 {{no|N}} || {{no|N}}
|-
! scope="row" | VAND
| <code>VANDPD</code>, <code>VANDPS</code>, <code>VANDNPD</code>, <code>VANDNPS</code>
| {{no|N}} || {{yes|Y}}
|-
! scope="row" | VCMP
| <code>VCMPPD</code>, <code>VCMPPS</code>, <code>VCMPSD</code>, <code>VCMPSS</code>
| rowspan=13 {{yes|Y}} || rowspan=2 {{no|N}} || rowspan=8 {{no|N}}
|-
! scope="row" | VCOM
| <code>VCOMISD</code>, <code>VCOMISS</code>
|-
! scope="row" | VDIV
| <code>VDIVPD</code>, <code>VDIVPS</code>, <code>VDIVSD</code>, <code>VDIVSS</code>
| rowspan=3 {{yes|Y}}
|-
! scope="row" | VCVT 
| <code>VCVTDQ2PD</code>, <code>VCVTDQ2PS</code>, <code>VCVTPD2DQ</code>, <code>VCVTPD2PS</code>, <code>VCVTPH2PS</code>, <code>VCVTPS2PH</code>, <code>VCVTPS2DQ</code>, <code>VCVTPS2PD</code>, <code>VCVTSD2SI</code>, <code>VCVTSD2SS</code>, <code>VCVTSI2SD</code>, <code>VCVTSI2SS</code>, <code>VCVTSS2SD</code>, <code>VCVTSS2SI</code>, <code>VCVTTPD2DQ</code>, <code>VCVTTPS2DQ</code>, <code>VCVTTSD2SI</code>, <code>VCVTTSS2SI</code> 
|-
! scope="row" | VMAX 
| <code>VMAXPD</code>, <code>VMAXPS</code>, <code>VMAXSD</code>, <code>VMAXSS</code>
|-
! scope="row" | VMIN
| <code>VMINPD</code>, <code>VMINPS</code>, <code>VMINSD</code>, <code>VMINSS</code>
| {{no|N}}
|-
! scope="row" | VMOV
| <code>VMOVAPD</code>, <code>VMOVAPS</code>, <code>VMOVD</code>, <code>VMOVQ</code>, <code>VMOVDDUP</code>, <code>VMOVHLPS</code>, <code>VMOVHPD</code>, <code>VMOVHPS</code>, <code>VMOVLHPS</code>, <code>VMOVLPD</code>, <code>VMOVLPS</code>, <code>VMOVNTDQA</code>, <code>VMOVNTDQ</code>, <code>VMOVNTPD</code>, <code>VMOVNTPS</code>, <code>VMOVSD</code>, <code>VMOVSHDUP</code>, <code>VMOVSLDUP</code>, <code>VMOVSS</code>, <code>VMOVUPD</code>, <code>VMOVUPS</code>, <code>VMOVDQA32</code>, <code>VMOVDQA64</code>, <code>VMOVDQU8</code>, <code>VMOVDQU16</code>, <code>VMOVDQU32</code>, <code>VMOVDQU64</code>
| rowspan=2 {{yes|Y}} || {{yes|Y}}
|-
! scope="row" | VMUL
| <code>VMULPD</code>, <code>VMULPS</code>, <code>VMULSD</code>, <code>VMULSS</code>
| rowspan=9 {{no|N}}
|-
! scope="row" | VOR
| <code>VORPD</code>, <code>VORPS</code>
| {{no|N}} || {{yes|Y}}
|-
! scope="row" | VSQRT
| <code>VSQRTPD</code>, <code>VSQRTPS</code>, <code>VSQRTSD</code>, <code>VSQRTSS</code>
| rowspan=2 {{yes|Y}} || rowspan=4 {{no|N}}
|-
! scope="row" | VSUB 
| <code>VSUBPD</code>, <code>VSUBPS</code>, <code>VSUBSD</code>, <code>VSUBSS</code>
|-
! scope="row" | VUCOMI
| <code>VUCOMISD</code>, <code>VUCOMISS</code>
| {{no|N}}
|-
! scope="row" | VUNPCK
| <code>VUNPCKHPD</code>, <code>VUNPCKHPS</code>, <code>VUNPCKLPD</code>, <code>VUNPCKLPS</code>
| rowspan=2 {{yes|Y}}
|-
! scope="row" | VXOR
| <code>VXORPD</code>, <code>VXORPS</code>
| {{no|N}} || {{yes|Y}}
|-
! scope="row" | VEXTRACTPS 
| rowspan="4" {{no}}
| rowspan="4" {{yes}}
| rowspan="4" {{no}}
| <code>VEXTRACTPS</code>
| rowspan=2 {{yes|Y}} || rowspan=4 {{no|N}} || rowspan=2 {{no|N}}
|-
! scope="row" | VINSERTPS
| <code>VINSERTPS</code>
|-
! scope="row" | VPEXTR
| <code>VPEXTRB</code>, <code>VPEXTRW</code>, <code>VPEXTRD</code>, <code>VPEXTRQ</code>
| rowspan=3 {{no|N}} || rowspan=4 {{yes|Y}} || rowspan=2 {{yes|Y}}
|-
! scope="row" | VPINSR
| <code>VPINSRB</code>, <code>VPINSRW</code>, <code>VPINSRD</code>, <code>VPINSRQ</code>
|-
! scope="row" | VPACK 
| rowspan="15" {{yes}}
| rowspan="15" {{yes}}
| rowspan="15" {{yes}}
| <code>VPACKSSWB</code>, <code>VPACKSSDW</code>, <code>VPACKUSDW</code>, <code>VPACKUSWB</code>
| rowspan=30 {{yes|Y}} || rowspan=15 {{no|N}}
|-
! scope="row" | VPADD 
| <code>VPADDB</code>, <code>VPADDW</code>, <code>VPADDD</code>, <code>VPADDQ</code>, <code>VPADDSB</code>, <code>VPADDSW</code>, <code>VPADDUSB</code>, <code>VPADDUSW</code>
| rowspan=2 {{yes|Y}}
|-
! scope="row" | VPAND 
| <code>VPANDD</code>, <code>VPANDQ</code>, <code>VPANDND</code>, <code>VPANDNQ</code>
| {{no|N}}
|-
! scope="row" | VPAVG 
| <code>VPAVGB</code>, <code>VPAVGW</code>
| {{no|N}} || rowspan=6 {{yes|Y}}
|-
! scope="row" | VPCMP 
| <code>VPCMPEQB</code>, <code>VPCMPEQW</code>, <code>VPCMPEQD</code>, <code>VPCMPEQQ</code>, <code>VPCMPGTB</code>, <code>VPCMPGTW</code>, <code>VPCMPGTD</code>, <code>VPCMPGTQ</code>
| rowspan=9 {{yes|Y}}
|-
! scope="row" | VPMAX 
| <code>VPMAXSB</code>, <code>VPMAXSW</code>, <code>VPMAXSD</code>, <code>VPMAXSQ</code>, <code>VPMAXUB</code>, <code>VPMAXUW</code>, <code>VPMAXUD</code>, <code>VPMAXUQ</code>
|-
! scope="row" | VPMIN 
| <code>VPMINSB</code>, <code>VPMINSW</code>, <code>VPMINSD</code>, <code>VPMINSQ</code>, <code>VPMINUB</code>, <code>VPMINUW</code>, <code>VPMINUD</code>, <code>VPMINUQ</code>
|-
! scope="row" | VPMOV 
| <code>VPMOVSXBW</code>, <code>VPMOVSXBD</code>, <code>VPMOVSXBQ</code>, <code>VPMOVSXWD</code>, <code>VPMOVSXWQ</code>, <code>VPMOVSXDQ</code>, <code>VPMOVZXBW</code>, <code>VPMOVZXBD</code>, <code>VPMOVZXBQ</code>, <code>VPMOVZXWD</code>, <code>VPMOVZXWQ</code>, <code>VPMOVZXDQ</code>
|-
! scope="row" | VPMUL 
| <code>VPMULDQ</code>, <code>VPMULUDQ</code>, <code>VPMULHRSW</code>, <code>VPMULHUW</code>, <code>VPMULHW</code>, <code>VPMULLD</code>, <code>VPMULLQ</code>, <code>VPMULLW</code>
|-
! scope="row" | VPOR 
| <code>VPORD</code>, <code>VPORQ</code>
| {{no|N}}
|-
! scope="row" | VPSUB 
| <code>VPSUBB</code>, <code>VPSUBW</code>, <code>VPSUBD</code>, <code>VPSUBQ</code>, <code>VPSUBSB</code>, <code>VPSUBSW</code>, <code>VPSUBUSB</code>, <code>VPSUBUSW</code>
| rowspan=2 {{yes|Y}}
|-
! scope="row" | VPUNPCK 
| <code>VPUNPCKHBW</code>, <code>VPUNPCKHWD</code>, <code>VPUNPCKHDQ</code>, <code>VPUNPCKHQDQ</code>, <code>VPUNPCKLBW</code>, <code>VPUNPCKLWD</code>, <code>VPUNPCKLDQ</code>, <code>VPUNPCKLQDQ</code>
|-
! scope="row" | VPXOR
| <code>VPXORD</code>, <code>VPXORQ</code>
| {{no|N}}
|-
! scope="row" | VPSADBW 
| <code>VPSADBW</code>
| {{no|N}} || rowspan=2 {{yes|Y}}
|-
! scope="row" | VPSHUF
| <code>VPSHUFB</code>, <code>VPSHUFHW</code>, <code>VPSHUFLW</code>, <code>VPSHUFD</code>, <code>VPSLLDQ</code>, <code>VPSLLW</code>, <code>VPSLLD</code>, <code>VPSLLQ</code>, <code>VPSRAW</code>, <code>VPSRAD</code>, <code>VPSRAQ</code>, <code>VPSRLDQ</code>, <code>VPSRLW</code>, <code>VPSRLD</code>, <code>VPSRLQ</code>, <code>VPSLLVW</code>, <code>VPSLLVD</code>, <code>VPSLLVQ</code>, <code>VPSRLVW</code>, <code>VPSRLVD</code>, <code>VPSRLVQ</code>, <code>VPSHUFPD</code>, <code>VPSHUFPS</code>
| rowspan=4 {{yes|Y}}
|-
! scope="row" | VEXTRACT
| rowspan="6" {{no}}
| rowspan="6" {{yes}}
| rowspan="6" {{yes}}
| <code>VEXTRACTF32X4</code>, <code>VEXTRACTF64X2</code>, <code>VEXTRACTF32X8</code>, <code>VEXTRACTF64X4</code>, <code>VEXTRACTI32X4</code>, <code>VEXTRACTI64X2</code>, <code>VEXTRACTI32X8</code>, <code>VEXTRACTI64X4</code>
| rowspan=2 {{no|N}} || rowspan=2 {{yes|Y}}
|-
! scope="row" | VINSERT
| <code>VINSERTF32x4</code>, <code>VINSERTF64X2</code>, <code>VINSERTF32X8</code>, <code> VINSERTF64x4</code>, <code>VINSERTI32X4</code>, <code>VINSERTI64X2</code>, <code>VINSERTI32X8</code>, <code>VINSERTI64X4</code>
|-
! scope="row" | VPABS 
| <code>VPABSB</code>, <code>VPABSW</code>, <code>VPABSD</code>, <code>VPABSQ</code>
| rowspan=2 {{yes|Y}} || rowspan=13 {{no|N}}
|-
! scope="row" | VPALIGNR
| <code>VPALIGNR</code>
| {{no|N}}
|-
! scope="row" | VPERM
| <code>VPERMD</code>, <code>VPERMILPD</code>, <code>VPERMILPS</code>, <code>VPERMPD</code>, <code>VPERMPS</code>, <code>VPERMQ</code>
| {{yes|Y}} || {{no|N}}
|-
! scope="row" | VPMADD 
| <code>VPMADDUBSW</code> <code>VPMADDWD</code>
| {{no|N}} || {{yes|Y}}
|-
! scope="row" | VFMADD 
| rowspan="9" {{no}}
| rowspan="9" {{no}}
| rowspan="9" {{yes}}
| <code>VFMADD132PD</code>, <code>VFMADD213PD</code>, <code>VFMADD231PD</code>, <code>VFMADD132PS</code>, <code>VFMADD213PS</code>, <code>VFMADD231PS</code>, <code>VFMADD132SD</code>, <code>VFMADD213SD</code>, <code>VFMADD231SD</code>, <code>VFMADD132SS</code>, <code>VFMADD213SS</code>, <code>VFMADD231SS</code>
| rowspan=9 {{yes|Y}} || rowspan=8 {{no|N}}
|-
! scope="row" | VFMADDSUB
| <code>VFMADDSUB132PD</code>, <code>VFMADDSUB213PD</code>, <code>VFMADDSUB231PD</code>, <code>VFMADDSUB132PS</code>, <code>VFMADDSUB213PS</code>, <code>VFMADDSUB231PS</code>
|-
! scope="row" | VFMSUBADD 
| <code>VFMSUBADD132PD</code>, <code>VFMSUBADD213PD</code>, <code>VFMSUBADD231PD</code>, <code>VFMSUBADD132PS</code>, <code>VFMSUBADD213PS</code>, <code>VFMSUBADD231PS</code>
|-
! scope="row" | VFMSUB
| <code>VFMSUB132PD</code>, <code>VFMSUB213PD</code>, <code>VFMSUB231PD</code>, <code>VFMSUB132PS</code>, <code>VFMSUB213PS</code>, <code>VFMSUB231PS</code>, <code>VFMSUB132SD</code>, <code>VFMSUB213SD</code>, <code>VFMSUB231SD</code>, <code>VFMSUB132SS</code>, <code>VFMSUB213SS</code>, <code>VFMSUB231SS</code>
|-
! scope="row" | VFNMADD
| <code>VFNMADD132PD</code>, <code>VFNMADD213PD</code>, <code>VFNMADD231PD</code>, <code>VFNMADD132PS</code>, <code>VFNMADD213PS</code>, <code>VFNMADD231PS</code>, <code>VFNMADD132SD</code>, <code>VFNMADD213SD</code>, <code>VFNMADD231SD</code>, <code>VFNMADD132SS</code>, <code>VFNMADD213SS</code>, <code>VFNMADD231SS</code>
|-
! scope="row" | VFNMSUB
| <code>VFNMSUB132PD</code>, <code>VFNMSUB213PD</code>, <code>VFNMSUB231PD</code>, <code>VFNMSUB132PS</code>, <code>VFNMSUB213PS</code>, <code>VFNMSUB231PS</code>, <code>VFNMSUB132SD</code>, <code>VFNMSUB213SD</code>, <code>VFNMSUB231SD</code>, <code>VFNMSUB132SS</code>, <code>VFNMSUB213SS</code>, <code>VFNMSUB231SS</code>
|-
! scope="row" | VGATHER
| <code>VGATHERDPS</code>, <code>VGATHERDPD</code>, <code>VGATHERQPS</code>, <code>VGATHERQPD</code>
|-
! scope="row" | VPGATHER
| <code>VPGATHERDD</code>, <code>VPGATHERDQ</code>, <code>VPGATHERQD</code>, <code>VPGATHERQQ</code>
|-
! scope="row" | VPSRAV
| <code>VPSRAVW</code>, <code>VPSRAVD</code>, <code>VPSRAVQ</code>
| {{yes|Y}}
|}

==CPUs with AVX-512==
* Intel
** [[Engineering:Xeon Phi#Knights Landing|Knights Landing]] (Xeon Phi x200):<ref name="reinders512"/><ref>{{cite web |url=https://www.intel.com/content/www/us/en/processors/xeon/xeon-phi-processor-product-brief.html |title=Intel Xeon Phi Processor product brief |publisher=Intel |access-date=12 October 2016}}</ref> AVX-512 F, CD, ER, PF
** [[Engineering:Xeon Phi#Knights Mill|Knights Mill]] (Xeon Phi x205):<ref name="iaiseaffpr">{{cite web |url=https://software.intel.com/en-us/intel-architecture-instruction-set-extensions-programming-reference |title=Intel Architecture Instruction Set Extensions and Future Features Programming Reference |access-date=2017-10-16 |publisher=Intel}}</ref> AVX-512 F, CD, ER, PF, 4FMAPS, 4VNNIW, VPOPCNTDQ
** [[Skylake (microarchitecture)#Skylake-SP (14 nm) Scalable Performance|Skylake-SP]], [[Skylake (microarchitecture)#Mainstream desktop processors|Skylake-X]]:<ref>{{cite news |url=https://arstechnica.com/gadgets/2017/05/intels-new-high-end-desktop-platform-up-to-18-cores-36-threads-2000/ |title=Intel unveils X-series platform: Up to 18 cores and 36 threads, from $242 to $2,000 |work=Ars Technica |access-date=2017-05-30 |language=en-us}}</ref><ref>{{cite web |url=https://gcc.gnu.org/wiki/cauldron2014?action=AttachFile&do=get&target=Cauldron14_AVX-512_Vector_ISA_Kirill_Yukhin_20140711.pdf |title=Intel Advanced Vector Extensions 2015/2016: Support in GNU Compiler Collection |website=Gcc.gnu.org |access-date=2016-10-20}}</ref><ref>{{cite web |url=https://www.itworld.com/article/2985214/hardware/intels-xeon-roadmap-for-2016-leaks.html |title=Intel's Xeon roadmap for 2016 leaks |first=Andy |last=Patrizio |website=Itworld.org |date=21 September 2015 |access-date=2016-10-20}}</ref> AVX-512 F, CD, VL, DQ, BW
** Cannon Lake:<ref name="iaiseaffpr"/> AVX-512 F, CD, VL, DQ, BW, IFMA, VBMI
** [[Cascade Lake (microarchitecture)|Cascade Lake]]: AVX-512 F, CD, VL, DQ, BW, VNNI
** Cooper Lake: AVX-512 F, CD, VL, DQ, BW, VNNI, BF16
** [[Ice Lake (microarchitecture)|Ice Lake]],<ref name="iaiseaffpr"/> [[Engineering:Rocket Lake|Rocket Lake]]:<ref>{{cite web |url=https://www.techpowerup.com/review/intel-core-i9-11900k/3.html#avx-512 |title=Intel Core i9-11900K Review - World's Fastest Gaming Processor? |website=www.techpowerup.com|date=30 March 2021 }}</ref><ref>{{cite web |url=https://gcc.gnu.org/git/?p=gcc.git;a=commitdiff;h=c02c39fad02c386f6e687e28282973f580fc95ac |title="Add rocketlake to gcc" commit |website=gcc.gnu.org}}</ref> AVX-512 F, CD, VL, DQ, BW, IFMA, VBMI, VBMI2, VPOPCNTDQ, BITALG, VNNI, VPCLMULQDQ, GFNI, VAES
** [[Tiger Lake (microarchitecture)|Tiger Lake]] (except Pentium and Celeron but some reviewer have the CPU-Z Screenshot of Celeron 6305 with AVX-512 support<ref>{{cite web |title=Intel Celeron 6305 Processor (4M Cache, 1.80 GHz, with IPU) Product Specifications |url=https://ark.intel.com/content/www/us/en/ark/products/208646/intel-celeron-6305-processor-4m-cache-1-80-ghz-with-ipu.html |url-status=live |access-date=2020-11-10 |website=ark.intel.com |language=en|archive-url=https://web.archive.org/web/20201018025359/https://ark.intel.com/content/www/us/en/ark/products/208646/intel-celeron-6305-processor-4m-cache-1-80-ghz-with-ipu.html |archive-date=2020-10-18 }}</ref><ref>{{Citation |title=Laptop Murah Kinerja Boleh Diadu {{!}} HP 14S DQ2518TU |url=https://www.youtube.com/watch?v=q0HvFnvjyb0&t=119s |language=en |access-date=2021-08-08}}</ref>):<ref name="gcc">{{cite web |url=https://gcc.gnu.org/onlinedocs/gcc/x86-Options.html |title=Using the GNU Compiler Collection (GCC): x86 Options |access-date=2019-10-14 |publisher=GNU}}</ref> AVX-512 F, CD, VL, DQ, BW, IFMA, VBMI, VBMI2, VPOPCNTDQ, BITALG, VNNI, VPCLMULQDQ, GFNI, VAES, VP2INTERSECT
** [[Engineering:Alder Lake|Alder Lake]] (never officially supported by Intel, completely removed in newer CPUs{{ref|adl-avx512-note|Note 1}}):<ref name='anandalderreview'>{{cite web|first1=Ian|last1=Cutress|first2=Andrei|last2=Frumusanu|title=The Intel 12th Gen Core i9-12900K Review: Hybrid Performance Brings Hybrid Complexity |url=https://www.anandtech.com/show/17047/the-intel-12th-gen-core-i912900k-review-hybrid-performance-brings-hybrid-complexity/2 |website=www.anandtech.com |access-date=5 November 2021}}</ref><ref>{{cite web|url=https://www.phoronix.com/scan.php?page=article&item=alder-lake-avx512&num=1|title=Intel Core i9 12900K "Alder Lake" AVX-512 On Linux|website=www.phoronix.com|first1=Michael|last1=Larabel|access-date=2021-11-08}}</ref> AVX-512 F, CD, VL, DQ, BW, IFMA, VBMI, VBMI2, VPOPCNTDQ, BITALG, VNNI, VPCLMULQDQ, GFNI, VAES, BF16, VP2INTERSECT, FP16
** Sapphire Rapids:<ref>{{cite web|url=https://www.phoronix.com/review/intel-sapphirerapids-avx512|title=AVX-512 Performance Comparison: AMD Genoa vs. Intel Sapphire Rapids & Ice Lake|website=www.phoronix.com|first1=Michael|last1=Larabel|access-date=2023-01-19}}</ref> AVX-512 F, CD, VL, DQ, BW, IFMA, VBMI, VBMI2, VPOPCNTDQ, BITALG, VNNI, VPCLMULQDQ, GFNI, VAES, BF16, FP16
* [[Company:Centaur Technology|Centaur Technology]]
** "CNS" core (8c/8t):<ref>{{cite web | url=https://centtech.com/ai-technology/ | archive-url=https://web.archive.org/web/20191212134128/https://centtech.com/ai-technology/ | url-status=usurped | archive-date=December 12, 2019 | title=The industry's first high-performance x86 SOC with server-class CPUs and integrated AI coprocessor technology | date=2 August 2022 }}</ref><ref name="instlatx64">{{cite web |title=x86, x64 Instruction Latency, Memory Latency and CPUID dumps (instlatx64) |url=http://users.atw.hu/instlatx64/ |website=users.atw.hu}}</ref> AVX-512 F, CD, VL, DQ, BW, IFMA, VBMI
* [[Engineering:AMD|AMD]]
** [[Engineering:Zen 4|Zen 4]]:<ref>{{cite web|date=2021-05-23|title=AMD Zen 4 Based Ryzen CPUs May Feature Up to 24 Cores, Support for AVX512 Vectors|url=https://www.hardwaretimes.com/amd-zen-4-based-ryzen-cpus-may-feature-up-to-24-cores-support-for-avx512-vectors/|access-date=2021-09-02|website=Hardware Times|language=en-US}}</ref><ref name="Hagedoorn">{{cite web |last=Hagedoorn |first=Hilbert |title=AMD working on a prodigious 96-core EPYC processor |url=https://www.guru3d.com/news-story/amd-working-on-prodigious-96-core-epyc-processor.html |access-date=2021-05-25 |website=Guru3D.com |date=18 May 2021 |language=en-us}}</ref><ref>{{cite web|title=Details on the Gigabyte Leak|author=clamchowder|url=https://chipsandcheese.com/2021/08/23/details-on-the-gigabyte-leak/|date=2021-08-23|access-date=2022-06-10|website=Chips And Cheese|language=en-us}}</ref><ref>{{cite web|title=AMD Answers Our Zen 4 Tech Questions, with Robert Hallock|author=((W1zzard))|url=https://www.techpowerup.com/review/amd-zen-4-ryzen-7000-technical-details/|access-date=2022-05-29|website=TechPowerUp|date=26 May 2022 |language=en-us}}</ref><ref>{{cite web|first=Michael|last=Larabel|title=AMD Zen 4 AVX-512 Performance Analysis On The Ryzen 9 7950X|url=https://www.phoronix.com/review/amd-zen4-avx512|website=www.phoronix.com|date=2022-09-26}}</ref> AVX-512 F, CD, VL, DQ, BW, IFMA, VBMI, VBMI2, VPOPCNTDQ, BITALG, VNNI, VPCLMULQDQ, GFNI, VAES, BF16

<div style="overflow-x: scroll">
{| class="wikitable"
! Subset
! F
! CD
! ER
! PF
! 4FMAPS
! 4VNNIW
! VPOPCNTDQ
! VL
! DQ
! BW
! IFMA
! VBMI
! VNNI
! BF16
! VBMI2
! BITALG
! VPCLMULQDQ
! GFNI
! VAES
! VP2INTERSECT
! FP16
|-
| [[Engineering:Xeon Phi#Knights Landing|Knights Landing]] (Xeon Phi x200, 2016)
| colspan="2" rowspan="9" {{Yes}}
| colspan="2" rowspan="2" {{Yes}}
| colspan="17" {{No}}
|-
| [[Engineering:Xeon Phi#Knights Mill|Knights Mill]] (Xeon Phi x205, 2017)
| colspan="3" {{Yes}}
| colspan="14" {{No}}
|-
| [[Skylake (microarchitecture)#Skylake-SP (14 nm) Scalable Performance|Skylake-SP]], [[Skylake (microarchitecture)#Mainstream desktop processors|Skylake-X]] (2017)
| colspan="4" rowspan="10" {{No}}
| rowspan="4" {{No}}
| colspan="3" rowspan="4" {{Yes}}
| colspan="11" {{No}}
|-
| Cannon Lake (2018)
| colspan="2" {{Yes}}
| colspan="9" {{No}}
|-
| [[Cascade Lake (microarchitecture)|Cascade Lake]] (2019)
| rowspan="2" colspan="2" {{No}}
| rowspan="2" {{Yes}}
| colspan="8" {{No}}
|-
| Cooper Lake (2020)
| {{Yes}}
| colspan="7" {{No}}
|-
| [[Ice Lake (microarchitecture)|Ice Lake]] (2019)
| colspan="7" rowspan="3" {{Yes}}
| rowspan="3" {{No}}
| colspan="5" rowspan="3" {{Yes}}
| colspan="2" {{No}}
|-
| [[Tiger Lake (microarchitecture)|Tiger Lake]] (2020)
| {{Yes}}
| {{No}}
|-
| [[Engineering:Rocket Lake|Rocket Lake]] (2021)
| colspan="2" {{No}}
|-
| [[Engineering:Alder Lake|Alder Lake]] (2021)
| colspan="2" {{Partial|Partial{{ref|adl-avx512-note|Note 1}}}}
| colspan="15" {{Partial|Partial{{ref|adl-avx512-note|Note 1}}}}
|-
| [[Engineering:Zen 4|Zen 4]] (2022)
| colspan="2" rowspan="2" {{Yes}}
| colspan="13" rowspan="2" {{Yes}}
| colspan="2" {{No}}
|-
| Sapphire Rapids (2023)
| {{no}}
| {{Yes}}
|}
</div>

{{note|adl-avx512-note|Note 1}}: Intel does not officially support AVX-512 family of instructions on the [[Engineering:Alder Lake|Alder Lake]] microprocessors. Intel has disabled in silicon (fused off) AVX-512 on recent steppings of Alder Lake microprocessors to prevent customers from enabling AVX-512.<ref>{{cite web |last=Alcorn |first=Paul |date=2022-03-02 |title=Intel Nukes Alder Lake's AVX-512 Support, Now Fuses It Off in Silicon |url=https://www.tomshardware.com/news/intel-nukes-alder-lake-avx-512-now-fuses-it-off-in-silicon |access-date=2022-03-07 |website=Tom's Hardware |language=en}}</ref>
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.<ref>{{cite web|url=https://www.anandtech.com/show/16881/a-deep-dive-into-intels-alder-lake-microarchitectures/5|title=Intel Architecture Day 2021: Alder Lake, Golden Cove, and Gracemont Detailed|date=2021-08-19|last1=Cutress|first1=Ian|last2=Frumusanu|first2=Andrei|website=AnandTech|language=en|access-date=2021-08-25}}</ref><ref>{{cite web|last=Alcorn|first=Paul|date=2021-08-19|title=Intel Architecture Day 2021: Alder Lake Chips, Golden Cove and Gracemont Cores|url=https://www.tomshardware.com/features/intel-architecture-day-2021-intel-unveils-alder-lake-golden-cove-and-gracemont-cores|access-date=2021-08-21|website=Tom's Hardware|language=en}}</ref><ref name='anandalderreview'/>

==Performance==
[[Software:Intel Advisor|Intel Vectorization Advisor]] (starting from version 2017) supports native AVX-512 performance and vector code quality analysis (for "Core", Xeon and Intel Xeon Phi processors). Along with traditional hotspots profile, Advisor Recommendations and "seamless" integration of Intel Compiler vectorization diagnostics, Advisor Survey analysis also provides AVX-512 ISA metrics and new AVX-512-specific "traits", e.g. Scatter, Compress/Expand, mask utilization.<ref>{{cite web|url=https://software.intel.com/en-us/articles/intel-advisor-xe-2016-update-3-what-s-new|title=Intel Advisor XE 2016 Update 3 What's new - Intel Software|website=Software.intel.com|access-date=2016-10-20}}</ref><ref>{{cite web|url=https://software.intel.com/en-us/intel-advisor-xe|title=Intel Advisor - Intel Software|website=Software.intel.com|access-date=2016-10-20}}</ref>

On some processors (mostly pre-[[Engineering:Ice Lake (microprocessor)|Ice Lake]] Intel), AVX-512 instructions can cause a frequency throttling even greater than its predecessors, causing a penalty for mixed workloads. The additional downclocking is triggered by the 512-bit width of vectors and depend on the nature of instructions being executed, and using the 128 or 256-bit part of AVX-512 (AVX-512VL) does not trigger it. As a result, gcc and [[Software:Clang|clang]] default to prefer using the 256-bit vectors for Intel targets.<ref>{{cite web |last1=Cordes |first1=Peter |title=SIMD instructions lowering CPU frequency |url=https://stackoverflow.com/a/56859700 |website=Stack Overflow}}</ref><ref>{{cite web |last1=Cordes |first1=Peter |title=why does gcc auto-vectorization for tigerlake use ymm not zmm registers |url=https://stackoverflow.com/a/74152602/4636534 |website=Stack Overflow}}</ref><ref>{{cite web |title=LLVM 10.0.0 Release Notes |url=https://releases.llvm.org/10.0.0/docs/ReleaseNotes.html#changes-to-the-x86-target}}</ref>

C/[[C++]] compilers also automatically handle [[Loop unrolling|loop unrolling]] and preventing [[Instruction pipelining#Pipeline bubble|stalls in the pipeline]] in order to use AVX-512 most effectively, which means a programmer using language [[Intrinsic function|intrinsics]] to try to force use of AVX-512 can sometimes result in worse performance relative to the code generated by the compiler when it encounters loops plainly written in the source code.<ref>{{cite AV media |people=Matthew Kolbe |date=2023-10-10 |title=Lightning Talk: How to Leverage SIMD Intrinsics for Massive Slowdowns - Matthew Kolbe - CppNow 2023 |url=https://www.youtube.com/watch?v=GleC3SZ8gjU |access-date=2023-10-15| via=YouTube| publisher=C++Now}}</ref> In other cases, using AVX-512 intrinsics in C/C++ code can result in a performance improvement relative to plainly written C/C++.<ref>{{cite arXiv |last=Clausecker |first=Robert |date=2023-08-05 |title=Transcoding Unicode Characters with AVX-512 Instructions |class=cs.DS |eprint=2212.05098 }}</ref>

==Reception==
There are many examples of [[Advanced Vector Extensions#Applications|AVX-512 applications]], including media processing, cryptography, [[Engineering:Video game|video game]]s,<ref>{{cite web |url=https://www.pcgamer.com/the-rpcs3-ps3-emulator-gets-a-hefty-boost-on-intel-alder-lake-cpus-with-avx-512-enabledenabled/ |title=The RPCS3 PS3 emulator gets a hefty boost on Intel Alder Lake CPUs with AVX-512 enabled |last=Szewczyk |first=Chris |date=2021-11-24 |publisher=PC Gamer |access-date=2023-10-11}}</ref> [[Neural network|neural network]]s,<ref>{{cite conference |url=https://ieeexplore.ieee.org/document/9631464 |title=Lightweight Deep Learning Applications on AVX-512 |last1=Carneiro |first1=André |last2=Serpa |first2=Matheus |date=2021-09-05 |publisher=IEEE |book-title=2021 IEEE Symposium on Computers and Communications (ISCC) |pages=1–6 |location=[[Place:Athens|Athens]] |doi=10.1109/ISCC53001.2021.9631464}}</ref> and even [[Software:OpenJDK|OpenJDK]], which employs AVX-512 for [[Sorting algorithm|sorting]].<ref>{{cite web |url=https://bugs.openjdk.org/browse/JDK-8309130 |title=JDK-8309130: x86_64 AVX512 intrinsics for Arrays.sort methods (int, long, float and double arrays) |last=Parasa |first=Srinivas |date=2023-05-30 |publisher=[[Software:OpenJDK|OpenJDK]] |access-date=2023-10-11}}</ref>

In a much-cited quote from 2020, Linus Torvalds said "I hope AVX-512 dies a painful death, and that Intel starts fixing real problems instead of trying to create magic instructions to then create benchmarks that they can look good on,"<ref>{{cite web |url=https://www.zdnet.com/article/linus-torvalds-i-hope-intels-avx-512-dies-a-painful-death/ |title=Linus Torvalds: I hope Intel's AVX-512 dies a painful death |last=Tung |first=Liam |date=2020-07-13 |publisher=ZDNet |access-date=2023-10-11}}</ref> stating that he would prefer the [[Engineering:Transistor count|transistor budget]] be spent on additional [[Multi-core processor|cores]] and integer performance instead, and that he "detests" floating point [[Benchmark (computing)|benchmark]]s.<ref>{{cite web |url=https://www.realworldtech.com/forum/?threadid=193189&curpostid=193190 |title=Alder Lake and AVX-512 |last=Torvalds |first=Linus |date=2020-07-11 |website=realworldtech.com |access-date=2023-10-11}}</ref>

[[Biography:Jeff Hawkins|Numenta]] touts their "highly [[Sparse network|sparse]]"<ref>{{cite web |url=https://www.numenta.com/assets/pdf/research-publications/papers/Sparsity-Enables-100x-Performance-Acceleration-Deep-Learning-Networks.pdf |title=Sparsity Enables 100x Performance Acceleration in Deep Learning Networks: A Technology Demonstration |author=<!--Not stated--> |date=2021-05-20 |website=numenta.com |access-date=2023-10-11}}</ref> neural network technology, which they say obviates the need for GPUs as their algorithms run on CPUs with AVX-512.<ref>{{cite web |url=https://www.techradar.com/pro/a-tiny-startup-has-helped-intel-trounce-amd-and-nvidia-in-critical-ai-tests-is-it-game-over-already |title=A tiny startup has helped Intel trounce AMD and Nvidia in critical AI tests — is it game over already? |last=Afifi-Sabet |first=Keumars |date=2023-10-08 |publisher=[[TechRadar]] |access-date=2023-10-11}}</ref> They claim a ten times [[Speedup|speedup]] relative to [[Engineering:Ampere (microarchitecture)|A100]] largely because their algorithms reduce the size of the neural network, while maintaining [[Accuracy and precision|accuracy]], by techniques such as the Sparse Evolutionary Training (SET) algorithm<ref>{{cite journal |last1=Mocanu |first1=Decebal |last2=Mocanu |first2=Elena |date=2018 |title=Scalable training of artificial neural networks with adaptive sparse connectivity inspired by network science |journal=Nature Communications |volume=9 |issue=1 |pages=2383 |doi=10.1038/s41467-018-04316-3 |pmid=29921910 |pmc=6008460 |bibcode=2018NatCo...9.2383M }}</ref> and Foresight Pruning.<ref>{{cite web |url=https://www.numenta.com/blog/2020/10/30/case-for-sparsity-in-neural-networks-part-2-dynamic-sparsity/ |title=The Case for Sparsity in Neural Networks, Part 2: Dynamic Sparsity |last=Souza |first=Lucas |date=2020-10-30 |website=numenta.com |access-date=2023-10-11}}</ref>

==See also==
* [[FMA instruction set]] (FMA)
* [[XOP instruction set]] (XOP)
* [[AArch64#Scalable Vector Extension (SVE)|Scalable Vector Extension for ARM]] – a new vector instruction set (supplementing VFP and NEON) supporting very wide bit-widths, and single binary code that can adapt automatically to maximum width supported by hardware.

==References==

* {{cite book |last=Kusswurm |first=Daniel |url=https://www.worldcat.org/oclc/1304243196 |title=Modern parallel programming with C++ and Assembly language : X86 SIMD development using AVX, AVX2, and AVX-512 |date=2022 |isbn=978-1-4842-7918-2 |publisher=Apress Media LLC |publication-place=New York, NY |oclc=1304243196}}

{{Reflist}}

{{Multimedia extensions}}

[[Category:X86 instructions]]

de:Advanced Vector Extensions#Erweiterung AVX-512

{{Sourceattribution|AVX-512}}