记录历史 QOS（BOOST/ASIO on TCP/UDP）限制每秒 RECEIVE ASYNC 的吞吐实现。

于 2023-06-28 03:00:49 发布
阅读量485 收藏
点赞数
文章标签： tcp/ip udp 网络协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liulilittle/article/details/131428377
版权

 本源文件实现仅供参考应用层实现QoS的一个实现，该实现是可用且正确的，但根据新的改进，不会再采纳这种不是很通用的实现，纵使它支持TCP、UDP。

头文件：

QoS.h

#pragma once

#include <ppp/stdafx.h>
#include <ppp/net/IPEndPoint.h>
#include <ppp/threading/Timer.h>

namespace ppp {
    namespace net {
        namespace asio {
            class QoS final : public std::enable_shared_from_this<QoS> {
            public:
                typedef std::recursive_mutex                                                                SynchronizedObject;
                typedef std::lock_guard<SynchronizedObject>                                                 SynchronizedObjectScope;
                typedef std::function<void(int sz)>                                                         ReceiveCallback;
                typedef std::function<void(int sz, boost::asio::ip::udp::endpoint&)>                        ReceiveFromCallback;
                struct ReceiveTransaction {
                public:
                    std::shared_ptr<boost::asio::ip::tcp::socket>                                           socket;
                    unsigned char*                                                                          buffer;
                    int                                                                                     offset;
                    int                                                                                     length;
                    bool                                                                                    demand;
                    std::shared_ptr<ReceiveCallback>                                                        callback;

                public:
                    typedef std::shared_ptr<ReceiveTransaction>                                             Ptr;
                };
                struct ReceiveFromTransaction {
                public:
                    std::shared_ptr<boost::asio::ip::udp::socket>                                           socket;
                    unsigned char*                                                                          buffer;
                    int                                                                                     offset;
                    int                                                                                     length;
                    std::shared_ptr<ReceiveFromCallback>                                                    callback;
                    boost::asio::ip::udp::endpoint*                                                         sourceEP;

                public:
                    typedef std::shared_ptr<ReceiveFromTransaction>                                         Ptr;
                };
                typedef std::unordered_map<boost::asio::ip::tcp::socket*, ReceiveTransaction::Ptr >         ReceiveTransactionTable;
                typedef std::unordered_map<boost::asio::ip::udp::socket*, ReceiveFromTransaction::Ptr>      ReceiveFromTransactionTable;

            public:
                QoS(int bandwidth) noexcept;
                ~QoS() noexcept;

            public:
                inline int                                                                                  GetBandwidth() noexcept { return this->_bandwidth; }
                inline void                                                                                 SetBandwidth(int bandwidth) noexcept {
                    this->_bandwidth = bandwidth < 1 ? 0 : bandwidth; // ReLU
                }
                inline bool                                                                                 IsDisposed() noexcept { return this->_disposed; }
                inline std::shared_ptr<QoS>                                                                 GetReference() noexcept { return this->shared_from_this(); }

            public:
                bool                                                                                        Initialize() noexcept;
                void                                                                                        Dispose() noexcept;
                bool                                                                                        Receive(
                    const std::shared_ptr<boost::asio::ip::tcp::socket>&                                    socket,
                    const void*                                                                             buffer,
                    int                                                                                     offset,
                    int                                                                                     length,
                    bool                                                                                    demand,
                    const std::shared_ptr<ReceiveCallback>&                                                 callback) noexcept;
                bool                                                                                        ReceiveFrom(
                    const std::shared_ptr<boost::asio::ip::udp::socket>&                                    socket,
                    const void*                                                                             buffer,
                    int                                                                                     offset,
                    int                                                                                     length,
                    boost::asio::ip::udp::endpoint&                                                         sourceEP,
                    const std::shared_ptr<ReceiveFromCallback>&                                             callback) noexcept;

            private:
                void                                                                                        Update() noexcept;
                bool                                                                                        IsPeek() noexcept;
                bool                                                                                        ReceiveImpl(
                    const std::shared_ptr<boost::asio::ip::tcp::socket>&                                    socket,
                    const void*                                                                             buffer,
                    int                                                                                     offset,
                    int                                                                                     length,
                    const std::shared_ptr<ReceiveTransaction>&                                              receive) noexcept;
                bool                                                                                        ReceiveFromImpl(
                    const std::shared_ptr<boost::asio::ip::udp::socket>&                                    socket,
                    const void*                                                                             buffer,
                    int                                                                                     offset,
                    int                                                                                     length,
                    boost::asio::ip::udp::endpoint&                                                         sourceEP,
                    const std::shared_ptr<ReceiveFromTransaction>&                                          receive) noexcept;

