optimizations in if statements using true and false

**Bigbio2002** · 11-07-2004

my compiler is msvc++ 6.0. when using an if statement, which of these lines of code would run faster?

Code:

if(variable==0)

or

Code:

if(!variable)

also the same question with these 2 lines of code

Code:

if(variable==1)

or

Code:

if(variable)

i know that it probably wouldnt matter as far as optimizations go, but im just wondering from a technical standpoint.

**Nyda** · 11-07-2004

I don't have msvcc (or any windows box for that matter), but I'd assume any decent compiler will optimize both to the same assembler code. This is what GCC does:

Code:

#include <stdlib.h>
extern volatile_exp;
  
int test() {
  int x= rand();
  int y= rand();

  if (x == 0)
    volatile_exp= 10;
  
  if (!y)
    volatile_exp= 10;
}

Code:

test:
  pushl %ebp
  movl  %esp, %ebp
  subl  $8, %esp
  movl  %ebx, -4(%ebp)

  # grab x,y, init with random value
  call  rand
  movl  %eax, %ebx
  call  rand
  # x now in ebx, y in eax
  
  # test x
  testl %ebx, %ebx
  jne .L20
  movl  $10, %ecx
  movl  %ecx, volatile_exp
.L20:

  # test y
  testl %eax, %eax
  jne .L21
  movl  $10, %edx
  movl  %edx, volatile_exp
.L21:
  
  movl  -4(%ebp), %ebx
  movl  %ebp, %esp
  popl  %ebp
  ret

As you can see, it's exactly the same. Now, in completely unoptimized mode (if thats possible) that will probably look different. But I don't think performance matters if you turn off safe optimizations.

**Prelude** · 11-07-2004

It's been suggested to me to use the short form for my own tests because it implies that I'm familar enough with the language to know the trick. This will impress people (especially interviewers) with my command of the language. My response has always been this: "I'm experienced enough to know the pitfalls of that construct and I choose not to use it because of them. I would rather have good code than make others think I'm some sort of C god." I'm telling that story because your question brings up an important issue about robust programming.

>which of these lines of code would run faster?
This isn't nearly as interesting as which of the lines would be more clear. In the end, the first two are identical in speed and even if they weren't, the difference would be infintesimally small. The second two are not the same because

Code:

if(variable==1)

Tests variable to see if it's 1, and

Code:

if(variable)

Tests variable to see if it's not 0. This mistake brings me back to the clarity issue. If you can't get the concise form right on the first try, then should you be using it in the first place? Would readers of your code be able to trust that you got it right?

**Bigbio2002** · 11-07-2004

thanks for your help Nyda and Prelude. another one of programmings great mysteries answered

**Prelude** · 11-07-2004

>another one of programmings great mysteries answered
What about: Why do hot dog buns come in packs of ten but hot dogs come in packs of eight? The answer of course is that hot dog manufacturers use the octal system and hot dog bun manufacturers use the decimal system. They both agreed that packs should hold ten items, but they forgot to agree on the numbering system.

**okinrus** · 11-07-2004

The two are slightly different, the first being true only when the expression == 1 and the second true for any value but 0. But, given a compiler that deduce-and-optimize your if-then chains, this difference in semantics shouldn't effect the resultant code if the expected result is the same, and if the difference is even worth it.

Interestingly enough, distinction occurs with pointers, where many programmers, mostly C programmers, write "if (ptr == NULL)", while other programmers simply write "if (!ptr)". Well, they both have their reasons, NULL being defined somewhere in a file included by stdilb.h

**Dave_Sinkula** · 11-07-2004

What distinction with pointers?
http://www.eskimo.com/~scs/C-faq/q5.3.html

**okinrus** · 11-07-2004

Forgot to qualify distinction. What I meant here was that there is a stylistic distinction between C++ programmers and C programmers. In C, where practically every pointer use will use malloc somewhere, including stdlib.h is quite common. In C++, however, where pointers are commonly used with operator new, the use of "if (!p) or if (p != 0)" is quite common. In fact, the C++ faq, I believe to avoid #define's, recommends the use const void* null = 0 or something similar.

**Jez** · 11-09-2004

Here's a variation on the theme:

Code:

#include <stdio.h>
int main(void)
{
	int foo[100];
	int bar[100];

	for (int i=0;i<100;i++) foo[i]=i;
	for (int i=100;i--;) bar[i]=i;
	
}

