gosuda.org/zstd: Drop-In DataDog/zstd Compression med Zero CGO og Crash Isolation

gosuda.org/zstd er et CGO_ENABLED=0 Go-komprimeringsbibliotek, der kører den officielle C Zstandard-motor (libzstd 1.5.7) inde i en isoleret arbejdsproces over HQQ-delt hukommelse. Det leverer en drop-in-erstatnings-API for github.com/DataDog/zstd (herunder Compress/Decompress i én enkelt handling, streamende io.Writer/io.Reader, præ-fordøjede ordbøger og genanvendelige kontekster uden allokering), samtidig med at C-udførelsen holdes fuldstændig uden for Go-runtime-adresseområdet.

1go get gosuda.org/zstd@v0.3.10507

Hvorfor dekomprimering hører til uden for din Go-heap

I produktionsbackendmiljøer sidder komprimering og dekomprimering direkte på grænsen for ikke-tillid til input. Logindsamlere, meddelelsesbrokerer, RPC-gateways og lagringsmotorer dekomprimerer gigabyte af eksternt leverede frames hvert minut.

Mange Go-teams vælger github.com/DataDog/zstd, fordi det binder direkte til upstream C libzstd: C-implementeringen leverer høj enkeltkernet gennemløb, stramme ordbogskomprimeringsforhold på små poster og C-arenaer uden for heapen (ZSTD_CCtx og ZSTD_DCtx), som ikke forstørrer Go-garbage-collection-scanningstider.

At sammenkæde libzstd i en Go-tjeneste via cgo medfører imidlertid to operationelle udfordringer:

1. Bygge- og udrulningsfriktion: Ligesom go-sqlite3 kræver DataDog/zstd CGO_ENABLED=1 og en målc-compiler-værktøjskæde. Krydskompilering af tjenester eller bygning af statiske binære filer til linux/arm64 eller windows/arm64 kræver eksterne C-sysroots.
2. Delt adresseområde på ikke-tillid til input: Dekomprimering af korrupte eller kontroversielle payloads inde i det samme virtuelle adresseområde som din Go-server betyder, at enhver fejl i den oprindelige C-kode eller tilpasset ordbogshåndtering kan afslutte hele Go-processen.

gosuda.org/zstd bevarer den nøjagtige upstream C libzstd 1.5.7-motor og den kendte github.com/DataDog/zstd-API, men flytter C-udførelsen ind i en verificeret børneproces (zstd_server), der er forbundet til dit Go-program over delt cache-linje-hukommelse.

Drop-in-erstatning for github.com/DataDog/zstd

Migration fra github.com/DataDog/zstd kræver kun ændring af importstien til "gosuda.org/zstd". Ingen ekstern binær installation eller opsætningskode er nødvendig: ved det første kald materialiserer gosuda.org/zstd en indlejret SLSA-attesteret zstd_server-binær fil til din platform, verificerer dens SHA-256-digest via gosuda.org/hqq/secureexec og åbner en delt hukommelse-sessionspulje.

 1package main
 2
 3import (
 4	"bytes"
 5	"fmt"
 6	"io"
 7	"log"
 8
 9	"gosuda.org/zstd"
10)
11
12func main() {
13	// 1. Komprimér / Dekomprimér i én handling (afspejler github.com/DataDog/zstd)
14	src := []byte("shared-memory zstd payload without cgo")
15	compressed, err := zstd.CompressLevel(nil, src, zstd.BestSpeed)
16	if err != nil {
17		log.Fatal(err)
18	}
19	plain, err := zstd.Decompress(nil, compressed)
20	if err != nil {
21		log.Fatal(err)
22	}
23	fmt.Printf("one-shot: %d bytes -> %d bytes (%s)\n", len(src), len(compressed), plain)
24
25	// 2. Streamende writer og reader med ordbogsunderstøttelse
26	var buf bytes.Buffer
27	w := zstd.NewWriterLevel(&buf, zstd.DefaultCompression)
28	if _, err := w.Write(src); err != nil {
29		log.Fatal(err)
30	}
31	if err := w.Close(); err != nil {
32		log.Fatal(err)
33	}
34
35	r := zstd.NewReader(&buf)
36	defer r.Close()
37	streamed, err := io.ReadAll(r)
38	if err != nil {
39		log.Fatal(err)
40	}
41	fmt.Printf("streamed: %s\n", streamed)
42}

Understøttede platforme og indlejrede binære filer

Alle seks målplatforme leveres med præbyggede, SHA-256-bundne arbejder-binære filer indlejret via platformsspecifikke byggetags (internal/embedded/embed_<goos>_<goarch>.go):

Ind i datastien for delt hukommelse

For at holde gennemløbet konkurrencedygtigt med in-process cgo undgår gosuda.org/zstd socketserialisering og heap-allokeringer på den kritiske sti.

1. Slot-kodning uden allokering (zstd_ctx.go og c/zstd_hooks.c)

Når du bruger en genanvendelig zstd.Ctx (eller når Compress- og Decompress-funktionerne på pakkeniveau låner en Ctx fra den interne sessionspulje), flyder data direkte gennem det mappede StandardLink-slot:

