This thread is a continuation of that started here: http://article.gmane.org/gmane.comp.lib.boost.devel/235427 It's been renamed because the new name is more topical. The tree_builder benchmarks mentioned here: http://article.gmane.org/gmane.comp.lib.boost.devel/235386 were refactored into: tuple_benchmark.tree_builder.cpp tuple_impl.bcon12_horizontal.hpp tuple_impl.bcon12_vertical.hpp and various other .hpp files. The benchmark was run as shown in the attached filt.compilation. The output after line: :filt_dr= shows with compiler=gcc4_8, the bcon12_horizontal implementation is slower than the bcon12_vertical. This agrees, at least qualitatively, with the page 12 bar chart from Eric's boostcon12 pdf file: trouble_with_tuples.pdf downloadable from here: https://github.com/boostcon/cppnow_presentations_2012/zipball/master and in the mon directory. The variadic bar in the pag12 bar chart corresponds to the: tuple_impl.bcon12_horizontal.hpp tuple implementation in the sandbox slim/test directory. The unrolled bar in the pag12 bar chart corresponds to the: tuple_impl.bcon12_vertical.hpp In contrast to the gcc4_8 compiler, with the clangxx compiler, the relative qualitative performance, is just the opposite. IOW, the bcon12_horizontal implementation is faster than the bcon12_vertical implementation. In fact, the rate of change of the performance difference accelerates as tree depth goes from 2 to 4. The rate of change is so stark that it suggests, at least to me, there may be some bug in clang. Of course that conclusion is based on almost no knowledge, on my part, of the clang implementation. The tuple_benchmark_filt.py can be modified to filter out other parts of the benchmark run output, which is here: http://svn.boost.org/svn/boost/sandbox/variadic_templates/sandbox/slim/test/... In conclusion, whether it's best to use vertical or horizontal tuple implementation depends on the compiler. -regards, Larry