关闭

IOCP性能优化:使用环形缓冲提升IOCP效率(无锁缓冲)

4485人阅读 评论(25) 收藏 举报

最近在重构之前写的网络底层时,从各个方面认真考虑了每一个细节实现。其中,在提交I/O(WSASend/WSARecv)和I/O完成(GetQueuedCompletionStatus)时,难免出现一个缓冲区需要两个线程公用的问题。


假设主线程不断发送该消息,这些消息被堆叠在一个缓冲区里,定时使用WSASend提交发送I/O请求,在GetQueuedCompletionStatus返回后,才能按照已发送的字节数去删掉该缓冲区里相应字节数的数据。不明白?好吧我说的简单一些。

WSASend调用后,你传递的参数只是说明:我希望发送这么多数据。但请求提交后,你的要求未必能够被全部满足,也就是说也许你想发送1024字节的东西,但也许GetQueuedCompletionStatus返回,操作完成后,本次只成功发送了1000个字节,也就是说剩余的24字节的数据,你还需要再调用WSASend,直到都发送成功为止。所以在这种情况下,一定要等待GetQueuedCompletionStatus返回,才知道究竟发送成功了多少,也才能从之前的发送缓冲里删掉数据。否则,如果你在提交WSASend时就把数据删掉了,而GetQueuedCompletionStatus返回后却告诉你只发了1000字节,那就杯具了-----那24字节的数据永远地离开了我们。

注:上面两个自然段锁阐述地情况我没有测试出来过,也没有专门对此测试。但因为文档上并未说明WSASend一定会发完全部数据,所以我一直认为要等操作完成后才知道。但也有不同观点。但即使如此,相信按照我下述方法处理也不会损失效率(至少我的应用是满足了)


而在这种情况下,我们发送消息,也就是向这个缓冲区后面堆放要发送的数据,是主线程中执行的,而GetQueuedCompletionStatus完成后,从缓冲区内弹出数据,却是IOCP的工作线程做的。当然,最简单的办法就是------加个锁呗。但是,在I/O频繁的情况下,可以想象会出现多少线程争用的情况。于是,就有了本文要说的东西:环形缓冲。


环形缓冲的原理并不难理解,只适用于一个线程写,一个线程读的情况。环形缓冲的原理我就不再赘述,可以自行搜索。


废话不多说。下面给出我在这次优化中写的一个环形缓冲类,该环形缓冲完美地在基于IOCP的网络框架中工作了起来,实实在在地解决了线程争用引发地效率低下。

2012.9.1 0:57 重贴代码
修改了一个可能出现的误置Full标志的BUG,之前的代码中,是先增加写指针,再判断是否等于读指针,等于则置Full标志,但若在该判断之前,读线程将数据读空,此时写线程继续工作,进行该判断时,就会发现写指针 = 读指针(但是是由于读空造成的),于是错误地将状态置为Full。


2014.8.4 2:08 重贴代码

重写代码,解决掉xiaolizi提出的可能会引发数据被覆盖的BUG,详细请见回复:(十分感谢您提出这个问题)


XRingBuffer.h 

#pragma once

#include "XBaseDefine.h"

const BYTE XRING_BUFFER_READ_POS_AND_WRITE_POS_SIZE = 2;

class XRingBuffer
{
public:
	XRingBuffer(const DWORD size);
	~XRingBuffer();

	bool pushData(const void* data, const DWORD size);

	bool copyData(void* dest, const DWORD destSize, const DWORD copySize);
	bool popData(void* dest, const DWORD destSize, const DWORD popSize);
	bool popData(const DWORD popSize);
	const DWORD getUsedSize() const;
	const DWORD getFreeSize() const;
private:
	bool copyDataWithAddReadPosOption(void* dest, const DWORD destSize, const DWORD popSize, bool addReadPos);
private:
	char* _buffer;
	const DWORD _size;
	volatile DWORD _write_pos;
	volatile DWORD _read_pos;
};

XRingBuffer.cpp

#include "XRingBuffer.h"
#include "XDebug.h"

XRingBuffer::XRingBuffer(const DWORD size) : 
_size(size + XRING_BUFFER_READ_POS_AND_WRITE_POS_SIZE),
_write_pos(1),
_read_pos(0),
_buffer(NULL)
{
	_buffer = new char[_size];
}

XRingBuffer::~XRingBuffer()
{
	delete [] _buffer;
}