1Go Caller (zstd.Ctx)                    Shared-Memory Slot                    C11 Worker (zstd_hooks.c)
2--------------------                    ------------------                    -------------------------
3src []byte  ------------------------->  Request Slot Payload  ------------->  ZSTD_compressCCtx(
4                                                                                cctx, resp_slot, src, level)
5dst []byte  <-------------------------  Response Slot Payload <-------------  Writes compressed frame directly
6                                                                              into shared response slot

1. Den genererede hqq-bindgen-klient kopierer src direkte ind i det hukommelsesmappede forespørgselsslot og vender SeqLock-sekvensordet.
2. C-arbejderen læser src på stedet fra forespørgselsslots og sender svarslots payload-pointer direkte som destinationbuffer til ZSTD_compressCCtx eller ZSTD_decompressDCtx.
3. Go-klienten kopierer det resulterende slice fra svarslottet ind i det af kalderen leverede dst-slice. I stabil tilstand udfører ctx.CompressTo(dst, src, level) og ctx.DecompressInto(dst, src) 0 allocs/op.

Præ-fordøjede ordbøger (CDict og DDict) ligger på C-arbejderen bag generationskontrollerede 64-bit-håndtag (handle CDict, handle DDict i zstd.idl). Oprettelse af en ordbog én gang via ctx.NewCDict(rawDict, level) parser ordbogstabellerne inde i C-arbejderen og returnerer et letvægtshåndtag, der kan genbruges på tværs af tusindvis af kald uden at gensende ordbogsbytene.

2. Amortisering af IPC-overhead med masse-inramning (zstd_bulk.go)

For store payloads (16 KiB og derover) er round-trippen på ~200 ns i delt hukommelse ubetydelig sammenlignet med den CPU-tid, der bruges inde i libzstd. For arbejdsbelastninger, der komprimerer tusindvis af små 100-byte til 1-KiB-meddelelser på én gang, løber det dog op at betale selv 200 ns pr. element.

gosuda.org/zstd leverer CompressBulk og DecompressBulk på BulkCtx (zstd_bulk.go) for at eliminere round-trips pr. element:

 1bctx, err := client.NewBulkCtx(1 << 20)
 2if err != nil {
 3	log.Fatal(err)
 4}
 5defer bctx.Close()
 6
 7items := [][]byte{
 8	[]byte(`{"event":"login","user":101}`),
 9	[]byte(`{"event":"purchase","user":101,"amount":4200}`),
10	[]byte(`{"event":"logout","user":101}`),
11}
12compressedItems, err := bctx.CompressBulk(nil, items, zstd.DefaultCompression)

CompressBulk pakker hele [][]byte-batchen ind i en enkelt længdepræfiks-forespørgselsframe i delt hukommelse. C-arbejderen løber igennem hvert element i C (compress_bulk i c/zstd_hooks.c), skriver alle komprimerede frames sammenhængende ind i svarslottet og returnerer hele batchen i en enkelt round-trip med delt hukommelse.

3. Overlevelse af arbejderafslutning uden nedbrud af kalderen

Fordi zstd_server kører i en separat OS-proces, vil en fatal fejl inde i C-arbejderen aldrig vælte din Go-applikation:

• Hvis zstd_server dræbes eksternt (for eksempel af SIGKILL eller en OOM-hændelse), opdager HQQ-transportlaget den ødelagte peer øjeblikkeligt og returnerer en typet *rt.TransportError fra det igangværende Compress- eller Decompress-kald.
• Funktioner på pakkeniveau (zstd.Compress, zstd.Decompress, zstd.NewWriter, zstd.NewReader) opdager automatisk, at den delte standardarbejder er væk, spawner en frisk verificeret zstd_server-instans ved det næste kald og genoptager normal drift.

Repositoriestruktur

Kodningsbasen adskiller drop-in-facaden DataDog/zstd fra de lavniveau hqq-bindgen-sessions- og masseparadigmer:

1gosuda.org/zstd
2├── autolaunch.go / hashes.go  # Drop-in Compress/Decompress API, auto-recovery pool, og SHA-256 hashes
3├── zstd_stream.go             # Streamende Writer/Reader (NewWriterLevelDict, NewReaderDict)
4├── zstd_ctx.go                # Zero-allokering Ctx, CDict, og DDict wrappers over hqq-bindgen
5├── zstd_bulk.go               # Single-round-trip CompressBulk og DecompressBulk inramning
6├── zstd.go                    # Genereret hqq-bindgen Go-klient for zstd IDL-tjenesten
7├── zstd.idl                   # HQQ IDL-skema der definerer Context, CDict, DDict, og RPC-metoder
8├── internal/embedded/         # Platform-tagget //go:embed zstd_server binære filer (6 OS/Arch mål)
9└── c/                         # C11-serverimplementering (zstd_server.c, zstd_hooks.c, main.c)

Kom godt i gang

Installer gosuda.org/zstd med go get og brug det med CGO_ENABLED=0:

1go get gosuda.org/zstd@v0.3.10507

• GitHub-repositorie: https://github.com/gosuda/hqq-zstd
• Arkitektur og benchmarks: docs/ARCHITECTURE.md
• HQQ Core Runtime: https://gosuda.org/hqq