Many Scree Space effects sucha as post-processing, SSAO or SSreflections are often done as a pixel-shader over the G-buffer (a texture representing the geometric and material properties of everything on screen as a multi-layered 2D picture)
As is often the case with graphics code, branching does not save you much performance if at all, so making a shader that computes, say:
"For every pixel on screen, check its angle on screenspace and march a ray bouncing off of it and modulate the opacity based on the material's reflectivity"
is just as fast as:
"check first if the pixel is reflective and only if it actually is then march the reflection ray"
In fact, the second option might be slower because internally the GPU is doing the ray-marching for every-pixel anyway and just discarding the already computed results if the first check turns out negative and so the initial check just wasted extra compute and BW for no reason.
Albeit, there are some smarter algos that manage to make this kind of optimisation possible by dividing the work in multiple steps, but that on itself adds enough overhead that it might not be a win in every case.
Afterall, in a dynamic scene, you never know if your screen might end up completely covered by a highly reflective material, so you might as well progran your renderer in a way that its performance is agnostic to the amount of reflective pixels anyway.
