.data
qEnqu dq 0
qPoll   dq 0
qHead dq 0
qEnd   dq 0

.code
;;;INPUT rcx = size to make array stack
;;;returns NONZERO = SUCCESS  0 = FAIL
QueueInit:
        shl     rcx,3 
        mov     rdx,rcx ;;; size to qword 
        xor     ecx,ecx 
        push    rdx ;;; save 
        mov     r8d,MEM_COMMIT or MEM_RESERVE 
        mov     r9d,PAGE_READWRITE 
        call    [VirtualAlloc] 
        test    rax,rax 
        jz      .fail 
        mov     qword[qEnqu],rax
        mov     qword[qHead],rax
        mov     qword[qPoll],rax
        pop     rcx
        lea     rax,[rax+rcx-8]
        mov     qword[qEnd],rax
        ret     0 
   .fail: 
        xor     eax,eax 
        invoke  ExitProcess,0 
        ret     0 

;;;return NONZERO = SUCCESS  0 = FAIL 
QueueDelete:
        mov     rcx,qword[qHead]
        xor     edx,edx 
        mov     r8d,MEM_RELEASE 
        call    [VirtualFree] 
        test    rax,rax 
        jz      .fail 
        ret     0 
   .fail: 
        xor     eax,eax 
        ret     0

;;;RCX = addr of data to put to the stack
;;;return NONZERO = success  0 = fail
QueueAdd:
        mov     rax,qword[qEnqu]
   .loop:
        lea     rdx,[rax+8]
        test    qword[rax],0 ;;;COMMENT OUT IF you want the queue
        jnz     .fail        ;;;to overwrite unPolled data
        cmp     rax,qword[qEnd]
        jnz     .skip
        mov     rdx,qword[qHead]
   .skip:
   lock cmpxchg qword[qEnqu],rdx
        jnz     .loop
        mov     qword[rax],rcx
        ret     0
   .fail:
        xor     eax,eax
        ret     0

;;;return data addr = success  0 = failure
QueueRemove:
        xor     ecx,ecx
        mov     rax,qword[qPoll]
   .loop:
        lea     rdx,[rax+8]
        test    qword[rax],0
        jz      .fail
        cmp     rax,qword[qEnd]
        jnz     .skip
        mov     rdx,qword[qHead]
   .skip:
   lock cmpxchg qword[qPoll],rdx
        jnz     .loop
        mov     rcx,rax
        xor     eax,eax
   lock xchg    qword[rcx],rax
        ret     0
   .fail:
        xor     eax,eax
        ret     0
    

       xor rax,rax
.wait: xchg [ptr_flag],rax
       test rax,rax
       je .wait    

revolution, see my code

;;;INPUT ecx = size to make array stack
;;;returns NONZERO = SUCCESS  0 = FAIL
QueueInit:
        push    ecx                ; bitRAKE: non-destructive of ECX
        shl     ecx, 2
        push    PAGE_READONLY
        push    MEM_COMMIT
        push    ecx
        push    0
        call    [VirtualAlloc] 
        test    eax, eax
        jz      .fail 
        mov     [qEnqu], eax
        mov     [qHead], eax
        mov     [qPoll], eax
        pop     ecx
        lea     eax, [eax+ecx*4-4] ; bitRAKE: non-destructive of ECX
        mov     [qEnd], eax
        ret
   .fail:
;        not     eax  ; bitRAKE: not needed, or should be "mov eax,0"
        ret    

QueueAdd:
        mov     eax, [qEnqu]
   .loop:
        ; advance to next item in EDX, wrap around at end
        lea     edx, [eax+4]
        cmp     eax, [qEnd]
        cmovz   edx, [qHead]

        cmp     dword [eax], 0 ; Do we have the slot free?
        jne     .fail
   lock cmpxchg [qEnqu], edx
        jnz     .loop

.putElement:
        mov     [eax], ecx
        ret

   .fail:
        xor     eax, eax
        ret    

;;;return data addr = success  0 = failure
QueueRemove:
        xor     ecx, ecx
        mov     eax, [qPoll]
   .loop:
        ; advance to next item in EDX, wrap around at end
        lea     edx, [eax+4]
        cmp     eax, [qEnd]
        cmovz   edx, [qHead]

        cmp     dword [eax], 0
        je      .fail

   lock cmpxchg [qPoll], edx
        jnz     .loop

        xchg    eax, ecx
        xchg    [ecx], eax
        ret

   .fail:
        xchg    eax, ecx
        ret    

QueueInit doesn't fail when it fails:

invoke  WaitForSingleObject, [hThreads+ebx*4], -1    

invoke  WaitForSingleObject, [hThreads+4*(ebx-1)], -1    

invoke  WaitForMultipleObjects, THREADS, hThreads, TRUE, -1    

; Lock-Free Queue Push 
; extern void acLfQueuePush( ac_LfQueue* pQueue, ac_LfNode* pNode ); 
acLfQueuePush PROC 
  ; Preserve
  push edi
  push esi
  push ebx

  ; Load the back
  mov  esi, [esp + 16]
  mov  edx, [esi + 12]
  mov  edi, [esi + 8]

acLfQueuePush_Retry: 
  ; Prepare the Cas
  mov  eax, 0
  mov  ebx, [esp + 20]
  lea  ecx, [edx + 1]

  ; Try to link the new node
  cmpxchg [edi], ebx
  je  acLfQueuePush_Success

  ; Prepare the Cas
  mov  ebx, eax
  mov  eax, edi

  ; Try to advance the back to the next
  cmpxchg8b qword ptr [esi + 8]
  mov  edi, eax
  jmp  acLfQueuePush_Retry

acLfQueuePush_Success: 

  ; Prepare the Cas
  mov  eax, edi

  ; Try to point the back to the new node
  cmpxchg8b qword ptr [esi + 8]

  ; Restore
  pop  ebx
  pop  esi
  pop  edi

  ret

acLfQueuePush ENDP 


; Lock-Free Queue Pop 
; extern ac_LfNode* acLfQueuePop( ac_LfQueue* pQueue ); 
acLfQueuePop PROC 

  ; Preserve
  push edi
  push esi
  push ebx

  mov  esi, [esp + 16]

acLfQueuePop_Retry: 

  ; Load the front
  mov  edx, [esi + 4]
  mov  edi, [esi]

  ; Load the back
  mov  ecx, [esi + 12]
  mov  ebx, [esi + 8]

  ; Load the next
  mov  eax, [edi]

  ; Validate
  test eax, eax
  je  acLfQueuePop_Fail

  cmp  edi, [esi]
  jne  acLfQueuePop_Retry

  cmp  edx, [esi + 4]
  jne  acLfQueuePop_Retry

  cmp  edi, [esi + 8]
  jne  acLfQueuePop_TryPop

  ; Prepare the Cas
  mov  eax, edi
  mov  edx, ebx
  mov  ebx, eax
  lea  ecx, [edx + 1]

  ; Try to advance the back to the next
  cmpxchg8b qword ptr [esi + 8]
  jmp  acLfQueuePop_Retry

acLfQueuePop_TryPop: 

  ; Load the object
  mov  ecx, [eax + 12]

  ; Prepare the Cas
  mov  ebx, eax
  mov  eax, edi
  mov  edi, ecx
  lea  ecx, [edx + 1]

  ; Try to unlink the next node
  cmpxchg8b qword ptr [esi]
  jne  acLfQueuePop_Retry

  ; Set the object on the popped node
  mov  [eax + 12], edi

acLfQueuePop_Fail: 

  ; Restore
  pop  ebx
  pop  esi
  pop  edi
  ret

acLfQueuePop ENDP