【KCP】UDP可靠性传输

最新推荐文章于 2024-04-06 22:06:31 发布
最新推荐文章于 2024-04-06 22:06:31 发布
阅读量899 收藏 5
点赞数 1
分类专栏： KCP 文章标签： udp 网络 tcp/ip
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37717687/article/details/128179265
版权

1 如何做到可靠性传输

◼ ACK机制
◼ 重传机制
◼ 序号机制 3 2 1 -》2 3 1
◼ 重排机制 2 3 1 ->3 2 1
◼ 窗口机制
Tcp不用我们管
可靠性udp 5种机制都需要用户层处理

2 UDP与TCP，我们如何选择

image.png

3 UDP如何可靠，KCP协议在哪些方面有优势

以10%-20%带宽浪费的代价换取了比 TCP快30%-40%的传输速度。

RTO翻倍vs不翻倍：
TCP超时计算是RTOx2，这样连续丢三次包就变成RTOx8了，十分恐怖，而 KCP启动快速模式后不x2，只是x1.5（实验证明1.5这个值相对比较好）， 提高了传输速度。 200 300 450 675 – 200 400 800 1600

选择性重传 vs 全部重传：
TCP丢包时会全部重传从丢的那个包开始以后的数据，KCP是选择性重传， 只重传真正丢失的数据包。
快速重传（跳过多少个包马上重传）（如果使用了快速重传，可以不考虑 RTO））： 发送端发送了1,2,3,4,5几个包，然后收到远端的ACK: 1, 3, 4, 5，当收到ACK3时，KCP知道2被跳过1次，收到ACK4时，知道2被跳过了2次，此时可以认为2号丢失，不用等超时，直接重传2号包，大大改善了丢包时的传输速度。 fastresend =2

延迟ACK vs 非延迟ACK：
TCP为了充分利用带宽，延迟发送ACK（NODELAY都没用），这样超时计算会算出较大 RTT时间，延长了丢包时的判断过程。KCP的ACK是否延迟发送可以调节。

UNA vs ACK+UNA：
ARQ模型响应有两种，UNA（此编号前所有包已收到，如TCP）和ACK（该编号包已收到），光用UNA将导致全部重传，光用ACK则丢失成本太高，以往协议都是二选其一，而 KCP协议中，除去单独的 ACK包外，所有包都有UNA信息。

非退让流控：
KCP正常模式同TCP一样使用公平退让法则，即发送窗口大小由：发送缓存大小、接收端剩余接收缓存大小、丢包退让及慢启动这四要素决定。但传送及时性要求很高的小数据时，可选择通过配置跳过后两步，仅用前两项来控制发送频率。
以牺牲部分公平性及带宽利用率之代价，换取了开着BT都能流畅传输的效果。

4 KCP精讲

4.1 kcp名词说明

◼ kcp官方：https://github.com/skywind3000/kcp

◼ 名词说明

  • 用户数据：应用层发送的数据，如一张图片2Kb的数据
  • MTU：最大传输单元。即每次发送的最大数据
  • RTO：Retransmission TimeOut，重传超时时间。
  • cwnd：congestion window，拥塞窗口，表示发送方可发送多少个KCP数据包。与接收方窗口有关，与网络状况（拥塞控制）有关，与发送窗口大小有关。
  • rwnd：receiver window,接收方窗口大小，表示接收方还可接收多少个KCP数据包
  • snd_queue：待发送KCP数据包队列
  • snd_nxt：下一个即将发送的kcp数据包序列号
  • snd_una：下一个待确认的序列号

4.2 kcp使用方式

  1. 创建 KCP对象：ikcpcb *kcp = ikcp_create(conv, user);
  2. 设置传输回调函数（如UDP的send函数）：kcp->output = udp_output;

真正发送数据需要调用sendto

  1. 循环调用 update：ikcp_update(kcp, millisec);
  2. 输入一个应用层数据包（如UDP收到的数据包）：

ikcp_input(kcp,received_udp_packet,received_udp_size);
我们要使用recvfrom接收，然后扔到kcp里面做解析

  1. 发送数据：ikcp_send(kcp1, buffer, 8); 用户层接口
  2. 接收数据：hr = ikcp_recv(kcp2, buffer, 10);

4.3 kcp源码流程图

image.png

