good news: my GPU-based SSAO implementation is looking good
bad news: I'm discovering all of the ways that my CPU-based implementation is wrong
Remote
Matt Keeter
@mjk@hachyderm.io
mastodon 4.7.3Weird CAD and graphics research; embedded software at @oxidecomputer@hachyderm.io
1397 Followers
991 Following
39 Posts
Joined November 13, 2022
tired: "Just trust the compiler, it's smarter than you are"
wired: "You are going to generate a fucking jump table, so help me god"
(this has made my GPU bytecode interpreter 1.5× faster)
Got my first PR to a rust-lang repo merged 🎉
Before going on leave, I published a small crate named ‘datamap’
If you, like me, have stored addressed chunks of non-overlapping data in a BTreeMap> then been annoyed at handling all the edge cases, this is the crate for you!
https://docs.rs/datamap/latest/datamap/
It's a weird feeling to get an email which
- asks questions about one of your open-source projects
- references specific files in the repo
- those files are definitely not in the project
Are you from a parallel universe? Do they have any cool Fanta or Kit-Kat flavors over there?
It's best practice for Rust crate docs to start with at least one research paper citation, which must be read before continuing.
quick thoughts on the Bun rewrite:
My "This is clearly a legitimate WebGPU rendering crate, not malware" t-shirt is raising questions—
I've just announced my new (blazing-fast) kernel for implicit surfaces: https://mattkeeter.com/projects/fidget
It's got something for everyone: Cool graphs! Multithreaded WebAssembly! Terrible mesh topology! JIT compilers!
After three years, I'm excited to finally show it off to a wider audience 😎
If this whole "computers" thing doesn't work out, I've got a bright future in aftermarket crib accessories!
...is this dolphin telling me to commit crimes?
bytecode serialization: 0.3 ms
GPU compute kernel: 8 ms
waiting for the WebGPU polling thread: 100 ms
GPU-to-CPU buffer copy: 2ms
someone help me budget this, my framerate is dying
https://bugzilla.mozilla.org/show_bug.cgi?id=1870699
Replying to
there are many blog posts that you can read today, but only one of them includes the sentence "the thing debugs like a goldfish with logorrhea"
Email Subject Lines With Threatening Auras
gonna go see the new adaptation of The Odyssey that everyone is talking about:
hey chat is it good when a house on my block is held together by 2x4s?
Replying to
@lisyarus@mastodon.gamedev.place
It's a bytecode interpreter for rendering implicit surfaces on the GPU! Bytecode lets us generate simplified sub-expressions while rendering (staying on the GPU the whole time), which overcomes the fact that GPUs kinda suck at running bytecode VMs.
(I'm basically porting + revamping https://www.mattkeeter.com/research/mpr/ to run with Rust + WebGPU)
Replying to
@whitequark@social.treehouse.systems I got nerd-sniped on bluesky to look at the actual wasm
The tailcall implementation does use return_branch_indirect as expected: https://gist.github.com/mkeeter/66df08eaf580f293c5f950baa43703b5
The traditional bytecode VM, on the user hand, uses br_table, at the end of a 250-deep stack of blocks (!):
https://gist.github.com/mkeeter/66df08eaf580f293c5f950baa43703b5
It's kinda incredible: each opcode is its own block, and they each end with a break N instruction to break back out to the top level.
Replying to
@gustav@merveilles.town It's a good question – if someone had come to me and said "I'll implement a rough draft of the x86-64 backend for $35", I'm not sure how I would have reacted.
And there's also the question of whether the vibes be different if I did this experiment with a local model, instead of paying Anthropic?
I care about the craft of programming and quality of the resulting code, which is why I spent days rewriting the initial implementation (git shows 924 insertions(+), 1504 deletions(-) on a 2351-line file), but I wouldn't have gotten started without the AI boost – too much else on my plate, and the barrier to getting started was high...
Replying to
and if you want to see it, the code is right here:
https://github.com/oxidecomputer/crucible/blame/2b58dba8/downstairs/src/extent_inner_raw.rs#L258-L424
between Porchfest and opening day for the Union Square Farmer's Market, it's a big Saturday for aging millenials in Somerville
Replying to
@8bit@social.lol and obviously I work with a tremendous team of talented coworkers who make this possible, up and down the stack!
Replying to
@lesley@mastodon.gamedev.place I wish this was possible on the GPU, but it's a long ways off!
(especially because WebGPU is the least common denominator of all the other graphics APIs)
Replying to
@jcreed@mastodon.social Two things are happening here: you're clipping into the near plane (as you suspected), and then interval arithmetic is proving that those regions are entirely full (because they're fully inside the sphere) and not subdividing down to voxels.
Normals are only rendered after per-voxel evaluation; tiles which are skipped due to interval evaluation write to the heightmap (so they block tiles behind them), but not to the normal map.
(There's nothing inherent about this behavior, that's just how I've coded it at the moment)
Replying to
@folkertdev@hachyderm.io Awesome, I was secretly hoping that a non-trivial example could be helpful to folks working on the feature 😊
Thanks for pushing it forward – I'm (obviously) very excited about it!
Replying to
@josi@fosstodon.org It is!
(Well, the demo is Rhai, which is a Rust-native scripting language, but the library as a whole is in Rust)
Replying to
@sarna@types.pl I've very much enjoyed following Ian's work, and definitely need to chat with them at some point 😄
Waymo spotted in Inman Square 👀
if only there was a high-throughput way to convert a large memory-unsafe codebase into a memory-safe language
https://github.com/v12-security/pocs/tree/main/fragnesia-5db89c99566fc
Replying to
Of course, this would be inefficient to do for just me – you'd want to have larger caches that could be used by multiple people, to amortize the cost of restocking them.