FOR i = 1 TO 0 is slow?

[MrFreyer]

Hi everyone,

I have a performance question about canceled FOR...NEXT loops.

Is this a bad and slow method of programming?

Code: QB64: [Select]

1. quantity = 0
2.  
3. FOR i = 1 TO quantity
4. '...
5. NEXT i

...and would this be a faster method?

Code: QB64: [Select]

1. quantity = 0
2.  
3. IF quantity > 0 THEN
4. FOR i = 1 TO quantity
5. '...
6. NEXT i
7. END IF

Thanks!

[RhoSigma]

No difference, if "quantity" is already less than the loop's start counter, then the loop will never be executed, but is skipped immediatly. The program proceeds with the line following the NEXT statement. However if "quantity" is greater than the start counter, then you only would add another (useless) check with the IF...THEN block, hence you are slower with your second example.

[Ashish]

It depends on what you intended to do.

Code: QB64: [Select]

1. FOR i = 1 to 0
2. '...
3. NEXT
4.  

It becomes a infinity type loop. It will continue forever unless you quit the program. If your intention was to move from 1 to 0 in a FOR NEXT loop
then you need to mention the STEP.
This will work -

Code: QB64: [Select]

1. FOR i = 1 to 0 STEP -1
2. '...
3. NEXT
4.  

EDIT : Oops. Sorry. This type of loop get skipped in BASIC. Hey, but in other like C++, it does become a forever loop.

[bplus]

FOR ...NEXT is slow loop structure, WHILE ...WEND or DO ...LOOP are faster, of course you have to code exit to avoid infinite loop.

[MrFreyer]

No difference, if "quantity" is already less than the loop's start counter, then the loop will never be executed, but is skipped immediatly. The program proceeds with the line following the NEXT statement. However if "quantity" is greater than the start counter, then you only would add another (useless) check with the IF...THEN block, hence you are slower with your second example.

Okay thanks, good to know.

FOR ...NEXT is slow loop structure, WHILE ...WEND or DO ...LOOP are faster, of course you have to code exit to avoid infinite loop.

So I should never use FOR...NEXT loops? Just DO...LOOPs with an counter as exit condition? Do you know why DO...LOOPs are faster?
I've read that SELECT CASE should also be faster than IF...THEN...ELSEIF (in some cases...). That's also correct?

[bplus]

I only mention this if you really need every boost you can get:

Code: QB64: [Select]

1. _DEFINE A-Z AS _INTEGER64
2. PRINT "Running 4 timed tests please wait..."
3.  
4. n = 1000000000
5.  
6. t! = TIMER
7. x = 0: i = 0
8. doloop:
9. i = i + 1
10. x = x + i
11. IF i < n THEN GOTO doloop
12. PRINT x
13. t2! = TIMER
14.  
15. x = 0: i = 0
16. WHILE i < n
17.     i = i + 1
18.     x = x + i
19. WEND
20. PRINT x
21. t3! = TIMER
22.  
23. x = 0
24. FOR i = 0 TO n
25.     x = x + i
26. NEXT
27. PRINT x
28. t4! = TIMER
29.  
30.  
31. x = 0: i = 0
32. DO
33.     i = i + 1
34.     x = x + i
35. LOOP UNTIL i = n
36. PRINT x
37. t5! = TIMER
38.  
39. PRINT n; "    times adding in Do... LOOP time is "; t5! - t4!
40. PRINT n; "   times adding in FOR... NEXT time is "; t4! - t3!
41. PRINT n; " times adding in While... Wend time is "; t3! - t2!
42. PRINT n; "     times adding in GOTO loop time is "; t2! - t!
43.  
44.  

Here are my results in Windows 10 laptop, core i5
  [ You are not allowed to view this attachment ]  

[SMcNeill]

DO...LOOP is, indeed, faster than FOR...NEXT statements.

The reason is mainly because of error checking and optional parameters need with FOR.

FOR variable = Start TO Finish STEP value

With the above, the translated C-code does several checks before running.  Is value zero?  Is it less than zero?  Greater than?

If value is less than zero (counting down, like from 10 to 1), then we need to repeat the incremental loop until variable is LESS THAN Finish.  If value is greater than zero, we repeat until GREATER THAN finish...

It’s extra decision making which the translated code runs, which a DO...LOOP structure doesn’t have.  Add in error checking, and it just increases the extra steps going on under the hood with FOR loops.

*******************

For optimized speed, use DO instead of FOR.  When speed isn’t such a concern, use FOR for easy of readability and speed coding.

At least, that’s how I recommend them with QB64.

[MrFreyer]

i don't know... :D

[bplus]

Hi McFreyer,

:D  I have to ask, what OS and computer are you using? What version of QB64? 

[Cobalt]

Run from my laptop with Vista I get rather random results from run to run.
but I think his computer is still better than mine.

[SMcNeill]

Let's take a moment to look at how our QB64 code translates into C-code.

First, let's start with a simple FOR...NEXT loop:

Code: QB64: [Select]

1. FOR i = 0 TO 100
2. NEXT

