Reuse typical instantiation DispatchMap for generic instantiations

[davidwrighton]

This PR contains two related optimizations to generic type loading / interface slot handling in the CoreCLR type loader.

1. Reuse typical instantiation DispatchMap for generic instantiations

When loading a non-typical instantiation of a generic type that undergoes a full MethodTableBuilder run (the __Canon canonical form and value-type instantiations such as List<int>), the interface DispatchMap was rebuilt from scratch via PlaceInterfaceMethods for every instantiation. The encoded DispatchMap is instantiation-independent (it stores type IDs and slot numbers), so it can instead be built once while constructing the type's typical instantiation and reused for all of its non-typical instantiations.

• Release: PlaceInterfaceMethods is skipped for a non-typical instantiation when the typical instantiation's DispatchMap can be reused, and the typical instantiation's encoded map bytes are copied into the new MethodTable's inline DispatchMap.
• Debug/Checked: the specific instantiation's DispatchMap is still built and asserted to be byte-for-byte identical to the typical instantiation's map, guarding the instantiation-independence invariant.

This is safe because PlaceInterfaceMethods only produces DispatchMap interface entries (it does not mutate the vtable; PlaceMethodImpls still always runs), and the two consumers that read the half-built dispatch map after PlaceInterfaceMethods (ValidateInterfaceMethodConstraints and VerifyVirtualMethodsImplemented) are already skipped for non-typical instantiations because fNoSanityChecks is TRUE for them.

2. Avoid iterating interface methods to size virtual-static slot table

bmtInterfaceEntry::CreateSlotTable walked every method of an interface that has virtual static methods, counting the static+virtual ones solely to size the bmtInterfaceSlotImpl array. The subsequent loop already recomputes the exact per-method placement, so the array can simply be over-allocated to the interface's method count, eliminating the extra MethodIterator walk.

Validation

• Release and Checked clr.runtime builds succeed with 0 warnings/errors.
• The Debug/Checked byte-equality assert (change WIP: repo consolidation scouting kick-off - make clr build locally on Windows #1) was exercised at runtime on a small generics workload: the reuse+validation branch executed 141 times, all passing the byte-equality assert, with correct interface dispatch.

Performance

Measured on an Rx cold-start micro-benchmark that isolates the System.Reactive construct+initialize type-loading path (interleaved A/B, 60 iterations each, release coreclr.dll swapped, baseline = before both changes):

Variant	Median workload	vs baseline
Baseline (neither change)	252.15 ms	—
DispatchMap reuse only	248.61 ms	−3.07 ms (−1.2%)
Both changes	248.62 ms	−3.53 ms (−1.4%)

Standard deviation was ~1.8 ms, so the ~1.4% improvement is a clear signal on type-loading-bound workloads. On WPF R2R startup (where type loading is a much smaller fraction of total startup) the effect is smaller and within run-to-run noise.

[dotnet-policy-service]

Tagging subscribers to this area: @agocke
See info in area-owners.md if you want to be subscribed.

[Copilot]

Pull request overview

This PR optimizes CoreCLR generic type loading by avoiding redundant work when building interface dispatch maps for non-typical generic instantiations, and by reducing per-interface iteration overhead when sizing virtual-static slot tables.

Changes:

• Reuse the typical instantiation’s encoded DispatchMap for eligible non-typical generic instantiations (release), with byte-for-byte validation against a rebuilt map in _DEBUG/Checked builds.
• Reduce work in bmtInterfaceEntry::CreateSlotTable by avoiding an extra MethodIterator pass when sizing storage for interfaces with virtual static methods.
• Add a DispatchMap helper to expose the encoded map bytes for reuse/copying.

Reviewed changes

Copilot reviewed 3 out of 3 changed files in this pull request and generated no comments.

File	Description
src/coreclr/vm/methodtablebuilder.h	Tracks typical instantiation MethodTable on all builds and adds helper declaration for DispatchMap reuse.
src/coreclr/vm/methodtablebuilder.cpp	Implements DispatchMap reuse (skip PlaceInterfaceMethods in release when safe) and adjusts interface slot table sizing for virtual static methods.
src/coreclr/vm/contractimpl.h	Adds DispatchMap::GetEncodedMapData() to access encoded map bytes for reuse/copying.