Double-check my lock-free voodoo

template<typename T>bool CompareAndSet( T* location, T setValue, T expectedValue ){	// ASM goes here}class LocklessMailbox{	// stores Node*s in a stack -- moves the single-threaded stuff out of the threading code	OneThreadNodeStack Read;	// A stack of the actual stuff we want to deliver.  Once again, less crud in the tricky	// threading code:	std::stack<MessageInfo*> PendingReads;	// The WriteHead is the hard threading part:	typedef volatile Node NodeVol;	typedef NodeVol *pNodeVol;	typedef volatile pNodeVol pvNodeVol;	pvNodeVol WriteHead;public:	LocklessMailbox()	{		WriteHead = new Node;	}public:	// [SNIP]	MessageInfo* PopTopPendingReads() {		if (PendingReads.empty()) return NULL;		MessageInfo* retval = PendingReads.top();		PendingReads.pop();		return retval;	}	// notice that there is no more volatile in this function.  Nor is there any memory management:	MessageInfo* GetMessage()	{		if(!PendingReads.empty())		{			return PopTopPendingReads();		}		if(Read.empty())			SwapReadAndWrite();		// pop_top() returns the data at the top of the Read stack,		// and returns NULL if the stack is empty.  It deals with memory		// management:		while(MessageInfo* message = Read.pop_top())		{			PendingReads.push(message);		}		return PendingReads.pop_top();	}	// here is the dangerous threading code:	void AppendMessage( MessageInfo* retval )	{		pNodeVol new_head = new Node( retval );		while (true) {			new_head->Next = WriteHead;			bool success = CompareAndSet<Node*>( &WriteHead, new_head, new_head->Next );			if (success) {				return;			}		}	}	void SwapReadAndWrite()	{		while (true)		{			Node* ReadHead = Read.GetHead();			Node* old_write = WriteHead;			bool success = CompareAndSet<Node*>( &WriteHead, ReadHead, old_write );			if (success) {				Read.SetHead( old_write );				return;			}		}	}	// [SNIP]};

//// Helper function for atomic compare-and-swap// Returns true on success//template <class DataType>bool CompareAndSwap(DataType* field, DataType oldvalue, DataType newvalue){	DataType retval;	_asm	{		mfence		mov eax, oldvalue		mov ecx, newvalue		mov edx, dword ptr [field]		lock cmpxchg dword ptr[edx], ecx		mov retval, eax		mfence	}	return (retval == oldvalue);}//// This class encapsulates a lockless mailbox algorithm for asynchronous message passing.// Each thread is granted a mailbox when it is started up; this mailbox is used for all// messages passed into that thread. Messages are dequeued in FIFO order.//// IMPORTANT: this algorithm is only safe for a many producer/single consumer scenario.//            Critical assumptions made by the code are only valid if a single consumer//            thread is used. However, any number of producer threads is permitted.//// The algorithm uses three distinct stacks: a read stack, a write stack, and a cache.// Producers push items onto the write stack using a simple and well-known CAS method.// When the consumer thread arrives to retrieve a message, it first checks the cache// for any waiting messages. If the cache is empty, the consumer thread swaps the read// and write stacks. At this point, the read stack is controlled entirely by the consumer// thread, so we don't need to worry about contention for elements in the read stack.// The entire read stack is then traversed and its contents pushed into the cache.// Note that we achieve FIFO semantics only by using this extra cache stack.//template <class PayloadType>class LocklessMailbox{// Construction and destructionpublic:	//	// Construct and initialize the read and write stacks	//	LocklessMailbox()	{		std::auto_ptr<Node> wh(new Node);		std::auto_ptr<Node> rh(new Node);		WriteHead = wh.release();		ReadHead = rh.release();	}	//	// Clean up the read, write, and cache stacks, freeing any	// remaining messages from each stack.	//	~LocklessMailbox()	{		Release();	}// Message passing interfacepublic:	//	// Register a message from a producer thread. Any number of threads	// may call this function.	//	void AddMessage(PayloadType* info)	{		Node* msgnode = new Node(info);		while(true)		{			msgnode->Next = WriteHead;			bool success = CompareAndSwap<Node*>(&WriteHead, msgnode->Next, msgnode);			if(success)				return;		}	}	//	// Retrieve a message from the mailbox.	// IMPORTANT: only ONE consumer thread (per mailbox) should call this function	//	PayloadType* GetMessage()	{		if(!PendingReads.empty())			return PopPendingRead();		if(ReadHead->Next == NULL)			SwapReadAndWrite();		Node* n = ReadHead;		while(ReadHead->Next)		{			PendingReads.push(n);			n = n->Next;			ReadHead = n;		}		if(PendingReads.empty())			return NULL;		return PopPendingRead();	}// Internal helpersprivate:	//	// Pop a pending read from the cache stack	//	PayloadType* PopPendingRead()	{		Node* readnode = PendingReads.top();		PayloadType* payload = readnode->Payload;		delete readnode;		PendingReads.pop();		return payload;	}	//	// Internal helper for swapping the read/write stacks	// See class comment for details	//	void SwapReadAndWrite()	{		while(true)		{			Node* readhead = ReadHead;			Node* oldwrite = WriteHead;			bool success = CompareAndSwap<Node*>(&WriteHead, oldwrite, readhead);			if(success)			{				ReadHead = oldwrite;				return;			}		}	}	//	// Release the mailbox and free any remaining messages	//	void Release()	{		for(std::stack<Node*>::container_type::iterator iter = PendingReads.c.begin(); iter != PendingReads.c.end(); ++iter)		{			delete (*iter)->Payload;			delete *iter;		}		Node* n = WriteHead;		while(n)		{			delete n->Payload;			Node* nextn = n->Next;			delete n;			n = nextn;		}		n = ReadHead;		while(n)		{			delete n->Payload;			Node* nextn = n->Next;			delete n;			n = nextn;		} 	}// Internal trackingprivate:	struct Node	{		Node() : Next(NULL), Payload(NULL) { }		Node(PayloadType* p) : Next(NULL), Payload(p) { }		Node* Next;		PayloadType* Payload;	};	Node* WriteHead;	Node* ReadHead;	std::stack<Node*> PendingReads;};