for-loop(downto,Reversed) vs for-loop(increase mode) vs while-loop in Delphi

Question

I have a micro-optimization issue. I have 3 methods for processing typed-Pointer(array) . Which one is better?

1

for I:=0 to ArrCount-1 do
begin  // I:Var is unused in below-block
  Inc(P) ; // P is typed-Pointer
  // do somethings 
end;

2

for I:=ArrCount-1  downto  0 do
begin  // I:Var is unused in below-block
  Inc(P) ; // P is typed-Pointer
  // do somethings 
end;

3

While ArrCount>0 do
begin  
  Inc(P) ; // P is typed-Pointer
  
  // do somethings 
  Dec(ArrCount);
end;

Answer 1

The answer that I will give to this question is rather more mundane than perhaps you are expecting. The fastest of these variants is the one that, wait for it, is timed to run most quickly.

It's entirely plausible that on different architectures you'll find that different variants win.

It's also conceivable that different variants will win depending on what is in the body of the loop.

It's also quite possible that the body of the loop takes sufficient time that the loop itself is negligible in comparison.

In short, it depends. Since only you know what happens inside the body, only you can answer the specific question.

As an aside, if the loop body does not refer to the loop variable, then the compiler re-writes the ascending loop as if it were a descending loop. So there may in fact be only two variants here. Indeed, that might mean that all three variants lead to identical compiled code!

Some advice:

• Never optimise without profiling.
• Never optimise code that is not a bottleneck.

Now, if you want me to take a guess, I predict that for any loop body that is more than a trivial nop, you'll find it hard to find any measurable difference between these variants.

I also see that you are using a pointer to walk across an array. You might find that if this code is a bottleneck, and if the loop body just handles this array iteration, that using arr[] indexing is more effective that pointer arithmetic. But again, it depends on many things and you have to profile, and look at the code the compiler produces.

Answer 2

Funny, but looking at disassembly window the speed is depending on weather is the loop variable used inside loop.

1) Not using - code is almost identical:

Project17.dpr.12: for i := 0 to 3 do
0040914D B804000000       mov eax,$00000004
Project17.dpr.13: Inc(j);
00409152 43               inc ebx
Project17.dpr.12: for i := 0 to 3 do
00409153 48               dec eax
00409154 75FC             jnz $00409152

Project17.dpr.15: for i := 3 downto 0 do
00409156 B8FCFFFFFF       mov eax,$fffffffc
Project17.dpr.16: Inc(j);
0040915B 43               inc ebx
Project17.dpr.15: for i := 3 downto 0 do
0040915C 40               inc eax
0040915D 75FC             jnz $0040915b

2) Used - first variant faster a bit because xor faster then mov:

Project17.dpr.12: for i := 0 to 3 do
0040914D 33C0             xor eax,eax
Project17.dpr.13: Inc(j, i);
0040914F 03D8             add ebx,eax
00409151 40               inc eax
Project17.dpr.12: for i := 0 to 3 do
00409152 83F804           cmp eax,$04
00409155 75F8             jnz $0040914f

Project17.dpr.15: for i := 3 downto 0 do
00409157 B803000000       mov eax,$00000003
Project17.dpr.16: Inc(j, i);
0040915C 03D8             add ebx,eax
0040915E 48               dec eax
Project17.dpr.15: for i := 3 downto 0 do
0040915F 83F8FF           cmp eax,-$01
00409162 75F8             jnz $0040915c

You can check third variant yourself.

PS: I am using D2007 for this test.