rudp

最新推荐文章于 2021-05-29 18:12:44 发布
最新推荐文章于 2021-05-29 18:12:44 发布
阅读量1w 收藏 4
点赞数
分类专栏： c makefile unix 数据结构与算法 工具 项目 linux c++ 文章标签： null struct thread iterator socket string
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cxxmaker/article/details/7779483
版权
本文深入探讨了可靠用户数据报协议（RUDP）的概念，分析其与TCP和UDP的区别，并详细介绍了如何在C++中利用struct、thread、socket等技术实现RUDP的基本功能，包括数据包的顺序传递和重传机制。
摘要由CSDN通过智能技术生成

lock.h:

#ifndef __LOCK_H__
#define __LOCK_H__


#include <pthread.h>

class MutexLocker
{
public:
    MutexLocker();
    ~MutexLocker();

    void lock();
    void unlock();

private:
    pthread_mutex_t m_locker;
};

class RWLocker
{
public:
    RWLocker();
    ~RWLocker();

    void rdlock();
    void wrlock();
    void unlock();

private:
    pthread_rwlock_t m_locker;
};


#endif

lock.cpp: 

#include <cstdio>
#include <cstdlib>
#include <error.h>
#include <cstring>
#include "lock.h"

MutexLocker::MutexLocker()
{
    int error_no = 0;
    if (0 != (error_no = pthread_mutex_init(&m_locker, NULL)))
    {
        printf("pthread_mutex_init error: %s\n", strerror(error_no));
        exit(1);
    }
}

MutexLocker::~MutexLocker()
{
    int error_no = 0;
    if (0 != (error_no = pthread_mutex_destroy(&m_locker)))
    {
        printf("pthread_mutex_destroy error: %s\n", strerror(error_no));
        exit(1);
    }
}

void MutexLocker::lock()
{
    int error_no = 0;
    if (0 != (error_no = pthread_mutex_lock(&m_locker)))
    {
        printf("pthread_mutex_lock error: %s\n", strerror(error_no));
        exit(1);
    }
}

void MutexLocker::unlock()
{
    int error_no = 0;
    if (0 != (error_no = pthread_mutex_unlock(&m_locker)))
    {
        printf("pthread_mutex_unlock error: %s\n", strerror(error_no));
        exit(1);
    }
}

RWLocker::RWLocker()
{
    int error_no = 0;
    if (0 != (error_no = pthread_rwlock_init(&m_locker, NULL)))
    {
        printf("pthread_rwlock_init error: %s\n", strerror(error_no));
        exit(1);
    }
}

RWLocker::~RWLocker()
{
    int error_no = 0;
    if (0 != (error_no = pthread_rwlock_destroy(&m_locker)))
    {
        printf("pthread_rwlock_destroy error: %s\n", strerror(error_no));
        exit(1);
    }
}

void RWLocker::rdlock()
{
    int error_no = 0;
    if (0 != (error_no = pthread_rwlock_rdlock(&m_locker)))
    {
        printf("pthread_rwlock_rdlock error: %s\n", strerror(error_no));
        exit(1);
    }
}

void RWLocker::wrlock()
{
    int error_no = 0;
    if (0 != (error_no = pthread_rwlock_wrlock(&m_locker)))
    {
        printf("pthread_rwlock_wrlock error: %s\n", strerror(error_no));
        exit(1);
    }
}

void RWLocker::unlock()
{
    int error_no = 0;
    if (0 != (error_no = pthread_rwlock_unlock(&m_locker)))
    {
        printf("pthread_rwlock_unlock error: %s\n", strerror(error_no));
        exit(1);
    }
}

types.h: 

#ifndef __TYPES_H__
#define __TYPES_H__


typedef unsigned char uint8_t;
typedef unsigned short uint16_t;
typedef unsigned int uint32_t;

typedef uint32_t seq_type;
typedef uint32_t time_type;


#endif

common.h: 

