swl::variant

A minimal compile-time overhead, C++20 implementation of std::variant. Fully standard conforming with a couple of documented differences.

Compile-time performance

Because std::variant is implemented in both GCC and Clang libraries using a simple recursive union, accessing each members result in approximately N^2 functions template instantiations for a variant of size N. This implementation instead use a "binary-tree of unions", resulting in N.log2(N) instantiations, which results in faster compile times (see measurements below).

Run-time performance and binary size

std::variant visit method is usually implemented using a table of functions pointers. Unfortunately, compilers cannot (yet?) "see through" those, and the generated code tends to be much larger and slower than a switch-case equivalent - more on this here. Similarly to Michael Park's implementation, this implementation use a big, recursive switch for visitation.

Testing

The tests come from the LLVM test suite, and are compiled/run by ./tests/all_tests.cpp.

Compile all_tests.cpp as follow :
clang++ -std=c++17 ./test/all_tests.cpp (or compile it as any .cpp)

To run the tests, pass the following arguments to the resulting binary :

• a string containing a prefix of the command necessary to compile a C++20 file with your compiler of choice...
• with the root directory and the ./test directory in the include paths...
• and specifying the output path for compilation of individual tests at the end of the command

For example : ./a.out g++ -std=c++20 -I . -I .. -o ./tmp_test

Some test files succeed by not compiling, so you will see some errors.
(this is a bit spartan, it would be nice to have a cleaner way of running all the tests).

Implementation divergence

• index() doesn't return a std::size_t, but an integer whose size depends on the numbers of type inside the variant. Basically either unsigned char or unsigned short.

Extensions and customization

• If you like to live dangerously, swl::unsafe_get behave just like get, but without any errors checking.

• Two macro based knobs are available :

  • SWL_VARIANT_NO_STD_HASH : this disable the std::hash specializations and avoid the #include , which is big
  • SWL_VARIANT_NO_CONSTEXPR_EMPLACE : this disable constexpr for emplace, and avoid the #include , which is even bigger. Note that this one is an ODR footgun : don't use it if you can't guarantee that it's enabled everywhere in your binaries.

  To use these macros, define them in a file named swl_variant_knobs.hpp, and put it either in the same directory as variant.hpp or at the root of a header search path.

  Both of these are provided to reduce compile times, whether or not this matter depends on your compiler : on my version of Clang, activating both of these macros result in a mere -0.5s, on GCC however, this reduce compile times by more than 4s.

Measurements

The measurements are of the form (compile time, executable file size).

All of these measurements were done without optimizations.

The compilers used were Clang 12 and GCC 10.

Single visitation :

Multi visitation of some variants of size 10 :

Tested compilers

• GCC 10

Note : Clang 12 will not work (as in : it works only for trivially destructible types).