Default arguments.

Or hidden cost of poor APIs.

One of the recent performance investigations led me to a piece of code that looked something like

It looks very innocent, but, as the name of the function suggests, there is a default argument involved

and, since luck is rarely on my side, Dummy constructor is not free

Because of this, every with_default invocation would call this expensive constructor and cause all performance engineers some noticeable grief.

There are many ways to deal with this sadness. The most straightforward way is to use a shared static variable

but since we don’t want to deal with Static Initialization Order Fiasco, we can use a static local variable instead

Both versions would prevent creating a new Dummy instance for each invocation

and instead reuse a static global

or static local variable

Based on assembly alone, I’d expect both static usages to outperform our initial implementation, potentially with static global variable having a slight edge due, since it does not require an extra if that checks whether default is initialized. It’s finally time to check out assumptions

And the results are

So with_static_default is 1.2x faster than with_default and with_static_local_default is 1.4x faster than with_default and 1.2x faster than with_static_default. I was a bit surprised to see that with_static_local_default was the winner, but since its branch is easy to predict, it probably shouldn’t come as a big surprise.

In any case, the moral of the story is that performance considerations should be applied equally if not more to APIs than to implementation.