[SRM] Optimize MetadataBuilder.GetOrAddConstantBlob.

[teo-tsirpanis]

In MetadataBuilder.GetOrAddConstantBlob, the pooled blob builder was replaced by writing to a stack-allocated span, resulting in a 2x performance improvement when repeatedly writing the same scalar value (see comments in the bottom for benchmark results).

[dotnet-policy-service]

Tagging subscribers to this area: @dotnet/area-system-reflection-metadata
See info in area-owners.md if you want to be subscribed.

[Copilot]

Pull Request Overview

This PR optimizes constant blob encoding by eliminating unnecessary allocations. It refactors the GetOrAddConstantBlob method and the WriteConstant methods to use stack-allocated buffers instead of pooled BlobBuilder instances for scalar (non-string) constants.

Key Changes:

• Introduced a new WriteScalarConstant method that writes scalar constants to a Span<byte> and returns the number of bytes written
• Refactored GetOrAddConstantBlob to use stack allocation for scalar values
• Updated both WriteConstant overloads to call WriteScalarConstant for non-string values

Reviewed Changes

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

File	Description
MetadataBuilder.Heaps.cs	Refactored GetOrAddConstantBlob to use stack-allocated buffer and new WriteScalarConstant method
BlobWriterImpl.cs	Added new WriteScalarConstant method and refactored existing WriteConstant overloads to use it

[Copilot]

The documentation should clarify that bytes must be at least sizeof(ulong) bytes in length to accommodate the largest scalar type. Additionally, it should document the expected behavior when value is null (returns 4 bytes for a zero uint).

Suggested change

	/// <param name="bytes">The span where the content will be encoded.</param>
	/// <param name="value">The constant value.</param>
	/// <param name="bytes">
	/// The span where the content will be encoded. Must be at least <c>sizeof(ulong)</c> bytes in length to accommodate the largest scalar type.
	/// </param>
	/// <param name="value">
	/// The constant value. If <paramref name="value"/> is <c>null</c>, writes 4 bytes representing a zero <c>uint</c>.
	/// </param>

[AaronRobinsonMSFT]

This looks good to me. Nothing obvious jumps out and I assume we have good test coverage for this area.

[jkotas]

optimizes

Do you have any perf numbers that show the benefit of this optimization?

[jkotas]

MetadataBuilder.GetOrAddConstantBlob will be faster because of the use of stack-allocated memory instead of pooled blob builders, but it's a little hard to benchmark this method in isolation because there's no MetadataBuilder.Clear method yet.

GetOrAddConstantBlob is returning interned blob, so I would expect that calling it with the same value multiple times is going to be significantly faster. Am I missing something?

[jkotas]

I do not think the benchmark you have shared above is exercising the code changed in this PR.

[teo-tsirpanis]

I do not think the benchmark you have shared above is exercising the code changed in this PR.

Oops, sorry; I should stop working on multiple PRs at the same time.

GetOrAddConstantBlob is returning interned blob, so I would expect that calling it with the same value multiple times is going to be significantly faster. Am I missing something?

Yes; the idea is that serializing the blob to check if it exists would be faster, as it would use stack-allocated memory instead of a pooled BlobBuilder.

[teo-tsirpanis]

Latest EgorBot results show a 2x slowdown for Blob(Builder|Writer).WriteConstant. There could be an argument made that the code is now deduplicated, and I still believe that MetadataBuilder.GetOrAddConstant will be a bit faster (can't think of any way to measure).

Alternatively, I'd be fine with optimizing just GetOrAddConstant by duplicating BlobWriterImpl.WriteConstant once more, or with closing this.

[teo-tsirpanis]

I had an idea on how to benchmark MetadataBuilder.GetOrAddConstantBlob, and will try it later today.

[Copilot]

Pull request overview

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

---

You can also share your feedback on Copilot code review. Take the survey.

[teo-tsirpanis]

Outdated.

[teo-tsirpanis]

I copied the minimum necessary subset of SRM's sources into a separate benchmark project, and compared the old and new implementations of MetadataBuilder.GetOrAddConstantBlob. The new implementation was found to be twice as fast:

BenchmarkDotNet v0.15.8, Windows 11 (10.0.26200.8037/25H2/2025Update/HudsonValley2)
AMD Ryzen 9 9950X 4.30GHz, 1 CPU, 32 logical and 16 physical cores
.NET SDK 11.0.100-preview.1.26104.118
  [Host]     : .NET 10.0.5 (10.0.5, 10.0.526.15411), X64 RyuJIT x86-64-v4
  DefaultJob : .NET 10.0.5 (10.0.5, 10.0.526.15411), X64 RyuJIT x86-64-v4

Method	Mean	Error	StdDev	Ratio	Rank	Gen0	Allocated	Alloc Ratio
Old	489.8 ns	5.24 ns	4.91 ns	1.00	2	0.0019	32 B	1.00
New	239.3 ns	2.58 ns	2.41 ns	0.49	1	0.0019	32 B	1.00

Benchmark sources

I reverted all other parts of the PR and scoped it down to optimizing just MetadataBuilder.GetOrAddConstantBlob. I might take another try at BlobBuilder.WriteConstant in the future.