@valigo@DoctorGester independent (e.g. loading adjacent pixels for a filter) loads are fint until you saturate hw.
Also, when threads hit waiting stage, GPU can put them aside, grab another pack and start same shader. Once those hit waiting, it switches back. But only if there is enough registers
@valigo@DoctorGester this breaks a bit once your loads are dependent. Driver will try to distribute the compute work between loads, but usually you load memory for things you need right away, so its only possible to extent - you simply wont have enough work to put between loads
@valigo@DoctorGester cool thing you may like to know: gpus have mechanisms to hide memory latency that are more than just cache.
Driver will split memory load into 2 parts: "initialize" and "collect" load, basically executing the expensive part asynchronously
@valigo@DoctorGester making shaders as simple as possible is also bad - you want to utilize hw.
This is why consoles are lovely to optimize for!
You know exactly how many registers they have, so you can tune shaders for no waste/idle.
Note: `if (cond) { x *= 2.0; }` isn't a branch
@valigo@DoctorGester worth noting: GPUs use registers for storing live data, not for everything.
E.g. zeroing out a number doesn't. Unlike a lot of vertex>fragment interpolation (use profiler to see).
you only have so many registers, when each thread uses more than total/threads, less get executed
@Hesamation "how people interact with llm" information is usable enough. In relation to coding, IDEs might provide even more (e.g. not only whether you accepted the change, but also what have you done afterwards if /not)
@TheGingerBill what's your retrospective on Odin's linalg primitives (op overloading, read/write swizzles)? How have they aged? Any regrets or "lessons learned"? Opinion on "shading" languages would also be handy
trying to bring them to Rust
@SpartanDev@nixcraft move computations up in the pipeline, i can see quite a lot of uniforms that could be one CPU side computation. Your driver might be magically moving this to CPU but this might not stand for all of them
@SpartanDev@nixcraft 5min thought:
2 pos / 2 uv corners = 8 floats per char is enough (rn each is duplicated twice - 16 floats). If UV size is proportional to screen size, reduces to 6 floats.
draw N instances, 6 verts each, bind a buffer with per-instance rate, calculate clip/UV in shader
@SpartanDev@nixcraft the picture shows you can saturate GPU with work and that there is nothing idiotic like per-drawcall GPU memory writes with flush, or drawcall per character