What's the performance of the "address of" operator &?

Question

I have to pass a lot of pointers in my code in the midst of a big loop, (so I have lots of expressions like foo(&x, &y, ...)). I was wondering whether I should store the pointers as separate variables (i.e. cache) for performance (at the cost of introducing more variables and clutter in my code)?

(Doing lots of matrix mult. and the CUBLAS library insists on pointers...)

This is the kind of macro optimization that are not worth thinking about. — Martin York, May 17 '13 at 04:02

score 10 · Accepted Answer · answered May 17 '13 at 03:55

10

No -- the address-of operator is about as inexpensive/fast as anything you can hope for. It's possible to overload it, and such an overload could be slower, but overloading it at all is fairly unusual.

answered May 17 '13 at 03:55

Jerry Coffin

476,176
80
629
1,111

If the address-of operator had been slow, C wouldn't be what it is now, much less C++. – Mark Garcia May 17 '13 at 03:58
+ , but why do you says `"overloading it at all is fairly unusual."`? – Grijesh Chauhan May 17 '13 at 04:02
4

@GrijeshChauhan: Well, hopefully, the fact that overloading it is an evil, satanic practice should discourage enough people from doing it so that it becomes unusual. And that seems to be what has happened. I certainly don't see this done often. Do you? – Benjamin Lindley May 17 '13 at 04:03
@BenjaminLindley :) your are correct because I have no example...Thanks! – Grijesh Chauhan May 17 '13 at 04:11

score 4 · Answer 2 · answered May 17 '13 at 03:56

std::addressof incurs no penalty at all. When it boils down to assembly code, we only refer to objects through their addresses anyway so the information is already at hand.

Concerning operator&, it depends whether it has been overloaded or not. The original, non-overloaded version behaves exactly like std::addressof. However if operator& has been overloaded (which is a very bad idea anyway, and quite frowned upon), all bets are off since we can't guess what the overloaded implementation will be.

So the answer to your question is: no need to store the pointers separately, you can just use std::addressof or operator& whenever you need them, even if you have to repeat it.

score 1 · Answer 3 · answered May 17 '13 at 03:54

in C++ there are references, what you are describing sounds more like a behaviour for the C language rather than C++.

that kind of signature for C++ methods it's usually implemented to avoid copying, by default when you call a method and pass some arguments to it, this arguments generate a local copy, having references it's a technique that help you avoid this overhead for the copy.

score 1 · Answer 4 · answered May 17 '13 at 07:36

It would be very efficient. If you are using Linux, you can check by using objdump. The following is how fooP(&var1, &var2) looks like in the x86 architecture. It is nothing more than a LEA instruction.

 fooP(&var1, &var2);
 8048642:       8d 44 24 1c        lea    0x1c(%esp),%eax  -> this is to get the address of var2 to eax
 8048646:       89 44 24 04        mov    %eax,0x4(%esp)   -> this is to save the address to the stack for later fooP call
 804864a:       8d 44 24 18        lea    0x18(%esp),%eax  -> address of var1
 804864e:       89 04 24           mov    %eax,(%esp)
 8048651:       e8 be ff ff ff     call   8048614 <_Z4fooPPiS_>

Reference in this case is actually same as the above.

What's the performance of the "address of" operator &?

4 Answers4