4.4 kcp配置模式

  1. 工作模式：int ikcp_nodelay(ikcpcb *kcp, int nodelay, int interval, int resend, int nc)
     nodelay ：是否启用 nodelay模式，0不启用；1启用。
     interval ：协议内部工作的 interval，单位毫秒，比如 10ms或者 20ms
     resend ：快速重传模式，默认0关闭，可以设置2（2次ACK跨越将会直接重传）
     nc ：是否关闭流控，默认是0代表不关闭，1代表关闭。
    普通模式： ikcp_nodelay(kcp, 0, 40, 0, 0);
    极速模式： ikcp_nodelay(kcp, 1, 10, 2, 1)
    2. 最大窗口：int ikcp_wndsize(ikcpcb *kcp, int sndwnd, int rcvwnd);
    该调用将会设置协议的最大发送窗口和最大接收窗口大小，默认为32，单位为包。
    3. 最大传输单元：int ikcp_setmtu(ikcpcb *kcp, int mtu);
    kcp协议并不负责探测 MTU，默认 mtu是1400字节
    4. 最小RTO：不管是 TCP还是 KCP计算 RTO 时都有最小 RTO 的限制，即便计算出来RTO为40ms，由于默认的 RTO是100ms，协议只有在100ms后才能检测到丢包，快速模式下为30ms，可以手动更改该值： kcp->rx_minrto = 10;

4.5 kcp协议头

image.png
 conv:连接号。UDP是无连接的，conv用于表示来自于哪个客户端。对连接的一种替代
 cmd:命令字。如，
IKCP_CMD_ACK确认命令，
IKCP_CMD_WASK接收窗口大小询问命令，
IKCP_CMD_WINS接收窗口大小告知命令，
 frg:分片，用户数据可能会被分成多个KCP包，发送出去
 wnd:接收窗口大小，发送方的发送窗口不能超过接收方给出的数值
 ts:时间序列
 sn:序列号
 una:下一个可接收的序列号。其实就是确认号，收到 sn=10的包，una为11
 len：数据长度
 data:用户数据
image.png

4.6 kcp发送数据过程

image.png

4.7 kcp接收数据过程

image.png

4.8 kcp确认包处理流程

image.png

4.9 kcp快速确认

image.png

4.10 流量控制和拥塞控制

RTO计算（与TCP完全一样）
RTT：一个报文段发送出去，到收到对应确认包的时间差。
SRTT(kcp->rx_srtt)：RTT的一个加权RTT平均值，平滑值。
RTTVAR(kcp->rx_rttval)：RTT的平均偏差，用来衡量
RTT的抖动。

4.11 如何在项目中集成kcp

#include <sys/types.h>
#include <sys/socket.h>
#include <pthread.h>
#include <netinet/in.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <sys/wait.h>
#include <arpa/inet.h>
#include "ikcp.h"
#define RECV_BUF 1500

static int number = 0;

typedef struct
{
	unsigned char *ipstr;
	int port;

	ikcpcb *pkcp;

	int sockfd;

	struct sockaddr_in addr;	  //存放服务器信息的结构体
	struct sockaddr_in CientAddr; //存放客户机信息的结构体

	char buff[RECV_BUF]; //存放收发的消息

} kcpObj;
// 编译:  gcc -o server server.c ikcp.c  
// 特别需要注意，这里的服务器端也只能一次使用，即是等客户端退出后，服务端也要停止掉再启动
// 之所以是这样，主要是因为sn的问题，比如客户端第一次启动 sn 0~5， 第二次启动发送的sn还是0 ~5 如果服务器端不停止则自己以为0~5已经收到过了就不会回复。

// 在真正使用的时候，还需要另外的通道让客户端和服务器端之前重新创建ikcpcb，以匹配ikcpcb的conv
/* get system time */
void itimeofday(long *sec, long *usec)
{
#if defined(__unix)
	struct timeval time;
	gettimeofday(&time, NULL);
	if (sec)
		*sec = time.tv_sec;
	if (usec)
		*usec = time.tv_usec;
#else
	static long mode = 0, addsec = 0;
	BOOL retval;
	static IINT64 freq = 1;
	IINT64 qpc;
	if (mode == 0)
	{
		retval = QueryPerformanceFrequency((LARGE_INTEGER *)&freq);
		freq = (freq == 0) ? 1 : freq;
		retval = QueryPerformanceCounter((LARGE_INTEGER *)&qpc);
		addsec = (long)time(NULL);
		addsec = addsec - (long)((qpc / freq) & 0x7fffffff);
		mode = 1;
	}
	retval = QueryPerformanceCounter((LARGE_INTEGER *)&qpc);
	retval = retval * 2;
	if (sec)
		*sec = (long)(qpc / freq) + addsec;
	if (usec)
		*usec = (long)((qpc % freq) * 1000000 / freq);
#endif
}

