test(profiling): add profiles dictionary benchmarks (#2088)

## What does this PR do?

Adds a focused Criterion benchmark for `ProfilesDictionary` unique string insertion.

The benchmark uses `ProfilesDictionary` and covers 1, 2, 4, and 16 producer threads, so follow-up arena sizing/growth changes have a baseline in the GitLab benchmark job.

#2048 changes the default configs for the ProfilesDictionary

## Why these thread counts?

This benchmark is focused on dictionary string interning. It is not a full end-to-end profiler benchmark.

| Thread count | Why it is useful |
|---|---|
| 1 | Approximates single-writer consumers such as ddprof. ddprof appears to intern from the worker thread while export happens from a separate inactive profile buffer. |
| 2 | Approximates current dd-trace-py contention: one native stack sampler thread can intern off-GIL while one Python/Cython collector path is active under the GIL. |
| 4 / 16 | Stress cases for future higher-concurrency scenarios, including possible free-threaded/no-GIL Python work. |

In dd-trace-py, profile mutation and serialization are guarded by `profile_mtx`, but dictionary interning can happen before a sample is added to the profile. This means dictionary insertion can still be concurrent even when profile writes are serialized.

## What this does not cover

This benchmark does not model every profiler behavior. In particular, it does not cover:

- function or mapping insertion,
- duplicate-heavy/cached lookup workloads,
- profile serialization reading from the dictionary,
- full profiler end-to-end behavior.

## Why only `ProfilesDictionary`?

I originally tried an additional synthetic benchmark comparing 4 vs 16 shards. Local exploratory results suggested 16 shards helps once there is concurrent insertion:

```text
1 thread:   4 shards ~40 µs,   16 shards ~55 µs
2 threads:  4 shards ~157 µs,  16 shards ~129 µs
4 threads:  4 shards ~385 µs,  16 shards ~280 µs
16 threads: 4 shards ~2.64 ms, 16 shards ~1.61 ms
```

However, that synthetic comparison also changed total initial hash-table capacity because the capacity was applied per shard. Since the current follow-up keeps the production shard count at 16, this PR stays minimal and only adds the `ProfilesDictionary` benchmark.

If we revisit shard count later, we should add a dedicated shard-count benchmark that holds total starting capacity constant across shard counts.

## How to test the change?

- cargo +nightly-2026-02-08 fmt --all -- --check
- cargo check -p libdd-profiling --benches
- cargo +stable clippy -p libdd-profiling --benches -- -D warnings

[PROF-14423](https://datadoghq.atlassian.net/browse/PROF-14423)


[PROF-14423]: https://datadoghq.atlassian.net/browse/PROF-14423?atlOrigin=eyJpIjoiNWRkNTljNzYxNjVmNDY3MDlhMDU5Y2ZhYzA5YTRkZjUiLCJwIjoiZ2l0aHViLWNvbS1KU1cifQ

Co-authored-by: morrisonlevi <levi.morrison@datadoghq.com>
Co-authored-by: taegyun.kim <taegyun.kim@datadoghq.com>

Author: taegyunkim

libdd-profiling/benches/main.rs

@@ -5,5 +5,10 @@ use criterion::criterion_main;
 
 mod add_samples;
 mod interning_strings;
+mod profiles_dictionary;
 
-criterion_main!(interning_strings::benches, add_samples::benches);
+criterion_main!(
+    interning_strings::benches,
+    add_samples::benches,
+    profiles_dictionary::benches
+);

libdd-profiling/benches/profiles_dictionary.rs

@@ -0,0 +1,103 @@
+// Copyright 2026-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+use criterion::{black_box, criterion_group, BatchSize, BenchmarkId, Criterion, Throughput};
+use libdd_profiling::profiles::datatypes::ProfilesDictionary;
+use std::sync::Barrier;
+use std::thread;
+use std::time::Duration;
+
+// 1-2 threads matches expected profiler usage; higher counts stress contention behavior.
+const THREAD_COUNTS: [usize; 4] = [1, 2, 4, 16];
+const STRINGS_PER_THREAD: usize = 1024;
+// Bound one generated function-name component so the input has repeated
+// function-like fragments, with some full strings shared across workers.
+const FUNCTION_NAME_VARIANTS: usize = 97;
+const STRING_SHAPE_VARIANTS: usize = 4;
+// Knuth/Fibonacci multiplicative hash constant, used only to vary synthetic input.
+const KNUTH_MULTIPLICATIVE_HASH: usize = 2_654_435_761;
+
+// The outer Vec partitions precomputed input by benchmark worker thread; each
+// inner Vec is the set of strings inserted by one worker.
+fn make_partitioned_strings(thread_count: usize) -> Vec<Vec<String>> {
+    (0..thread_count)
+        .map(|thread_id| {
+            (0..STRINGS_PER_THREAD)
+                .map(|string_id| {
+                    let function_id = string_id % FUNCTION_NAME_VARIANTS;
+                    let mixed_id = string_id.wrapping_mul(KNUTH_MULTIPLICATIVE_HASH);
+
+                    match string_id % STRING_SHAPE_VARIANTS {
+                        0 => format!("function_{function_id}::{mixed_id}"),
+                        1 => format!("/src/thread_{thread_id}/module_{function_id}/file_{string_id:04}.rs"),
+                        2 => {
+                            format!("datadog::profiling::module_{function_id}::function_{mixed_id}")
+                        }
+                        _ => format!(
+                            "/opt/datadog/profiler/thread-{thread_id}/module-{function_id}/src/file_{string_id:04}.rs::function_{function_id}::{mixed_id}",
+                        ),
+                    }
+                })
+                .collect()
+        })
+        .collect()
+}
+
+fn insert_profile_strings(dict: &ProfilesDictionary, strings: &[String]) {
+    for string in strings {
+        black_box(dict.try_insert_str2(string.as_str()).unwrap());
+    }
+}
+
+fn insert_dictionary_strings_concurrently(strings: &[Vec<String>]) -> ProfilesDictionary {
+    let dict = ProfilesDictionary::try_new().unwrap();
+
+    if let [strings] = strings {
+        insert_profile_strings(&dict, strings);
+        return dict;
+    }
+
+    let barrier = Barrier::new(strings.len());
+    thread::scope(|scope| {
+        for thread_strings in strings {
+            let dict = &dict;
+            let barrier = &barrier;
+            scope.spawn(move || {
+                barrier.wait();
+                insert_profile_strings(dict, thread_strings);
+            });
+        }
+    });
+
+    dict
+}
+
+pub fn bench_profile_string_inserts(c: &mut Criterion) {
+    let mut group = c.benchmark_group("profiles_dictionary/profile_string_inserts");
+    group.warm_up_time(Duration::from_secs(1));
+    group.measurement_time(Duration::from_secs(5));
+    group.sample_size(10);
+
+    for thread_count in THREAD_COUNTS {
+        // Precompute input outside the measured closure so the benchmark measures
+        // dictionary insertion rather than string formatting/allocation.
+        let strings = make_partitioned_strings(thread_count);
+        let total_strings = thread_count * STRINGS_PER_THREAD;
+        group.throughput(Throughput::Elements(total_strings as u64));
+        group.bench_with_input(
+            BenchmarkId::new("threads", thread_count),
+            &strings,
+            |b, strings| {
+                b.iter_batched(
+                    || strings,
+                    |strings| black_box(insert_dictionary_strings_concurrently(strings)),
+                    BatchSize::LargeInput,
+                );
+            },
+        );
+    }
+
+    group.finish();
+}
+
+criterion_group!(benches, bench_profile_string_inserts);