Now, we can't get any simpler than this, and even this simple little batch of code turns into the following:

Code: [Select]

S_1:;
fornext_value2= 0 ;
fornext_finalvalue2= 100 ;
fornext_step2= 1 ;
if (fornext_step2<0) fornext_step_negative2=1; else fornext_step_negative2=0;
if (new_error) goto fornext_error2;
goto fornext_entrylabel2;
while(1){
fornext_value2=fornext_step2+(*__SINGLE_I);
fornext_entrylabel2:
*__SINGLE_I=fornext_value2;
if (fornext_step_negative2){
if (fornext_value2<fornext_finalvalue2) break;
}else{
if (fornext_value2>fornext_finalvalue2) break;
}
fornext_error2:;
if(qbevent){evnt(1);if(r)goto S_1;}
fornext_continue_1:;
}
fornext_exit_1:;
As you can see, there's quite a bit of error checking and conditioning checking going on in the code.  Each time the code runs, we have to check to see if the fornext_step_negative2 is negative or not, and then we check to see if our current value is greater (or lesser) than the final value. 

Now, let's compare this code to how a DO...LOOP is translated.  First, let's start with the QB64 code:

Code: QB64: [Select]

1. i = 0
2. DO
3.     i = i + 1
4. LOOP UNTIL i > 100

And the translation to this simple DO...LOOP code:

Code: [Select]

do{
*__SINGLE_I= 0 ;
if(!qbevent)break;evnt(1);}while(r);
S_2:;
do{
if(qbevent){evnt(2);if(r)goto S_2;}
do{
*__SINGLE_I=*__SINGLE_I+ 1 ;
if(!qbevent)break;evnt(3);}while(r);
S_4:;
dl_continue_1:;
}while((!(-(*__SINGLE_I> 100 )))&&(!new_error));
dl_exit_1:;
if(qbevent){evnt(4);if(r)goto S_4;}
As you can see, there's a lot fewer IF checks going in inside the DO..LOOP, as we don't need to check to see if we're counting up or down with the command.  Those checks are dependent on the user to code what's proper for their needs.

**************************

And, if we turn the checking off, like in the following code, it's even easier to see exactly how large a difference there is in the two processes.

Code: QB64: [Select]

1. $CHECKING:OFF
2. i = 0
3. DO
4.     i = i + 1
5. LOOP UNTIL i > 100
6.  

With checking off, the above code translates into a very simple little:

Code: [Select]

*__SINGLE_I= 0 ;
do{
*__SINGLE_I=*__SINGLE_I+ 1 ;
dl_continue_1:;
}while((!(-(*__SINGLE_I> 100 )))&&(!new_error));
dl_exit_1:;
And, if we do the same with the FOR..NEXT loop, what we see is the following:

Code: QB64: [Select]

1. $CHECKING:OFF
2. FOR i = 0 TO 100
3. NEXT

Which translates to:

Code: [Select]

fornext_value2= 0 ;
fornext_finalvalue2= 100 ;
fornext_step2= 1 ;
if (fornext_step2<0) fornext_step_negative2=1; else fornext_step_negative2=0;
if (new_error) goto fornext_error2;
goto fornext_entrylabel2;
while(1){
fornext_value2=fornext_step2+(*__SINGLE_I);
fornext_entrylabel2:
*__SINGLE_I=fornext_value2;
if (fornext_step_negative2){
if (fornext_value2<fornext_finalvalue2) break;
}else{
if (fornext_value2>fornext_finalvalue2) break;
}
fornext_error2:;
fornext_continue_1:;
}
fornext_exit_1:;
Which, once we compare the two routines closely against each other, easily (in my opinion) showcases why the DO...LOOP structure is inherently faster than the FOR...NEXT translation.

************************

As to why some people are seeing faster times with the FOR..NEXT, over the DO...LOOP, I have no idea what's going on.  Logic tells us that it's going to be faster to simply add a value to a number, than it is to add a value to a number and then check to see if it's counting up or down...  DO simply has fewer steps to its process than FOR does. 

Out of curiosity, could you guys who are seeing the faster FOR loops add the $CHECKING:OFF command to Bplus's code and then run it.  I'm curious how much of a delay the internal error checking processes are making on the code.

Tr this, and see how it performs for you folks:

Code: QB64: [Select]

1. $CHECKING:OFF
2. _DEFINE A-Z AS _INTEGER64
3. PRINT "Running 4 timed tests please wait..."
4.  
5. n = 1000000000
6.  
7. t! = TIMER
8. x = 0: i = 0
9. doloop:
10. i = i + 1
11. x = x + i
12. IF i < n THEN GOTO doloop
13. PRINT x
14. t2! = TIMER
15.  
16. x = 0: i = 0
17. WHILE i < n
18.     i = i + 1
19.     x = x + i
20. WEND
21. PRINT x
22. t3! = TIMER
23.  
24. x = 0
25. FOR i = 0 TO n
26.     x = x + i
27. NEXT
28. PRINT x
29. t4! = TIMER
30.  
31.  
32. x = 0: i = 0
33. DO
34.     i = i + 1
35.     x = x + i
36. LOOP UNTIL i = n
37. PRINT x
38. t5! = TIMER
39.  
40. PRINT n; "    times adding in Do... LOOP time is "; t5! - t4!
41. PRINT n; "   times adding in FOR... NEXT time is "; t4! - t3!
42. PRINT n; " times adding in While... Wend time is "; t3! - t2!
43. PRINT n; "     times adding in GOTO loop time is "; t2! - t!
44.  

