rudp

最新推荐文章于 2023-04-02 17:37:50 发布
VIP文章 最新推荐文章于 2023-04-02 17:37:50 发布
阅读量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
版权

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
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
一个老外写的RUDP的源代码
06-29
http://blog.csdn.net/u014630768/article/details/34929689 系列文章的源代码
RUDP：可靠用户数据报协议
cnrandy 的专栏
08-03 1885
UDT协议-基于UDP的可靠数据传输协议 RUDP：可靠用户数据报协议如何用udp实现可靠的传输？ 
UDP如何实现可靠性传输
weixin_37990128的博客
10-12 1778
1udp与tcp的区别          TCP（TransmissionControl Protocol 传输控制协议）是一种面向连接的、可靠的、基于字节流的传输层通信协议。          UDP是User Datagram Protocol，一种...
C语言基础-合集2
whaosoft143ai的博客
04-02 48
C语言基础-合集2 whaosoft aiot http://143ai.com
基于UDP的用于视频应用的几个协议
u014571011的博客
11-09 6005
TCP由于其协议为保证可靠性，如三次握手，导致其比较慢，不能支持交互视频，会议等实时服务。UDP虽然是一个不可靠协议，不支持丢包重传，但是UDP可以根据端口号对应用程序进行多路复用，并能利用校验和检查数据完整性，对实时服务很有利的。故在许多实时服务上使并不是用TCP，而是使用如RUDP,RTP,UDT。   RUDP（Reliable User Datagram Protocol） 是一种基
C++后台开发面试常见问题汇总
ljh_shuai的博客
09-25 3211
搬运自牛客网大神总结 extern关键字 extern修饰变量 是个声明，此变量/函数是在别处定义的，要在此处引用 extern修饰函数 暗示这个函数可能在别的源文件里定义，没有其它作用。 extern C的作用？用法？ 告诉编译器在编译函数名时按着C的规则去翻译相应的函数名而不是C++的(C++要支持多态，C没有) static关键字作用 ...
C++高性能服务框架revolver：RUDP(可靠UDP)算法详解
互联网
03-19 810
上一篇BLOG已经介绍了revolver RUDP的传输性能、基本的框架和接口，这篇文章我重点讲述RUDP的实现细节。在RUDP的模块中最为重要的是其收发缓冲控制和CCC发送窗口控制、CCC发送慢启动控制、CCC快恢复控制等几个过程。（关于RUDP源代码实现在revolver开源项目的RUDP目录:点击打开链接） 数据块定义 在RUDP模块中，所有发送的数据被定义成RUDPRecvSeg...
Revolver源码解析之——RUDP发送速率控制器
Martian的博客
07-11 649
1、功能：实现带宽评估、发送窗口决策、RTT与RTC的计算。2、成员函数解析。[1].处理接收到的ACK。void RUDPCCCObject::on_ack(uint64_t ack_seq) { if(ack_seq &lt;= last_ack_id_) { return; } uint32_t space = (uint32_t)(ack_seq - last_ack_i...
C++高性能服务框架revover:rudp总体介绍（可靠UDP传输）
paradox_1_0的博客
03-30 1348
在revolver框架中实现了一个高效可靠的RUDP通信方式，这个通信方式是基于UDP实现一种模拟TCP传输数据的行为。在很多实际应用中,udp/TCP都不是最好的通信方式，例如:点对点文件传输、视频数据高速传输、服务器之间大数据备份同步、高实时rts操作类网游等。TCP和UDP在一定程度上是无法满足此类要求。故revolver实现了一套可靠UDP的传输方式。我们先来看看它的传输效率，以下是WIN...
简单的可靠udp的实现（RUDP）
qq_37200329的博客
08-25 1470
可靠的概念 在实时通信过程中，不同的需求场景对可靠的需求是不一样的，我们在这里总体归纳为三类定义： 尽力可靠：通信的接收方要求发送方的数据尽量完整到达，但业务本身的数据是可以允许缺失的。例如：音视频数据、幂等性状态数据。 无序可靠：通信的接收方要求发送方的数据必须完整到达，但可以不管到达先后顺序。例如：文件传输、白板书写、图形实时绘制数据、日志型追加数据等。 有序可靠：通信接收...
Tonk：可靠的UDP（rUDP）网络库和无限窗口擦除代码-C/C++开发
05-27
C ++中的Tonk可靠UDP（rUDP）网络库Tonk.h为功能强大的多线程网络引擎提供了一个简单的C API。 Tonk网络引擎使用C ++中的Tonk可靠UDP（rUDP）网络库通过自定义协议在Internet上传输消息数据Tonk.h为功能强大的多线程网络引擎提供了简单的C API。 Tonk网络引擎使用UDP / IP套接字上的自定义协议通过Internet传输消息数据。 与TCP一样，Tonk可靠且按顺序提供数据。 TCP的主要改进是，由于拥塞控制和行头阻塞问题，使用Tonk发送的数据到达时的延迟要短得多。 Tonk是实验性的：仅经过单元测试和测试
rudp 高性能，可靠性传输UDP网络库（远胜TCP）
01-19
rudp 高性能，可靠性传输UDP网络库（远胜TCP）
RUDP－基于UDP的点对点协议代码
09-20
基于UDP的点对点协议代码，逻辑比较清楚，但还有很多bug。可用作参考学习。
基于UDP的GBN协议（C语言实现）
12-26
基于UDP的GBN协议（C语言实现），在不可靠链接基础上实现可靠数据传输。
rudp:可靠性 UDP，用 Go 编写
06-26
鲁普 可靠性 UDP，用 Go 编写
UNITY3D RUDP
05-24
UNITY3D RUDP, Reliable UDP Protocol can be used with Unity3D.
RUDP.rar_RUDP_RUDP c#_UDP 可靠_c# RUDP
09-23
Rudp c# 用于可靠udp 传输的c#封装
RUDP C++协议
06-27
借鉴其他版本的RUDP协议，模仿写了C++版的，水平有限，自己还在改善中
Java RUDP(Reliable UDP)
05-17
RUDP:可靠性数据报协议，代码版本1.2.3，亲测可用，解压之后有源代码和api文档，分享给各位需要的朋友，记得好评哦
把tcp协议转化成udp
最新发布
07-13
TCP（Transmission Control Protocol）和UDP（User Datagram Protocol）是两种不同的传输层协议，它们具有不同的特点和用途。TCP是一种面向连接的可靠协议，而UDP是一种无连接的不可靠协议。由于它们的设计目的和特性不同，直接将TCP协议转化为UDP协议是不可行的。 TCP协议提供了可靠的数据传输、流控制、拥塞控制和错误校验等功能，它使用三次握手建立连接，保证数据的有序性和完整性。而UDP协议则更加轻量级，没有连接建立的过程，不提供可靠性保证，并且没有流控制和拥塞控制等功能。 如果你需要将应用程序使用的TCP协议转化为UDP协议，你需要重新设计和实现你的应用程序，以适应UDP的特点。你需要自己处理数据的可靠性、有序性和完整性等问题，可能需要设计自己的协议或使用现有的可靠UDP协议（如RUDP或UDT）来实现。 总结起来，直接将TCP协议转化为UDP协议是不可行的，因为它们的设计目的和特性不同。如果你需要使用UDP协议来替代TCP协议，你需要重新设计和实现你的应用程序，以适应UDP的特点。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值