            private:
                SynchronizedObject                                                                          _syncobj;
                int                                                                                         _bandwidth;
                UInt64                                                                                      _per_seconds;
                std::atomic<bool>                                                                           _disposed;
                std::atomic<int>                                                                            _current_traffic;
                ReceiveTransactionTable                                                                     _recv_tcps;
                ReceiveFromTransactionTable                                                                 _recv_iips;
                std::shared_ptr<ppp::threading::Timer>                                                      _work_timer;
            };
        }
    }
}

源文件：

QoS.cpp

#include <ppp/stdafx.h>
#include <ppp/net/Socket.h>
#include <ppp/net/asio/QoS.h>
#include <ppp/threading/Timer.h>
#include <ppp/threading/Executors.h>

using ppp::threading::Timer;
using ppp::threading::Executors;

namespace ppp {
    namespace net {
        namespace asio {
            QoS::QoS(int bandwidth) noexcept
                : _bandwidth(0)
                , _per_seconds(0)
                , _disposed(false)
                , _current_traffic(0) {
                if (bandwidth < 1) {
                    bandwidth = 0;
                }
                this->_bandwidth = bandwidth;
            }

            QoS::~QoS() noexcept {
                this->Dispose();
            }

            void QoS::Dispose() noexcept {
                std::vector<std::shared_ptr<ReceiveFromTransaction> > recv_iips;
                std::vector<std::shared_ptr<ReceiveTransaction> > recv_tcps;
                if (!this->_disposed.exchange(true)) {
                    SynchronizedObjectScope scope(this->_syncobj);
                    ReceiveTransactionTable::iterator recv_tcps_tail = this->_recv_tcps.begin();
                    ReceiveTransactionTable::iterator recv_tcps_endl = this->_recv_tcps.end();
                    for (; recv_tcps_tail != recv_tcps_endl; recv_tcps_tail++) {
                        recv_tcps.push_back(std::move(recv_tcps_tail->second));
                    }

                    ReceiveFromTransactionTable::iterator recv_iips_tail = this->_recv_iips.begin();
                    ReceiveFromTransactionTable::iterator recv_iips_endl = this->_recv_iips.end();
                    for (; recv_iips_tail != recv_iips_endl; recv_iips_tail++) {
                        recv_iips.push_back(std::move(recv_iips_tail->second));
                    }

                    this->_recv_tcps.clear();
                    this->_recv_iips.clear();
                }

                for (size_t i = 0, count = recv_tcps.size(); i < count; i++) {
                    const std::shared_ptr<ReceiveTransaction>& r = recv_tcps[i];
                    if (NULL != r) {
                        (*r->callback)(-1);
                    }
                }

                for (size_t i = 0, count = recv_iips.size(); i < count; i++) {
                    const std::shared_ptr<ReceiveFromTransaction>& r = recv_iips[i];
                    if (NULL != r) {
                        (*r->callback)(-1, *r->sourceEP);
                    }
                }
            }

            bool QoS::Initialize() noexcept {
                SynchronizedObjectScope scope(this->_syncobj);
                if (this->IsDisposed()) {
                    return false;
                }

                std::shared_ptr<Timer> t = this->_work_timer;
                if (NULL != t) {
                    return false;
                }

                int bandwidth = this->_bandwidth;
                if (bandwidth < 1) {
                    return true;
                }
                else {
                    this->_per_seconds = Executors::GetTickCount();
                }

                std::shared_ptr<QoS> self = this->GetReference();
                t = make_shared_object<ppp::threading::Timer>(Executors::GetDefault());
                t->TickEvent = make_shared_object<Timer::TickEventHandler>(
                    [self, this](Timer* sender, Timer::TickEventArgs& e) noexcept {
                        this->Update();
                    });
                t->SetInterval(10);
                t->Start();
                this->_work_timer = std::move(t);

                return true;
            }

            bool QoS::IsPeek() noexcept {
                int bandwidth = this->_bandwidth;
                if (bandwidth < 1) {
                    return false;
                }

                int traffic = this->_current_traffic;
                return traffic >= bandwidth;
            }

