Re: Top 10 most common hard skills listed on resumes...

I've run the numbers on different kinds of virtual indirection:
#include <iostream>
#include <functional>
#include <chrono>
#include <atomic>
#include <memory>
using namespace std;
using namespace chrono;
static atomic_int x( 0 );
auto adder = []( int a, int b ) { return a + b + ::x.load( memory_order_relaxed ); };
struct V
{
virtual int operator ()( int a, int b )
{
return adder( a, b );
}
};
function<int ( int, int )> fn( adder );
function<int ( int, int )> fnRef( ref( adder ) );
function<int ( int, int )> fnC( +adder );
atomic<int (*)( int, int )> cFn( +adder );
unique_ptr<V> v( make_unique<V>() );
int main()
{
int sum = 0;
auto bench = [&]<typename Fn>( char const *what, Fn fn )
{
using hr_t = high_resolution_clock;
using dur_t = hr_t::duration;
dur_t tMin = dur_t::max();
for( int turn = 100; turn--; )
{
auto start = hr_t::now();
for( int a = 100; a--; )
for( int b = 100; b--; )
sum += fn( a, b );
dur_t dur = hr_t::now() - start;
tMin = tMin > dur ? dur : tMin;
}
cout << what << duration_cast<nanoseconds>( tMin ).count() / 1.0e4 << endl;
};
bench( "function<>: ", []( int a, int b ) { return ::fn( a, b ); } );
bench( "function<> ref'd: ", []( int a, int b ) { return ::fnRef( a, b ); } );
bench( "function<> C'd: ", []( int a, int b ) { return ::fnC( a, b ); } );
bench( "virtual method: ", []( int a, int b ) { return (*::v)( a, b ); } );
bench( "c-function ptr: ", []( int a, int b ) { return ::cFn.load( memory_order_relaxed )( a, b ); } );
bench( "compile-time polymorphism: ", ::adder );
return sum;
}
This are the results for my Zen4-CPU:
function<>: 0.91
function<> ref'd: 1.09
function<> C'd: 1.1
virtual method: 0.92
c-function ptr: 0.95
compile-time polymorphism: 0.41
So there's only half a nanosecond more overhead when using a function<>
-object with external storage (similar to a virtual function, but only
with one indirection since there's no virtual function table) over di-
rect inlining. No matter if you have a function<>-object, whether it is
initialized with a reference_wrapper (no external storage) or a C func-
tion pointer or if you use a C function pointler directly: it's all the
same performance. Although there are different complexities there are
enough calculation units in the Zen4-CPU to do it all in about the same
time.