/* get clock in millisecond 64 */
IINT64 iclock64(void)
{
	long s, u;
	IINT64 value;
	itimeofday(&s, &u);
	value = ((IINT64)s) * 1000 + (u / 1000);
	return value;
}

IUINT32 iclock()
{
	return (IUINT32)(iclock64() & 0xfffffffful);
}

int64_t first_recv_time = 0;
/* sleep in millisecond */
void isleep(unsigned long millisecond)
{
#ifdef __unix /* usleep( time * 1000 ); */
	struct timespec ts;
	ts.tv_sec = (time_t)(millisecond / 1000);
	ts.tv_nsec = (long)((millisecond % 1000) * 1000000);
	/*nanosleep(&ts, NULL);*/
	usleep((millisecond << 10) - (millisecond << 4) - (millisecond << 3));
#elif defined(_WIN32)
	Sleep(millisecond);
#endif
}

int udp_output(const char *buf, int len, ikcpcb *kcp, void *user)
{

	kcpObj *send = (kcpObj *)user;

	//发送信息
	int n = sendto(send->sockfd, buf, len, 0, (struct sockaddr *)&send->CientAddr, sizeof(struct sockaddr_in));
	if (n >= 0)
	{
		//会重复发送，因此牺牲带宽
		printf("send: %d bytes, t:%lld\n", n, iclock64() - first_recv_time); //24字节的KCP头部
		return n;
	}
	else
	{
		printf("error: %d bytes send, error\n", n);
		return -1;
	}
}

int init(kcpObj *send)
{
	send->sockfd = socket(AF_INET, SOCK_DGRAM, 0);

	if (send->sockfd < 0)
	{
		perror("socket error！");
		exit(1);
	}

	bzero(&send->addr, sizeof(send->addr));

	send->addr.sin_family = AF_INET;
	send->addr.sin_addr.s_addr = htonl(INADDR_ANY); //INADDR_ANY
	send->addr.sin_port = htons(send->port);

	printf("服务器socket: %d  port:%d\n", send->sockfd, send->port);

	if (send->sockfd < 0)
	{
		perror("socket error！");
		exit(1);
	}

	if (bind(send->sockfd, (struct sockaddr *)&(send->addr), sizeof(struct sockaddr_in)) < 0)
	{
		perror("bind");
		exit(1);
	}
}

void loop(kcpObj *send)
{
	unsigned int len = sizeof(struct sockaddr_in);
	int n, ret;
	//接收到第一个包就开始循环处理
	int recv_count = 0;

	isleep(1);
	ikcp_update(send->pkcp, iclock());

	char buf[RECV_BUF] = {0};

	while (1)
	{
		isleep(1);
		ikcp_update(send->pkcp, iclock());
		//处理收消息
		n = recvfrom(send->sockfd, buf, RECV_BUF, MSG_DONTWAIT, (struct sockaddr *)&send->CientAddr, &len);
		if (n > 0)
		{
			printf("UDP recv[%d]  size= %d   \n", recv_count++, n);
			if (first_recv_time == 0)
			{
				first_recv_time = iclock64();
			}
			//预接收数据:调用ikcp_input将裸数据交给KCP，这些数据有可能是KCP控制报文，并不是我们要的数据。
			//kcp接收到下层协议UDP传进来的数据底层数据buffer转换成kcp的数据包格式
			ret = ikcp_input(send->pkcp, buf, n);
			if (ret < 0)
			{
				continue;
			}
			//kcp将接收到的kcp数据包还原成之前kcp发送的buffer数据
			ret = ikcp_recv(send->pkcp, buf, n); //从 buf中 提取真正数据，返回提取到的数据大小
			if (ret < 0)
			{ // 没有检测ikcp_recv提取到的数据
				isleep(1);
				continue;
			}
			int send_size = ret;
			//ikcp_send只是把数据存入发送队列，没有对数据加封kcp头部数据
			//应该是在kcp_update里面加封kcp头部数据
			//ikcp_send把要发送的buffer分片成KCP的数据包格式，插入待发送队列中。
			ret = ikcp_send(send->pkcp, buf, send_size);
			printf("Server reply ->  bytes[%d], ret = %d\n", send_size, ret);
			ikcp_flush(send->pkcp);	// 快速flush一次 以更快让客户端收到数据
			number++;
		}
		else if (n == 0)
		{
			printf("finish loop\n");
			break;
		}
		else
		{
			// printf("n:%d\n", n);
		}
	}
}

