# Go SIMD i pakiet ArchSIMD w 2026: Optymalizacja wydajności i pytania rekrutacyjne

> Kompleksowy przewodnik po pakiecie simd/archsimd w Go 1.26. Implementacja operacji wektorowych z przyrostem wydajności 30-50%, detekcja funkcji CPU oraz przygotowanie do rozmów kwalifikacyjnych z 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 wprowadza eksperymentalny pakiet `simd/archsimd`, który przynosi natywne operacje wektorowe do Go bez konieczności pisania kodu asemblerowego czy używania CGo. Pakiet udostępnia typy wektorów 128-bitowych, 256-bitowych i 512-bitowych, które mapują się bezpośrednio na rejestry SSE, AVX2 i AVX-512 architektury AMD64, umożliwiając osiągnięcie przyrostu wydajności rzędu 30-50% w porównaniu do implementacji skalarnych.

> **Wymagania kompilacji**
>
> Aby włączyć archsimd, należy ustawić `GOEXPERIMENT=simd` podczas kompilacji. Pakiet jest dostępny tylko przy tej fladze i obecnie obsługuje wyłącznie architekturę AMD64.

## Architektura SIMD w Go

SIMD (Single Instruction, Multiple Data) przetwarza wiele elementów danych równolegle, wykorzystując szerokie rejestry wektorowe. Przed Go 1.26 dostęp do SIMD wymagał ręcznego pisania asemblera — trudnego w utrzymaniu, uniemożliwiającego asynchroniczne wywłaszczanie i blokującego inlining dla małych jąder obliczeniowych. Pakiet [archsimd](https://pkg.go.dev/simd/archsimd) eliminuje te bariery.

Podejście Go opiera się na dwupoziomowej architekturze:

| Poziom | Pakiet | Przeznaczenie |
|--------|--------|---------------|
| Niski | `simd/archsimd` | Intrinsyki specyficzne dla architektury (AMD64 teraz, ARM64/Wasm w Go 1.27) |
| Wysoki | `simd` (planowany) | Przenośne API wektorowe abstrahujące różnice sprzętowe |

Ta struktura odzwierciedla relację między pakietami `syscall` i `os` — zaawansowani programiści mają bezpośredni dostęp do sprzętu, podczas gdy większość kodu korzysta z przenośnych abstrakcji.

## Typy wektorowe i mapowanie rejestrów

Pakiet archsimd definiuje typy wektorowe jako nieprzezroczyste struktury. Kompilator traktuje je specjalnie, mapując na rejestry wektorowe zamiast na tablice w pamięci.

```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 }
```

Operacje są metodami na typach wektorowych, a nie samodzielnymi funkcjami. Dzięki temu kod jest zwięzły podczas łańcuchowania operacji:

```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
```

## Implementacja zwektoryzowanej sumy

Praktyczny przykład demonstruje przyrost wydajności z archsimd. Ta implementacja sumuje slice int64 używając 256-bitowych rejestrów YMM, przetwarzając cztery elementy na iterację.

```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
}
```

Wyniki benchmarków z [przeglądu archsimd autorstwa marselester](https://marselester.com/go-archsimd-preview.html) pokazują, że to podejście osiąga około 47.6% szybsze wykonanie w porównaniu do pętli skalarnych.

> **Eliminacja sprawdzania granic**
>
> Konwersja dostępu do slice'a na arytmetykę wskaźników z `unsafe.Add()` eliminuje nadmiarowe sprawdzanie granic, dając dodatkowe ~14% przyspieszenia. W połączeniu z SIMD całkowity zysk sięga ~54.7%.

## Wydajność w praktyce: parsowanie CSV

Biblioteka [go-simdcsv](https://github.com/nnnkkk7/go-simdcsv) demonstruje archsimd w produkcji. Skanuje dane CSV w 64-bajtowych fragmentach używając AVX-512, wykrywając separatory jako maski bitowe.

```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, ',')
}
```

Benchmarki na AMD EPYC 9R14 z AVX-512:

| Zbiór danych | encoding/csv | go-simdcsv | Poprawa |
|--------------|-------------|-----------|----------|
| Bez cudzysłowów (100K wierszy) | 214 MB/s | 288 MB/s | +35% |
| 10% z cudzysłowami | 254 MB/s | 275 MB/s | +8% |
| 40% z cudzysłowami | 308 MB/s | 328 MB/s | +6% |

Trzystopniowy potok — skanowanie SIMD, parsowanie masek bitowych i ekstrakcja stringów — demonstruje, jak archsimd przyspiesza obciążenia związane z I/O.

## Kodowanie Base64: 33x szybciej niż stdlib

Biblioteka [simdenc](https://github.com/dans-stuff/simdenc) wykorzystuje archsimd do granic możliwości, osiągając przepustowość kodowania 64.6 GB/s — 33 razy szybciej niż `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
}
```

> **Pułapka wydajnościowa**
>
> Kompilator Go nie inline'uje intrinsyków SIMD wewnątrz domknięć. Powoduje to, że `LoadUint8x32Slice` i `StoreSlice` stają się prawdziwymi instrukcjami CALL, co skutkuje 7-8-krotnym spowolnieniem. Kod SIMD powinien znajdować się w zwykłych funkcjach.

## Detekcja funkcji CPU

Wykrywanie w czasie wykonania zapewnia, że kod działa na odpowiednim sprzęcie:

```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
    }
}
```

Kompilator traktuje `HasAVX512()` i `HasAVX2()` jako funkcje czyste, ponieważ funkcje CPU nie zmieniają się po inicjalizacji. Umożliwia to eliminację martwego kodu podczas targetowania konkretnych architektur.

## Operacje maskowe dla warunkowego przetwarzania

Maski umożliwiają selektywne operacje na elementach, co jest niezbędne przy obsłudze danych o zmiennej długości lub warunkowych aktualizacji:

```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)
    }
}
```

Typy masek abstrahują różnice platformowe — AVX-512 używa 1 bitu na element, podczas gdy ARM64 SVE używa 1 bitu na bajt. Kompilator obsługuje konwersje.

## Pytania rekrutacyjne: SIMD w Go

Rozmowy techniczne coraz częściej obejmują optymalizację SIMD. Oto typowe pytania do [przygotowania do rozmów z Go](/technologies/go):

**P: Dlaczego archsimd w Go używa metod zamiast funkcji?**

Metody łańcuchują się naturalnie bez zmiennych tymczasowych. `v.Add(w).Mul(x)` czyta się lepiej niż `Mul(Add(v, w), x)`. Ten design zapobiega również przekazywaniu niekompatybilnych rozmiarów wektorów — `Int32x4.Add()` akceptuje tylko `Int32x4`.

**P: Jaki jest wpływ domknięć na wydajność kodu SIMD?**

Domknięcia uniemożliwiają inlining intrinsyków. Ładowania i zapisy SIMD stają się prawdziwymi wywołaniami funkcji zamiast instrukcji inline, powodując 7-8-krotne spowolnienie. Gorące ścieżki SIMD powinny zawsze znajdować się w zwykłych funkcjach.

**P: Jak archsimd obsługuje stałe operandy, takie jak wartości przesunięcia?**

Instrukcje jak `VPSLLD` (przesunięcie w lewo) wymagają stałych znanych w czasie kompilacji. Metody jak `ShiftLeftConst(uint8)` dokumentują to wymaganie. Przekazywanie zmiennych uruchamia strategie awaryjne z potencjalną degradacją wydajności.

**P: Wyjaśnij redukcję horyzontalną w SIMD.**

Redukcja horyzontalna łączy elementy wektora w skalar. Dla wektorów 256-bitowych: wyodrębnij górną/dolną połowę 128-bitową, dodaj je, następnie wyodrębnij poszczególne elementy do końcowego sumowania. Minimalizuje to operacje między ścieżkami.

## Zapowiedź Go 1.27: ARM64 i przenośne SIMD

[Go 1.27 RC1](https://go.dev/blog/go1.26) znacząco rozszerza wsparcie SIMD:

- **ARM64 NEON/SVE**: Natywne wsparcie archsimd dla Apple Silicon i serwerów ARM
- **WebAssembly**: 128-bitowe operacje SIMD
- **Przenośny pakiet `simd`**: API wektorowe niezależne od rozmiaru, abstrahujące różnice architektoniczne
- **Udoskonalenia API AMD64**: Na podstawie opinii użytkowników Go 1.26

Dla kodu wieloplatformowego targetującego zarówno AMD64, jak i ARM64, warto poczekać na przenośny pakiet `simd` lub użyć bibliotek takich jak [go-highway](https://github.com/ajroetker/go-highway), które zapewniają warstwy abstrakcji.

## Podsumowanie

- Włącz archsimd za pomocą `GOEXPERIMENT=simd` dla buildów AMD64; Go 1.27 dodaje ARM64/Wasm
- Typy wektorowe mapują się bezpośrednio na rejestry sprzętowe; dostępne szerokości 128/256/512 bitów
- Metody łańcuchują się naturalnie: `v.Add(w).Mul(x)` kompiluje się do efektywnych sekwencji instrukcji
- Unikaj domknięć w gorących ścieżkach SIMD — przerywają one inlining intrinsyków
- Kopiuj zmienne globalne do lokalnych, aby zapobiec powtórnym ładowaniom z pamięci (Go nie ma LICM)
- Połącz z eliminacją sprawdzania granic przez `unsafe` dla maksymalnej przepustowości
- Rzeczywiste zyski: 35% dla parsowania CSV, 33x dla kodowania base64

---

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