# Go SIMD та пакет ArchSIMD у 2026: Оптимізація продуктивності та питання на співбесіді

> Повний посібник з пакету simd/archsimd у Go 1.26. Реалізація векторних операцій з приростом продуктивності 30-50%, виявлення функцій CPU та підготовка до співбесід з Go.

- Published: 2026-08-05
- Updated: 2026-08-05
- Author: SharpSkill
- Tags: go, simd, performance, go-1.26, archsimd
- Reading time: 9 min

---

Go 1.26 представляє експериментальний пакет `simd/archsimd`, який приносить нативні векторні операції до Go без необхідності писати assembly-код чи використовувати CGo. Пакет надає типи векторів 128-біт, 256-біт та 512-біт, які безпосередньо відображаються на регістри SSE, AVX2 та AVX-512 архітектури AMD64, забезпечуючи приріст продуктивності 30-50% порівняно зі скалярними реалізаціями.

> **Вимоги до компіляції**
>
> Для активації archsimd потрібно встановити `GOEXPERIMENT=simd` під час компіляції. Пакет існує лише при встановленому цьому прапорці та наразі підтримує виключно архітектуру AMD64.

## Розуміння архітектури SIMD у Go

SIMD (Single Instruction, Multiple Data) обробляє декілька елементів даних паралельно, використовуючи широкі векторні регістри. До Go 1.26 доступ до SIMD вимагав написання assembly вручну — складного в підтримці, що блокує асинхронне витіснення та інлайнинг для малих обчислювальних ядер. Пакет [archsimd](https://pkg.go.dev/simd/archsimd) усуває ці бар'єри.

Підхід Go базується на дворівневій архітектурі:

| Рівень | Пакет | Призначення |
|--------|-------|-------------|
| Низький | `simd/archsimd` | Інтринсіки, специфічні для архітектури (зараз AMD64, ARM64/Wasm у Go 1.27) |
| Високий | `simd` (планується) | Портативний векторний API, що абстрагує апаратні відмінності |

Ця структура відображає відношення між пакетами `syscall` та `os` — досвідчені розробники мають прямий доступ до апаратного забезпечення, тоді як більшість коду використовує портативні абстракції.

## Типи векторів та відображення регістрів

Пакет archsimd визначає типи векторів як непрозорі структури. Компілятор обробляє їх особливим чином, відображаючи на векторні регістри замість масивів у пам'яті.

```go
// vector_types.go
// Core vector types available in simd/archsimd

// 128-bit vectors (XMM registers)
type Int8x16 struct { a0, a1, ... a15 int8 }
type Int32x4 struct { a0, a1, a2, a3 int32 }
type Float64x2 struct { a0, a1 float64 }

// 256-bit vectors (YMM registers)
type Int64x4 struct { a0, a1, a2, a3 int64 }
type Float32x8 struct { a0, a1, ... a7 float32 }

// 512-bit vectors (ZMM registers)
type Uint8x64 struct { a0, a1, ... a63 uint8 }
type Float64x8 struct { a0, a1, ... a7 float64 }
```

Операції є методами на типах векторів, а не окремими функціями. Це забезпечує лаконічний код при ланцюжковому виклику операцій:

```go
// operations.go
// Method-based API design

func (v Uint32x4) Add(other Uint32x4) Uint32x4    // Maps to VPADDD
func (v Float64x4) Mul(other Float64x4) Float64x4 // Maps to VMULPD
func (v Int8x16) And(other Int8x16) Int8x16       // Maps to VPAND
```

## Реалізація векторизованої суми

Практичний приклад демонструє приріст продуктивності з archsimd. Ця реалізація підсумовує slice int64, використовуючи 256-бітні регістри YMM, обробляючи чотири елементи за ітерацію.

```go
// simd_sum.go
package main

import "simd/archsimd"

// SumInt64SIMD processes 4 elements per iteration using YMM registers.
// Requires: GOEXPERIMENT=simd go build
func SumInt64SIMD(input []int64) int64 {
    n := len(input)
    if n == 0 {
        return 0
    }
    
    // Process 4 elements at a time with 256-bit vectors
    y0 := archsimd.LoadInt64x4Slice(input[:4])
    
    for i := 4; i+4 <= n; i += 4 {
        y1 := archsimd.LoadInt64x4Slice(input[i : i+4])
        y0 = y0.Add(y1)  // VPADDQ: parallel 64-bit addition
    }
    
    // Horizontal reduction: 256-bit → 128-bit → scalar
    x0 := y0.GetLo()              // Extract lower 128 bits
    x1 := y0.GetHi()              // Extract upper 128 bits
    x0 = x0.Add(x1)               // Add halves
    
    sum := x0.GetElem(0) + x0.GetElem(1)  // Final scalar sum
    
    // Handle remaining elements (tail loop)
    remainder := n % 4
    for i := n - remainder; i < n; i++ {
        sum += input[i]
    }
    
    return sum
}
```

Результати бенчмарків з [огляду archsimd від marselester](https://marselester.com/go-archsimd-preview.html) показують, що цей підхід забезпечує приблизно 47.6% швидше виконання порівняно зі скалярними циклами.

> **Усунення перевірки меж**
>
> Перетворення доступу до slice на арифметику вказівників з `unsafe.Add()` усуває надлишкові перевірки меж, даючи додаткові ~14% прискорення. У поєднанні з SIMD загальний виграш сягає ~54.7%.

## Продуктивність у реальному світі: парсинг CSV

Бібліотека [go-simdcsv](https://github.com/nnnkkk7/go-simdcsv) демонструє використання archsimd у продакшені. Вона сканує CSV-дані 64-байтними фрагментами з використанням AVX-512, виявляючи роздільники як бітові маски.

```go
// simdcsv_example.go
package main

import (
    "strings"
    csv "github.com/nnnkkk7/go-simdcsv"
)

func main() {
    // Drop-in replacement for encoding/csv
    reader := csv.NewReader(strings.NewReader("name,age\nAlice,30"))
    records, _ := reader.ReadAll()
    
    // Direct byte parsing for maximum throughput
    data := []byte("name,age\nAlice,30\nBob,25")
    records, _ = csv.ParseBytes(data, ',')
}
```

Бенчмарки на AMD EPYC 9R14 з AVX-512:

| Набір даних | encoding/csv | go-simdcsv | Покращення |
|-------------|-------------|-----------|------------|
| Без лапок (100K рядків) | 214 МБ/с | 288 МБ/с | +35% |
| 10% з лапками | 254 МБ/с | 275 МБ/с | +8% |
| 40% з лапками | 308 МБ/с | 328 МБ/с | +6% |

Триетапний конвеєр — SIMD-сканування, парсинг бітових масок та екстракція рядків — демонструє, як archsimd прискорює навантаження, пов'язані з I/O.

## Кодування Base64: у 33 рази швидше за stdlib

Бібліотека [simdenc](https://github.com/dans-stuff/simdenc) використовує archsimd на межі можливостей, досягаючи пропускної здатності кодування 64.6 ГБ/с — у 33 рази швидше за `encoding/base64`.

```go
// simdenc_base64.go
package main

import "simd/archsimd"

// Constants loaded once, used across iterations
const maskHi = uint64(0x0FC0FC000FC0FC00)

// Preload into 512-bit vector for AVX-512 path
var encMaskHi512 = archsimd.LoadUint64x8(&[8]uint64{
    maskHi, maskHi, maskHi, maskHi, 
    maskHi, maskHi, maskHi, maskHi,
}).AsUint16x32()

func encode512(dst, src []byte) {
    // Shadow global into local to maintain register allocation
    // Go lacks LICM, so globals reload from memory each iteration
    mask := encMaskHi512
    
    // Process 48 input bytes → 64 output bytes per iteration
    // Uses VPERMI2B for combined validation + translation
    // ... implementation
}
```

> **Підводний камінь продуктивності**
>
> Компілятор Go не інлайнить SIMD-інтринсіки всередині замикань. Це призводить до того, що `LoadUint8x32Slice` та `StoreSlice` стають справжніми інструкціями CALL, спричиняючи уповільнення у 7-8 разів. Тримайте SIMD-код у звичайних функціях.

## Виявлення функцій CPU

Виявлення під час виконання забезпечує роботу коду на відповідному апаратному забезпеченні:

```go
// feature_detection.go
package main

import "simd/archsimd"

func ProcessData(data []byte) {
    switch {
    case archsimd.HasAVX512():
        processAVX512(data)  // 512-bit vectors
    case archsimd.HasAVX2():
        processAVX2(data)    // 256-bit vectors
    default:
        processScalar(data)  // Fallback
    }
}
```

Компілятор розглядає `HasAVX512()` та `HasAVX2()` як чисті функції, оскільки можливості CPU не змінюються після ініціалізації. Це дозволяє елімінацію мертвого коду при націлюванні на конкретні архітектури.

## Операції з масками для умовної обробки

Маски дозволяють селективні операції з елементами, що є необхідним для обробки даних змінної довжини або умовних оновлень:

```go
// mask_operations.go
package main

import "simd/archsimd"

// FilterPositive keeps only positive values, zeroing negatives
func FilterPositive(values []int32) {
    for i := 0; i+4 <= len(values); i += 4 {
        v := archsimd.LoadInt32x4Slice(values[i:])
        
        // Create mask: true where element > 0
        zero := archsimd.Int32x4{}
        mask := v.GreaterThan(zero)
        
        // Blend: keep positive values, zero out negatives
        result := v.And(mask.AsInt32x4())
        
        archsimd.StoreSlice(values[i:], result)
    }
}
```

Типи масок абстрагують платформні відмінності — AVX-512 використовує 1 біт на елемент, тоді як ARM64 SVE використовує 1 біт на байт. Компілятор обробляє перетворення.

## Питання на співбесіді: SIMD у Go детально

Технічні співбесіди дедалі частіше охоплюють оптимізацію SIMD. Ось типові питання для [підготовки до співбесід з Go](/technologies/go):

**П: Чому archsimd у Go використовує методи замість функцій?**

Методи природно ланцюжкуються без тимчасових змінних. `v.Add(w).Mul(x)` читається краще, ніж `Mul(Add(v, w), x)`. Цей дизайн також запобігає передачі несумісних розмірів векторів — `Int32x4.Add()` приймає лише `Int32x4`.

**П: Який вплив замикань на продуктивність SIMD-коду?**

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

**П: Як archsimd обробляє константні операнди, такі як величини зсуву?**

Інструкції на кшталт `VPSLLD` (зсув вліво) вимагають констант часу компіляції. Методи на кшталт `ShiftLeftConst(uint8)` документують цю вимогу. Передача змінних запускає резервні стратегії з потенційною деградацією продуктивності.

**П: Поясніть горизонтальну редукцію в SIMD.**

Горизонтальна редукція об'єднує елементи вектора в скаляр. Для 256-бітних векторів: витягніть верхню/нижню 128-бітні половини, додайте їх, потім витягніть окремі елементи для фінального підсумовування. Це мінімізує крос-лінійні операції.

## Попередній огляд Go 1.27: ARM64 та портативний SIMD

[Go 1.27 RC1](https://go.dev/blog/go1.26) значно розширює підтримку SIMD:

- **ARM64 NEON/SVE**: Нативна підтримка archsimd для Apple Silicon та ARM-серверів
- **WebAssembly**: 128-бітні SIMD-операції
- **Портативний пакет `simd`**: Векторний API, незалежний від розміру, що абстрагує архітектурні відмінності
- **Вдосконалення API AMD64**: На основі відгуків користувачів Go 1.26

Для кросплатформного коду, націленого на AMD64 та ARM64, варто почекати портативний пакет `simd` або використовувати бібліотеки на кшталт [go-highway](https://github.com/ajroetker/go-highway), що надають рівні абстракції.

## Висновок

- Активуйте archsimd за допомогою `GOEXPERIMENT=simd` для збірок AMD64; Go 1.27 додає ARM64/Wasm
- Типи векторів безпосередньо відображаються на апаратні регістри; доступні ширини 128/256/512 біт
- Методи природно ланцюжкуються: `v.Add(w).Mul(x)` компілюється в ефективні послідовності інструкцій
- Уникайте замикань у гарячих шляхах SIMD — вони порушують інлайнинг інтринсіків
- Копіюйте глобальні змінні в локальні, щоб запобігти повторним завантаженням з пам'яті (Go не має LICM)
- Поєднуйте з усуненням перевірки меж через `unsafe` для максимальної пропускної здатності
- Реальні виграші: 35% для парсингу CSV, 33x для кодування base64

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/uk/blog/go/go-simd-archsimd-performance-optimization