Why does the performance of my #pragma-unrolled loop degrade if the trip count is not constant?

Question

I have following code using loop unrolling:

#pragma unroll
for (int i=0;i<n;i++)
{
    ....
}

here if n is a defined constant, everything works fine. However, if n is a variable, performance dramatically reduced. I noticed roughly 3 times the instructions are issued and executed. I guess I am looking for a way to do loop unrolling at run time, may be that's just not feasible.

Damalas

Answer 1

CUDA is a compiled language. Loop unrolling is a compiler optimization. Runtime loop unrolling would imply some sort of runtime interpreter or dynamic code generation. That clearly can't happen.

It would make sense that the unrolled case executes as many or more instructions than the naïve loop, because the compiler will replace the loop with repetitions of the loop contents. If the unrolled case executes less instructions, that would imply that the compiler is pre-calculating some or all of the loop contents and replacing code with a constant result.

It all depends on what is contained in the loop.

Homozygous

Even more basic, constants are known at compile time, variables are not. – Encasement

Loop unrolling can and does occur with the open64 even when the trip count of the loop is not known at compile time, and it is often an optimization to do it, because it can increase instruction level parallelism. The "mystery" here is the volume of instructions in the non constant trip count case, and that must be due to code substitution rather than loop unrolling for the constant trip case. – Homozygous

I'll agree with you on the code substitution. I guess I missed out with an assumption that the statements in the loop were not independent. As you said, it all depends on what's in the loop. – Encasement