Designing the Processing Pipeline
Stages, buffers, and data flow.
Designing the Processing Pipeline is a free CUDA Academy lesson on CoddyKit — lesson 1 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the CUDA Academy learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.
Think in Stages
A real image pipeline is a chain of stages: load, blur, sharpen, color-correct, save. Each stage is one clear transformation you can reason about alone. 🧩
Data Flows One Way
Pixels move forward through the pipeline: each stage reads the previous output and produces the next input. This one-way data flow keeps the design simple to follow.
Buffers Hold the In-Between
Between two stages you need a place to park pixels. A buffer is just a device array that one kernel writes and the next kernel reads. Plan a buffer per boundary.
float* d_stage1;
cudaMalloc(&d_stage1, width * height * sizeof(float));Ping-Pong Two Buffers
You rarely need a fresh buffer per stage. Ping-pong between two buffers: read from one, write to the other, then swap. Two buffers serve a whole chain.
std::swap(d_in, d_out);One Kernel Per Stage, For Now
Start with one kernel per stage. It is the clearest design and the easiest to verify. You will fuse stages later once each one is correct.
Map Pixels to Threads
The natural mapping is one thread per pixel. A 2D grid covers width and height, so each thread owns exactly one (x, y) location to process.
int x = blockIdx.x * blockDim.x + threadIdx.x;
int y = blockIdx.y * blockDim.y + threadIdx.y;Index With Row Pitch
Images are stored row by row. Turn (x, y) into a flat offset with row-major indexing so every thread reads the right pixel.
int idx = y * width + x;Guard the Image Borders
Your grid is rounded up, so some threads fall outside the image. A simple bounds check keeps them from touching memory they should not.
if (x >= width || y >= height) return;Choose a 2D Block Shape
A block like 16x16 or 32x8 gives good coverage and warp-friendly rows. Pick a 2D block shape that divides the image cleanly when you can.
dim3 block(16, 16);
dim3 grid((width+15)/16, (height+15)/16);Allocate Once, Reuse Often
Allocating device memory is costly, so do it once before the loop. Reuse the same buffers for every frame instead of malloc and free each time.
Sketch Before You Code
Draw the stages, their buffers, and the arrows between them first. A clear diagram of data flow catches design mistakes long before any kernel runs. ✏️
Quick Check
You have a chain of stages. How do you avoid allocating a new buffer for every stage?
Recap
You designed a pipeline as one-way stages joined by buffers, mapped one thread per pixel with a 2D grid, and learned to ping-pong buffers and sketch the flow first. 🎯
Frequently asked questions
Is the “Designing the Processing Pipeline” lesson free?
Yes — the full text of “Designing the Processing Pipeline” is free to read here on the web, and the CUDA Academy course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the CUDA Academy course, upgrade to CoddyKit PRO.
What will I learn in “Designing the Processing Pipeline”?
Stages, buffers, and data flow. You practise CUDA Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.
Do I need any experience to start CUDA Academy?
No prior experience is required. CUDA Academy on CoddyKit is structured for beginners through advanced learners; this is — lesson 1 of 4, so you can start here or from the beginning and move at your own pace.
How long does the “Designing the Processing Pipeline” lesson take?
Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.
Can I write and run code in this CUDA Academy lesson?
Yes. Every CUDA Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.
All lessons in this course
- Designing the Processing Pipeline
- Fusing Filters into One Kernel
- Streaming Tiles for Big Images
- Profile, Optimize, Ship