While-loop with if-statement faster than while-loop

Question

I am doing some testing regarding the speed of if-statements in loops and their effect on speed. Something I found was that consistently, the if-statement improved performance. My code:

import time
t = time.time

start = t()
x = 0
while x < 10000000:
    x += 1
time1 = t()
x = 0
while x < 10000000:
    x += 1
    if True:
        pass
time2 = t()

print(start)
print(time1 - start) # Time for simple while-loop
print(time2 - time1) # Time for while+if

A sample output would be:

1355517837.993
1.7850000858306885
1.7209999561309814

Which is completely counter-intuitive. The while-if-loop is working ever-so-slightly faster than the standard while-loop. This happens almost every time I run it; perhaps 1 in 20 times take longer. Does anyone know why?

What happens if you move x=0 out of both timed blocks? I bet what you're seeing is the interpreter having to allocate x for the first block but not the second. — Silas Ray
– Silas Ray, Commented Dec 14, 2012 at 21:10
not the same here, tho'; i have timings like: $ python t.py 1355519439.65 1.92616391182 2.65010595322; ran on Python 2.7.3 — Rubens
– Rubens, Commented Dec 14, 2012 at 21:11
Is result the same if you first run the if loop and then the one without it? For me the first one is always faster. — Edu
– Edu, Commented Dec 14, 2012 at 21:12
I'm getting the results you'd expect in 2.7, and the strange ones in 3.2. — dupersuper
– dupersuper, Commented Dec 14, 2012 at 21:12
I also consistently get longer times for the second version (in Python 3.2.3), as expected. Remember that time.time() is not the correct way to profile your program (since other tasks may affect the results). Use timeit.timeit() instead. — Tim Pietzcker
– Tim Pietzcker, Commented Dec 14, 2012 at 21:13

Jakob Bowyer · Accepted Answer · 2012-12-14 21:21:26Z

5

The dis shows that there are more steps to the if statement while loop.

In [4]: dis.dis(t2)
  2           0 LOAD_CONST               1 (0)
              3 STORE_FAST               0 (x)

  3           6 SETUP_LOOP              26 (to 35)
        >>    9 LOAD_FAST                0 (x)
             12 LOAD_CONST               2 (10000000)
             15 COMPARE_OP               0 (<)
             18 POP_JUMP_IF_FALSE       34

  4          21 LOAD_FAST                0 (x)
             24 LOAD_CONST               3 (1)
             27 INPLACE_ADD
             28 STORE_FAST               0 (x)
             31 JUMP_ABSOLUTE            9
        >>   34 POP_BLOCK
        >>   35 LOAD_CONST               0 (None)
             38 RETURN_VALUE

In [5]: dis.dis(t1)
  2           0 LOAD_CONST               1 (0)
              3 STORE_FAST               0 (x)

  3           6 SETUP_LOOP              35 (to 44)
        >>    9 LOAD_FAST                0 (x)
             12 LOAD_CONST               2 (10000000)
             15 COMPARE_OP               0 (<)
             18 POP_JUMP_IF_FALSE       43

  4          21 LOAD_FAST                0 (x)
             24 LOAD_CONST               3 (1)
             27 INPLACE_ADD
             28 STORE_FAST               0 (x)

  5          31 LOAD_GLOBAL              0 (True)
             34 POP_JUMP_IF_FALSE        9

  6          37 JUMP_ABSOLUTE            9
             40 JUMP_ABSOLUTE            9
        >>   43 POP_BLOCK
        >>   44 LOAD_CONST               0 (None)
             47 RETURN_VALUE

answered Dec 14, 2012 at 21:21

Jakob Bowyer

34.8k8 gold badges80 silver badges91 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

Yos233 Over a year ago

Thanks for posting this, I was not aware of the dis module before now. However it is still confusing that the while-if-loop runs faster, when even at this very low level it takes more steps.

Foo · Accepted Answer · 2012-12-14 21:13:07Z

3

I'd guess that the compiler would remove the if True block since it is constant.

When I run I get mostly the opposite results from you. I may just be random effects of the execution environment.

1355519587.2 0.832797050476 1.04382395744

1355519590.03 0.863899946213 1.09347200394

1355519593.72 0.831655025482 1.05389809608

1355519599.71 0.831452131271 1.41783499718

1355519602.99 0.815280914307 1.05724310875

1355519605.72 0.826404094696 1.05700492859

1355519608.94 0.827296972275 1.07807898521

answered Dec 14, 2012 at 21:13

Foo

4623 silver badges14 bronze badges

5 Comments

Tim Pietzcker Over a year ago

Which engine? There is no just-in-time compiler or anything. At least not in CPython. In fact, there is no compiler at all, we're talking about Python here.

alexvassel Over a year ago

agree. my results are: 1355519852.98, 0.830796003342, 1.11595201492 with python 2.7.1

Foo Over a year ago

@TimPietzcker, it is 2.7.1. Python does compile, but to bytecode. You can't execute raw text in most operating environments.

Tim Pietzcker Over a year ago

@delnan: Can you give an example or a link to some documentation about what kinds of optimization the compiler can do? It's obviously not able to remove the empty if statement.

user395760 Over a year ago

@TimPietzcker I don't think this is documented, as it's an implementation detail and very rarely matters. One mention of the optimizer I've seen is in the 3.2 whatsnew. And of course, there's the source: peephole.c (there are quite a few comments detailing the optimizations performed). See line 446 for a optimization of jumps depending on constants.

Collectives™ on Stack Overflow

While-loop with if-statement faster than while-loop

2 Answers 2

1 Comment

5 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1 Comment

5 Comments

Your Answer

Sign up or log in

Post as a guest

Related