int main(int argc, char *argv[])
{
	printf("this is kcpServer\n");
	if (argc < 2)
	{
		printf("请输入服务器端口号\n");
		return -1;
	}

	kcpObj send;
	send.port = atoi(argv[1]);
	send.pkcp = NULL;

	bzero(send.buff, sizeof(send.buff));
	char Msg[] = "Server:Hello!"; //与客户机后续交互
	memcpy(send.buff, Msg, sizeof(Msg));

	ikcpcb *kcp = ikcp_create(0x1, (void *)&send); //创建kcp对象把send传给kcp的user变量
	ikcp_setmtu(kcp, 1400);
	kcp->output = udp_output;		//设置kcp对象的回调函数
	ikcp_nodelay(kcp, 0, 10, 0, 0); //1, 10, 2, 1
	ikcp_wndsize(kcp, 128, 128);

	send.pkcp = kcp;

	init(&send); //服务器初始化套接字
	loop(&send); //循环处理

	return 0;
}

#include <sys/types.h>
#include <sys/socket.h>
#include <pthread.h>
#include <netinet/in.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include "ikcp.h"

#include <sys/time.h>
#include <sys/wait.h>
#include <arpa/inet.h>


#include "delay.h"
#define DELAY_TEST2_N 5
#define UDP_RECV_BUF_SIZE 1500

// 编译:  gcc -o client client.c ikcp.c delay.c  -lpthread


 typedef struct {
	unsigned char *ipstr;
	int port;
	
	ikcpcb *pkcp;
	
	int sockfd;
	struct sockaddr_in addr;//存放服务器的结构体
	
	char buff[UDP_RECV_BUF_SIZE];//存放收发的消息
}kcpObj;


/* sleep in millisecond */
void isleep(unsigned long millisecond)
{
	#ifdef __unix 	/* usleep( time * 1000 ); */
	struct timespec ts;
	ts.tv_sec = (time_t)(millisecond / 1000);
	ts.tv_nsec = (long)((millisecond % 1000) * 1000000);
	/*nanosleep(&ts, NULL);*/
	usleep((millisecond << 10) - (millisecond << 4) - (millisecond << 3));
	#elif defined(_WIN32)
	Sleep(millisecond);
	#endif
}



int udp_output(const char *buf, int len, ikcpcb *kcp, void *user){
   
 //  printf("使用udp_output发送数据\n");
   
    kcpObj *send = (kcpObj *)user;

	//发送信息
    int n = sendto(send->sockfd, buf, len, 0,(struct sockaddr *) &send->addr,sizeof(struct sockaddr_in));//【】
    if (n >= 0) 
	{       
		//会重复发送，因此牺牲带宽
	 	printf("send:%d bytes\n", n);//24字节的KCP头部
        return n;
    } 
	else 
	{
        printf("udp_output: %d bytes send, error\n", n);
        return -1;
    }
}


int init(kcpObj *send)
{	
	send->sockfd = socket(AF_INET,SOCK_DGRAM,0);
	
	if(send->sockfd < 0)
	{
		perror("socket error！");
		exit(1);
	}
	
	bzero(&send->addr, sizeof(send->addr));
	
	//设置服务器ip、port
	send->addr.sin_family=AF_INET;
    send->addr.sin_addr.s_addr = inet_addr((char*)send->ipstr);
    send->addr.sin_port = htons(send->port);
	
	printf("sockfd = %d ip = %s  port = %d\n",send->sockfd,send->ipstr,send->port);
	
}

