class ZwAsynCount
{
public:
	ZwAsynCount(unsigned uSize)	//uSize必须为2的n次方
	{
		m_uReadCount = 0;
		m_uWriteCount = 0;
		m_uSize = uSize;
	}
	int Write(int nLen)			//返回元素位置 -1表示读失败
	{
		int nRet = -1;

		if (GetFree() >= nLen)
		{
			nRet = m_uWriteCount&(m_uSize-1);
		}
		return nRet;
	}
	void AddWrite(int nCount = 1)
	{
		m_uWriteCount += nCount;
	}
	int GetUsed()
	{
		return m_uWriteCount - m_uReadCount;
	}
	int GetFree()
	{
		return m_uSize - GetUsed();
	}
	int Read(int nLen)		//返回元素位置 -1表示写失败
	{
		int nRet = -1;

		if (GetUsed() <= nLen)
		{
			nRet = m_uReadCount&(m_uSize-1);
		}

		return nRet;
	}
	void AddRead(int nCount = 1)
	{
		m_uReadCount+= nCount;
	}
private:
	unsigned m_uSize;
	volatile unsigned m_uReadCount;
	volatile unsigned m_uWriteCount;
};

class CCycleBuffer
{
public:
	CCycleBuffer(int nSize):m_asynCount(nSize)
	{
		m_pBuf = new char[nSize];  
		m_nTalLen = nSize;
	}
	int GetFreeSpace()
	{
		return m_asynCount.GetFree();
	}
	int GetLength()
	{
		return m_asynCount.GetUsed();
	}
	~CCycleBuffer()
	{
		if (m_pBuf)
		{
			delete m_pBuf;
		}
	}
	bool Write(char* buf, int count)
	{
		bool bRet = false;
		int  nPos = m_asynCount.Write(count);

		if (nPos >=0)
		{
			if (m_nTalLen - nPos >=  count)
			{
				memcpy(m_pBuf + nPos, buf, count);
			}
			else
			{
				memcpy(m_pBuf + nPos, buf, m_nTalLen - nPos);
				memcpy(m_pBuf, buf + m_nTalLen - nPos, count - (m_nTalLen - nPos));
			}

			m_asynCount.AddWrite(count);
			bRet = true;
		}

		return bRet;
	}
	bool Read(char* buf, int count)
	{
		bool bRet = false;
		int  nPos = m_asynCount.Read(count);

		if (nPos >=0)
		{
			if (m_nTalLen - nPos >=  count)
			{
				memcpy(buf,m_pBuf + nPos,count);
			}
			else
			{
				memcpy(buf,m_pBuf + nPos, m_nTalLen - nPos);
				memcpy(buf + m_nTalLen - nPos,m_pBuf, count - (m_nTalLen - nPos));
			}

			m_asynCount.AddRead(count);
			bRet = true;
		}

		return bRet;
	}
private:
	char	*m_pBuf;
	int		m_nTalLen;
	ZwAsynCount m_asynCount;
};

/* Interlocked SList queue using keyed event signaling */
struct queue {
    SLIST_HEADER slist;
    // Note: Multiple queues can (and should) share a keyed event handle
    HANDLE keyed_event;
    // Initial value: 0
    // Prior to blocking, the queue_pop function increments this to 1, then
    // rechecks the queue. If it finds an item, it attempts to compxchg back to
    // 0; if this fails, then it's racing with a push, and has to block
    LONG block_flag;
};
void init_queue(queue *qPtr) {
    NtCreateKeyedEvent(&qPtr->keyed_event, -1, NULL, 0);
    InitializeSListHead(&qPtr->slist);
    qPtr->blocking = 0;
}
void queue_push(queue *qPtr, SLIST_ENTRY *entry) {
    InterlockedPushEntrySList(&qPtr->slist, entry);
    // Transition block flag 1 -> 0. If this succeeds (block flag was 1), we
    // have committed to a keyed-event handshake
    LONG oldv = InterlockedCompareExchange(&qPtr->block_flag, 0, 1);
    if (oldv) {
        NtReleaseKeyedEvent(qPtr->keyed_event, (PVOID)qPtr, FALSE, NULL);
    }
}
SLIST_ENTRY *queue_pop(queue *qPtr) {
    SLIST_ENTRY *entry = InterlockedPopEntrySList(&qPtr->slist);
    if (entry)
        return entry; // fast path
    // Transition block flag 0 -> 1. We must recheck the queue after this point
    // in case we race with queue_push; however since ReleaseKeyedEvent
    // blocks until it is matched up with a wait, we must perform the wait if
    // queue_push sees us
    LONG oldv = InterlockedCompareExchange(&qPtr->block_flag, 1, 0);
    assert(oldv == 0);
    entry = InterlockedPopEntrySList(&qPtr->slist);
    if (entry) {
        // Try to abort
        oldv = InterlockedCompareExchange(&qPtr->block_flag, 0, 1);
        if (oldv == 1)
            return entry; // nobody saw us, we can just exit with the value
    }
    // Either we don't have an entry, or we are forced to wait because
    // queue_push saw our block flag. So do the wait
    NtWaitForKeyedEvent(qPtr->keyed_event, (PVOID)qPtr, FALSE, NULL);
    // block_flag has been reset by queue_push
    if (!entry)
        entry = InterlockedPopEntrySList(&qPtr->slist);
    assert(entry);
    return entry;
}