warning X3557: loop only executes for 0 iteration(s), forcing loop to unroll

The compiler produce a "warning X3557: loop only executes for 0 iteration(s), forcing loop to unroll" and I don't understand why.

Here is the source code. It is a revisited itoa() function for HLSL producing resulting ascii codes in an array of uint.

#define ITOA_BUFFER_SIZE 16
// Convert uint to ascii and return number of characters
uint UIntToAscii(
    in  uint Num,                   // Number to convert
    out uint Buf[ITOA_BUFFER_SIZE], // Where to put resulting ascii codes
    in  uint Base)                  // Numeration base for convertion
{
    uint I, J, K;

    I = 0;
    while (I < (ITOA_BUFFER_SIZE - 1)) {   // <==== Warning X3557
        uint Digit = Num % Base;
        if (Digit < 10)
            Buf[I++] = '0' + Digit;
        else
            Buf[I++] = 'A' + Digit - 10;
        if ((Num /= Base) == 0)
            break;
    }

    // Reverse buffer
    for (K = 0, J = I - 1; K < J; K++, J--) {     // <==== Warning X3557
        uint T = Buf[K];
        Buf[K] = Buf[J];
        Buf[J] = T;
    }

    // Fill remaining of buffer with zeros to make compiler happy
    K = I;
    while (K < ITOA_BUFFER_SIZE)
        Buf[K++] = 0;

    return I;
}

I tried to rewrite the while loop but this doesn't change anything. Also tried to use attribute [fastopt] without success. As far as I can see the function produce the correct result.

Any help appreciated.

Solution

The warning you are getting is

WAR_TOO_SIMPLE_LOOP 3557 The loop only executes for a limited number of iterations or doesn't seem to do anything so consider removing it or forcing it to unroll.

The warning is pretty much self explanatory, if you consider that loops are considered inefficient in GPGPU, so the compiler tries to unroll them when it's possible. What the compiler is telling you is that you created some loops that can run more efficiently if unrolled, or can be removed because they never run. If a loop is unrollable, it means that you can predict at compile time the number of times it will run. Your loops on first look should not fulfill this criterium.

    I = 0;
    while (I < (ITOA_BUFFER_SIZE - 1)) {   // <==== Warning X3557
        uint Digit = Num % Base;
        if (Digit < 10)
            Buf[I++] = '0' + Digit;
        else
            Buf[I++] = 'A' + Digit - 10;
        if ((Num /= Base) == 0)
            break;
    }

This while loop runs up to 15 times I < (ITOA_BUFFER_SIZE - 1), depending on (Num /= Base) == 0. Final value of I is between 1 and 15, depending on how if ((Num /= Base) == 0) evaluates on each cycle. Nonetheless, it still is unrollable, because the compiler may still insert a conditional jump over the iterations.

// Reverse buffer
for (K = 0, J = I - 1; K < J; K++, J--) {     // <==== Warning X3557
    uint T = Buf[K];
    Buf[K] = Buf[J];
    Buf[J] = T;
}

This second loop, instead should not be unrollable, because I should not be known to the compiler. The warning you reported

warning X3557: loop only executes for 0 iteration(s), forcing loop to unroll

might refer to the first loop if if ((Num /= Base) == 0) always evaluates to true on first iteration. In that case, I would be equal to 1, and J would be equal to 0 on the second loop. That second loop would not run because K < J would evaluate to false on first iteration. What you get in the end if you let it [unroll] is probably a single iteration on the while loop and the complete removal of the subsequent for loop. I highly suspect this is not your intended behaviour, and while it might suppress the warning, you might want to check the code and see if something does not run the way it should.