Fusión de filtros en un solo kernel

Running five kernels means five launches and five round-trips to global memory. Fusing filters into one kernel cuts both, often giving a big speedup. 🚀

Every kernel launch costs a few microseconds. On a tiny image that fixed launch overhead can dwarf the real work, so fewer launches means more useful time.

Separate stages write a pixel to global memory then read it right back. Fusing keeps that value in a register, erasing the wasted round-trip entirely.

In a fused kernel each thread reads its pixel a single time. That one load then feeds every filter in sequence without touching global memory again.

Apply each filter to the value already in hand. The pixel flows through brightness, gamma, and contrast as plain math, all kept in fast registers.

After the whole chain runs, store the final result. One store replaces the many writes that separate kernels would have made.

Filters that touch only one pixel are pointwise and fuse with zero fuss. Brightness, gamma, and color tweaks are the easiest wins to combine.

A blur reads nearby pixels, so fusing it needs shared memory tiles, not just registers. Fuse pointwise stages freely and treat stencils with extra care.

A big fused kernel uses more registers per thread. Too many and occupancy drops or values spill, so fuse aggressively but keep an eye on the cost.

Fusing reorders work, so always compare the fused output against the staged version. A quick diff confirms the math still matches before you celebrate.

The payoff is real: a single launch reads, transforms, and writes each pixel exactly once. That is the heart of a well-tuned fused image kernel.

You merged three pointwise filters into one kernel. What is the main performance win?

You learned to fuse filters: load once, chain pointwise math in registers, write once. It cuts launches and global traffic, but watch register pressure and verify the output. ✅