[API Proposal]: Volatile read/write for new supported types of Interlocked exchange

[ShadedBlink]

Background and motivation

.Net 9 now allows us to exchange more types like byte, short and enums. It would be nice to expand Volatile.Write() and Volatile.Read() with such overloads as well.

API Proposal

public static class Volatile
{
    // Remove constraints from existing methods, making them work for primitives and throw for unsupported types,
    // as was done with Interlocked.{Compare}Exchange
    public static T Read<T>([NotNullIfNotNull(nameof(location))] ref readonly T location)
-        where T : class?
    public static void Write<T>([NotNullIfNotNull(nameof(value))] ref T location, T value) 
-        where T : class?
}

API Usage

var x = SomeEnumType.DefaultValue;
Volatile.Write(ref x, SomeEnumType.NonDefaultValue);

Alternative Designs

No response

Risks

No risks, everything already implemented in net9.0.

[dotnet-policy-service]

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

[Clockwork-Muse]

These already exist. Are you thinking of something else?

[ShadedBlink]

@Clockwork-Muse , sorry, I missed the byte part. However, generic case supports only object types, like it was before with Interlocked.Exchange<T>(). In net9.0 Interlocked.Exchange<T>() was updated to support both primitives and objects so enums are supported as well. Same changes should be applied to generic case of Volatile.Write() and Volatile.Read(). I updated proposal.

[ShadedBlink]

@Clockwork-Muse @mangod9
So what is to expect? net9.0 is near, Interlocked.Exchange() changes are already implemented and announced, will we have corresponding changes to Volatile? This seems as a small enough change to add it before release.

[mangod9]

at this point we are already locked down for 9, so we will have to consider these for next release.

[timcassell]

Unlike the new Interlocked functionality, this should be able to support all types. Any type <= IntrPtr.Size can be special-cased, and any larger type can use the new Volatile.(Read/Write)Barrier APIs.

[jkotas]

Yes, it can support all type. I think the question is whether it should support all types. Volatile has been historically limited to atomically read/written values. Relaxing it is going to lead to more subtle thread-safety bugs that will get unnoticed. Is the extra convenience worth it? Also, if we relax Volatile.Read/Write, are we also going to remove C# restriction that allows volatile to be used for atomically read/written values only?