The two loops have the same effect, however the second one compiles to tighter assembly on my system (LCC-win32) and runs faster.
The arrays are just to illustrate a use for the loop indexing.

I use this method for speed critical loops only, otherwise I stick to the idiomatic form.

**xErath** · 11-09-2004

Originally Posted by Jez

Here's a variation on the theme:

Code:

#include <stdio.h>
int main(void)
{
	int foo[100];
	int bar[100];

	for (int i=0;i<100;i++) foo[i]=i;
	for (int i=100;i--;) bar[i]=i;
	
}

The two loops have the same effect....

Almost... the fact that i is incremented/decremented may be important in the cicle

Originally Posted by okinrus

(...) NULL being defined somewhere in a file included by stdilb.h

Defined in stdio.h

**Jez** · 11-09-2004

Almost... the fact that i is incremented/decremented may be important in the cicle

Yes one increments, one decrements, but they have the same effect (in this case)
What's a cicle?

Here's what I was playing with a few moments ago:

Code:

#include <stdio.h>
#include <time.h>

#define COUNT 1000000000
#define TIMENOW (double)clock()/(double)CLOCKS_PER_SEC

int main(void)
{
	for (int j=5;j--; )
	{

		int x=0;
		double t1 = TIMENOW;
		for (register int i=0;i<COUNT;i++) x++;
		double t2 = TIMENOW;
		printf ("time for idiomatic method = %f\t",t2-t1);
		printf ("value of x = %d\n",x);

		x=0;
		t1 = TIMENOW;
		for (register int i=COUNT;i--;) x++;
		t2 = TIMENOW;
		printf ("time for short method = %f\t",t2-t1);
		printf ("value of x = %d\n",x);
	}
}

I was just investigating why I got inconsistent results. The first version of this omitted the outer for loop (repeats 5 times), and just did the timings once. The short way was faster.
Now it does it 5 times, and the idiomatic way is faster.

I've looked at the assembly, and the short way looks better. It might be an optimization issue. I'll take another look at it tommorrow.

**Nyda** · 11-10-2004

Originally Posted by Jez

The two loops have the same effect, however the second one compiles to tighter assembly on my system (LCC-win32) and runs faster.
The arrays are just to illustrate a use for the loop indexing.

I use this method for speed critical loops only, otherwise I stick to the idiomatic form.

Might well be true for your compiler, but in general I'd say it makes no difference at all. This is the incremental version, compiled with gcc -O3

Code:

	xorl	%eax, %eax
.L6:
	movl	%eax, foo(,%eax,4)
	incl	%eax
	cmpl	$99, %eax
	jle	.L6

and the other one:

Code:

	movl	$99, %eax
.L11:
	movl	%eax, bar(,%eax,4)
	decl	%eax
	cmpl	$-1, %eax
	jne	.L11

I'm not an expert in assembler programming, but I'm fairly certain the instructions within the loop (inc/decrement and conditional jumps) are executed at the same speed (that is, no additional overhead in the pipeline). Usually the initialization doesn't really matter, but since everything else is identical, I'd say that clearing a register with xor reg,reg is faster than filling it with an immediate. The effect is probably one of the closest things to "nothing".

I'd really suggest to write readable code. Leave the optimization to the compiler. If neccessary, make a profiled compilation (if supported - if not get a better compiler). i.e. this let's the compiler detect slow loops and unroll them. Something you wouldn't want to do in your code anyways - unless you work for a company and want to make sure they can't fire you without losing all your work, that is

**dagdarian** · 11-10-2004

Why there is a light when open the fridge door, but not the freezer?

**Bigbio2002** · 11-10-2004

great question dagdarian. i hate having to hold the fridge door open with my foot so i can pick a tv dinner and set the microwave (which is one of those cheap 700 watt ones)

**Prelude** · 11-11-2004

>Why there is a light when open the fridge door, but not the freezer?
The refrigerator gnomes don't live in the freezer because they don't have parkas. Duh.

Thread: optimizations in if statements using true and false

Thread Tools

Search Thread

Display

optimizations in if statements using true and false

Similar Threads

BIG problem. How do I find a bug in so much code?

C++ FTP class won't work

Reducing Code size from ridiculous length

Something is wrong with this menu...