After quickly glancing the code, I concluded that they wrote C++ like there is no static type. It seems they faithfully ported the very dynamic nature of their existing code to C++ without thinking.

Like what is this? https://github.com/ExaScience/elprep-bench/blob/master/cpp/f...

  auto alns = any_cast<shared_ptr<deque<shared_ptr<sam_alignment>>>>(data);

So the data is sam_alignment type inside shared_ptr inside deque inside another share_ptr inside god forbid any? Why did they do that? What kind of abomination is this? Also from the context, it is the only possible type. they use:

  try { any_cast<abomination_type>(data) ; }
  catch ( bad_any_cast ) { throw runtime_error(...) ; }

If you're so sure an object of any only hold exactly one type and everything else is unexpected error, you shouldn't use any at all!

They really like std::deque<T> and use it everywhere even though the sizeof(T) is like a few dozen bytes at best so they should rather use std::vector. The data structure of deque is a list of array. while it can amortize the continious adding of the elements to front or back, since the element size is very small, they should rather use vector.

Speaking of data structure, they also use std::unordered_map<int, any>. the unordered_map is very slow(it's a node based hash map, not suitable for the modern hardware) and the sizeof(int) + sizeof(any) is like 20 bytes(sizeof(int) + two pointers) so they got no benefit of using node based data structure here. They should rather use sorted vector and binary search it.

My conclusion, it's slow because they wrote C++ like a dynamic typed language and they choose the wrong data structures.