接收和发送缓冲区的设计

最新推荐文章于 2022-11-07 18:14:01 发布
最新推荐文章于 2022-11-07 18:14:01 发布
阅读量772 收藏 2
点赞数 1
分类专栏： 网络通信基础重难点解析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34462436/article/details/108068061
版权

文章目录

环形队列

前言

循环队列：队列有着先入先出的特性。但是对于队列如果删除队头以后剩下的空间将不会被释放，又由于队列只能由队尾插入这就导致被删除部分的空间被浪费。

解决这个问题就是循环队列。循环队列顾名思义就是将队列串起来形成一个类似与环的结构。

概念示意图

内存中不存在环形数据结构，均由基础结构实现逻辑上的闭环效果

img

环形队列与普通队列的区别

  1. front头部指针：

  • 一般队列：front头部指针初始值为-1，从队列取数据时，该值依次递增，指向的元素即待取出的数据，而队列的头部数据所在的指针位置为front+1。当front=maxSize-1时，队列最后一个数据取出，此时队列为空。

  • 环形队列：front头部指针初始值为0，指向的元素既是队列的头部数据也是待取出的数据。从队列取数据时，因逻辑上的闭环，指针可能再次回到前面的位置，不能单一递增处理，需通过取模来重新计算指针的值。

  1. rear尾部指针

  • 一般队列：rear尾部指针初始值为-1，队列添加数据时，该值依次递增，当rear=maxSize-1时，队列满，无法再添加数据。

  • 环形队列：rear尾部指针初始值为0，指向待添加数据的位置，队列添加数据时，因逻辑上的闭环，指针可能再次回到前面的位置，不能单一递增处理，会出现角标越界异常，需通过取模来重新计算指针的值。

  1. 队列空的判断逻辑

  • 一般队列：rear == front时，队列空。

  • 环形队列：rear == front时，队列空。

  1. 队列满的判断逻辑

  • 一般队列：rear = maxSize - 1时，队列满。

  • 环形队列：(rear + 1) % maxSize == front时，队列满。

设计图

在这里插入图片描述

源码

头文件

#pragma once

#include <algorithm>
#include <vector>
#include <string>
#include <string.h>

#include "../base/Platform.h"
#include "Sockets.h"
#include "Endian.h"
//#include <unistd.h>  // ssize_t


namespace net
{

	/// A buffer class modeled after org.jboss.netty.buffer.ChannelBuffer
	///
	/// @code
	/// +-------------------+------------------+------------------+
	/// | prependable bytes |  readable bytes  |  writable bytes  |
	/// |                   |     (CONTENT)    |                  |
	/// +-------------------+------------------+------------------+
	/// |                   |                  |                  |
	/// 0      <=      readerIndex   <=   writerIndex    <=     size
	/// @endcode
	class Buffer
	{
	public:
		static const size_t kCheapPrepend = 8;
		static const size_t kInitialSize = 1024;

		explicit Buffer(size_t initialSize = kInitialSize)
			: buffer_(kCheapPrepend + initialSize),
			readerIndex_(kCheapPrepend),
			writerIndex_(kCheapPrepend)
		{
			//assert(readableBytes() == 0);
			//assert(writableBytes() == initialSize);
			//assert(prependableBytes() == kCheapPrepend);
		}

		// implicit copy-ctor, move-ctor, dtor and assignment are fine
		// NOTE: implicit move-ctor is added in g++ 4.6

		void swap(Buffer& rhs)
		{
			buffer_.swap(rhs.buffer_);
			std::swap(readerIndex_, rhs.readerIndex_);
			std::swap(writerIndex_, rhs.writerIndex_);
		}

		size_t readableBytes() const
		{
			return writerIndex_ - readerIndex_;
		}

		size_t writableBytes() const
		{
			return buffer_.size() - writerIndex_;
		}

		size_t prependableBytes() const
		{
			return readerIndex_;
		}

		const char* peek() const
		{
			return begin() + readerIndex_;
		}

        const char* findString(const char* targetStr) const
        {
            const char* found = std::search(peek(), beginWrite(), targetStr, targetStr + strlen(targetStr));
            return found == beginWrite() ? nullptr : found;
        }