#ifndef __COMMON_H__
#define __COMMON_H__


#include "types.h"

time_type getcurtime();
void big2little(void * object, int size);


#endif

common.cpp: 

#include <cstdio>
#include <sys/time.h>
#include "common.h"

time_type getcurtime()
{
    static struct timeval base;
    static bool first_time = true;

    if (first_time)
    {
        gettimeofday(&base, NULL);
        first_time = false;
    }

    struct timeval curtime;
    gettimeofday(&curtime, NULL);

    time_type delta = 0;
    if (curtime.tv_usec < base.tv_usec)
    {
        delta = (1000000 + curtime.tv_usec - base.tv_usec) / 1000;
        --curtime.tv_sec;
    }
    else
    {
        delta = (curtime.tv_usec - base.tv_usec) / 1000;
    }
    delta += (curtime.tv_sec - base.tv_sec) * 1000;

    return(delta);
}

void big2little(void * object, int size)
{
    static union
    {
        uint16_t us;
        unsigned char uc[sizeof(uint16_t)];
    } un;

    un.us = 0x0001;

    if (0x00 == un.uc[0])
    {
        char * ptr = (char *)object;
        for (int i = 0; i < size / 2; ++i)
        {
            char temp = ptr[i];
            ptr[i] = ptr[size - 1 - i];
            ptr[size - 1 - i] = temp;
        }
    }
}

nodes.hpp: 

#ifndef __NODES_H__
#define __NODES_H__


#include <cassert>
#include <iostream>
using std::min;
using std::max;

#include "types.h"
#include "lock.h"

template <typename NodeType>
class NodePool
{
public:
    NodePool(NodePool<typename NodeType::InnerNode> * p) : first_node(NULL), inner_pool(p)
    {

    }

    ~NodePool()
    {
        locker.lock();
        NodeType * ptr = first_node;
        while (NULL != ptr)
        {
            first_node = first_node->next;
            delete ptr;
            ptr = first_node;
        }
        locker.unlock();
    }

    NodeType * get_node()
    {
        NodeType * ptr = NULL;

        locker.lock();
        if (NULL != first_node)
        {
            ptr = first_node;
            first_node = first_node->next;
            if (NULL != first_node)
            {
                first_node->prev = NULL;
            }
            ptr->prev = NULL;
            ptr->next = NULL;
        }
        else
        {
            ptr = new NodeType(inner_pool);
        }
        locker.unlock();

        return(ptr);
    }

    void put_node(NodeType * node)
    {
        put_node(node, node);
    }

    void put_node(NodeType * head, NodeType * tail)
    {
        assert(NULL != head && NULL != tail);

        locker.lock();
        tail->next = first_node;
        if (NULL != first_node)
        {
            first_node->prev = tail;
        }
        first_node = head;
        first_node->prev = NULL;
        locker.unlock();
    }

private:
    NodeType * first_node;
    NodePool<typename NodeType::InnerNode> * inner_pool;
    MutexLocker locker;
};

template <typename NodeType>
struct NodeLink
{
    typedef NodePool<NodeType> PoolType;

    NodeType * head;
    NodeType * tail;
    PoolType * pool;
    uint16_t size;

    NodeLink(PoolType * p)
     : head(NULL), tail(NULL), pool(p), size(0)
    {
        assert(NULL != pool);
    }

    ~NodeLink()
    {
        clear();
    }

    bool push_after(NodeType * loc, NodeType * node)
    {
        if (NULL == loc)
        {
            assert(false);
            return(false);
        }

        if (NULL == node)
        {
            assert(false);
            return(false);
        }

        node->prev = loc;
        node->next = loc->next;
        if (NULL != loc->next)
        {
            loc->next->prev = node;
        }
        else
        {
            tail = node;
        }
        loc->next = node;

        ++size;

        return(true);
    }

