[Bug libstdc++/56785] New: std::tuple of two elements does not apply empty base class optimization when one of its elements is a std::tuple with two elements

[Bug libstdc++/56785] New: std::tuple of two elements does not apply empty base class optimization when one of its elements is a std::tuple with two elements

[david at doublewise dot net]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=56785

             Bug #: 56785
           Summary: std::tuple of two elements does not apply empty base
                    class optimization when one of its elements is a
                    std::tuple with two elements
    Classification: Unclassified
           Product: gcc
           Version: 4.7.2
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: libstdc++
        AssignedTo: unassigned@gcc.gnu.org
        ReportedBy: david@doublewise.net


#include <tuple>

class Empty {
};

int main() {
    static_assert(sizeof(std::tuple<Empty, std::tuple<int, int>>) ==
sizeof(std::tuple<int, int>), "Too big");
}

[david@localhost test]$ g++ source/test.cpp -std=c++11 -Wall -Wextra -pedantic
source/test.cpp: In function ‘int main()’:
source/test.cpp:23:2: error: static assertion failed: Too big


The static_assert does not fail if I change it to be a std::tuple<int, int,
int> on both sides, however, or any number of int other than exactly 2. I also
get this bug regardless of the type in the std::tuple (for instance, my own
class type).

Therefore, I have created a workaround, demonstrated such:

#include <tuple>

class Empty {
};
class Empty2 {
};

int main() {
    static_assert(sizeof(std::tuple<Empty, std::tuple<int, short>, Empty2>) ==
sizeof(std::tuple<int, short, Empty2>), "Too big");
    static_assert(sizeof(std::tuple<Empty, std::tuple<int, int>, Empty2>) ==
sizeof(int) * 2, "Too big");
}






[david@localhost test]$ g++ -v
Using built-in specs.
COLLECT_GCC=g++
COLLECT_LTO_WRAPPER=/usr/libexec/gcc/x86_64-redhat-linux/4.7.2/lto-wrapper
Target: x86_64-redhat-linux
Configured with: ../configure --prefix=/usr --mandir=/usr/share/man
--infodir=/usr/share/info --with-bugurl=http://bugzilla.redhat.com/bugzilla
--enable-bootstrap --enable-shared --enable-threads=posix
--enable-checking=release --disable-build-with-cxx
--disable-build-poststage1-with-cxx --with-system-zlib --enable-__cxa_atexit
--disable-libunwind-exceptions --enable-gnu-unique-object
--enable-linker-build-id --with-linker-hash-style=gnu
--enable-languages=c,c++,objc,obj-c++,java,fortran,ada,go,lto --enable-plugin
--enable-initfini-array --enable-java-awt=gtk --disable-dssi
--with-java-home=/usr/lib/jvm/java-1.5.0-gcj-1.5.0.0/jre
--enable-libgcj-multifile --enable-java-maintainer-mode
--with-ecj-jar=/usr/share/java/eclipse-ecj.jar --disable-libjava-multilib
--with-ppl --with-cloog --with-tune=generic --with-arch_32=i686
--build=x86_64-redhat-linux
Thread model: posix
gcc version 4.7.2 20121109 (Red Hat 4.7.2-8) (GCC)
>From gcc-bugs-return-418792-listarch-gcc-bugs=gcc.gnu.org@gcc.gnu.org Sat Mar 30 02:58:38 2013
Return-Path: <gcc-bugs-return-418792-listarch-gcc-bugs=gcc.gnu.org@gcc.gnu.org>
Delivered-To: listarch-gcc-bugs@gcc.gnu.org
Received: (qmail 12416 invoked by alias); 30 Mar 2013 02:58:38 -0000
Mailing-List: contact gcc-bugs-help@gcc.gnu.org; run by ezmlm
Precedence: bulk
List-Id: <gcc-bugs.gcc.gnu.org>
List-Archive: <http://gcc.gnu.org/ml/gcc-bugs/>
List-Post: <mailto:gcc-bugs@gcc.gnu.org>
List-Help: <mailto:gcc-bugs-help@gcc.gnu.org>
Sender: gcc-bugs-owner@gcc.gnu.org
Delivered-To: mailing list gcc-bugs@gcc.gnu.org
Received: (qmail 12373 invoked by uid 48); 30 Mar 2013 02:58:30 -0000
From: "jvdelisle at gcc dot gnu.org" <gcc-bugzilla@gcc.gnu.org>
To: gcc-bugs@gcc.gnu.org
Subject: [Bug libfortran/49791] [4.6/4.7/4.8/4.9 Regression] Formatted namelist reads fails with: Cannot match namelist object
Date: Sat, 30 Mar 2013 02:58:00 -0000
X-Bugzilla-Reason: CC
X-Bugzilla-Type: changed
X-Bugzilla-Watch-Reason: None
X-Bugzilla-Product: gcc
X-Bugzilla-Component: libfortran
X-Bugzilla-Keywords: wrong-code
X-Bugzilla-Severity: normal
X-Bugzilla-Who: jvdelisle at gcc dot gnu.org
X-Bugzilla-Status: NEW
X-Bugzilla-Priority: P4
X-Bugzilla-Assigned-To: jvdelisle at gcc dot gnu.org
X-Bugzilla-Target-Milestone: 4.6.4
X-Bugzilla-Changed-Fields:
Message-ID: <bug-49791-4-a6bNkNeaxz@http.gcc.gnu.org/bugzilla/>
In-Reply-To: <bug-49791-4@http.gcc.gnu.org/bugzilla/>
References: <bug-49791-4@http.gcc.gnu.org/bugzilla/>
X-Bugzilla-URL: http://gcc.gnu.org/bugzilla/
Auto-Submitted: auto-generated
Content-Type: text/plain; charset="UTF-8"
MIME-Version: 1.0
X-SW-Source: 2013-03/txt/msg02233.txt.bz2
Content-length: 360


