How to accurately predict loop execution duration?

You cannot simply multiply the number of loops with some constant, since you don't take the overhead of the rest of the code into account.

Instead, the correct formula is: time(loops) = loops * K1 + K2.

We have the times for 1 and for 2 loops. This gives us the constant K1.

K1 = time(2) - time(1) = 0.017625 ms - 0.0100625 ms = 0.0075625 ms

With this result we can calculate the constant K2.

K2 = time(1) - 1 * K1 = 0.0100625 ms - 1 * 0.0075625 ms = 0.0025 ms

Let's look at results again.

Looks good, doesn't it? The differences for the last two values are certainly rounding errors of the used output routine. Calculations with floats are commonly limited to about 6 non-zero digits.

Note 1:

K1 is the time for one loop:

• Checking the outer loop condition (positively)
• The inner for loop inside the outer loop
• The dummy calculation and assignment

K2 is the time of the one-time overhead:

• Start/stop the timer (details depend on the exact working of the timer)
• Call and return of the function
• Prologue and epilogue in the function
• Quitting the outer loop

K1  K2
    x   T0CON0bits.EN = 1; // Start timer
    x   DummyLoop(10000);
    x   T0CON0bits.EN = 0; // Stop timer

    x   void DummyLoop(long y)
    x   {
    x       long counter = 0;
    x       long DummyArray[3];
    x       char loopArray;
    
x   x       while(counter < y)
x           {
x               for(loopArray = 0; loopArray < 3; loopArray++)
x               {
x                   DummyArray[x] = 10000/50; // Some int division operation
x               }
x               counter++;
x           }
    x   }

Note 2:

You can sum these times from the generated machine code.

Or if this is too complicated, use a port pin to toggle and an oscilloscope to measure the interval at this pin.