            void QoS::Update() noexcept {
                std::vector<std::shared_ptr<ReceiveFromTransaction> > recv_iips;
                std::vector<std::shared_ptr<ReceiveTransaction> > recv_tcps;
                do {
                    SynchronizedObjectScope scope(this->_syncobj);
                    do {
                        UInt64 now = Executors::GetTickCount();
                        if ((this->_per_seconds / 1000) == (now / 1000)) {
                            return;
                        }

                        this->_per_seconds = now;
                    } while (false);

                    this->_current_traffic = 0;
                    for (; ;) {
                        ReceiveTransactionTable::iterator tail = this->_recv_tcps.begin();
                        ReceiveTransactionTable::iterator endl = this->_recv_tcps.end();
                        if (tail == endl) {
                            break;
                        }

                        std::shared_ptr<ReceiveTransaction> r = tail->second;
                        this->_recv_tcps.erase(tail);
                        if (!this->ReceiveImpl(r->socket, r->buffer, r->offset, r->length, r)) {
                            recv_tcps.push_back(std::move(r));
                        }
                    }

                    this->_recv_tcps.clear();
                    for (; ;) {
                        ReceiveFromTransactionTable::iterator tail = this->_recv_iips.begin();
                        ReceiveFromTransactionTable::iterator endl = this->_recv_iips.end();
                        if (tail == endl) {
                            break;
                        }

                        std::shared_ptr<ReceiveFromTransaction> r = tail->second;
                        this->_recv_iips.erase(tail);
                        if (!this->ReceiveFromImpl(r->socket, r->buffer, r->offset, r->length, *r->sourceEP, r)) {
                            recv_iips.push_back(std::move(r));
                        }
                    }
                    this->_recv_iips.clear();
                } while (false);

                for (size_t i = 0, count = recv_tcps.size(); i < count; i++) {
                    const std::shared_ptr<ReceiveTransaction>& r = recv_tcps[i];
                    if (NULL != r) {
                        (*r->callback)(0);
                    }
                }

                for (size_t i = 0, count = recv_iips.size(); i < count; i++) {
                    const std::shared_ptr<ReceiveFromTransaction>& r = recv_iips[i];
                    if (NULL != r) {
                        (*r->callback)(0, *r->sourceEP);
                    }
                }
            }

            bool QoS::ReceiveImpl(
                const std::shared_ptr<boost::asio::ip::tcp::socket>&                                socket,
                const void*                                                                         buffer,
                int                                                                                 offset,
                int                                                                                 length,
                const std::shared_ptr<ReceiveTransaction>&                                          receive) noexcept {

                if (!socket->is_open()) {
                    return false;
                }

                std::shared_ptr<QoS> self = this->GetReference();
                std::shared_ptr<ReceiveTransaction> receive_ = receive;
                if (receive_->demand) {
                    boost::asio::async_read(*socket.get(), boost::asio::buffer((char*)buffer + offset, length),
                        [self, this, receive_](const boost::system::error_code& ec, UInt32 sz) noexcept {
                            int by = std::max<int>(-1, ec ? -1 : sz);
                            if (by > 0) {
                                this->_current_traffic += by;
                            }
                            (*receive_->callback)(by);
                        });
                }
                else {
                    socket->async_read_some(boost::asio::buffer((char*)buffer + offset, length),
                        [self, this, receive_](const boost::system::error_code& ec, UInt32 sz) noexcept {
                            int by = std::max<int>(-1, ec ? -1 : sz);
                            if (by > 0) {
                                this->_current_traffic += by;
                            }
                            (*receive_->callback)(by);
                        });
                }
                return true;
            }

            bool QoS::Receive(
                const std::shared_ptr<boost::asio::ip::tcp::socket>& socket,
                const void* buffer,
                int                                                                                 offset,
                int                                                                                 length,
                bool                                                                                demand,
                const std::shared_ptr<ReceiveCallback>&                                             callback) noexcept {

                if (this->IsDisposed()) {
                    return false;
                }

                if (socket == NULL || callback == NULL || !socket->is_open()) {
                    return false;
                }

                if (this->_bandwidth < 1) {
                    std::shared_ptr<ReceiveTransaction> r = make_shared_object<ReceiveTransaction>();
                    r->socket = socket;
                    r->buffer = (unsigned char*)buffer;
                    r->offset = offset;
                    r->length = length;
                    r->callback = callback;
                    r->demand = demand;
                    return this->ReceiveImpl(socket, buffer, offset, length, r);
                }

                if (buffer == NULL && (offset != 0 || length != 0)) {
                    return false;
                }

                if (offset < 0 || length < 0) {
                    return false;
                }

                std::shared_ptr<ReceiveTransaction> r;
                do {
                    SynchronizedObjectScope scope(this->_syncobj);
                    ReceiveTransactionTable::iterator tail = this->_recv_tcps.find(socket.get());
                    ReceiveTransactionTable::iterator endl = this->_recv_tcps.end();
                    if (tail != endl) {
                        return false;
                    }

                    r = make_shared_object<ReceiveTransaction>();
                    r->socket = socket;
                    r->buffer = (unsigned char*)buffer;
                    r->offset = offset;
                    r->length = length;
                    r->callback = callback;
                    r->demand = demand;
                    if (this->IsPeek()) {
                        this->_recv_tcps[socket.get()] = r;
                        return true;
                    }
                } while (false);
                return this->ReceiveImpl(socket, buffer, offset, length, r);
            }