http://gcc.gnu.org/bugzilla/show_bug.cgi?idI791

--- Comment #24 from Jerry DeLisle <jvdelisle at gcc dot gnu.org> 2013-03-30 02:58:25 UTC ---
Created attachment 29751
  --> http://gcc.gnu.org/bugzilla/attachment.cgi?id)751
Related test case

This example fails with a runtime error and passes with ifort.  The other cases
in this PR are fixed.

[Bug libstdc++/56785] std::tuple of two elements does not apply empty base class optimization when one of its elements is a std::tuple with two elements

[glisse at gcc dot gnu.org]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=56785

--- Comment #1 from Marc Glisse <glisse at gcc dot gnu.org> 2013-03-30 09:06:44 UTC ---
I assume (needs to be checked) this is related to the issue, reported
elsewhere, that makes the size of
std::tuple<std::tuple<std::tuple<std::tuple<>>>> grow linearly with the nesting
depth.

[Bug libstdc++/56785] std::tuple of two elements does not apply empty base class optimization when one of its elements is a std::tuple with two elements

[redi at gcc dot gnu.org]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=56785

Jonathan Wakely <redi at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
           Severity|normal                      |enhancement

[Bug libstdc++/56785] std::tuple of two elements does not apply empty base class optimization when one of its elements is a std::tuple with two elements

[gcc-bugzilla at contacts dot eelis.net]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56785

Eelis <gcc-bugzilla at contacts dot eelis.net> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |gcc-bugzilla at contacts dot eelis
                   |                            |.net

--- Comment #2 from Eelis <gcc-bugzilla at contacts dot eelis.net> ---
Another manifestation of this is that 

  sizeof(pair<pair<char,char>,pair<char,char>>) == 4

while

  sizeof(tuple<tuple<char,char>,tuple<char,char>>) == 5 (!!).

I think that at the moment, GCC users are best advised to avoid using stdlib
tuples if efficiency is a concern.

[Bug libstdc++/56785] std::tuple of two elements does not apply empty base class optimization when one of its elements is a std::tuple with two elements

