What's the difference between while(--i); and while(i) --i;?

Question

My first submission of 61.Rotate List ran for 16 ms and I was not happy with that. So I changed this part of my code

k += 1;
while (--k) {
    p = p->next;
}

to

while (k) {
    p = p->next;
    --k;
}

and then magic happened. Runtime decreased to 8 ms.

So what's the difference between them? Why the runtime gap is so large?

And please read about [how to ask good questions](http://stackoverflow.com/help/how-to-ask), as well as [this question checklist](https://codeblog.jonskeet.uk/2012/11/24/stack-overflow-question-checklist/). Lastly please try to create an [mcve] to show us. — Some programmer dude, Nov 20 '18 at 09:17
These codes are equivalent, unless `k+=1` causes integer overflow — M.M, Nov 20 '18 at 09:19
I wouldn’t use leetcode to judge efficiency of your code if I were you — Killzone Kid, Nov 20 '18 at 09:21
G++ sees no difference with -O1. Did you forget to toggle code optimization when doing bench-marking? — felix, Nov 20 '18 at 09:26
A difference of 8ms isn't really measurable and is affected by many things outside of your control. — DeiDei, Nov 20 '18 at 09:33
as there is a "As if" rule which compiler can utilize, I wouldn't be surprised if generated code has no differences for those two. — Marek R, Nov 20 '18 at 09:34
What is the type of `k`? You should also try with `while(k--) p = p->next;`. But this also dependes on the use of `k` after the loop. — Bo R, Nov 20 '18 at 09:34
@DeiDei 8ms is not measurable?? Its not huge, but of course it can be measured — 463035818_is_not_an_ai, Nov 20 '18 at 09:36
With -O1 it results into the exact same assemblycode... https://godbolt.org/z/d3YrBx — user1810087, Nov 20 '18 at 09:49
Maybe unrelated: making directly a rotation of order _k_ should be more efficient than performing _k_ rotations of order _1_ — Damien, Nov 20 '18 at 10:24

patatahooligan · Answer 1 · 2018-11-20T12:52:48.127

This is probably just a compiler quirk or a benchmarking error. Code segments that produce identical results under all circumstances should theoretically compile to the same assembly. Usually the compiler fails to optimize if parts of the code are obfuscated (eg in different translation units) or if the code segment is complex enough that the optimizer fails to see the equivalency.

In this particular case, there should be no problem. Indeed, GCC compiles these segments to the same assembly.

struct P {
    P* next;
};

P* func1(unsigned int k, P* p) {
    k += 1;
    while (--k) {
        p = p->next;
    }
    return p;
}

P* func2(unsigned int k, P* p) {
    while (k) {
        p = p->next;
        --k;
    }
    return p;
}

The assembly output is

func1(unsigned int, P*):
movq %rsi, %rax
testl %edi, %edi
je .L2
.L3:
movq (%rax), %rax
subl $1, %edi
jne .L3
.L2:
ret
func2(unsigned int, P*):
movq %rsi, %rax
testl %edi, %edi
je .L10
.L11:
movq (%rax), %rax
subl $1, %edi
jne .L11
.L10:
ret

Jump labels aside, the assembly for those functions is identical. You can view it in godbolt here.

@MikeBorkland Thanks for pointing that out. I messed up when copy-pasting, but I fixed it now. — patatahooligan, Nov 20 '18 at 12:55

What's the difference between while(--i); and while(i) --i;?

1 Answers1