Add an attribute inline-cache benchmark to cinderx/benchmarks

Summary:
`LOAD_ATTR` and `STORE_ATTR` cost almost entirely depends on the *layout* of
the receiver, where the attribute physically lives and what has to be checked
to prove a cached answer is still valid. There was no benchmark isolating
that, so `attr_cache.py` builds one receiver per distinct layout CPython 3.12,
3.14 and 3.15 can produce and hammers a separately generated hot function
against each, one cache shape per workload.

Storage layouts: `inline` (managed dict, values still inline), `split`
(materialized dict sharing the type's keys), `combined` (dict detached and
unshared), `exhausted` (shared keys full, name absent from them), `dictoffset`
(non-managed heap type with a positive `tp_dictoffset`), `slots`, `slotsdict`,
`varsize` (managed dict on a variable-sized type, which gets no inline values
on 3.14+ but does on 3.12) and `afteritems` (`__slots__` on a `tuple`
subclass, 3.15 only, skipped elsewhere). Lookup kinds that bypass instance
storage: `classvar`, `property`, `descriptor`, `getset`, `method`, `typeattr`,
`module`, `getattr`, `getattribute`. Polymorphic runs are separate workloads,
`poly2` through `poly16` plus `polylayout` and `polytype`, so the megamorphic
cliff past `CINDERX_JIT_ATTR_CACHE_SIZE` and the single-entry type-attribute
cache both show up on their own lines.

Receivers are passed in as an untyped `list`, which keeps the JIT from folding
loads into raw field accesses and holds the sites on the inline-cache path
being measured. Results are ns per attribute op, reported as the median of the
timed runs.

Three flags support verifying rather than just timing. `--describe` reports
the layout each workload's receivers actually ended up with, read through the
GC so the probe does not itself materialize a dict. `--specialization` reports
which adaptive-interpreter opcode CPython settled on. Every result block
prints whether the hot function was really JIT-compiled.

`--cinderx` and `--compare` follow `inference_pipeline.py`. Also adds a
`py_versions` argument to `cinderx_benchmark_binary` so this benchmark, whose
only dep is click, can also generate a 3.15 variant for the 3.15-only layouts.
`_cinderx` is not wired into `python_binary` for 3.15, so that variant
measures the interpreter only and warns on stderr.

Reviewed By: yoney

Differential Revision: D114683513

fbshipit-source-id: 8967cf54df165ddd660d7a73cdb46cf09ff787d4

Author: alexmalyshev

cinderx/benchmarks/README.md

@@ -30,6 +30,38 @@ uv run python benchmarks/spectral_norm.py 3
 
 The numeric argument controls the number of iterations (higher = longer run).
 
+## Attribute Cache Benchmark
+
+`attr-cache` hammers `LOAD_ATTR` and `STORE_ATTR` against one receiver per
+distinct object layout, so CinderX's inline caches can be measured against the
+CPython interpreter's adaptive specializations one cache shape at a time. There
+is a workload for each of inline values, split and combined dicts, exhausted
+shared keys, a fixed `tp_dictoffset`, `__slots__`, variable-sized types,
+properties and other descriptors, class/type/module attributes and the
+`__getattr__` / `__getattribute__` hooks, plus polymorphic and megamorphic
+variants of a single site.
+
+```bash
+# One layout, plus which adaptive-interpreter specialization CPython chose:
+buck run fbcode//cinderx/benchmarks:attr-cache-314 -- --workload inline --specialization
+
+# Baseline vs JIT across every workload:
+buck run fbcode//cinderx/benchmarks:attr-cache-314 -- --compare
+
+# What layout each workload's receivers actually ended up with:
+buck run fbcode//cinderx/benchmarks:attr-cache-314 -- --describe
+```
+
+Results are nanoseconds per attribute operation, reported as the median of the
+timed runs. Each run prints the receiver layout it measured and whether the hot
+function was actually JIT-compiled, so a suspicious number can be traced back to
+what really ran.
+
+A `attr-cache-315` variant exists for the 3.15-only layouts, notably `__slots__`
+on a `tuple` subclass. The `_cinderx` native extension is not wired into
+`python_binary` for 3.15, so that variant measures the interpreter only and says
+so on stderr.
+
 ## JIT Compilation Time Benchmark
 
 Measures how long the JIT takes to compile functions (not runtime performance):
@@ -130,6 +162,7 @@ CINDERJIT_DISABLE=1 uv run python benchmarks/runner.py
 | `richards` | Operating system task scheduler simulation (object-oriented workload) |
 | `spectral_norm` | Numerical computation of the spectral norm of a matrix |
 | `compile_time` | Measures JIT compilation speed (not runtime performance) |
+| `attr-cache` | LOAD_ATTR/STORE_ATTR against every receiver layout, monomorphic through megamorphic |
 | `fastmark` | Full pyperformance suite (~60 benchmarks) with CinderX integration |
 | `torchbench` | Run of a real TorchBench model (default `pyhpc_equation_of_state`), kept Python-bound for the JIT |