// 特别说明，当我们使用kcp测试rtt的时候，如果发现rtt过大，很大一种可能是分片数据没有及时发送出去，需要调用ikcp_flush更快速将分片发送出去。
void delay_test2(kcpObj *send) {
    // 初始化 100个 delay obj
    char buf[UDP_RECV_BUF_SIZE];
	unsigned int len = sizeof(struct sockaddr_in);

    size_t obj_size = sizeof(t_delay_obj);
    t_delay_obj *objs = malloc(DELAY_TEST2_N * sizeof(t_delay_obj));
	int ret = 0;

	int recv_objs = 0;
	//ikcp_update包含ikcp_flush，ikcp_flush将发送队列中的数据通过下层协议UDP进行发送
 	ikcp_update(send->pkcp,iclock());//不是调用一次两次就起作用，要loop调用
    for(int i = 0; i < DELAY_TEST2_N; i++) {
		//  isleep(1);
		delay_set_seqno_send_time(&objs[i], i);  
		ret = ikcp_send(send->pkcp, (char *) &objs[i], obj_size); 
        if(ret < 0) {
            printf("send %d seqno:%u failed, ret:%d, obj_size:%ld\n", i, objs[i].seqno, ret, obj_size);
            return;
        } 
        // ikcp_flush(send->pkcp);		// 调用flush能更快速把分片发送出去
		//ikcp_update包含ikcp_flush，ikcp_flush将发送队列中的数据通过下层协议UDP进行发送
		ikcp_update(send->pkcp,iclock());//不是调用一次两次就起作用，要loop调用
		
		int n = recvfrom(send->sockfd, buf, UDP_RECV_BUF_SIZE, MSG_DONTWAIT,(struct sockaddr *) &send->addr,&len);
		// printf("print recv1:%d\n", n);
		if(n < 0) {//检测是否有UDP数据包 
			// isleep(1);
			continue;
		}
		ret = ikcp_input(send->pkcp, buf, n);	// 从 linux api recvfrom先扔到kcp引擎
		if(ret < 0)//检测ikcp_input是否提取到真正的数据
		{
			//printf("ikcp_input ret = %d\n",ret);
			continue;			// 没有读取到数据
		}	
		ret = ikcp_recv(send->pkcp, (char *)&objs[i], obj_size);		
		if(ret < 0)//检测ikcp_recv提取到的数据	
		{
			printf("ikcp_recv1 ret = %d\n",ret);
			continue;
		}
		delay_set_recv_time(&objs[recv_objs]);
		recv_objs++;
		printf("recv1 %d seqno:%d, ret:%d\n", recv_objs, objs[i].seqno, ret);
        if(ret != obj_size) {
            printf("recv1 %d seqno:%d failed, size:%d\n", i, objs[i].seqno, ret);
            delay_print_rtt_time(objs, i);
            return;
        }
    }

	// 还有没有发送完毕的数据
	for(int i = recv_objs; i < DELAY_TEST2_N; ) {
		//  isleep(1);
		//ikcp_update包含ikcp_flush，ikcp_flush将发送队列中的数据通过下层协议UDP进行发送
		ikcp_update(send->pkcp,iclock());//不是调用一次两次就起作用，要loop调用
		//ikcp_flush(send->pkcp);		// 调用flush能更快速把分片发送出去  
		int n = recvfrom(send->sockfd, buf, UDP_RECV_BUF_SIZE, MSG_DONTWAIT,(struct sockaddr *) &send->addr,&len);
		// printf("recv2:%d\n", n);
		if(n < 0) {//检测是否有UDP数据包
			printf("recv2:%d\n", n);
			isleep(1);
			continue;
		}
			
		ret = ikcp_input(send->pkcp, buf, n);	
		if(ret < 0)//检测ikcp_input是否提取到真正的数据
		{
			printf("ikcp_input2 ret = %d\n",ret);
			continue;			// 没有读取到数据
		}	
		ret = ikcp_recv(send->pkcp, (char *)&objs[i], obj_size);		
		if(ret < 0)//检测ikcp_recv提取到的数据	
		{
			printf("ikcp_recv2 ret = %d\n",ret);
			continue;
		}
		printf("recv2 %d seqno:%d, ret:%d\n", recv_objs,  objs[i].seqno, ret);
		delay_set_recv_time(&objs[recv_objs]);
		recv_objs++;
		i++;
        if(ret != obj_size) {
            printf("recv2 %d seqno:%d failed, size:%d\n", i, objs[i].seqno, ret);
            delay_print_rtt_time(objs, i);
            return;
        }
        
	}
	ikcp_flush(send->pkcp);

    delay_print_rtt_time(objs, DELAY_TEST2_N);
}

void loop(kcpObj *send)
{
	unsigned int len = sizeof(struct sockaddr_in);
	int n,ret;

	// while(1)
	{
		isleep(1);
		delay_test2(send);
	}
	printf("loop finish\n");
	close(send->sockfd);
	
}

