Recommended way to bridge generic constraints

[colejohnson66]

What is the recommended way to bridge generic constraints? For example, say I have a generic T : IFloatingPoint<T>, but I have an optimized routine for T : IFloatingPointIeee754. Until dotnet/csharplang#6308 lands, we're very restricted, but there's still options.

I've seen in the runtime usage of (T)(object)value. The JIT elides this box/unbox pair, but are there restrictions/limitations? What if I have two values I need to do this on? For example, is this guaranteed to elide the box/unbox?

public static T SomeLogic<T>(T input, out T output)
    where T : IFloatingPoint<T>
{
    if (typeof(T) == typeof(float))
    {
        T result = (T)(object)SomeLogic_Ieee754((float)(object)input, out float outputTemp);
        output = (T)(object)outputTemp;
        return result;
    }
    if (typeof(T) == typeof(double))
    {
        T result = (T)(object)SomeLogic_Ieee754((double)(object)input, out double outputTemp);
        output = (T)(object)outputTemp;
        return result;
    }

    return SomeLogic_NotIeee754(input, out output);
}

private static T SomeLogic_NotIeee754<T>(T input, out T output)
    where T : IFloatingPoint<T>
{ /* ... */ }

private static T SomeLogic_Ieee754<T>(T input, out T output)
    where T : IFloatingPointIeee754<T>
{ /* ... */ }

Alternatively, is Unsafe.As/Unsafe.BitCast recommended, or will it confuse the JIT?

public static T SomeLogic<T>(T input, out T output)
    where T : struct, IFloatingPoint<T>
{
    if (typeof(T) == typeof(float))
    {
        T result = Unsafe.BitCast<float, T>(SomeLogic_Ieee754(Unsafe.BitCast<T, float>(input), out float outputTemp);
        output = Unsafe.As<float, T>(outputTemp);
        return result;
    }
    if (typeof(T) == typeof(double))
    {
        T result = Unsafe.BitCast<double, T>(SomeLogic_Ieee754(Unsafe.BitCast<T, double>(input), out double outputTemp);
        output = Unsafe.As<double, T>(outputTemp);
        return result;
    }

    return SomeLogic_NotIeee754(input, out output);
}

[neon-sunset]

Depending on the use case, in lieu of absence of "bridging generic constraints in C#" feature, you can get the necessary codegen today with the following:

static void OpenGenericMethod<T>(T value) {
    if (value is IFastPathFeature) {
        ((IFastPathFeature)value).FastPathMethod();
    }
    Fallback();
}

Assuming T is struct, this will be zero-cost. It gets a bit out of hand once you want to specialize the entire downstream method - the casts get old fast, but at least it gives you guaranteed results.

[colejohnson66]

Yes. As I noted in my question, I'm dealing with generics. For my example, I have an IFloatingPoint<T> generic constraint, and I have an optimized routine for IFloatingPointIeee754<T>. There's no official guidance on how to do so, but I've noted two forms I've seen in the runtime. I'm asking what is the recommended method to do so, if any, and what are the limitations/restrictions of them. Are there others?

Your offering of constrained calls doesn't work with TSelf generics. This fails to compile:

public T Exp10<T>(T input) where T : IFloatingPoint<T>
{
    if (input is IFloatingPointIeee754<T>)
        return ((IFloatingPointIeee754<T>)input).Exp10(input); // ERROR
    return Exp10_Slow(input);
}

The type 'T' must be convertible to 'System.Numerics.IFloatingPointIeee754<T>?' in order to use it as parameter 'TSelf' in the generic interface 'System.Numerics.IFloatingPointIeee754<TSelf>'

[tannergooding]

Short of reflection, there isn't a way to bridge generic constraints like that today. It's why the corresponding language ask exists.

It's not possible even with manual IL as the runtime doesn't allow such calls to exist.

[colejohnson66]

@tannergooding Yes, I'm aware of the limitation. My question, again, is: which is the better way to do so given the current limitations of the system? Should one use (T)(object)value or Unsafe.BitCast<double, T>(value)? Does the JIT recognize both, or are there limitations we should be aware of?

[tannergooding]

If you've done a if (typeof(T) == typeof(...)) typecheck, then (T)(object)value is the more common pattern.

Unsafe.BitCast<double, T> should also work fine on any version of RyuJIT and the version of Mono shipping alongside .NET 9. Older versions of Mono didn't handle it well (and may not handle (T)(object)value well either, as they tend to not do generic specialization in the same way RyuJIT does).

If you've not done a if (typeof(T) == typeof(...)) check, then its not safe. So this pattern only works for a concrete set of T you've opted to support and that can be problematic, since you can miss cases. The original sample code would not be handling Half for example or the existing NFloat, some future BFloat16 or Float128, etc.

[colejohnson66]

Yes, I'm aware that it misses some things; It was just a truncated example. Thanks for your response!