Can I create my own runtime constant?

[msedi]

Vector or the SIMD libraries have runtime constant that are evaluated in a sense that code pathes that do not fit the conditions are elided. For example Vector.IsHardwareAccelerated or Sse2.IsSupported. Is this something very specific to these types and they were made known to the runtime? Or is this something I can created myself (with some special treatment, e.g. some special attribute).

In my case I need to check if CUDA is supported. I do this once in a static readonly property. After that all code pathes that do not fit this condition could be elided.

[tannergooding]

static readonly properties are already elided where possible (at least for primitive value types).

That is the following program:

class Program
{
    public static readonly uint DebugLevel = GetAppContextData("DebugLevel", defaultValue: 0);

    private static uint GetAppContextData(string name, uint defaultValue)
    {
        var data = AppContext.GetData(name);

        if (data is uint value)
        {
            return value;
        }
        else if ((data is string stringValue) && uint.TryParse(stringValue, out var result))
        {
            return result;
        }
        else
        {
            return defaultValue;
        }
    }

    public static void Main(string[] args)
    {
        Console.WriteLine(DebugLevel);
        Test();
    }

    [MethodImpl(MethodImplOptions.AggressiveOptimization | MethodImplOptions.NoInlining)]
    private static void Test()
    {
        if (DebugLevel != 0)
        {
            Console.Write("Debug: ");
        }
        Console.WriteLine("Hello World!");
    }
}

Will resolve and save DebugLevel once in the static constructor and then can optimize away the if check based on its value.
So, if you insert a breakpoint in Test and go to the disassembly, you will see:

sub         rsp,28h
mov         rcx,2153FD055F0h
mov         rcx,qword ptr [rcx]
call        CLRStub[MethodDescPrestub]@7ffdfcdf5f00 (07FFDFCDF5F00h)  
nop
add         rsp,28h
ret

It's worth noting that you don't need NoInlining or AggressiveOptimization and that I only added them to make this sample simple. Namely, it ensured TieredJIT is bypassed, since this optimization doesn't (AFAIR) happen in in non-optimized code (which Tier 0 is). It also ensures that DebugLevel is "definitely" initialized and was initialized in a separate method from the one using the value in the check.

Normally, you'd get debug code for the first 30 or so calls and so Test would also have a hidden check which calls the static constructor if it hasn't been called already, which causes it to initialize DebugLevel. After ~30 calls, the JIT will consider the method hot and will recompile it with optimizations, it will see that the static constructor has been called and so it will elide the check and optimize any conditions in Test based on the value of DebugLevel.

[gfoidl]

SIMD comes most often with loops, and by default Quick-JIT (Tier-0) is diesabled for loops, meaning these methods (with loops) are Tier-1 JITed and at this time it can't be assumed that static initialization is done. So the JIT emits a check for this.
With module initializers we can force the static initialization, the JIT knows it's done, hence it can omit this check.

See this gist for a demo.

[msedi]

@tannergooding && @gfoidl. As always thanks a lot for your detailed explanations. That helps ;-)