Atomic writes in ConcurrentDictionary

[sakno]

Source code of ConcurrentDictionary contains the following comment:

runtime/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary.cs

Lines 63 to 64 in 3ae8739

	// Section 12.6.6 of ECMA CLI explains which types can be read and written atomically without
	// the risk of tearing. See https://www.ecma-international.org/publications/files/ECMA-ST/ECMA-335.pdf

But the current revision of ECMA-335 standard says:

A conforming CLI shall guarantee that read and write access to properly aligned memory
locations no larger than the native word size

Value in Node is always aligned to machine word. I'm supposing that calculation of s_isValueWriteAtomic can be replaced with a single line of code:

s_isValueWriteAtomic = Unsafe.SizeOf<TValue>() <= IntPtr.Size;

Currently, the type like struct SmallStruct { int X, Y } is not considered by the current implementation as tearing-free type on 64-bit platform.

I checked my assumption using SharpLab:

public class C {
    public struct S
    {
        public int X, Y;
    }
    
    public static void M(in S x1, out S x2) => x2 = x1;
    
    public static void M2(in long x1, out long x2) => x2 = x1;
}

Assembly code:

; Core CLR 6.0.121.56705 on amd64

C..ctor()
    L0000: ret

C.M(S ByRef, S ByRef)
    L0000: mov rax, [rcx]
    L0003: mov [rdx], rax
    L0006: ret

C.M2(Int64 ByRef, Int64 ByRef)
    L0000: mov rax, [rcx]
    L0003: mov [rdx], rax
    L0006: ret

As we can see here, read/write of word-sized value type are atomic.

EDIT: Any type that is less than or equal to native int is eligible for atomic write without risk of tearing.

[danmoseley]

That seems reasonable to me, if you want to throw up a PR maybe we will discover whether it's not 🙂

[sakno]

Sure, I can make a PR. Also I'll check other places across .NET codebase. Probably, ConcurrentDictionary is not the only place where the atomicity of arbitrary type is not accurate.