		const char* findCRLF() const
		{
			// FIXME: replace with memmem()?
			const char* crlf = std::search(peek(), beginWrite(), kCRLF, kCRLF + 2);
			return crlf == beginWrite() ? nullptr : crlf;
		}

		const char* findCRLF(const char* start) const
		{
            if (peek() > start)
                return nullptr;

            if (start > beginWrite())
                return nullptr;

			// FIXME: replace with memmem()?
			const char* crlf = std::search(start, beginWrite(), kCRLF, kCRLF + 2);
			return crlf == beginWrite() ? nullptr : crlf;
		}

		const char* findEOL() const
		{
			const void* eol = memchr(peek(), '\n', readableBytes());
			return static_cast<const char*>(eol);
		}

		const char* findEOL(const char* start) const
		{
            if (peek() > start)
                return nullptr;

            if (start > beginWrite())
                return nullptr;

			const void* eol = memchr(start, '\n', beginWrite() - start);
			return static_cast<const char*>(eol);
		}

		// retrieve returns void, to prevent
		// string str(retrieve(readableBytes()), readableBytes());
		// the evaluation of two functions are unspecified
		bool retrieve(size_t len)
		{
            if (len > readableBytes())
                return false;

			if (len < readableBytes())
			{
				readerIndex_ += len;
			}
			else
			{
				retrieveAll();
			}

            return true;
		}

		bool retrieveUntil(const char* end)
		{
            if (peek() > end)
                return false;

            if (end > beginWrite())
                return false;

			retrieve(end - peek());

            return true;
		}

		void retrieveInt64()
		{
			retrieve(sizeof(int64_t));
		}

		void retrieveInt32()
		{
			retrieve(sizeof(int32_t));
		}

		void retrieveInt16()
		{
			retrieve(sizeof(int16_t));
		}

		void retrieveInt8()
		{
			retrieve(sizeof(int8_t));
		}

		void retrieveAll()
		{
			readerIndex_ = kCheapPrepend;
			writerIndex_ = kCheapPrepend;
		}

		std::string retrieveAllAsString()
		{
			return retrieveAsString(readableBytes());;
		}

		std::string retrieveAsString(size_t len)
		{
            if (len > readableBytes())
                return "";

			std::string result(peek(), len);
			retrieve(len);
			return result;
		}

		std::string toStringPiece() const
		{
			return std::string(peek(), static_cast<int>(readableBytes()));
		}

		void append(const std::string& str)
		{
			append(str.c_str(), str.size());
		}

		void append(const char* /*restrict*/ data, size_t len)
		{
			//其实相当于把已有数据往前挪动
            ensureWritableBytes(len);
			std::copy(data, data + len, beginWrite());
			hasWritten(len);
		}

		void append(const void* /*restrict*/ data, size_t len)
		{
			append(static_cast<const char*>(data), len);
		}

		bool ensureWritableBytes(size_t len)
		{
			//剩下的可写空间如果小于需要的空间len，则增加len长度个空间
            if (writableBytes() < len)
			{
				makeSpace(len);
			}

            return true;

            //if (writableBytes() >= len)
            //    return false;
		}

		char* beginWrite()
		{
			return begin() + writerIndex_;
		}

		const char* beginWrite() const
		{
			return begin() + writerIndex_;
		}

		bool hasWritten(size_t len)
		{
            if (len > writableBytes())
                return false;

			writerIndex_ += len;
            return true;
		}

		bool unwrite(size_t len)
		{
            if (len > readableBytes())
                return false;

			writerIndex_ -= len;
            return true;
		}

		///
		/// Append int64_t using network endian
		///
		void appendInt64(int64_t x)
		{
			int64_t be64 = sockets::hostToNetwork64(x);
			append(&be64, sizeof be64);
		}

		///
		/// Append int32_t using network endian
		///
		void appendInt32(int32_t x)
		{
			int32_t be32 = sockets::hostToNetwork32(x);
			append(&be32, sizeof be32);
		}

		void appendInt16(int16_t x)
		{
			int16_t be16 = sockets::hostToNetwork16(x);
			append(&be16, sizeof be16);
		}

		void appendInt8(int8_t x)
		{
			append(&x, sizeof x);
		}

		///
		/// Read int64_t from network endian
		///
		/// Require: buf->readableBytes() >= sizeof(int32_t)
		int64_t readInt64()
		{
			int64_t result = peekInt64();
			retrieveInt64();
			return result;
		}

