esp32p4-simd

name: esp32p4-simd description: ESP32-P4 PIE (Processor Instruction Extensions) SIMD instruction set reference and optimization guide. Use when working with ESP32-P4 custom AI/DSP SIMD instructions in assembly orintrinsic form, converting scalar code to vectorized SIMD code, or implementing neural network operators for esp-dl. Covers read/write, data exchange, arithmetic, comparison, bitwise logical, shift, and FFT-dedicated instructions with 128-bit QR vector registers.

ESP32-P4 SIMD (PIE) Instruction Set

Architecture Overview

The ESP32-P4 HP core includes a custom PIE SIMD extension supporting 128-bit vector operations on 8-bit, 16-bit, and 32-bit data elements. It integrates data transfer into arithmetic instructions and supports non-aligned 128-bit vector data access.

Key Features

• 128-bit general-purpose vector registers (8 QR registers)
• 16 x 8-bit multipliers, 8 x 16-bit multipliers
• 256-bit accumulators (QACC_H, QACC_L) + 40-bit accumulator (XACC)
• Fused load-arithmetic and arithmetic-store instructions
• Configurable rounding and saturation modes
• Hardware misaligned access support

Registers

General-Purpose Registers (AR)

Only 16 of 32 RISC-V registers are available for PIE instructions:

Vector Registers (QR)

Eight 128-bit vector registers q0-q7. Each can hold:

• 16 x 8-bit elements
• 8 x 16-bit elements
• 4 x 32-bit elements

Special Registers

CFG Register Fields

SAR Usage Constraints

• Vector shifts (ESP.VSR.32, ESP.VSL.32): Uses lower 5 bits as shift amount
• Multiplications (ESP.VMUL., ESP.CMUL., ESP.FFT.AMS.*): Uses full SAR value for right-shift of intermediate results
• Set SAR via: esp.movx.w.sar or esp.movx.w.cfg with appropriate vxrm

Instruction Categories

Instructions are organized into these categories. See references/instructions.md for the complete reference:

1. Read Instructions - Load 128-bit/64-bit/broadcast/unaligned data from memory to QR registers
2. Write Instructions - Store QR/accumulator data to memory
3. Data Exchange Instructions - Move data between AR/QR registers, zip/unzip, sign/zero extend
4. Arithmetic Instructions - Vector add/sub/mul, MAC operations, complex multiply, ReLU, clamping
5. Comparison Instructions - Vector min/max, compare equal/less-than/greater-than, saturation
6. Bitwise Logical Instructions - AND/OR/XOR/NOT on 128-bit QR registers
7. Shift Instructions - Vector shifts, spliced shifts, immediate/register-controlled shifts
8. FFT Dedicated Instructions - Radix-2 butterfly, complex multiply, bit-reverse, real FFT

Quick Instruction Reference

Most Common Instructions (from esp-dl patterns)

Optimization Workflow

When converting scalar functions to SIMD:

1. Check data alignment: Use 16-byte aligned data when possible (faster). Handle unaligned with esp.ld.128.usar.ip + esp.src.q / esp.src.q.qup
2. Set SAR before multiply instructions: esp.movx.w.sar rs to configure output shift
3. Process in 128-bit chunks: Loop count = total_elements / elements_per_128b (8 for 16-bit, 16 for 8-bit, 4 for 32-bit)
4. Use fused load-arithmetic instructions where possible to reduce instruction count:
   • esp.vadd.s16.ld.incp qz, qx, qy, rs, imm - add and load next
   • esp.vmul.s16.ld.incp qz, qx, qy, rs, imm - multiply and load next
5. Use QACC/XACC for accumulation chains: Initialize with esp.zero.qacc, accumulate with esp.vmulas.*.qacc, extract with esp.srcmb.*.qacc
6. Use broadcast loads for scalar operands: esp.vldbc.16.ip qN, rs, 0
7. Handle remainders: Process full 128-bit blocks in loop, handle tail elements separately

Data Alignment Handling

Aligned Access (16-byte boundary)

esp.vld.128.ip q0, a1, 16   # load and advance by 16
esp.vst.128.ip q0, a0, 16   # store and advance by 16

Unaligned Access Pattern

# Get SAR_BYTE for output pointer
esp.ld.128.usar.ip q5, a0, 0
esp.movx.r.sar.bytes a5    # save output sar_byte

# Load unaligned data from input
esp.ld.128.usar.ip q0, a1, 16
esp.ld.128.usar.ip q1, a1, 16

# Extract aligned data from two consecutive loads
esp.src.q q2, q0, q1       # q2 = properly aligned 128-bit data

Instruction Naming Convention

ESP.<operation>.<datatype>[.<variant>]

• operation: vadd, vsub, vmul, vmulas, vsadds, etc.
• datatype: s8, s16, s32 (signed); u8, u16 (unsigned)
• variant: ld.incp (load + addr++), st.incp (store + addr++), ld.xp (load + addr+=reg), etc.

Label Naming Convention (REQUIRED)

For branch/loop targets, use local labels: either a plain number (0:, 1:, referenced as 0f/0b) or a .L-prefixed name (.Lloop, .Lremainder). Do not use full descriptive labels like loop_start: / end_label:.

• Numeric local labels keep tight inner loops compact and avoid name clashes.
• .L labels stay local to the file (not emitted into the symbol table) and clearly mark internal jump targets.

; GOOD — numeric local label
    loopgtz a6, 0f
        esp.vmin.s16.ld.incp q0, a3, q2, q0, q1
        esp.vld.128.ip       q1, a4, 16
        esp.vst.128.ip       q2, a2, 16
    0:

; GOOD — .L local label
    bgez  a9, .Lleft_shift
.Lright_shift_loop:
    ; ...
    bnez  a5, .Lright_shift_loop
.Lleft_shift:

; BAD — full descriptive global-style labels
right_shift_loop:
    ; ...
    bnez a5, right_shift_loop

References

• Full instruction listing: See references/instructions.md for all instructions organized by category with syntax and semantics
• Code examples: See references/examples.md for patterns from esp-dl (conv2d, elementwise ops, depthwise conv, etc.)