    bool push_front(NodeType * node)
    {
        if (NULL == node)
        {
            assert(false);
            return(false);
        }

        node->prev = NULL;
        node->next = head;
        if (NULL != head)
        {
            head->prev = node;
        }
        else
        {
            tail = node;
        }
        head = node;

        ++size;

        return(true);
    }

    bool push_back(NodeType * node)
    {
        if (NULL == node)
        {
            assert(false);
            return(false);
        }

        node->prev = tail;
        node->next = NULL;
        if (NULL == tail)
        {
            head = node;
        }
        else
        {
            tail->next = node;
        }
        tail = node;

        ++size;

        return(true);
    }

    bool push_back(NodeLink<NodeType> & node_list)
    {
        if (NULL == node_list.head)
        {
            assert(false);
            return(false);
        }

        node_list.head->prev = tail;
        if (NULL == tail)
        {
            head = node_list.head;
        }
        else
        {
            tail->next = node_list.head;
        }
        tail = node_list.tail;

        size += node_list.size;

        node_list.head = node_list.tail = NULL;
        node_list.size = 0;

        return(true);
    }

    bool erase(NodeType * node)
    {
        assert(NULL != pool);

        if (NULL == node)
        {
            assert(false);
            return(false);
        }

        if (NULL != node->prev)
        {
            node->prev->next = node->next;
        }
        else
        {
            head = node->next;
        }
        if (NULL != node->next)
        {
            node->next->prev = node->prev;
        }
        else
        {
            tail = node->prev;
        }

        node->clear();
        pool->put_node(node);

        --size;

        return(true);
    }

    void clear()
    {
        assert(NULL != pool);

        NodeType * node = head;
        while (NULL != node)
        {
            node->clear();
            node = node->next;
        }

        if (NULL != head)
        {
            pool->put_node(head, tail);
        }
        head = tail = NULL;
        size = 0;
    }
};

typedef struct TimeInfo
{
    uint8_t index;
    time_type time;
    struct TimeInfo * prev;
    struct TimeInfo * next;

    typedef void InnerNode;

    TimeInfo(NodePool<void> * p) : index(0), time(0), prev(NULL), next(NULL)
    {

    }

    ~TimeInfo()
    {
        clear();
    }

    void clear()
    {

    }
} TimeNode;

typedef struct SeqInfo
{
    seq_type front_sequence;
    seq_type behind_sequence;
    NodeLink<TimeNode> time_list;
    struct SeqInfo * prev;
    struct SeqInfo * next;

    typedef TimeNode InnerNode;

    SeqInfo(NodePool<TimeNode> * p)
     : front_sequence(0), behind_sequence(0),
       time_list(p), prev(NULL), next(NULL)
    {

    }

    ~SeqInfo()
    {
        clear();
    }

    int compare(const struct SeqInfo * other) const
    {
        assert(NULL != other);

        if (front_sequence < other->front_sequence)
        {
            assert(behind_sequence <= other->front_sequence);
            return(-1);
        }
        else if (front_sequence > other->front_sequence)
        {
            assert(front_sequence >= other->behind_sequence);
            return(1);
        }
        else /* if (front_sequence == other->front_sequence) */
        {
            assert(behind_sequence == other->behind_sequence);
            return(0);
        }
    }

    TimeNode * find_time_node(uint8_t index)
    {
        assert(0 != index);

        TimeNode * node = time_list.head;
        while (NULL != node)
        {
            if (index < node->index)
            {
                assert(false);
                return(NULL);
            }
            else if (index > node->index)
            {
                node = node->next;
            }
            else
            {
                return(node);
            }
        }
        return(NULL);
    }

    void clear()
    {
        time_list.clear();
    }
} SeqNode;