bool XRingBuffer::pushData(const void* data, const DWORD size)
{
	const DWORD freeSize = getFreeSize();
	if(freeSize < size)
	{
		return false;
	}
	const DWORD readPos =_read_pos;
	const DWORD writePos = _write_pos;
	if(writePos > readPos)
	{
		const DWORD lenFromWritePosToBufferEnd = _size - writePos;
		if(size <= lenFromWritePosToBufferEnd)
		{
			memcpy(_buffer + _write_pos, data, size);
			_write_pos += size;
			if(_write_pos == _size)
			{
				_write_pos = 0;
			}
			else if(_write_pos > _size)
			{
				assert_fail("wirtepos cannot bigger than size");
				return false;
			}
			return true;
		}
		else
		{	// 先拷贝前一部分到缓冲区尾部
			memcpy(_buffer + _write_pos, data, lenFromWritePosToBufferEnd);
			const DWORD secondPartLen = size - lenFromWritePosToBufferEnd;
			// 拷贝后一部分到缓冲区前部
			memcpy(_buffer, ((char*)data) + lenFromWritePosToBufferEnd, secondPartLen);
			_write_pos = secondPartLen;
			return true;
		}
	}
	else if(writePos < readPos)
	{
		memcpy(_buffer + writePos, data, size);
		_write_pos += size;
		return true;
	}
	else
	{
		assert_fail("write pos equal read pos, it's an error");
		return false;
	}
}


bool XRingBuffer::copyData(void* dest, const DWORD destSize, const DWORD copySize)
{
	return copyDataWithAddReadPosOption(dest, destSize, copySize, false);
}

bool XRingBuffer::popData(void* dest, const DWORD destSize, const DWORD popSize)
{
	return copyDataWithAddReadPosOption(dest, destSize, popSize, true);
}

bool XRingBuffer::popData(const DWORD popSize)
{
	return copyDataWithAddReadPosOption(NULL, 0, popSize, true);
}

const DWORD XRingBuffer::getUsedSize() const
{
	const DWORD writePos = _write_pos;
	const DWORD readPos = _read_pos;
	if(writePos > readPos)
	{
		return writePos - readPos - 1;
	}
	else if(writePos < readPos)
	{
		return (_size - readPos - 1) + _write_pos;
	}
	else
	{
		assert_fail("write pos equal read pos, it's an error");
		return 0;
	}
}

const DWORD XRingBuffer::getFreeSize() const
{
	const DWORD usedSize = getUsedSize();
	return _size - (usedSize + XRING_BUFFER_READ_POS_AND_WRITE_POS_SIZE);
}

bool XRingBuffer::copyDataWithAddReadPosOption(void* dest, const DWORD destSize, const DWORD copySize, bool addReadPos)
{
	const DWORD usedSize = getUsedSize();
	if(usedSize < copySize)
	{
		assert_fail("data is not enought to copy");
		return false;
	}
	if(dest != NULL)
	{
		if(destSize < copySize)
		{
			assert_fail("dest buffer size is smaller than copy size");
			return false;
		}	
	}
	const DWORD writePos = _write_pos;
	const DWORD readPos = _read_pos;
	if(writePos > readPos)
	{
		if(dest != NULL)
		{
			memcpy(dest, _buffer + readPos + 1, copySize);
		}
		if(addReadPos)
		{
			_read_pos += copySize;
		}
		return true;
	}
	else if(writePos < readPos)
	{
		const DWORD lenFromReadPosToBufferEnd = _size - readPos - 1;
		if(copySize <= lenFromReadPosToBufferEnd)
		{
			if(dest != NULL)
			{
				memcpy(dest, _buffer + readPos + 1, copySize);
			}
			if(addReadPos)
			{
				_read_pos += copySize;
				assert(_read_pos < _size);
			}
			return true;
		}
		else
		{
			const DWORD secondPartLen = copySize - lenFromReadPosToBufferEnd;
			if(dest != NULL)
			{
				memcpy(dest, _buffer + readPos + 1, lenFromReadPosToBufferEnd);
				memcpy(((char*)dest) + lenFromReadPosToBufferEnd, _buffer, secondPartLen);
			}
			if(addReadPos)
			{
				_read_pos = secondPartLen - 1;
			}
			return true;
		}
	}
	else
	{
		assert_fail("write pos equal read pos, it's an error");
		return false;
	}
}


0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:329798次
    • 积分:3538
    • 等级:
    • 排名:第9301名
    • 原创:74篇
    • 转载:37篇
    • 译文:0篇
    • 评论:76条
    好站链接
    尤龙同学的代码与诗歌