		///
		/// Read int32_t from network endian
		///
		/// Require: buf->readableBytes() >= sizeof(int32_t)
		int32_t readInt32()
		{
			int32_t result = peekInt32();
			retrieveInt32();
			return result;
		}

		int16_t readInt16()
		{
			int16_t result = peekInt16();
			retrieveInt16();
			return result;
		}

		int8_t readInt8()
		{
			int8_t result = peekInt8();
			retrieveInt8();
			return result;
		}

		///
		/// Peek int64_t from network endian
		///
		/// Require: buf->readableBytes() >= sizeof(int64_t)
		int64_t peekInt64() const
		{
            if (readableBytes() < sizeof(int64_t))
                return -1;

			int64_t be64 = 0;
			::memcpy(&be64, peek(), sizeof be64);
			return sockets::networkToHost64(be64);
		}

		///
		/// Peek int32_t from network endian
		///
		/// Require: buf->readableBytes() >= sizeof(int32_t)
		int32_t peekInt32() const
		{
            if (readableBytes() < sizeof(int32_t))
                return -1;

			int32_t be32 = 0;
			::memcpy(&be32, peek(), sizeof be32);
			return sockets::networkToHost32(be32);
		}

		int16_t peekInt16() const
		{
            if (readableBytes() < sizeof(int16_t))
                return -1;

			int16_t be16 = 0;
			::memcpy(&be16, peek(), sizeof be16);
			return sockets::networkToHost16(be16);
		}

		int8_t peekInt8() const
		{
            if (readableBytes() < sizeof(int8_t))
                return -1;

			int8_t x = *peek();
			return x;
		}

		///
		/// Prepend int64_t using network endian
		///
		void prependInt64(int64_t x)
		{
			int64_t be64 = sockets::hostToNetwork64(x);
			prepend(&be64, sizeof be64);
		}

		///
		/// Prepend int32_t using network endian
		///
		void prependInt32(int32_t x)
		{
			int32_t be32 = sockets::hostToNetwork32(x);
			prepend(&be32, sizeof be32);
		}

		void prependInt16(int16_t x)
		{
			int16_t be16 = sockets::hostToNetwork16(x);
			prepend(&be16, sizeof be16);
		}

		void prependInt8(int8_t x)
		{
			prepend(&x, sizeof x);
		}

		bool prepend(const void* /*restrict*/ data, size_t len)
		{
            if (len > prependableBytes())
                return false;

			readerIndex_ -= len;
			const char* d = static_cast<const char*>(data);
			std::copy(d, d + len, begin() + readerIndex_);
            return true;
		}

		void shrink(size_t reserve)
		{
			// FIXME: use vector::shrink_to_fit() in C++ 11 if possible.
			Buffer other;
			other.ensureWritableBytes(readableBytes() + reserve);
			other.append(toStringPiece());
			swap(other);
		}

		size_t internalCapacity() const
		{
			return buffer_.capacity();
		}

		/// Read data directly into buffer.
		///
		/// It may implement with readv(2)
		/// @return result of read(2), @c errno is saved
		int32_t readFd(int fd, int* savedErrno);

	private:

		char* begin()
		{
			return &*buffer_.begin();
		}

		const char* begin() const
		{
			return &*buffer_.begin();
		}

		void makeSpace(size_t len)
		{
			//kCheapPrepend为保留的空间
            if (writableBytes() + prependableBytes() < len + kCheapPrepend)
			{
				// FIXME: move readable data
				buffer_.resize(writerIndex_ + len);
			}
			else
			{
				// move readable data to the front, make space inside buffer
				//assert(kCheapPrepend < readerIndex_);
                if (kCheapPrepend >= readerIndex_)
                    return;

				size_t readable = readableBytes();
				std::copy(begin() + readerIndex_,
					begin() + writerIndex_,
					begin() + kCheapPrepend);
				readerIndex_ = kCheapPrepend;
				writerIndex_ = readerIndex_ + readable;
				//assert(readable == readableBytes());
			}
		}

	private:
		std::vector<char>           buffer_;
		size_t                      readerIndex_;
		size_t                      writerIndex_;

		static const char           kCRLF[];
	};

}

源码文件

#include "Buffer.h"

