Updated "Sep 0.10.0 - 21 GB/s CSV Parsing Using SIMD on AMD 9950X 
" to make it 300% clear the graph shows #performance progression over different Sep, #dotnet versions and CPUs.
To show how runtime and library improvements go hand in hand with hardware changes. E.g. AVX512 #SIMD
As it should be 
Faster Integer Division with Floating Point - Multiplication on a common microcontroller is easy. But division is much more diff... - https://hackaday.com/2024/12/22/faster-integer-division-with-floating-point/ #softwaredevelopment #softwarehacks #optimization #assembly #avx-512 #x86_64 #simd #x86
there's this trick i randomly found a few years ago and i've been wondering if there's a name for it or if other people have done this before
```
for enforcing floating point determinism with realigned buffers
if we have
x x x 0 1 2 3 4 5 6 7 x x x
where x is the identity for my operation, and our operation is commutative (not necessarily associative)
then adding x padding doesn't affect the result as long as we do a tree reduction at the end
e.g.
accumulate in register: v = 0+4 1+5 2+6 3+7
tree reduction step 0: (0+4)+(2+6) (1+5)+(3+7)
tree reduction step 1: ((0+4)+(2+6)) + ((1+5)+(3+7))
if we add padding (e.g., by realigning the buffer and using a masked load)
accumulate in register: v = x+1+5 x+2+6 x+3+7 0+4+x
tree reduction step 0: (1+5)+(3+7) (0+4)+(2+6)
tree reduction step 1: ((1+5)+(3+7)) + ((0+4)+(2+6))
commuting the elements shows us that this is the exact same result as the previous one, so the bit pattern of the final result is unaffected (modulo signed zero, nan, etc)
```
Hey friends! Looking for clarity on the topic of the matrix extensions to #RISCV.
I’ve seen a lot of proposals for specs around, but is there an actual, in progress, official *spec* that someone can point me towards?
Clang/LLVM friends, trying to understand *why* Clang (18) doesn't see through what seems to me like an obvious optimization.
#compiler_explorer link here, explanation of what I don't understand follows:
https://godbolt.org/z/j8WqsMjb6
Going through Hackers delight and doing some of the dirt simple exercises, I dumped the assembly for Chapter 1 exercise 2 "loop that goes from 1 to 0xFFFFFFFF". (changed to not fault in CE)
(continues in next post, but putting hashtags here)
One of the best SIMD intro articles I've ever come across thus far. Very nicely explains all the core concepts and operations, lots of sketches/diagrams... Noice! 
https://mcyoung.xyz/2023/11/27/simd-base64/
Btw. If you're using TypeScript/JavaScript, you can play with some of these concepts/ops directly from the REPL using https://thi.ng/simd. This package uses WASM behind the scenes, but doesn't expose the full set of available SIMD instructions (it's a lil' bit more highlevel...)
Also see recent #HowToThing post and practical example about it here:
https://mastodon.thi.ng/@toxi/111283262419126958
#HowToThing #025 — Sampling, fitting, transforming & plotting 10k data points per frame using a whole bunch of underexposed thi.ng packages:
- https://thi.ng/colored-noise: using violet noise as fake data source
- https://thi.ng/matrices: fitting/transformation matrix creation
- https://thi.ng/simd: WASM-based batch processing
- https://thi.ng/malloc: Memory management for WASM/SIMD data buffers
- https://thi.ng/hiccup-canvas: 2D canvas visualization
As noted in the comments, the SIMD batch processing here is to illustrate the overall usage and handling. In this specific example, the main bottleneck is the actual canvas drawing step (esp. in Firefox, which in this case is ~3.75x slower than Chrome [latter easily manages 60fps]). The SIMD step could handle magnitude(s) more points per frame, also on FF...
As an aside, this is now already the 140th (!!!) fully documented small example project, bundled as part of the https://thi.ng/umbrella monorepo... Please do tell me at which point the prejudice of not having enough starting points & info about these packages will be fading into oblivion... 
Demo:
https://demo.thi.ng/umbrella/simd-plot/
Source:
https://github.com/thi-ng/umbrella/tree/develop/examples/simd-plot/src/index.ts
Also big thanks to Maximillian Schulte for sending me off on this topic (as a tangent) via an issue on GitHub... I've been meaning to create more examples for these above packages for a while! Last but not least, hat tip & nerd sniping @demofox re: colored noise... 
Hi friends! Very excited to announce that I'll be giving an @easybuild Tech Talk on the 13th of October on #AVX10!
The Talk is titled "AVX10 for HPC:
A reasonable solution to the 7 levels of AVX-512 folly"
Registration is free, all #x86, #AVX, #AVX512, #SIMD, and #HPC experience levels welcome!
The page is here: https://easybuild.io/tech-talks/008_avx10.html
And you can register here! https://event.ugent.be/registration/ebtechtalk008avx10
As I've been updating the build files for my various #ziglang projects & templates, also learned that quite a few of them have to be overhauled/refactored due to syntax changes and a more strict compiler. One example is this #WASM #voxel #renderer from 1.5 years ago which doesn't build anymore without major code updates, but the old build still works:
https://demo.thi.ng/zig/voxel-trace/
Reload for random views. Press `x` to export current frame. The renderer is incremental (never finishes) and slowly reduces pixel size from 8 down to 1. It would be much faster, but I had some ideas for creating a more stylistic output and in this current state it only renders a fixed area per frame...
The 2-bit 512^3 voxel model was generated with a custom fork of @R4_Unit's voxel automata... 
Other renders & process on my old Twitter:
https://twitter.com/search?q=from%3A%40toxi+voxel+ziglang
Ps. This renderer is heavily using this #SIMD vector library:
https://github.com/thi-ng/zig-thing/tree/main/vectors
...and is a rewrite of my 2013 hybrid #OpenCL #Clojure voxel renderer:
An #introduction,
I'm Nick, a principal software engineer at #Akamai. I've been working on Image & Video Manager to make working with images on the #web fast and easy. I've worked on bits as high as frontend UI and as low as hand written #ASM and #SIMD. #webperf
I'm enthusiastic about synthesizers, particularly modular synths. I use a large #Buchla clone system in the studio and a #Eurorack system when I perform live. #synth
I also enjoy ergonomic mechanical keyboards.
Nice to meet you!
Sep 
Tweaks and new 
Lots of benchmarks
