perf(profiling): speed up stack walking by using function run_time_cache

[morrisonlevi]

Description

This is for PHP 8 only. It uses two slots in the function run_time_cache to store:

• The function name, which looks something like "module|Namespace\\ClassName::method".
• The file name.

These two strings are interned and live between requests. This allows us to share them as Cow<'static, str> with the ddprof_time thread (fewer copies).

This is not ZTS safe. The profiler doesn't support ZTS yet anyway, I'm just pointing this out informationally.

This is not using PHP's own interning. It uses a OwnedStringTable which allocates the string data in an arena, and deduplicates using a HashMap. It also holds references to the strings in a contiguous Vec; this property is not particularly useful for this PR, but it probably will be in the future with some libdatadog work. This string_table module has cherry-picked bits from that libdatadog work-in-process.

Also fixes the initial Vec size in the ddprof_time thread when converting a SampleMessage into a Sample for libdatadog. I noticed this while reviewing profiles that it was spending a good amount of time allocating.

Readiness checklist

• Changelog has been added to the release document.
• Tests added for this feature/bug.

Reviewer checklist

• Appropriate labels assigned.
• Milestone is set.

[morrisonlevi]

Numbers time! Using the Datadog native profiler, I analyzed memory and CPU characteristics. Here's the short version:

• When just wall-time and cpu-time are enabled, CPU and latency are about the same, but down slightly. The number of allocations and bytes allocated are also down.
• When wall-time, cpu-time, and allocation profiling are enabled, then it's a clear win. CPU time spent stack walking is down ~55%, and allocated bytes are down ~35%.

In all cases, the total memory in use goes up a bit as the OwnedStringTable lives essentially forever in thread-local storage.

Some screenshots:

CPU time before/after. This is with allocation profiling enabled.

Bytes allocated before/after. Again, with allocation profiling enabled.