typedef struct SendDataInfo
{
    enum { send_node_block_size = 16384 };
    seq_type first_sequence;
    uint16_t using_size;
    uint16_t blank_size;
    NodeLink<SeqNode> seq_list;
    struct SendDataInfo * prev;
    struct SendDataInfo * next;
    unsigned char data[send_node_block_size];

    typedef SeqNode InnerNode;

    SendDataInfo(NodePool<SeqNode> * p)
     : first_sequence(0), using_size(0),
       blank_size(send_node_block_size),
       seq_list(p), prev(NULL), next(NULL)
    {


    }

    ~SendDataInfo()
    {
        clear();
    }

    int get_relation(seq_type front_sequence, uint16_t offset)
    {
        assert(0 != offset);
        assert(front_sequence + offset > front_sequence);

        if (first_sequence > front_sequence)
        {
            return(1);
        }
        else if (first_sequence + using_size <= front_sequence)
        {
            return(-1);
        }
        else
        {
            assert(front_sequence + offset <= first_sequence + using_size);
            return(0);
        }
    }

    SeqNode * find_seq_node(const SeqNode * node)
    {
        assert(NULL != node);

        SeqNode * ret = seq_list.head;
        while (NULL != ret)
        {
            int comp = node->compare(ret);
            if (comp < 0)
            {
                return(NULL);
            }
            else if (comp > 0)
            {
                ret = ret->next;
            }
            else
            {
                return(ret);
            }
        }
        return(NULL);
    }

    void clear()
    {
        seq_list.clear();
    }
} SendDataNode;

typedef struct RttInfo
{
    enum { g = 8, h = 4 };
    enum { min_rto = 200, max_rto = 1000 };
    time_type srtt;
    time_type rttvar;
    time_type rto;

    RttInfo() : srtt(0), rttvar(250), rto(srtt + 4 * rttvar)
    {

    }

    void update(time_type rtt)
    {
        int delta = rtt - srtt;
        srtt += delta / g;

        if (delta < 0)
        {
            delta = -delta;
        }

        rttvar += (delta - rttvar) / h;

        rto = srtt + 4 * rttvar;

        if (rto < min_rto)
        {
            rto = min_rto;
        }
        else if (rto > max_rto)
        {
            rto = max_rto;
        }
    }
} RttType;

typedef struct AckInfo
{
    seq_type front_sequence;
    uint16_t region_size;
    uint8_t count;

    AckInfo() : front_sequence(0), region_size(0), count(4)
    {

    }

    AckInfo & operator = (const struct AckInfo & other)
    {
        if (this != &other)
        {
            front_sequence = other.front_sequence;
            region_size = other.region_size;
            count = other.count;
        }
        return(*this);
    }
} AckRegion;

typedef struct RegionInfo
{
    seq_type front_sequence;
    seq_type behind_sequence;
    struct RegionInfo * prev;
    struct RegionInfo * next;

    typedef void InnerNode;

    RegionInfo(NodePool<void> * p)
     : front_sequence(0), behind_sequence(0), prev(NULL), next(NULL)
    {

    }

    ~RegionInfo()
    {
        clear();
    }

    void clear()
    {

    }
} RegionNode;

typedef struct RecvDataInfo
{
    enum { recv_node_block_size = 16384 };
    seq_type min_sequence;
    seq_type max_sequence;
    struct RecvDataInfo * prev;
    struct RecvDataInfo * next;
    unsigned char data[recv_node_block_size];

    typedef void InnerNode;

    RecvDataInfo(NodePool<void> * p)
     : min_sequence(0), max_sequence(0), prev(NULL), next(NULL)
    {

    }

    ~RecvDataInfo()
    {
        clear();
    }

    void clear()
    {

    }
} RecvDataNode;


#endif

rudp.h: 

#ifndef __RUDP_H__
#define __RUDP_H__


#include "nodes.hpp"
#include "lock.h"

class RudpMgr;

