Optimize allocation patterns in item and elsewhere

[akrieger]

Summary

Performance "Optimizing mostly item to reduce load-time allocation by over 20%"

Purpose of change

Memory profiling cdda is extremely painful because just getting through load can take a stupid amount of time. Reducing the number of allocations done during load can help with that specifically, but also generally optimizing for allocations is beneficial for performance.

Describe the solution

There's a few things going on here.

• item contains several std:: container types. These types are not all noexcept movable, so item can't be noexcept movable either. This means containers of items like vectors have to copy items on move, instead of efficiently moving them, which is a horrendous waste of allocations. Introduce a heap<> template wrapper which we can use to put these nested containers into the heap. Although this is another level of indirection, these aren't hotly accessed members, so the penalty is negligible. But, by wrapping the std containers in the heap<> type, we can make item be noexcept movable, which is vastly more performant. This by itself eliminates many millions of allocations.
• Secondarily, because the heap<> type operates as unique_ptr on move, we don't pay the penalty of reinitializing the containers when they are moved-from. These reinitializations are typically wasted allocations that are immediately freed. This does mean a moved-from item is definitely not reusable anymore, but the typical pattern is moved-from objects aren't reusable anyway.
• We can save a few more millions of allocations by introducing an 'externally allocating' version of utf8_display_split. The original creates a separate string per non-zero-width utf8 character in mapgen pallettes, afaict. We can instead write a version that pushes string_views into a by-ref vector argument. That vector of string_views can then be statically allocated in mapgen and cached across calls, resulting in effectively constant allocation space. (Alternatively, using a cata::small_literal_vector to stack allocate may work because string_view is trivial and qualifies for that helper class).
• Apply lazy<> to a few more members, such as field::_field_type_list and, notably, item's safe_reference_anchor member, also saves noticable amounts of allocs.

Describe alternatives you've considered

Testing

Use a gui based heapprof like program to instrument the game loading.

Before:

After:

The number is 'number of allocations made', as in, calls to malloc, not bytes allocated. Most of the savings are in Item_factory::check_definitions

Additional context

[akrieger]

Great, I managed to make every compiler mad at me somehow.

[Maleclypse]

Clang has many errors. Do they belong to you?

[akrieger]

Yep I made it mad. I'll have to fix.

[akrieger]

Hm all my stuff together, not separately, seems to be hitting an issue. Let me verify I didn't mess up a merge somewhere.

[akrieger]

Ok this is fine, I messed up a merge with #70685, so just merge this and when it's in master I'll manually rebase #70685 (easy to miss a ! to invert a bool).