int main(int argc,char *argv[])
{
	//printf("this is kcpClient,请输入服务器 ip地址和端口号：\n");
	if(argc != 3)
	{
		printf("请输入服务器ip地址和端口号\n");
		return -1;
	}
	printf("this is kcpClient\n");
	
	unsigned char *ipstr = (unsigned char *)argv[1];
	unsigned char *port  = (unsigned char *)argv[2];
	
	kcpObj send;
	send.ipstr = ipstr;
	send.port = atoi(argv[2]);
	
	init(&send);//初始化send,主要是设置与服务器通信的套接字对象
	
	bzero(send.buff,sizeof(send.buff));
	
	// 每个连接都是需要对应一个ikcpcb
	ikcpcb *kcp = ikcp_create(0x1, (void *)&send);//创建kcp对象把send传给kcp的user变量
	kcp->output = udp_output;//设置kcp对象的回调函数
	ikcp_nodelay(kcp,0, 10, 0, 0);//(kcp1, 0, 10, 0, 0); 1, 10, 2, 1
	ikcp_wndsize(kcp, 128, 128);
	ikcp_setmtu(kcp, 1400);
	send.pkcp = kcp;	
	loop(&send);//循环处理
	ikcp_release(send.pkcp);
	printf("main finish\n");
	return 0;	
}

5.0 QUIC衍生版本XQUIC（作学习参考）

https://www.yuque.com/docs/share/01d83f75-0fd5-4c9f-976a-0dfcf417e0cc?#
《阿里XQUIC：标准QUIC实现自研之路》

