thecppzoo

Since the assembler sources of strlen for AVX2 in GLIBC are virtually obfuscated by the macros, here's the actual assembler: (comments are mine)

Dump of assembler code for function __strlen_avx2: (obtained with GDB disassable)

   0x00007ffff7bf27e0 <+0>:	endbr64 
   0x00007ffff7bf27e4 <+4>:	mov    %edi,%eax
   0x00007ffff7bf27e6 <+6>:	mov    %rdi,%rdx
   0x00007ffff7bf27e9 <+9>:	vpxor  %xmm0,%xmm0,%xmm0

thecppzoo

• Hash Tables
• Hash Table invariants
• Robin Hood
• SWAR
• Benchmarks & Compiler explorer disassemblies

thecppzoo

// This example requires the boost preprocessing library headers

#include <boost/preprocessor/seq/for_each_i.hpp>
#include <boost/preprocessor/seq/for_each.hpp>
#include <boost/preprocessor/punctuation/comma_if.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/seq/transform.hpp>
#include <boost/preprocessor/seq/enum.hpp>

// Macro naming convention:

thecppzoo

Goals

The main aim of AnyContainer is to solve the need for subtyping without the problems of subclassing, i.e., not forcing user types to inherit from base classes, allowing value semantics, and having the option of the performance of normal C++ code rather being forced to the inefficient dynamic dispatch through a virtual table.

We think the goals have been achieved: the performance and object code size are optimal as far as we know, and it is possible to have general solutions for runtime polymorphism, including infinite refinement.

Comparison to folly::Poly

First let us see a comparison to another type-erasure framework.

thecppzoo

This is a description about a recent small project:

I've been researching and working on how to implement the best mechanisms for event handlers. Frequently the events are received by a dispatcher component that classifies the event and activates the correct processing function. For example, if the event is a market data message which could be a trade, a bid or an ask:

void dispatch(int eventType, void *data) {
    switch(eventType) {
        case 0: processTrade(data); break;
        case 1: processBid(data); break;
 case 2: processAsk(data); break;

thecppzoo

To do:

1. Correct noexcept of swap
2. Confirm the move-operations preserve the value category
3. Deduce the return type of visit
4. Deduce the noexceptness of visit
5. Comple the set of constructors (not just by index, but also by type)
6. Refactor components to the rest of the library -- Maxer, Largest, ...
7. Rename BadVariant
8. Refactor implementations into their namespace

thecppzoo

Imagine there is a template that tells you from an operation type a class-function "operate", and a type called "inverse" which gives you the inverse operation:

template<typename Operation>
struct OperatorTraits {
    template<typename Argument>
    static Argument operate(Argument x, Argument y);

    using Inverse = // ...
};

thecppzoo

The code below emulates "restrict", the function argument attribute that indicates the ranges of the pointers do not overlap. It explains its limitations:

struct Aligned {
    alignas(1024) double d;
};

using u = unsigned;
constexpr u count = 1 << 10;
using ul = unsigned long;

thecppzoo

I have been working on a simple precision-doubling template.

The largest integer supported by GCC and Clang are the __int128 and unsigned __int128 types.

Addition

In general, there is no way to access the carry flag necessary to implement multiple precision additions. Fortunately Clang detects that's what one is doing and generate good assembler, at least in AMD64 (x86-64):

#include <stdint.h>

thecppzoo

It turns out that both GCC and Clang compile recursive code for factorial as a simple loop:

template<typename T>
constexpr
T factorial_impl(T value) {
    return value <= 1 ? 1 : value * factorial(value - 1);
}

long factorial(long arg) { return factorial_impl(arg); }