Boost logo

Boost :

Subject: Re: [boost] [operators] A modern SFINAE-based version of boost::operators?
From: Gavin Lambert (gavinl_at_[hidden])
Date: 2017-11-16 01:39:59

On 16/11/2017 05:41, Peter Dimov wrote:
> It's all slightly misleading anyway, because for the small matrix case
> the copy/move constructors don't actually have side effects and
> therefore get optimized out; they are only relevant in the case of
> something like std::string where copy/move aren't defaulted.

That was my point; your test code doesn't test copy elision because your
constructors have side effects, so can't be elided.

Of course, if you remove the counting side effects in that code then the
compiler just inlines everything to a single mov constant 10 :)

FWIW, in VC14.0 if you force it to use external parameters it can't
inline away then this code:

__declspec(noinline) T calc(int a, int b, int c, int d)
     return T(a) + T(b) + T(c) + T(d);

Turns into this with the rvalue-ref-return operators:

; _a$ = edx
   00003 03 55 08 add edx, DWORD PTR _b$[ebp]
   00006 03 55 0c add edx, DWORD PTR _c$[ebp]
   00009 8b 45 10 mov eax, DWORD PTR _d$[ebp]
   0000c 03 c2 add eax, edx
   0000e 89 01 mov DWORD PTR [ecx], eax
   00010 8b c1 mov eax, ecx

; _a$ = edx
; _b$ = r8d
; _c$ = r9d
   00000 41 03 d0 add edx, r8d
   00003 48 8b c1 mov rax, rcx
   00006 41 03 d1 add edx, r9d
   00009 03 54 24 28 add edx, DWORD PTR d$[rsp]
   0000d 89 11 mov DWORD PTR [rcx], edx

Whereas with the value-return operators:

; _a$ = edx
   00003 8b 45 08 mov eax, DWORD PTR _b$[ebp]
   00006 03 c2 add eax, edx
   00008 03 45 0c add eax, DWORD PTR _c$[ebp]
   0000b 03 45 10 add eax, DWORD PTR _d$[ebp]
   0000e 89 01 mov DWORD PTR [ecx], eax
   00010 8b c1 mov eax, ecx

; _a$ = edx
; _b$ = r8d
; _c$ = r9d
   00000 42 8d 04 02 lea eax, DWORD PTR [rdx+r8]
   00004 41 03 c1 add eax, r9d
   00007 03 44 24 28 add eax, DWORD PTR d$[rsp]
   0000b 89 01 mov DWORD PTR [rcx], eax
   0000d 48 8b c1 mov rax, rcx

The rvalue versions are very slightly more efficient, it looks like,
although they're pretty similar (and it's even sneaky enough to turn one
of the adds into an lea in the last one). Though, of course, counting
assembly ops means little with modern CPUs, so take that with a grain of

And again granted something bigger than an int or with non-trivial copy
constructors will get different results, but overall it looks like I was
wrong with my initial supposition.

Boost list run by bdawes at, gregod at, cpdaniel at, john at