I
Ian Collins
So you can guess better than the computer can measure? Performing
accurate and repeatable measurements is an ideal task for an entity with
an IQ of zero, such as a computer.
accurate and repeatable measurements is an ideal task for an entity with
an IQ of zero, such as a computer.
K
karthikbalaguru
Can you post the snapshot of the internal of a*2 and a+a that you
got ?
Karthik Balaguru
R
robertwessel2
It's been demonstrated repeatedly over the last few decades that
programmers are absolutely *terrible* at identifying hotspots in their
code. Sure, some easy cases are easy to spot, but others are not, and
it's very, very easy to spend a lot of time optimizing a piece of code
(and making it vastly less maintainable in the process) that isn't
actually a hotspot. Profiling will tell you the truth. Nor are all
these possible optimizations consistently beneficial, and often depend
on the implementation of the processor, so you must always measure
your optimizations.
I
iesvs
Performing
I love your point of view.
I love your point of view.
I
iesvs
Can you post the snapshot of the internal of a*2 and a+a that you
I can't, it was in past. But I'm sure. I asked a friend, and he
explain me that on some architecture (like the HP adding machine)
there wasn't a multiplication in the CPU, so the multiplication was a
software and it was better to use + than *. And it was not a lshift, I
swear it.
I can't, it was in past. But I'm sure. I asked a friend, and he
explain me that on some architecture (like the HP adding machine)
there wasn't a multiplication in the CPU, so the multiplication was a
software and it was better to use + than *. And it was not a lshift, I
swear it.
I
iesvs
It's been demonstrated repeatedly over the last few decades that
Like they're terrible to produce a correct code.
Like they're terrible to produce a correct code.
J
Joachim Schmitz
Look at the machine/assembly code that get's generated _now_ on _your
platform_ and compare the code it generated for
a+a
a*2
a<<1
Repeat the comparision with the various optimization levels your compiler
provides.
Then lookup the the processors assembly manual and count CPU cycles.
Bye, Jojo
I
iesvs
Finnaly I can, here you are :
I made gcc -S mult.c to get the assembly code.
****mult.c****
**************
int mult_by_7 (int a)
{
return a * 7;
}
int mult_by_2 (int a)
{
return a * 2;
}
****mult.s****
**************
.file "mult.c"
.text
..globl mult_by_7
.type mult_by_7, @function
mult_by_7:
pushl %ebp
movl %esp, %ebp
movl 8(%ebp), %edx
movl %edx, %eax
sall $3, %eax
subl %edx, %eax
popl %ebp
ret
.size mult_by_7, .-mult_by_7
..globl mult_by_2
.type mult_by_2, @function
mult_by_2:
pushl %ebp
movl %esp, %ebp
movl 8(%ebp), %eax
addl %eax, %eax
popl %ebp
ret
.size mult_by_2, .-mult_by_2
.ident "GCC: (GNU) 4.1.2 (Ubuntu 4.1.2-0ubuntu4)"
.section .note.GNU-stack,"",@progbits
I don't understand the first (assembly language is a little bit new
for me).
Bu for mult_by_2 you can see the addl %eax,%eax
so it changed a * 2 by a + A.
Or perhaps I don't understand what does this assembly code.
I
iesvs
I also try a << 1
and it converted it into a + a
and it converted it into a + a
R
Richard Tobin
[/QUOTE]
You are misunderstanding the term. Micro-optimisation doesn't mean
optimisation that has a very small effect, it means optimisation of
small operations, as opposed to optimisation of the algorithm.
Micro-optimisation can have have very large effects, but compilers are
generally better at it than humans.
-- Richard
J
Joachim Schmitz
Looks like it. The other one looks likes a "a<<3 - a" to me, but that's only
a guess...
Now compare with the code for a shift_by_one.
Then switch on compiler optimization and check again.
Bye, Jojo
J
Joachim Schmitz
Exactly our point here. So coding a*2 has no performance advantage over a<<1
(or a+a), but a*2 has the advantage of readability.
Bye, Jojo
R
robertwessel2
The first routine compiles the (a*7) to ((a*8-a), with the
multiplication by eight done via a shift. In any event it looks like
you have not, as suggested, turned up the optimization level for GCC,
so he's generated fairly lame code. Try it with -O2 and see if that
doesn't reduce to a mov/lea/sub/ret sequence.
A
Army1987
If the first operand is positive, it is.
I
iesvs
Looks like it. The other one looks likes a "a<<3 - a" to me, but that's only
No you're right. It's just I'm not able to read assembly code.
I can't understand the result of my test. Maybe you're right.
I don't know.
No you're right. It's just I'm not able to read assembly code.
I can't understand the result of my test. Maybe you're right.
I don't know.
R
robertwessel2
Indeed. And please be sure to remember to include yourself in that
category.
R
Richard Heathfield
pete said:
I agree. It does, however, show that shifting doesn't always double the
number. The fact that doubling doesn't always double the number is another
issue.
I agree. It does, however, show that shifting doesn't always double the
number. The fact that doubling doesn't always double the number is another
issue.
R
Richard Bos
[email protected] said:
You overestimate yourself. That's ok; nearly everybody does, until he
gets a taste of what a _real_ profiler and debugging suite can do. But
it isn't wise to refuse to learn better.
Richard
K
karthikbalaguru
What is the optimisation level you have ?
Does it treat a<<1 and a*2 as a+a for all the optimisation levels ?
What is the architecture you use ?
It is dependent on your architecture and compiler you use.
Karthik Balaguru
J
Joachim Schmitz
I've checked with gcc on a pentium running Linux. It generates identicalkarthikbalaguru said:
code for a*2 and a<<1 in all optimization levels and identical code for a+a
with -O1 and higher (and only slightly different code with -O0).
Bye, Jojo