Introduction to compute shaders | Hacker News Reader

Introduction to compute shaders

anteru.net

137 pointsnoch12 comments

This is certainly interesting and informative for somebody who already kinda knows how the code->gpu->screen pipeline works and wants to know how it's made fast, but I'm still missing some of the "pre"/"post" background for how/when the request to the shading system is made and what happens after the GPU is done.

I just started poking at doing computer graphics "from scratch" (working my way up from ray tracers now). I know that modern graphics systems are huge and ultimately your C++ library or whatever is just gonna flip some bits on graphics-card registers/busses or something, but I was really hoping for some background on "here's a bit of code that asks the shader to add depth to a triangle" and then how that gets mapped back to the screen.

Start here. Work through all 5 parts. http://chrishecker.com/Miscellaneous_Technical_Articles

You'll have to implement each part yourself to understand them. It's not something that can be skimmed. But it's so worth it.

After that, most of the mystery of graphics will be gone. (But not the thrill.)

One of the most frustrating aspects of learning graphics programming was that most resources immediately start talking about theory. Partial derivatives of uv's and xy's, gradient values and mipmap selection, and you're just trying to draw a damn picture on a triangle. Learning from working code and implementing it yourself is a better teacher.

https://fgiesen.wordpress.com/2011/07/09/a-trip-through-the-...

is a great intro to GPU architecture that I think answers your question indirectly.

It's mainly just command FIFOs, semaphores, and cache flushes. Vulkan's API is a pretty good high level approximation of current architecture.

I think these might help. yes they are WebGL but the concepts are the same

http://webglfundamentals.org

You can look at MIAOW which is an open source implementation of the AMD Southern Islands GPU ISA.[0]

The RTL can be found here [1]

The best part is the white paper [2], PDF

I had been looking around for information similar to ECS[3], building a GPU from first principles and MIAOW is one step closer that.

[0] http://miaowgpu.org/index.html

[1] https://github.com/VerticalResearchGroup/miaow

[2] https://raw.githubusercontent.com/wiki/VerticalResearchGroup...

[3] https://www.nand2tetris.org/

Not sure "Introduction to compute shaders" is the right title here. I was expecting to see come code, but it's more about the history of its design.

There's some great information about how GPUs are organized here. It's interesting that GPUs and CPUs aren't that different, even though maximizing performance requires different considerations. SIMD lanes are just wider on the GPU, and you have to treat memory differently (registers are bigger, main memory has higher latency but better bandwidth, etc).

It's also funny that Nvidia lists the total number of SIMD lanes as "CUDA cores", meaning that a single compute unit with 64 SIMD lanes counts as 64 CUDA cores. That's cheating, if you ask me :P

In Volta, each "SIMD lane" has its own PC, if that makes it more legit.

I admit I'm not really keeping up here, but if it has its own PC (rather than doing SIMT lane-masking), how is it a SIMD lane?

That sounds like manycore, not SIMD/SIMT, no?

Citation? SXM2 didn't look that different, and adding that many ports to the new instruction cache they added would be absolutely crazy.

https://devblogs.nvidia.com/inside-volta/

Ctrl-F "volta SIMT model"

And to browse cool shaders: https://www.shadertoy.com/

Reply on news.ycombinator.com