            bool QoS::ReceiveFromImpl(
                const std::shared_ptr<boost::asio::ip::udp::socket>&                                socket,
                const void*                                                                         buffer,
                int                                                                                 offset,
                int                                                                                 length,
                boost::asio::ip::udp::endpoint&                                                     sourceEP,
                const std::shared_ptr<ReceiveFromTransaction>&                                      receive) noexcept {

                if (!socket->is_open()) {
                    return false;
                }

                std::shared_ptr<QoS> self = this->GetReference();
                std::shared_ptr<ReceiveFromTransaction> receive_ = receive;
                socket->async_receive_from(boost::asio::buffer((char*)buffer + offset, length), sourceEP,
                    [self, this, receive_](const boost::system::error_code& ec, UInt32 sz) noexcept {
                        int by = std::max<int>(-1, ec ? -1 : sz);
                        if (by > 0) {
                            this->_current_traffic += by;
                        }
                        (*receive_->callback)(by, *receive_->sourceEP);
                    });
                return true;
            }

            bool QoS::ReceiveFrom(
                const std::shared_ptr<boost::asio::ip::udp::socket>&                                socket,
                const void*                                                                         buffer,
                int                                                                                 offset,
                int                                                                                 length,
                boost::asio::ip::udp::endpoint&                                                     sourceEP,
                const std::shared_ptr<ReceiveFromCallback>&                                         callback) noexcept {

                if (this->IsDisposed()) {
                    return false;
                }

                if (socket == NULL || callback == NULL || !socket->is_open()) {
                    return false;
                }

                if (this->_bandwidth < 1) {
                    std::shared_ptr<ReceiveFromTransaction> r = make_shared_object<ReceiveFromTransaction>();
                    r->socket = socket;
                    r->buffer = (unsigned char*)buffer;
                    r->offset = offset;
                    r->length = length;
                    r->callback = callback;
                    r->sourceEP = std::addressof(sourceEP);
                    return this->ReceiveFromImpl(socket, buffer, offset, length, sourceEP, r);
                }

                if (buffer == NULL && (offset != 0 || length != 0)) {
                    return false;
                }

                if (offset < 0 || length < 0) {
                    return false;
                }

                std::shared_ptr<ReceiveFromTransaction> r;
                do {
                    SynchronizedObjectScope scope(this->_syncobj);
                    ReceiveFromTransactionTable::iterator tail = this->_recv_iips.find(socket.get());
                    ReceiveFromTransactionTable::iterator endl = this->_recv_iips.end();
                    if (tail != endl) {
                        return false;
                    }

                    r = make_shared_object<ReceiveFromTransaction>();
                    r->socket = socket;
                    r->buffer = (unsigned char*)buffer;
                    r->offset = offset;
                    r->length = length;
                    r->callback = callback;
                    r->sourceEP = std::addressof(sourceEP);
                    if (this->IsPeek()) {
                        this->_recv_iips[socket.get()] = r;
                        return true;
                    }
                } while (false);
                return this->ReceiveFromImpl(socket, buffer, offset, length, sourceEP, r);
            }
        }
    }
}

