Softanza
DémarrerEnglish
Softanza
Visuel et spatial

GPU

Calcul et rendu sur un même périphérique, avec une fonderie qui se règle et se vérifie elle-même ; f64 et multi-GPU refusés par choix.

5 Strong · 4 Solid · 3 Partial · 0 Emerging

Mesuré contre : wgpu · taichi · three.js · Dossiers : base/gpu(s'ouvre dans un nouvel onglet) · Pour les programmeurs : la référence de ce domaine

neuf matériaux rendus par la fonderie GPU
neuf matériaux rendus par la fonderie GPU. rendu par le garde gg5_gallery de la bibliothèque et commis avec lui à 0e72e2e2c sous le nom gg5_gallery.png · la source(s'ouvre dans un nouvel onglet)

Repensé depuis les premiers principes

Ce que Softanza a gardé de ce qui marche, et ce qu'elle a repensé, tel que la bibliothèque l'a écrit dans ses documents de conception et ses narrations.

La manière SoftanzaLe GPU n'est utilisé que là où une mesure prouve qu'il gagne, et le chemin CPU reste toujours la réponse de référence.

Gardé des meilleures pratiques

  • Une seule bibliothèque légère et éprouvée est intégrée : wgpu-native (WebGPU). Les noyaux se compilent depuis du texte à l'exécution, et les mêmes noyaux tournent aussi dans un navigateur. source(s'ouvre dans un nouvel onglet)
  • Les données restent sur la carte : un envoi, plusieurs noyaux enchaînés, une seule relecture, car déplacer les données coûte plus que les traiter. source(s'ouvre dans un nouvel onglet)
  • Chaque opération GPU est livrée avec une vérification de parité contre le résultat CPU, dans une tolérance fixée par la mesure. source(s'ouvre dans un nouvel onglet)

Repensé

  • Le calcul exact en double précision reste sur le CPU : les cartes grand public y sont 32 à 64 fois plus lentes. Le GPU se limite à la simple précision. source(s'ouvre dans un nouvel onglet)
  • Chaque passage au GPU doit gagner une mesure, selon des critères d'abandon écrits d'avance. Les opérations élément par élément isolées ont été écartées : le transfert pesait 92 % du coût. source(s'ouvre dans un nouvel onglet)
  • Le calcul GPU se décrit au lieu de s'écrire. stzKernelMaker change une courte formule en noyau, ce qui le rend abordable, comme le générateur de regex l'a fait pour les motifs. source(s'ouvre dans un nouvel onglet)
  • Les variantes de noyaux viennent d'une simple boucle, et non d'un modèle de langage, car l'espace de recherche est petit. Un vérificateur contrôle chacune et refuse les vitesses impossibles. source(s'ouvre dans un nouvel onglet)

An in-house wgpu plane that does what neither three.js (render-only) nor taichi (compute-only) does: compute and render on one device, zero-copy. Its distinctive core is a self-tuning foundry; real consumers are accelerated and verified (t-SNE 5-8x, UMAP up to 16x, k-means 6x, neural forward 5x, exact vector search 18x), always with a bit-identical CPU fallback. What it refuses by measured decision — f64 on GPU, multi-GPU, deep 3D — are scope boundaries, not oversights.

Ce qu'un artisan en fait, et ce qui se distingue

  • a self-tuning, self-checking calibration foundry: category-of-one
  • compute and render zero-copy on one device
  • every GPU route measured, verified, and reversible to CPU
  • byte-identical WGSL native vs browser

Ce qui est dû

  • broaden the kernel transpiler beyond elementwise
  • whole-pipeline GPU residency
  • idle-aware routing (GK1b)
  • deeper 3D rendering

La manière Softanza, exécutée

Ce que Softanza fait autrement dans ce domaine, montré par du code tiré de ses narrations et de ses gardes, et exécuté pour cette page.

Une formule d'une ligne devient un noyau GPU ; l'écrire ne demande aucun appareil, et le code produit se lit avant toute exécution.

Softanza
k1 = StzKernelMakerQ()
k1.TakesVector(:A)
k1.TakesVector(:B)
k1.TakesScalar(:alpha)
k1.ReturnsVector(:C)
k1.ForEachElement('{ @C = alpha * @A + @B }')
cW = k1.ToWGSL()
? cW
Sortie
struct StzTile { xoff : u32, p0 : u32, p1 : u32, p2 : u32 }
@group(0) @binding(0) var<uniform> tile : StzTile;
struct P { n : u32, pad : u32, s_alpha : f32 }
@group(0) @binding(1) var<uniform> p : P;
@group(0) @binding(2) var<storage, read> v_a : array<f32>;
@group(0) @binding(3) var<storage, read> v_b : array<f32>;
@group(0) @binding(4) var<storage, read_write> v_c : array<f32>;
@compute @workgroup_size(256)
fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
  let i = gid.x + tile.xoff * 256u;
  if (i < p.n) { v_c[i] = p.s_alpha * v_a[i] + v_b[i]; }
}

exécuté le 2026-10-01 21:17 dans la bibliothèque au commit 0e72e2e2c ; tiré de base/test/gpu/gpu_declarative_narrated.ring(s'ouvre dans un nouvel onglet)

Les couloirs, un par un

Les couloirs et leurs notes sont cités tels qu'ils ont été lus à la source, le Read from the source on 2026-09-16, from a read-only main worktree.

The calibration foundry
Strong
A checker runs reference vs candidate at a visible and a hidden shape, refusing by name any time under a measured roofline; a shape-keyed store keeps the winnergpu_verify.zig / gpu_foundry.zig (GK0)
Device & runtime (wgpu)
Strong
gpu.zig over vendored wgpu-native v29: generation-keyed handles, bounded VRAM cache, WGSL compile-cache, TDR-safe tiling, async dispatch, live instrumentsgpu.zig
Compute kernels
Strong
A WGSL kernel library: matmul (tiled + register-blocked), pairdist, softmax, reductions, FFT convolution (Stockham radix-2), fused multi-head attentiongpu_ops.zig / gpu_fft.zig
Compute + render on one device
Strong
Compute and render in one DLL sharing one device: instanced 2D display list, HarfBuzz text, texture atlas, 3D meshes in one instanced draw; zero-copy provengpu_scene.zig / gpu_text.zig / gpu_scene3d.zig
Acceleration seams (GS)
Strong
t-SNE 5-8x, UMAP 9.8-16.5x, k-means up to 6.1x, semantic index 2-2.5x, neural backbone 5.3x, vector search 17.9x; each with a bit-identical CPU fallbacktsne_gpu / umap_gpu / kmeans_gpu / neural_backbone.zig
W-string -> WGSL transpiler
Solid
gpu_wgsl.zig turns a stzKernelMaker spec into elementwise WGSL: f32-only, 20-function whitelist, refuses unknown functions by name; elementwise-onlygpu_wgsl.zig / stzKernelMaker
Browser / WebGPU edge tier
Solid
The transpiler compiles into stz.wasm; same spec -> byte-identical WGSL native vs browser -> f32-exact results (5/5); elementwise kernels onlytest/gpu/edge_proof
Residency & buffer model
Solid
Upload once -> run N kernels -> read once; every op takes and returns stzGpuBuffer handles; bounded FIFO VRAM cache; single-device, not usage-awarestzGpuBuffer
Idle / power management
Solid
stz_gpu_wake(cap_ms) does adaptive copies until one runs at full speed; every guard wakes the device before timing; idle-aware routing (GK1b) not builtWake(400)
Precision — f64 on GPU
Partial
f32 throughout; f64 refused by measured decision (consumer NVIDIA runs it at 1/64 of f32); the f64 solver tier stays CPU SIMDgpu_math.zig
Multi-GPU / scaling
Partial
Adapter enumeration and selection of one device, per-adapter calibration; no two-device parallelism, out of scope with a pre-written 1.5x kill lineSelectAdapter
3D render depth
Partial
A camera, one directional light, instanced meshes in a single call; no PBR materials, shadows, post-processing or a deep scene graphgpu_scene3d.zig / gpu_mesh.zig