qq_37717687
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
1-UDP可靠性传输-202111201
08-03
1. 如果做到可靠性传输 2. UDP与TCP，我们如何选择 3. UDP如何可靠，KCP协议在哪些方面有优势 4. KCP协议精讲（重点讲解） 5. QUIC
QuickLZ 1.5.x 压缩.docx
08-12
QuickLZ是世界上最快的压缩库，每个内核达到308 Mbyte / s。 简单易用，易于集成。 在几分钟之内完成并继续开发！ 流模式，用于压缩大小小于200-300字节的小数据包的最佳压缩率。 自动检测并快速处理不可压缩的数据。 qpress文件存档器 qzip / qcat QuickLZ C 1.5.x手册 1、功能 2、标志 3、重叠减压 4、线程安全 5、内存需求 6、架构相容性 7、向后兼容 8、样例代码
基于UDP实现可靠传输——KCP协议
最新发布
weixin_45634782的博客
04-06 1347
基于UDP实现可靠传输——KCP协议
快速可靠协议：KCP
热门推荐
linshuhe1的专栏
08-12 1万+
KCP 是一个快速可靠协议，能以比 TCP浪费10%-20%的带宽的代价，换取平均延迟降低 30%-40%，且最大延迟降低三倍的传输效果。纯算法实现，并不负责底层协议（如UDP）的收发，需要使用者自己定义下层数据包的发送方式，以 callback的方式提供给 KCP。连时钟都需要外部传递进来，内部不会有任何一次系统调用。 整个协议只有 ikcp.h, ikcp.c两个源文件，可以方便的集成到
UDP可靠性传输KCP实现原理和应用
locahuang的博客
02-18 2348
一、如何做到可靠性传输 二、TCP可靠性传输原理 三、UDP可靠性传输实现
Qcon演讲实录 | XQUIC与多路径传输技术Multipath QUIC
淘系技术
01-05 4029
大家好，我是阿里巴巴淘系技术部的刘彦梅（花名喵吉），今天给大家介绍的演讲内容是<XQUIC与多路径传输技术>, 下面是我在Qcon 2020上海站大会上的演讲内容，收录于专题...
UDP可靠传输（KCP））
asdaqqwc的博客
01-09 2339
在阅读本文之前，可以先阅读一下之前的文章，了解tcp是如何保证可靠传输的 本文主要以KCP协议展开讲解，KCP是UDP可靠传输协议 分片   链路层具有最大传输单元MTU这个特性，它限制了数据帧的最大长度，不同的网络类型都有一个上限值。以太网的MTU是1500，你可以用 netstat -i 命令查看这个值。如果IP层有数据包要传，而且数据包的长度超过了MTU，那么IP层就要对数据包进行分片（fragmentation）操作，使每一片的长度都小于或等于MTU。我们假设要传输一个UDP数据包，以太网的MTU为
源码刨析 KCP 可靠传输机制
键盘敲的劈啪响
02-16 697
KCP是一种基于UDP的可靠传输算法层
实现UDP可靠性传输（KCP介绍使用）
weixin_45715405的博客
08-09 832
TCP协议是基于IP协议，面向连接，可靠基于字节流的传输层协议1、基于IP协议：TCP协议是基于IP协议之上传输的，TCP协议报文中的源端口+IP协议报文中的源地址+TCP协议报文中的目标端口+IP协议报文中的目标地址，组合起来唯一确定一条TCP连接。2、面向连接：与UDP不同，TCP在传输数据之前，需要进行三次握手，建立一条TCP连接，然后在进行数据传输，释放需要进行四次挥手。
UDP可靠性传输协议kcp
qq_37181864的博客
11-02 350
本文先介绍TCP中实现可靠传输的方式, 引出KCP是如何在应用层实现UDP可靠性传输本专栏知识点是通过零声教育的线上课学习，进行梳理总结写下文章，对c/c++linux课程感兴趣的读者，可以点击链接C/C++后台高级服务器课程介绍详细查看课程的服务。
kcp.rar_UDP可靠_kcp_kcp udp_socket udp_udp数据包
07-15
c语言实现的可靠udp传输协议，能够在丢包50%的情况下恢复数据
kcp:Rust的可靠UDP库
05-06
千cp Rust的可靠UDP库这个项目只是KCP的Rust翻译查看其他
可靠udp协议kcp
01-14
kcp可靠udp协议，c源码，仅供参考，可以编译到任何游戏中。
kcp：KCP-一种快速可靠的ARQ协议
02-17
KCP是一个快速可靠的协议，能以比TCP浪费10％-20％的带宽的代价，换取平均延迟降低30％-40％，并且最大延迟降低三倍的传输效果。纯算法实现，并不负责任协议（如UDP）的收发，需要用户自己定义的下层数据包的发送...
【XQUIC】XQUIC 阿里自研标准化协议库
突围
04-11 1135
阿里自研标准化协议库XQUIC正式开源 阿里自研标准化协议库 XQUIC 正式开源！ XQUIC是阿里自研的IETF QUIC标准化传输协议库，基于IETF QUIC协议实现的UDP传输框架，包含加密可靠传输、HTTP/3两大块主要内容， 为应用提供可靠、安全、高效的数据传输功能，可以极大改善弱网和移动网络下产品的用户网络体验。 据介绍，XQUIC是一个轻量、高性能、标准化的跨平台协议库。 开源仓库已经提供了基于draft-34校订的草案中文翻译，后续会陆续更新RFC8999-9...
linux udp传输收不到_可靠UDP，KCP协议快在哪？
weixin_39991935的博客
11-27 288
云真机已经支持手机端的画面投影。云真机实时操作，对延迟的要求比远程视频对话的要求更高（100ms以内）。在无线网络下，如何更实时、更可靠的传输视频流就成了一个挑战。通过websocket、RTMP、UDP的比较，最后选择了可靠的UDP协议KCP来进行实时音视频的传输。1 简介KCP是一个快速可靠协议，能以比 TCP浪费10%-20%的带宽的代价，换取平均延迟降低 30%-40%，且最大延迟降低三倍...
【网络通信 -- 直播】网络通信协议简介 -- UDP 可靠性保证 KCP 协议
CopperSun 技术博客
05-28 425
【网络通信 -- 直播】网络通信协议简介 -- UDP 可靠性保证 KCP 协议 【1】KCP 协议简介 KCP 是一个快速可靠协议，能以比 TCP 浪费 10%-20% 的带宽的代价，换取平均延迟降低 30%-40%，且最大延迟降低三倍的传输效果；纯算法实现并不负责底层协议(如 UDP) 的收发，需要使用者自定义下层数据包的发送方式，以 callback 的方式提供给 KCP，内部不会有任何一次系统调用；在整个网络结构中的位置如下图所示 【2】KCP 提高 "流速" 的策略 RTO 翻倍 vs
网络编程-UDP可靠传输(KCP)
u012173846的博客
09-02 1216
网络编程-UDP可靠传输(KCP)
golang kcp
08-10
它通过增加冗余数据、前向纠错、ACK确认等机制来提高传输的可靠性。同时，KCP还采用了自适应拥塞控制算法，在网络状况变化时可以动态调整传输速率，以保证传输的稳定性。 在Go语言中，有一些开源的KCP库可以使用，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值