Optimizing a runtime-generated constant value

[sharwell]

This property always returns a constant value for a given T:
https://github.com/dotnet/roslyn/blob/6d527c3fb4b223f35bca50d364f46ac3732c4a76/src/Dependencies/Collections/SegmentedArray%601.cs#L33-L40

It relies on these helpers to produce the constant value:
https://github.com/dotnet/roslyn/blob/6d527c3fb4b223f35bca50d364f46ac3732c4a76/src/Dependencies/Collections/Internal/SegmentedArrayHelper.cs#L26-L37
https://github.com/dotnet/roslyn/blob/6d527c3fb4b223f35bca50d364f46ac3732c4a76/src/Dependencies/Collections/Internal/SegmentedArrayHelper.cs#L138
https://github.com/dotnet/roslyn/blob/6d527c3fb4b223f35bca50d364f46ac3732c4a76/src/Dependencies/Collections/Internal/SegmentedArrayHelper.cs#L145

I was hoping this implementation would produce an inline constant value at runtime via the JIT. However, I'm seeing calls to SegmentedArrayHelper.GetSegmentShift<T> in runtime profiling traces. I tried using SharpLab to find a better way to generate these, but my ideas so far rely on static constructors which are not supported by its assembly output feature.

Tagging subscribers to this area: @JulieLeeMSFT, @jakobbotsch, @kunalspathak
See info in area-owners.md if you want to be subscribed.

Issue Details

---

This property always returns a constant value for a given T:
https://github.com/dotnet/roslyn/blob/6d527c3fb4b223f35bca50d364f46ac3732c4a76/src/Dependencies/Collections/SegmentedArray%601.cs#L33-L40

It relies on these helpers to produce the constant value:
https://github.com/dotnet/roslyn/blob/6d527c3fb4b223f35bca50d364f46ac3732c4a76/src/Dependencies/Collections/Internal/SegmentedArrayHelper.cs#L26-L37
https://github.com/dotnet/roslyn/blob/6d527c3fb4b223f35bca50d364f46ac3732c4a76/src/Dependencies/Collections/Internal/SegmentedArrayHelper.cs#L138
https://github.com/dotnet/roslyn/blob/6d527c3fb4b223f35bca50d364f46ac3732c4a76/src/Dependencies/Collections/Internal/SegmentedArrayHelper.cs#L145

I was hoping this implementation would produce an inline constant value at runtime via the JIT. However, I'm seeing calls to SegmentedArrayHelper.GetSegmentShift<T> in runtime profiling traces. I tried using SharpLab to find a better way to generate these, but my ideas so far rely on static constructors which are not supported by its assembly output feature.

Author:	sharwell
Assignees:	-
Labels:	tenet-performance, area-CodeGen-coreclr
Milestone:	-

[stephentoub]

However, I'm seeing calls to SegmentedArrayHelper.GetSegmentShift in runtime profiling traces.

Presumably only when T is a reference type?

Are the callers on those code paths also generic?

[stephentoub]

As an example, consider this boiled down version of your links:

using System.Runtime.CompilerServices;

class Program
{
    public static void Main()
    {
        while (true)
        {
            AddAll<string>();
            AddAll<int>();
        }
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    public static int AddAll<T>() => SegmentedArray<T>.SegmentSize;
}

internal readonly struct SegmentedArray<T>
{
    internal static int SegmentSize
    {
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        get => SegmentedArrayHelper.GetSegmentSize<T>();
    }
}

class SegmentedArrayHelper
{
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    internal static int GetSegmentSize<T>() =>
        Unsafe.SizeOf<T>() == Unsafe.SizeOf<object>() ?
            ReferenceTypeSegmentHelper.SegmentSize :
            ValueTypeSegmentHelper<T>.SegmentSize;
}

static class ReferenceTypeSegmentHelper
{
    public static readonly int SegmentSize = 123;
}

static class ValueTypeSegmentHelper<T>
{
    public static readonly int SegmentSize = 456;
}

Set the DOTNET_JitDisasm environment variable to "AddOnly" and run it (ignore the name choice... it used to be doing more stuff and I simplified and then didn't rename :). You'll see four blocks of asm output, two for AddAll<int> (one at tier 0 and one at tier 1) and two for AddAll<string> (again one at tier 0 and one at tier 1).

Here's it for int:

; Assembly listing for method Program:AddAll[int]():int
; Emitting BLENDED_CODE for X64 CPU with AVX - Windows
; Tier-1 compilation
; optimized code
; rsp based frame
; partially interruptible
; No PGO data
; 0 inlinees with PGO data; 1 single block inlinees; 1 inlinees without PGO data

G_M000_IG01:                ;; offset=0000H

G_M000_IG02:                ;; offset=0000H
       B8C8010000           mov      eax, 456

G_M000_IG03:                ;; offset=0005H
       C3                   ret

; Total bytes of code 6

but here's it for string:

; Assembly listing for method Program:AddAll[System.__Canon]():int
; Emitting BLENDED_CODE for X64 CPU with AVX - Windows
; Tier-1 compilation
; optimized code
; rsp based frame
; partially interruptible
; No PGO data

G_M000_IG01:                ;; offset=0000H
       4883EC28             sub      rsp, 40
       48894C2420           mov      qword ptr [rsp+20H], rcx

G_M000_IG02:                ;; offset=0009H
       488B5110             mov      rdx, qword ptr [rcx+10H]
       488B5210             mov      rdx, qword ptr [rdx+10H]
       4885D2               test     rdx, rdx
       7402                 je       SHORT G_M000_IG04

G_M000_IG03:                ;; offset=0016H
       EB12                 jmp      SHORT G_M000_IG05

G_M000_IG04:                ;; offset=0018H
       48BA589C0020FC7F0000 mov      rdx, 0x7FFC20009C58
       E85946A95F           call     CORINFO_HELP_RUNTIMEHANDLE_METHOD
       488BD0               mov      rdx, rax

G_M000_IG05:                ;; offset=002AH
       488BCA               mov      rcx, rdx
       FF15C52A2200         call     [SegmentedArray`1[System.__Canon]:get_SegmentSize():int]
       90                   nop

G_M000_IG06:                ;; offset=0034H
       4883C428             add      rsp, 40
       C3                   ret

; Total bytes of code 57

Basically if you end up having multiple degrees of indirection with generics, inlining can be impacted. It's one of the reason why, for example, we didn't make ArgumentNullException.ThrowIfNull generic.

[EgorBo]

dotnet/roslyn#67558 🙂

[EgorBo]

Fixed via dotnet/roslyn#67558 and a follow up PR