TryDequeue return True but get null result

[lust4life]

using System;
using System.Threading.Tasks;
using BenchmarkDotNet.Running;

namespace MPMCQueue.NET.Benchmarks
{
  class Program
  {
    static MPMCQueue queue { get; } = new MPMCQueue(2);
    static void Enqueue()
    {
      while (true) { queue.TryEnqueue(1); }
    }

    static void Dequeue()
    {
      while (true)
      {
        if (queue.TryDequeue(out object t) && t == null)
        {
          System.Console.WriteLine("Dequeue null");
          break;
        }
      }
    }

    static void Main(string[] args)
    {
      var t1 = Task.Run(() => Enqueue());
      var t2 = Task.Run(() => Dequeue());
      Task.WaitAll(t1, t2);
    }
  }
}

output:

λ  .\benchmarks\MPMCQueue.NET.Benchmarks\bin\Release\MPMCQueue.NET.Benchmarks.exe
Dequeue null

if (cell.Sequence == pos + 1 && Interlocked.CompareExchange(ref _dequeuePos, pos + 1, pos) == pos)
{
    result = Volatile.Read(ref cell.Element);
    buffer[index] = new Cell(pos + bufferMask + 1, null);  // maybe here is the problem, 
//    buffer[index].Element = null;
//    buffer[index].Sequence = pos + bufferMask + 1;
    return true;
}

00007ffe`162b0b6a e891325f5f      call    clr!JIT_CheckedWriteBarrier (00007ffe`758a3e00)
00007ffe`162b0b6f 8d443701        lea     eax,[rdi+rsi+1]
00007ffe`162b0b73 33d2            xor     edx,edx
00007ffe`162b0b75 8903            mov     dword ptr [rbx],eax
00007ffe`162b0b77 48895308        mov     qword ptr [rbx+8],rdx
00007ffe`162b0b7b b801000000      mov     eax,1
00007ffe`162b0b80 4883c420        add     rsp,20h

two mov here, if use struct constructor seems can not guarantee the order. Sequence should be modified after cell.Element

[lust4life]

The C# ECMA specification guarantees that the following types will be written atomically: reference types, bool, char, byte, sbyte, short, ushort, uint, int and float. Values of other types—including user-defined value types—could be written into memory in multiple atomic writes. As a result, a reading thread could observe a torn value consisting of pieces of different values.

One caveat is that even the types that are normally read and written atomically (such as int) could be read or written non-atomically if the value is not correctly aligned in memory. Normally, C# will ensure that values are correctly aligned, but the user is able to override the alignment using the StructLayoutAttribute class (bit.ly/Tqa0MZ).

The C# Memory Model in Theory and Practice
atomicity-volatility-and-immutability-are-different-part-one

[alexandrnikitin]

@lust4life , thank you for the issue! Indeed, you are right! It happens because we first write sequence and then element in dequeue (which overwrites the enqueued element).

[alexandrnikitin]

Closed by #5