simd

Bilingual

Matt Godbolt's blog
2 months ago
- SIMD allows CPUs to process multiple data points with a single instruction, improving performance for array-heavy computations.
- Compilers can automatically vectorize loops with flags like -O3 and -march=skylake, but require proper data layout (e.g., arrays of integers).
- Conditional updates (e.g., max) can be vectorized using mask moves or by rewriting as unconditional operations that map to SIMD instructions like vpmaxsd.
- Compilers add runtime checks for array overlap to ensure vectorization correctness, often generating a fallback scalar loop.
Matt Godbolt's blog
2 months ago
- SIMD auto-vectorization works efficiently for integer sums by processing 8 integers per loop iteration and then summing the 8 subtotals with fix-up code.
- Floating-point addition is not associative due to rounding, so compilers cannot safely regroup additions the same way, leading to scalar per-element addition even when processing 8 floats per iteration.
- Workarounds include using -Ofast or -funsafe-math-optimizations (global, risky) or using a GCC attribute to assume associativity for a specific function; std::reduce with unsequenced execution policy did not work in testing.
Matt Godbolt's blog
2 months ago
- Compilers optimize string comparisons against compile-time constants using overlapping memory reads and bitwise XOR operations.
- For constant strings of varying lengths, compilers inline comparisons and use efficient techniques like checking length first, then performing byte or word-level comparisons.
- The permutation for comparing a 7-character string uses two overlapping 32-bit reads and XOR operations to avoid individual byte checks, leveraging that XOR of identical values yields zero.
- Modern compilers (e.g., Clang) automatically apply such optimizations (e.g., branchless conditionals, unaligned reads) from simple code like `sv == "ABCDEFG"sv`, allowing developers to focus on clarity.
- Differences exist across compilers: for instance, GCC may produce more straightforward but less optimized code compared to Clang for similar string comparisons.
Ghostty Devlog 006
2 months ago
- Focus on IO throughput speed improvements in Ghostty terminal emulator.
- SIMD optimization for plain text processing: 7.3x faster ASCII, 16.6x faster UTF-8 decode.
- Precomputed lookup tables for codepoint width: 2.8x faster ASCII, 5x faster random UTF-8.
- Optimized grapheme break detection using small lookup table, nearly 8x faster.
- CSI sequence fast-path parser improved throughput by 1.4-2x in control-heavy workloads.
- Real-world results: cat'ing large files 2-5x faster, outperforming other terminals even with grapheme clustering.
- Community contributions and future plans to further improve performance.
SIMD for Collision
2 months ago
- The author applies 'wide SIMD' to collision detection by processing multiple edge-edge tests simultaneously, similar to previous work on the contact solver.
- 'Wide SIMD' processes multiple work units (like 4 edges) at once, differing from 'narrow SIMD' which vectorizes single 3-vector operations.
- The Separating Axis Test (SAT) for convex hull collision in 3D has quadratic complexity, especially edge-edge tests which dominate for complex hulls.
- With many edges (e.g., 89 edges in a boulder hull), SIMD using SSE2 gives over 2x speed improvement in the full simulation.
- The optimization primarily benefits complex hulls; it has negligible effect on box-box collisions.
- Box3D uses SAT instead of GJK+EPA, avoiding collision margins and numerical brittleness.
Everyone Should Know SIMD
2 months ago
- SIMD enables CPUs to process multiple values in parallel, often used to accelerate loops over large data.
- Common SIMD code follows five steps: broadcast constants, loop over vector-width chunks, perform parallel operations, reduce results, and handle remainder with a scalar tail.
- A real example (searching for control characters) shows how a scalar loop can be vectorized, achieving 4x-16x speedup.
- Compilers can auto-vectorize simple loops but are often limited; manual SIMD provides explicit and predictable performance.
- Every developer should understand SIMD basics and recognize opportunities for vectorization without fear.
Static search trees: 40x faster than binary search (2024)
2 months ago
- The post implements an optimized static search tree (S+ tree) for high-throughput searching of sorted 32-bit unsigned integers, focusing on throughput measured as queries per second.
- Key optimizations include using SIMD instructions for node searches, batching queries to parallelize memory accesses, prefetching to reduce latency, and pointer arithmetic to streamline operations.
- Tree layouts like S+ trees with branching factor 16 or 17 are explored, with interleaved queries balancing CPU and memory-bound workloads, achieving over 40x speedup from 1150 ns/query to 27 ns/query for 4GB data.
- Prefix partitioning by top bits is tested but adds complexity with limited speed gains, especially on skewed real data like human genome k-mers, making it less practical than interleaved queries.
- Future work suggestions include branchy search for variable iterations, interpolation search to reduce RAM accesses, packing data into 16 bits, supporting range queries, sorting queries for cache reuse, and applying to suffix array searching.

Matt Godbolt's blog

Matt Godbolt's blog

Matt Godbolt's blog

Ghostty Devlog 006

SIMD for Collision

Everyone Should Know SIMD

Static search trees: 40x faster than binary search (2024)