#include "../base/Platform.h"
#include "Sockets.h"
#include "Callbacks.h"

using namespace net;

const char Buffer::kCRLF[] = "\r\n";

const size_t Buffer::kCheapPrepend;
const size_t Buffer::kInitialSize;

int32_t Buffer::readFd(int fd, int* savedErrno)
{
	// saved an ioctl()/FIONREAD call to tell how much to read
	char extrabuf[65536];
    const size_t writable = writableBytes();
#ifndef WIN32
	struct iovec vec[2];
	
	vec[0].iov_base = begin() + writerIndex_;
	vec[0].iov_len = writable;
	vec[1].iov_base = extrabuf;
	vec[1].iov_len = sizeof extrabuf;
	// when there is enough space in this buffer, don't read into extrabuf.
	// when extrabuf is used, we read 128k-1 bytes at most.
	const int iovcnt = (writable < sizeof extrabuf) ? 2 : 1;
	const ssize_t n = sockets::readv(fd, vec, iovcnt);
#else
    const int32_t n = sockets::read(fd, extrabuf, sizeof(extrabuf));
#endif
	if (n <= 0)
	{
#ifdef WIN32
        *savedErrno = ::WSAGetLastError();
#else
		*savedErrno = errno;
#endif
	}
	else if (implicit_cast<size_t>(n) <= writable)
	{
#ifdef WIN32
        //Windows平台需要手动把接收到的数据加入buffer中，Linux平台已经在 struct iovec 中指定了缓冲区写入位置
        append(extrabuf, n);
#else
        writerIndex_ += n;
#endif
	}
	else
	{
#ifdef WIN32
		//Windows平台直接将所有的字节放入缓冲区去
        append(extrabuf, n);
#else
        //Linux平台把剩下的字节补上去
        writerIndex_ = buffer_.size();
        append(extrabuf, n - writable);
#endif
	}
	// if (n == writable + sizeof extrabuf)
	// {
	//   goto line_30;
	// }
	return n;
}
四九城小白~阿勋
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单片机缓冲区串口读写代码
lishoubox的专栏
03-25 8276
<br />单片机缓冲区串口读写代码<br /> <br />单片机通讯应用，可以读写内部缓冲区中的数据，协议如下：<br /> <br />1.       读数据<br />表1  读Len个字节数据指令格式<br />指令格式：<br />地址<br />读命令<br />01<br />读取数据的长度<br />Len<br />接收缓冲区的起始地址<br />（00，01，…）<br />接收Len个数据<br />XX，XX，…<br />举例：<br />01<br />01<br />03<
linux网络编程系列(十三)--缓冲区设计及收发大量数据
cpp加油站的专栏
07-02 1064
1. 自定义缓冲区 我们在使用TCP/IP编程的时候除了socket有收发数据缓冲区之外，通常我们还要自己定一个数据的收发缓冲区。 1.1 为什么要自定义缓冲区 假设应用程序需要发送40kB数据,但是操作系统的TCP发送缓冲区只有25kB剩余空间,那么剩下的15kB数据怎么办?如果等待OS缓冲区可用,会阻塞当前线程,因为不知道对方什么时候收到并读取数据。因此网络库应该把这15kB数据缓存起来,放...
基于stm32串口环形缓冲队列处理机制
zhen
11-07 3084
环形队列
数据结构 - 队列 && 环形队列（循环队列）
张大安的博客
04-27 3200
文章目录队列介绍数组模拟队列数组模拟队列设计思路数组模拟环形队列 队列介绍 队列是一个有序列表，可以用数组或是链表来实现。 遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出。 数组模拟队列 队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如下图, 其中 MaxSize 是该队列的最大容量。 因为队列的输出、输入是分别从前后端来处理，因此需要两个变量 front及 rear分别记录队列前后端的下标，front 会随着数据输出而改变，而 rear则是随着数据输入而改
vector常见错误：缓冲区溢出
asdfghwunai的博客
03-28 2296
刚初始化一个vector对象时，注意其capacity和size的大小 。 容量太小而去操作会造成缓冲区溢出。 #include <iostream> #include <vector> #include <string> using namespace std; int main() { vector<int> ivec; ...
【服务器系统设计】缓冲区的设计总结
ghscarecrow的博客
01-22 1664
为什么需要发送缓冲区和接收缓冲区 网络层在发送数据的过程中，由于TCP窗口太小，会导致数据无法发送出去，而上层可能源源不断地产生新的数据，此时就需要将数据先存储起来，以便等到socket可写时再次发送，这个存储数据的地方就叫做发送缓冲区。 对于接收缓冲区也是一样的道理，在收到数据后，我们可以直接对其进行解包，但是这样做不好，有三个理由 理由一：除去一些通用的协议格式，大多数业务都是采用的自定义协议格式，也就是说对一个数据包里面的数据格式的解读应该是业务层应该做的。不同的业务一般有不同的协议格式，协议格式与具
UART.rar_串口 缓冲区
09-24
在"UART.txt"文件中，很可能是详细阐述了以上提到的概念和函数实现的代码示例或教程，有助于读者深入理解UART串口通信以及如何设计和优化自定义接收缓冲区。通过学习这些内容，开发者能够更好地处理PC机与单片机之间...
sc.rar_串口 缓冲区
09-24
总的来说，"sc.rar_串口 缓冲区"的主题涵盖了串口通信的基础知识，中断处理机制，以及接收缓冲区的使用，这些都是嵌入式系统开发中的重要概念和技术。通过学习和实践这些内容，开发者可以更好地理解和控制单片机与...
RingBuffer_环形缓冲区_
10-02
2. 网络通信：在网络协议栈中，环形缓冲区常用于接收和发送数据包，减少数据拷贝次数，提高吞吐量。 3. 实时数据分析：在实时监控或日志收集系统中，环形缓冲区可以作为临时存储，快速收集和传递数据。 4. 并行计算...
基于C++的环形缓冲区.zip
09-01
- **网络传输**：在网络编程中，环形缓冲区常用于接收和发送数据，能够有效利用带宽，减少因数据包积压导致的丢包问题。 - **多线程通信**：在多线程环境下的线程间通信，环形缓冲区可以作为共享内存，使得数据...
无锁 环形缓冲区
08-15
在实际应用中，无锁环形缓冲区可以用于各种并发场景，比如在多线程之间的数据传递、网络数据包的接收与发送、音频/视频流的处理等。无锁特性使得这种数据结构特别适用于高性能计算和实时系统，因为它减少了锁带来的...
接收和发送缓冲区
Emilio563的博客
10-09 1247
这两天一直对Linux平台的TCP服务器进行压力测试，发现Linux平台在使用epoll的情况下，发送和接收的速度确实比完成端口的Windows服务器快一点，但消耗内存也大一些；由于没有设置过缓冲区大小，所以怀疑两个平台对socket设置的默认接收和发送缓冲区不同造成的，随后查询了网络上的资料，但对此问题都没有详细描述，只好自己进行了测试。 先对Windows平台进行了测试，具体的环境是WinX
TCP的发送缓冲区和接收缓冲区
kesenzhang的博客
03-15 6699
TCP协议是作用是用来进行端对端数据传送的，那么就会有发送端和接收端，在操作系统有两个空间即user space和kernal space。 每个Tcp socket连接在内核中都有一个发送缓冲区和接收缓冲区，TCP的全双工的工作模式以及TCP的流量(拥塞)控制便是依赖于这两个独立的buffer以及buffer的填充状态。 单工：只允许甲方向乙方传送信息，而乙方不能向甲方传送 ，如汽车单行道。 半...
socket的发送与接收缓冲区（转）
blackstar8888的专栏
11-20 1992
应用程序可通过调用send(write, sendmsg等)利用tcp socket向网络发送应用数据，而tcp/ip协议栈再通过网络设备接口把已经组织成struct sk_buff的应用数据(tcp数据报)真正发送到网络上，由于应用程序调用send的速度跟网络介质发送数据的速度存在差异，所以，一部分应用数据被组织成tcp数据报之后，会缓存在tcp socket的发送缓存队列中，等待网络空闲时
UDP发送缓冲区和接收缓冲区
最新发布
05-12
UDP是一种面向无连接的协议，它不保证数据包的可靠传输，也没有流量控制和拥塞控制机制，因此它的发送缓冲区和接收缓冲区的设计比TCP简单。 UDP发送缓冲区是用来存储待发送的数据包，当应用程序通过socket发送数据...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值