[RhoSigma]

I'm still wondering, why the FOR...NEXT loop has such a bulky (goto label) implementation from QB64 -> C++ level. Wouldn't it be better simply translated into a C++ "for" loop?

Using "goto" in C++ is even more frowned upon than some people already do in BASIC.

counting up:

Code: C: [Select]

1. for (int i = 0; i <= 100; i++) {
2.     // do stuff here;
3. }

counting down:

Code: C: [Select]

1. for (int i = 100; i >= 0; i--) {
2.     // do stuff here;
3. }

or given a STEP (eg. 5):

Code: C: [Select]

1. for (int i = 0; i <= 100; i+=5) {
2.     // do stuff here;
3. }

[SMcNeill]

I'm still wondering, why the FOR...NEXT loop has such a bulky (goto label) implementation from QB64 -> C++ level. Wouldn't it be better simply translated into a C++ "for" loop?

Only Galleon knows why he translated some of the commands the way he has.  After all, I also wonder, why does a FOR loop need a temp variable?

Code: [Select]

fornext_value2=fornext_step2+(*__SINGLE_I);
fornext_entrylabel2:
*__SINGLE_I=fornext_value2;
Why not simply let the variable equal the value naturally?  Reduce a few assignment processes each loop.  Why not just a simple:

__SINGLE_I = __SINGLE_I + fornext_step2;

[MrFreyer]

Hi McFreyer,

:D  I have to ask, what OS and computer are you using? What version of QB64?

Windows 10 Laptop, Intel Celeron 2.16GHz, 4GB RAM
QB64 v0.954
I will download the latest version now...

Let's take a moment to look at how our QB64 code translates into C-code.

Thanks for the insight!!!!

EDIT:
the 1.3 version (64 bit) was faster, from 10.6 sec (FOR...NEXT) till 11.9 sec (DO...LOOP)
the FOR...NEXT loop was still the fastest...

[bplus]

Windows 10 Laptop, Intel Celeron 2.16GHz, 4GB RAM
QB64 v0.954
I will download the latest version now...
Thanks for the insight!!!!

EDIT:
the 1.3 version (64 bit) was faster, from 10.6 sec (FOR...NEXT) till 11.9 sec (DO...LOOP)
the FOR...NEXT loop was still the fastest...

Wow such unexpected (by me at least) results.

Can Celeron processor support Windows 10?
For processing, Windows 10 requires a CPU with a minimum speed of 1GHz. This is a very low bar to clear, as even Intel's low-powered Atom and Celeron processors have been above the 1GHz mark for several years. ... You'll also want to look up whether or not your processor supports a 64-bit operating system.Oct 17, 2017

Well it must support 64 bit or it couldn't run QB64 v1.3 64 bit for Windows, I imagine.

I am interested also in results Steve requested from folks whose FOR ...NEXT loop is running faster than others:

Let's take a moment to look at how our QB64 code translates into C-code.

First, let's start with a simple FOR...NEXT loop:

...

Out of curiosity, could you guys who are seeing the faster FOR loops add the $CHECKING:OFF command to Bplus's code and then run it.  I'm curious how much of a delay the internal error checking processes are making on the code.

Tr this, and see how it performs for you folks:

Code: QB64: [Select]

1. $CHECKING:OFF
2. _DEFINE A-Z AS _INTEGER64
3. PRINT "Running 4 timed tests please wait..."
4.  
5. n = 1000000000
6.  
7. t! = TIMER
8. x = 0: i = 0
9. doloop:
10. i = i + 1
11. x = x + i
12. IF i < n THEN GOTO doloop
13. PRINT x
14. t2! = TIMER
15.  
16. x = 0: i = 0
17. WHILE i < n
18.     i = i + 1
19.     x = x + i
20. WEND
21. PRINT x
22. t3! = TIMER
23.  
24. x = 0
25. FOR i = 0 TO n
26.     x = x + i
27. NEXT
28. PRINT x
29. t4! = TIMER
30.  
31.  
32. x = 0: i = 0
33. DO
34.     i = i + 1
35.     x = x + i
36. LOOP UNTIL i = n
37. PRINT x
38. t5! = TIMER
39.  
40. PRINT n; "    times adding in Do... LOOP time is "; t5! - t4!
41. PRINT n; "   times adding in FOR... NEXT time is "; t4! - t3!
42. PRINT n; " times adding in While... Wend time is "; t3! - t2!
43. PRINT n; "     times adding in GOTO loop time is "; t2! - t!
44.