liulilittle
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
2、boost asio 教程---Tcp和Udp
Knowledgebase的博客
09-06 7274
与TCP相比，UDP没有这样的事情作为UDP连接。传输控制协议-TCP 简而言之，TCP连接几乎就像一个文件-你打开它，你从中读取一些数据，你写入其他一些数据，当你完成时关闭它。实际上并不能保证您将收到发送给您的应用程序的所有数据包。用于接收UDP数据包的缓冲区必须足够大，以包含整个数据包的一部分，否则您将什么也收不到。因此，您需要了解将要接收的数据包的上限大小。正如您所看到的，UDP比TCP更棘手一些。在TCP连接的情况下，您不能这样做。这是您目前需要了解的关于协议的所有内容。
udp单播，广播，多播实现（ReceiveFromAsync，SendToAsync）
weixin_30785593的博客
07-16 916
注意：客户端和服务器实现基本一致，本地host和port和多播的host和port可以一样 （1）多播 1.将本地host加入多播组中，只有加入多播组的成员才能接受同组的节点发送的多播 MulticastOption mcastOption = new MulticastOption(IPAddress.Parse(MultiCastHost), IPAddress.Parse(l...
C# 利用ICMP协议实现Ping功能
elie_yang的博客
04-19 1074
注意：linux环境下运行：var socket = new Socket(AddressFamily.InterNetwork, SocketType.Raw, ProtocolType.Icmp);可能会因为权限不够，报错：临时解决办法可以使用sudio 提升运行权限，或者给当前用户socket权限；.net core中有Ping类可以实现Ping功能；ICMP协议数据包收发。
C/C++ TCP/IP, boost::asio, QoS流速控制实现
liulilittle的博客
09-26 945
应用层实现TCP/IP读入流速控制，与在L2/L3层通过对于某个IP或MAC地址进行丢包来控制速度不同，应用层是通过当读入的字节达到 Peek（峰值）就挂起TCP/IP读入流的动作，等到下一秒在恢复执行TCP/IP读入流的动作。
基于boost asio实现sync tcp server通信
tutu_hu的博客
07-19 1204
基于boost asio实现server端通信，one by one处理方式，实现string和byte两种数据类型通信
基于boost asio TCP/SSL 网络库
08-25
在标题中提到的“基于boost asio TCP/SSL网络库”是一个利用Boost.Asio实现的，具备TCP和SSL功能的网络库。这个库为开发者提供了构建高效、可靠的网络应用程序的基础。 **TCP（Transmission Control Protocol）** ...
基于ASIO封装的网络库，支持TCP/UDP，支持长连接、短连接，支持组播、单播、广播
08-23
在IT行业中，网络编程是构建分布式系统和互联网应用的基础，而`ASIO`（Asynchronous Service Input/Output）是C++中广泛使用的异步网络库，由Boost库提供。本项目基于ASIO进行封装，提供了对TCP和UDP协议的支持，...
基于boost.asio库的C++http/https web server
07-27
Boost.ASIO的`async_read_until`函数可以用来异步地读取直到特定分隔符的数据，比如请求行的结束符。 3. **解析请求**：解析收到的HTTP请求，提取出方法、URL、HTTP版本和头部信息。这通常需要自定义解析器或者使用...
boost asio tcp服务器的实现
04-24
本篇文章将详细探讨如何使用Boost.Asio实现一个TCP服务器，以及涉及的关键技术点。 首先，`boost::asio`是一个强大的C++库，它提供了异步I/O操作，适用于网络通信、定时器和信号处理等场景。它的设计基于C++标准库...
C++ boost::asio编程-同步TCP详解及实例代码
12-31
boost.asio库支持TCP、UDP、ICMP通信协议。 下面介绍同步TCP模式： 大家好！我是同步方式！ 我的主要特点就是执着！所有的操作都要完成或出错才会返回，不过偶的执着被大家称之为阻塞，实在是郁闷~~（场下一片...
c++ boost asio网络库 异步tcp方式文件传输 速度在10M左右.zip
01-18
在TCP（传输控制协议）网络通信中，Boost.ASIO允许开发人员实现高效的文件传输，尤其是在大数据量的情况下。在这个场景中，我们讨论的是使用Boost.ASIO实现的异步TCP文件传输，其传输速度可以达到大约10MB/s。 1. *...
C#网络编程系列文章(五)之Socket实现异步UDP服务器
热门推荐
超纯的小白兔
03-15 1万+
原创性声明 本文作者：小竹zz 本文地址http://blog.csdn.net/zhujunxxxxx/article/details/44258719 转载请注明出处 本文介绍 在.Net中，System.Net.Sockets 命名空间为需要严密控制网络访问的开发人员提供了 Windows Sockets (Winsock) 接口的托管实现。System.Net 命名空间中的所有其他网
boost库之异步函数async_receive_from非阻塞特性
Leo's blog
10-14 3117
说明：async_receive_from函数是异步且 非阻塞 的，它告诉系统如果有相应的操作，直接调用 回调函数 进行接收操作；
Socket.BeginReceive 参数解释
宁静致远
06-15 1万+
Socket.BeginReceive 方法 (Byte[], Int32, Int32, SocketFlags, AsyncCallback, Object) .NET Framework (current version) 其他版本   开始从连接的 Socket 中异步接收数据。 命名空间:   System.N
#include <boost/asio.hpp>
最新发布
07-25
boost/asio.hpp 是一个用于异步 I/O 和网络编程的 C++ 库。它提供了一套跨平台的 API，可用于处理各种网络协议，如 TCP、UDP、HTTP 等。使用 boost/asio.hpp，你可以编写高性能的异步网络应用程序。 你有关于 boost...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值