Static volatile fields on .net framework

[eterekhin]

It seems that "B" field will be loaded before "A". It is true? I am wondering because it seems there is reordering here even though A is marked as volatile.

using System;
using System.Threading;

public class Program
{
  public static volatile int A;
  public static int B;

  public bool ReadAndCheck()
  {
    var a = A;
    var b = B;
    return a > b;
  }
}

// AMD 64
Program.ReadAndCheck()
    L0000: mov eax, [rip+0xa269a]
    L0006: cmp [rip+0xa2690], eax
    L000c: setg al
    L000f: movzx eax, al
    L0012: ret

csharplab .net framework

in .net core both fields are loaded into registers csharplab .net core

You can play around with it

using System;
using System.Threading;

public class Program
{
    public static volatile int A = 1;
    public static int B = 1;

    public static bool ReadAndCheck()
    {
        var a = A;
        var b = B;
        return a > b;
    }

    public static void First()
    {
        while (true)
        {
            e.WaitOne();

            if (ReadAndCheck())
            {
                Console.WriteLine("reordering");
            }

            e.Set();
        }
    }


    private static AutoResetEvent e;

    public static void Second()
    {
        while (true)
        {
            A = 1;
            B = 1;
            
            e.Set();

            B = 2;
            A = 2;

            e.WaitOne();
        }
    }

    public static void Main()
    {
        e = new AutoResetEvent(false);
        new Thread(First).Start();
        new Thread(Second).Start();
    }
}

[danmoseley]

Cc @stephentoub

[EgorBo]

Can confirm, a quick fix to spill such trees in the importer works: EgorBo@4cfc8fa

new codegen:

G_M57035_IG02: 
       8B050E201000         mov      eax, dword ptr [reloc classVar[0x76c00358]] ;; A
       8B150C201000         mov      edx, dword ptr [reloc classVar[0x76c00370]] ;; B
       3BC2                 cmp      eax, edx
       0F9FC0               setg     al
       0FB6C0               movzx    rax, al
G_M57035_IG03: 
       C3                   ret 

old codegen:

G_M57035_IG02:              
       8B0512201000         mov      eax, dword ptr [reloc classVar[0x677a0370]] ;; B
       390508201000         cmp      dword ptr [reloc classVar[0x677a0358]], eax ;; A
       0F9FC0               setg     al
       0FB6C0               movzx    rax, al
G_M57035_IG03:              
       C3                   ret 

[AndyAyersMS]

Note:

• we don't need to spill globrefs without the order constraint (that is, normally two reads can be reordered)
• we may need to spill in other cases (ldind for instance)
• I think we get store-store and store-load orderings correct, which is why this has gone under the radar

[AndyAyersMS]

Was thinking it might just be simpler to spill volatile reads when we produce them, rather than waiting for a subsequent read to trigger the spilling.

This might also allow us to handle #10619.

[AndyAyersMS]

@eterekhin I'm likely going to transfer this over as an issue so we can fix this in .NET Core 6.0.

The "bar" for us fixing this in .NET Framework is quite high. The current behavior has been in place for many years and to my knowledge has not lead to any reported problems. If this is impacting your ability to use .NET Framework, please share more details.

[eterekhin]

Thanks for the investigation. This doesn't affect me at all, I was playing around the volatile fields to better understand them and ran into the "strange" behavior. I was not sure if it is a bug, so decided to ask here instead of creating the issue.