class Rudp
{
public:  /* both end */
    Rudp(RudpMgr * mgr, int sockfd, uint32_t unique_id);
    ~Rudp();

public:  /* send end, for user */
    bool send_data(unsigned char * data, uint16_t len, bool reliable);
    bool send_heart_beat_package();

public:  /* both end, for RudpMgr */
    bool recv_data(unsigned char * data, uint16_t len);
    bool is_alive();
    uint32_t get_unique_id();
    void kill();

private: /* both end */
    enum { unreliable_udp, reliable_udp, ack_message, heart_beat };
    RudpMgr * m_rudp_mgr;
    int m_sockfd;
    uint32_t m_unique_id;
    bool m_is_alive;
    time_type m_last_recv_heart_beat_time;

public:  /* send end, for RudpMgr */
    bool has_data_to_send();
    bool send_data();

private: /* send end */
    bool store_send_data(unsigned char * data, uint16_t len);
    bool recv_ack(unsigned char * data, uint16_t len);

    void send_new_data(uint8_t & send_count);
    void send_old_data(uint
最低0.47元/天 解锁文章
ken_scott
关注
专栏目录
RUDP－基于UDP的点对点协议代码
09-20
基于UDP的点对点协议代码，逻辑比较清楚，但还有很多bug。可用作参考学习。
C++高性能服务框架revolver：RUDP(可靠UDP)算法详解
互联网
03-19 878
上一篇BLOG已经介绍了revolver RUDP的传输性能、基本的框架和接口，这篇文章我重点讲述RUDP的实现细节。在RUDP的模块中最为重要的是其收发缓冲控制和CCC发送窗口控制、CCC发送慢启动控制、CCC快恢复控制等几个过程。（关于RUDP源代码实现在revolver开源项目的RUDP目录:点击打开链接） 数据块定义 在RUDP模块中，所有发送的数据被定义成RUDPRecvSeg...
RUDP
weixin_33856370的博客
03-14 434
RUDP：Reliable UDP（可靠用户数据报协议） 　　可靠用户数据报协议（RUDP）是一种基于可靠数据协议（RDP： RFC908 和 1151 （第二版））的简单分组传输协议。作为一个可靠传输协议，RUDP 用于传输 IP 网络间的电话信号。它允许独立配置每个连接属性，这样在不同的平台可以同时实施不同传输需求下的协议。UDP/IP 协议中的 RUDP 是分层的并为...
RUDP学习
小石头
08-24 595
用UDP实现可靠文件传输 : http://blog.csdn.net/max2008/archive/2007/08/21/1752890.aspx RUDP：可靠用户数据报协议: http://blog.csdn.net/max2008/archive/2007/08/21/1752620.aspx
C++高性能服务框架revover:rudp总体介绍（可靠UDP传输）
paradox_1_0的博客
03-30 1600
在revolver框架中实现了一个高效可靠的RUDP通信方式，这个通信方式是基于UDP实现一种模拟TCP传输数据的行为。在很多实际应用中,udp/TCP都不是最好的通信方式，例如:点对点文件传输、视频数据高速传输、服务器之间大数据备份同步、高实时rts操作类网游等。TCP和UDP在一定程度上是无法满足此类要求。故revolver实现了一套可靠UDP的传输方式。我们先来看看它的传输效率，以下是WIN...
RUDP.rar_RUDP_RUDP c#_UDP 可靠_c# RUDP
09-23
RUDP，全称为Reliable User Datagram Protocol，是用户数据报协议（UDP）的一种增强版本，旨在提供类似于TCP的可靠性，但仍然保持UDP的低延迟和无连接特性。在某些网络应用中，例如实时音视频传输、在线游戏等，对...
Tonk：可靠的UDP（rUDP）网络库和无限窗口擦除代码-C/C++开发
05-27
C ++中的Tonk可靠UDP（rUDP）网络库Tonk.h为功能强大的多线程网络引擎提供了一个简单的C API。 Tonk网络引擎使用C ++中的Tonk可靠UDP（rUDP）网络库通过自定义协议在Internet上传输消息数据Tonk.h为功能强大的多线程...
rudp:可靠性 UDP，用 Go 编写
06-26
然而，在某些场景下，我们可能需要在保持UDP的效率的同时，增加其可靠性的特性，这就是所谓的“可靠性UDP”或RUDP。本文将深入探讨如何使用Go语言实现这一概念。 首先，让我们理解RUDP的核心概念。RUDP是在UDP基础...
RUDP.zip_RUDP_RUDP-6539_ru_rudp code_rudp 代码
09-22
RUDP，即Reliable User Datagram Protocol（可靠的用户数据报协议），是一种在用户数据报协议（UDP）基础上构建的实现可靠传输的协议。UDP是互联网协议栈中的一个无连接、不可靠的传输层协议，它不提供顺序传递、重...
RUDP在分布式网络管理架构中的探究与应用.pdf
08-09
接着，我们将针对RUDP协议在分布式网络管理架构中的探究与应用进行详细的分析。 TCP（传输控制协议）是一种面向连接的、可靠的、基于流的协议。其核心特点包括保证数据包按照发送顺序被接收，以及在发生丢包时进行...
rudp 高性能，可靠性传输UDP网络库（远胜TCP）
01-19
rudp 高性能，可靠性传输UDP网络库（远胜TCP）
Java RUDP(Reliable UDP)
05-17
RUDP:可靠性数据报协议，代码版本1.2.3，亲测可用，解压之后有源代码和api文档，分享给各位需要的朋友，记得好评哦
一个老外写的RUDP的源代码
06-29
http://blog.csdn.net/u014630768/article/details/34929689 系列文章的源代码
RUDP源代码
09-10
RUDP源代码 很不错
RUDP C++协议
06-27
借鉴其他版本的RUDP协议，模仿写了C++版的，水平有限，自己还在改善中
简单的可靠udp的实现（RUDP）
qq_37200329的博客
08-25 1594
可靠的概念 在实时通信过程中，不同的需求场景对可靠的需求是不一样的，我们在这里总体归纳为三类定义： 尽力可靠：通信的接收方要求发送方的数据尽量完整到达，但业务本身的数据是可以允许缺失的。例如：音视频数据、幂等性状态数据。 无序可靠：通信的接收方要求发送方的数据必须完整到达，但可以不管到达先后顺序。例如：文件传输、白板书写、图形实时绘制数据、日志型追加数据等。 有序可靠：通信接收...
UDP VS TCP
缥缈的云 专栏
06-16 3004
原文:http://gafferongames.com/networking-for-game-programmers/udp-vs-tcp/ 介绍 大家好，我是Glenn Fiedler，欢迎阅读我的网上电子书《游戏程序的网络设计》第一章。 在这一章中，我们将从网络编程的最基本方面开始，通过网络收发数据。这是一切的开始—网络程序员工作中最简单和最基本的操作，但最佳的网络通讯策略还是很复
RUDP详解
weixin_45750967的博客
05-29 357
最近和很多实时音视频领域的朋友交流中都有谈论到RUDP(Reliable UDP)，这其实是个老生常谈的问题，RUDP在很多著名的项目上都有使用，例如google的QUIC和webRTC。在UDP之上做一层可靠，很多朋友认为这是很不靠谱的事情，也有朋友认为这是一个大杀器，可以解决实时领域里大部分问题。作为在教育公司来说，学霸君在很多实时场景下确实使用RUDP技术来解决我们的问题，不同场景我们采用的RUDP方式也不一样。先来看看学霸君哪些场景使用了RUDP: 1） 全局250毫秒延迟的实时1V1答疑，采用的是
RUDP：可靠用户数据报协议
坚持到底
08-21 4315
RUDP：可靠用户数据报协议   （RUDP：Reliable UDP） 　　可靠用户数据
RUDP代码库：C#实现的可靠UDP传输解决方案
资源摘要信息: "RUDP.zip是一个包含RUDP协议实现的压缩包文件，主要用C#语言编写，目的是为了解决标准UDP协议中数据传输可靠性不高的问题。RUDP（Reliable UDP）是一种在UDP基础上增加可靠传输特性的协议，它通过...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值