[redi at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56785

--- Comment #3 from Jonathan Wakely <redi at gcc dot gnu.org> ---
(In reply to Eelis from comment #2)
> Another manifestation of this is that 
> 
>   sizeof(pair<pair<char,char>,pair<char,char>>) == 4
> 
> while
> 
>   sizeof(tuple<tuple<char,char>,tuple<char,char>>) == 5 (!!).

Oh noes, one byte more for a silly edge case!

> I think that at the moment, GCC users are best advised to avoid using stdlib
> tuples if efficiency is a concern.

That's a ridiculous conclusion to reach based on an edge case.

There are many realistic situations where std::tuple is more compact that
std::pair.

[Bug libstdc++/56785] std::tuple of two elements does not apply empty base class optimization when one of its elements is a std::tuple with two elements

[redi at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56785

--- Comment #4 from Jonathan Wakely <redi at gcc dot gnu.org> ---
The cause is that every N-tuple hierarchy ends with an empty _Tuple_impl<N>
base, so when there are several of those in the same hierarchy they need to
have separate addresses.

It should be possible to fix by eliminating that terminal objet in the
inheritance hierarchy. The obvious way duplicates a chunk of code, I think it
should be possible to do it in a nicer way, which I'm experimenting with.

[Bug libstdc++/56785] std::tuple of two elements does not apply empty base class optimization when one of its elements is a std::tuple with two elements

[gcc-bugzilla at contacts dot eelis.net]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56785

--- Comment #6 from Eelis <gcc-bugzilla at contacts dot eelis.net> ---
Clang's libc++ (which gives the expected result) might be another source of
inspiration.

[Bug libstdc++/56785] std::tuple of two elements does not apply empty base class optimization when one of its elements is a std::tuple with two elements

[redi at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56785

--- Comment #7 from Jonathan Wakely <redi at gcc dot gnu.org> ---
IIRC with libc++ tuple<> is not an empty type, so has more overhead than ours
in other edge cases. Maybe you should recommend users stay away from that too.

[Bug libstdc++/56785] std::tuple of two elements does not apply empty base class optimization when one of its elements is a std::tuple with two elements

[gcc-bugzilla at contacts dot eelis.net]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56785

--- Comment #8 from Eelis <gcc-bugzilla at contacts dot eelis.net> ---
With Clang 3.5, given

  struct X: std::tuple<> { char c; };

I get sizeof(X)==1. Is that not what you mean?

[Bug libstdc++/56785] std::tuple of two elements does not apply empty base class optimization when one of its elements is a std::tuple with two elements

[glisse at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56785

--- Comment #9 from Marc Glisse <glisse at gcc dot gnu.org> ---
Try:
  struct X: std::tuple<Empty> { double d; };

[Bug libstdc++/56785] std::tuple of two elements does not apply empty base class optimization when one of its elements is a std::tuple with two elements

[gcc-bugzilla at contacts dot eelis.net]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56785

--- Comment #10 from Eelis <gcc-bugzilla at contacts dot eelis.net> ---
I see what you mean! And while stuff with empty types and EBO is IMHO not
nearly as serious as random superfluous bytes that are inserted when you use
tuples of a bread and butter type like char, I agree it would be good to file a
ticket in http://llvm.org/bugs/ if there isn't one already. :)

[Bug libstdc++/56785] std::tuple of two elements does not apply empty base class optimization when one of its elements is a std::tuple with two elements

[redi at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56785

--- Comment #11 from Jonathan Wakely <redi at gcc dot gnu.org> ---
Created attachment 32994
  --> https://gcc.gnu.org/bugzilla/attachment.cgi?id=32994&action=edit
stop the inheritance recursion at the last element

This fixes all the issues mentioned here

[Bug libstdc++/56785] std::tuple of two elements does not apply empty base class optimization when one of its elements is a std::tuple with two elements

[redi at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56785

--- Comment #13 from Jonathan Wakely <redi at gcc dot gnu.org> ---
(In reply to Marc Glisse from comment #1)
> I assume (needs to be checked) this is related to the issue, reported
> elsewhere, that makes the size of
> std::tuple<std::tuple<std::tuple<std::tuple<>>>> grow linearly with the
> nesting depth.

That's PR51653. With the attached patch that occupies a single byte, for any
depth.

[Bug libstdc++/56785] std::tuple of two elements does not apply empty base class optimization when one of its elements is a std::tuple with two elements

[gcc-bugzilla at contacts dot eelis.net]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56785

--- Comment #12 from Eelis <gcc-bugzilla at contacts dot eelis.net> ---
Ooh, very nice! Thanks!

[Bug libstdc++/56785] std::tuple of two elements does not apply empty base class optimization when one of its elements is a std::tuple with two elements

[redi at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56785

Jonathan Wakely <redi at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|UNCONFIRMED                 |ASSIGNED
   Last reconfirmed|                            |2014-09-19
           Assignee|unassigned at gcc dot gnu.org      |redi at gcc dot gnu.org
   Target Milestone|---                         |5.0
     Ever confirmed|0                           |1

[Bug libstdc++/56785] std::tuple of two elements does not apply empty base class optimization when one of its elements is a std::tuple with two elements

[redi at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56785

--- Comment #14 from Jonathan Wakely <redi at gcc dot gnu.org> ---
Author: redi
Date: Sat Jan 17 00:21:41 2015
New Revision: 219785

URL: https://gcc.gnu.org/viewcvs?rev=219785&root=gcc&view=rev
Log:
    PR libstdc++/56785
    * include/std/tuple (_Tuple_impl): Remove zero-element specialization
    and define one-element specialization.
    * testsuite/20_util/tuple/56785.cc: New.

Added:
    trunk/libstdc++-v3/testsuite/20_util/tuple/56785.cc
Modified:
    trunk/libstdc++-v3/ChangeLog
    trunk/libstdc++-v3/include/std/tuple

[Bug libstdc++/56785] std::tuple of two elements does not apply empty base class optimization when one of its elements is a std::tuple with two elements

[redi at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56785

Jonathan Wakely <redi at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|ASSIGNED                    |RESOLVED
         Resolution|---                         |FIXED

--- Comment #15 from Jonathan Wakely <redi at gcc dot gnu.org> ---
Fixed for GCC 5