Greater than operator Vs Equal to operator : Which one is efficient?

[Vivek Mandava]

Hello All,

Which one is an expensive operation?
'>' or '==" ?

I know this won't matter much. However, if I'm executing this
operation million times, I would prefer the better choice.

My gut feeling is that '>' should be efficient. However, when
translated to assembly code all it generates is "cmpl" instruction
(gcc -S <prog.c>). So, my question here is :: how is "cmpl"
instruction executed by the cpu?

Ex: (1) if (n == 0) vs if (n > 0)
(2) if (len == 12) vs if (len < 13)

Thanks in advance.

Regards,
Vivek

web: http://students.iiit.net/~vivek/

[Martin Dickopp]

hy********@yaho o.com (Vivek Mandava) writes:

Which one is an expensive operation?
'>' or '==" ?
The C standard doesn't define the performance of these operations.
I know this won't matter much. However, if I'm executing this
operation million times, I would prefer the better choice.

My gut feeling is that '>' should be efficient. However, when
translated to assembly code all it generates is "cmpl" instruction
(gcc -S <prog.c>). So, my question here is :: how is "cmpl"
instruction executed by the cpu?

This is not a C question, but a question about assembler/machine code
on a specific platform. It is off-topic here; please ask in a newsgroup
dedicated to programming the CPU in question.

Martin

[Nils Petter Vaskinn]

On Fri, 05 Sep 2003 01:25:30 -0700, Vivek Mandava wrote:

Hello All,

Which one is an expensive operation?

That would depend on both plattform and compiler I think.

int main()
int i,j;

i=INT_MAX;
j=INT_MAX;

print_system_ti me();

while(1) {
if (i == 0) {
break;
} else {
++i;
}
}

print_system_ti me();

while(1) {
if (j < 1) {
break;
} else {
++j;
}
}

print_system_ti me;

return 0;
}

hth
--
NPV
"Linux is to Lego as Windows is to Fisher Price." - Doctor J Frink

[Jeff]

"Vivek Mandava" <hy********@yah oo.com> wrote in message
news:bb******** *************** ***@posting.goo gle.com...

Hello All,

Which one is an expensive operation?
'>' or '==" ?

I know this won't matter much. However, if I'm executing this
operation million times, I would prefer the better choice.

My gut feeling is that '>' should be efficient. However, when
translated to assembly code all it generates is "cmpl" instruction
(gcc -S <prog.c>). So, my question here is :: how is "cmpl"
instruction executed by the cpu?

Why don't ask in your platform specific newsgroup ?
--
Jeff

[Tom Zych]

Vivek Mandava wrote:

Which one is an expensive operation?
'>' or '==" ?

That's highly system-dependent and therefore OT here. That said, I'd
be surprised if there were any difference. It should use some kind
of "compare" instruction either way.

Why not put a tight loop of 10^7 of them in a function and run your
profiler on it?

--
Tom Zych
This email address will expire at some point to thwart spammers.
Permanent address: echo 'g******@cbobk. pbz' | rot13

[Martin Dickopp]

hy********@yaho o.com (Vivek Mandava) writes:

Which one is an expensive operation?
'>' or '==" ?
The C standard doesn't define the performance of these operations.
I know this won't matter much. However, if I'm executing this
operation million times, I would prefer the better choice.

My gut feeling is that '>' should be efficient. However, when
translated to assembly code all it generates is "cmpl" instruction
(gcc -S <prog.c>). So, my question here is :: how is "cmpl"
instruction executed by the cpu?

This is not a C question, but a question about assembler/machine code
on a specific platform. It is off-topic here; please ask in a newsgroup
dedicated to programming the CPU in question.

Martin

[John Bode]

hy********@yaho o.com (Vivek Mandava) wrote in message news:<bb******* *************** ****@posting.go ogle.com>...

Hello All,

Which one is an expensive operation?
'>' or '==" ?

That's entirely a function of the target instruction set, not the C
language.
I know this won't matter much. However, if I'm executing this
operation million times, I would prefer the better choice.

The only way to know for sure is to write code using each operator and
gather performance statistics on that code, recognizing that your
results are only valid for that particular architecture. FWIW,
they're equally expensive on all the platforms I'm familiar with (they
all generate similar instructions). I'd honestly be surprised if
there was a platform where one was significantly more expensive than
the other.
My gut feeling is that '>' should be efficient. However, when
translated to assembly code all it generates is "cmpl" instruction
(gcc -S <prog.c>). So, my question here is :: how is "cmpl"
instruction executed by the cpu?

Assuming you're on x86:
http://www.penguin.cz/~literakl/intel/intel.html
Ex: (1) if (n == 0) vs if (n > 0)
(2) if (len == 12) vs if (len < 13)

Thanks in advance.

Regards,
Vivek

web: http://students.iiit.net/~vivek/

[Nils Petter Vaskinn]

On Fri, 05 Sep 2003 01:25:30 -0700, Vivek Mandava wrote:

Hello All,

Which one is an expensive operation?

That would depend on both plattform and compiler I think.

int main()
int i,j;

i=INT_MAX;
j=INT_MAX;

print_system_ti me();

while(1) {
if (i == 0) {
break;
} else {
++i;
}
}

print_system_ti me();

while(1) {
if (j < 1) {
break;
} else {
++j;
}
}

print_system_ti me;

return 0;
}

hth
--
NPV
"Linux is to Lego as Windows is to Fisher Price." - Doctor J Frink

[Jeff]

"Vivek Mandava" <hy********@yah oo.com> wrote in message
news:bb******** *************** ***@posting.goo gle.com...

Hello All,

Which one is an expensive operation?
'>' or '==" ?

I know this won't matter much. However, if I'm executing this
operation million times, I would prefer the better choice.

My gut feeling is that '>' should be efficient. However, when
translated to assembly code all it generates is "cmpl" instruction
(gcc -S <prog.c>). So, my question here is :: how is "cmpl"
instruction executed by the cpu?

Why don't ask in your platform specific newsgroup ?
--
Jeff

[E. Robert Tisdale]

Vivek Mandava wrote:

Which one is the more expensive operation?

'>' or '==' ?

I know this won't matter much.
However, if I'm executing this operation million times,
I would prefer the better choice.

My gut feeling is that '>' should be efficient.
However, when translated to assembly code
all it generates is "cmpl" instruction (gcc -S <prog.c>).
So, my question here is,
"How is the 'cmpl' instruction executed by the cpu?"

Ex: (1) if (n == 0) vs if (n > 0)
(2) if (len == 12) vs if (len < 13)

The cmpl instruction is a subtraction which does *not* save a result.
It just sets some status register flags.
The branch instructions (je, jne, jlt, jle, jgt, jge, etc.)
test these status bits and branch accordingly.
None of them are inherently faster than the others.
Your CPU almost certainly includes branch prediction hardware
which it can use to prefetch instructions for the most likely branch.
Your compiler almost certainly includes optimizations
to assist branch prediction.

It is almost always a bad idea to attempt to outsmart
your optimizing compiler.
You will probably only succeed in frustrating these optimizations.
Write your code in the most straight forward and readable way
that you can and let your optimizing compiler figure out
how to generate instructions that yield the highest performance
and efficiency. If performance is not satisfactory,
use a profiler to locate the code that produces the bottleneck
and concentrate on optimizing that code first.