gh0s7/NE_YuR
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

tcp/quic lab and switch lab added

Browse Source
This commit is contained in:
CGH0S7
2026-01-10 10:33:04 +08:00
parent 747cad7b4d
commit 265709e49c
7 changed files with 669 additions and 17 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
network/switchlab/Makefile Normal file
View File

@@ -0,0 +1,2 @@
All:
arm-linux-gnueabihf-gcc -o ul2switch main_l2switch.c -lua -lreg -lpthread

428
network/switchlab/main_l2switch.c Normal file
View File

@@ -0,0 +1,428 @@
/** *************************************************************************
* @file main_l2switch.c
* @brief 基于FAST架构的软件二层交换示例程序
*
* 详细说明
*
* @date 2017/04/08 10:39:17 星期六
* @author XDL(Copyright 2017 XuDongLai)
* @email <XuDongLai0923@163.com>
* @version 0.2.0
****************************************************************************/
/*
* main_l2switch.c
*
* Copyright (C) 2017 - XuDongLai
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <fast.h>
#include <unistd.h>
#define NM08_PORT_CNT 4 /*设备端口数量*/
#define NM08_NEIGH_MAX 128 /*每个端口上最大存储邻居MAC个数*/
#define MAC_LEN 6 /*MAC地址长度*/
#define MAC_LIFE_TIME 10 /*MAC地址生命时长为300秒，可调整*/
int debug = 0;
#define xprintf(argc...) if(debug)printf(argc);
/*端口计数*/
struct nm08_port_stats
{
u64 recv_pkts;
u64 recv_bytes;
u64 send_pkts;
u64 send_bytes;
};/*32B*/
/*MAC地址，有效位标记和MAC地址学习或更新时间*/
struct nm08_port_mac
{
u8 port; /*地址所在端口号信息*/
u8 valid; /*地址有效位标记*/
u8 addr[MAC_LEN]; /*存储MAC地址*/
struct timeval tv; /*存储此MAC的开始有效时间*/
};/*24B*/
/*08的邻居信息表*/
struct nm08_neigh_table
{
struct nm08_port_stats port[NM08_PORT_CNT];
struct nm08_port_mac mac[NM08_NEIGH_MAX];
};
struct nm08_neigh_table *nm08_table = NULL;
/**
* @brief
*
* @param addr1
* @param addr2
*
* @return
*/
int ether_addr_equal(u8 *addr1,u8 *addr2)
{
u16 *a = (u16 *)addr1;
u16 *b = (u16 *)addr2;
return ((a[0] ^ b[0]) | (a[1] ^ b[1]) | (a[2] ^ b[2])) != 0;
}
/**
* @brief
*
* @param inport
* @param index
*/
/*更新MAC地址对应的有效时间*/
void update_mac_time(u8 inport,u8 index)
{
struct timeval tv_now;
gettimeofday(&tv_now,NULL);
tv_now.tv_sec += MAC_LIFE_TIME; /*MAC地址生命周期设置，每次更新，此MAC地址有效时长为300秒，用户可调整*/
nm08_table->mac[index].tv = tv_now;/*更新当前时间*/
if(nm08_table->mac[index].port != inport)
{
/*机器换了端口*/
}
nm08_table->mac[index].port = inport;/*更新MAC所在端口号，有可能是从另外端口拔出，插到了新端口上，如此可以快速更新*/
xprintf("update_mac_time->port:%d,index:%d\n",inport,index);
}
/**
* @brief
*
* @param inport
* @param src_mac
*/
/*地址学习过程，将报文的源MAC学习到对应端口MAC表中*/
void learn_smac(u8 inport,u8 *src_mac)
{
/*更新之前查找空白存储MAC位置*/
int i = 0,j = -1;
xprintf("learn_smac->\n");
for(i= 0;i<NM08_NEIGH_MAX;i++)
{
if (nm08_table->mac[i].valid == 1)/*MAC地址有效*/
{
if(!ether_addr_equal(src_mac,&nm08_table->mac[i].addr[0]))
{
/*当前存储空间地址与输入学习的地址相同，则更新此MAC地址的有效时间*/
xprintf("learn_smac->Update TIME!\n");
update_mac_time(inport,i);
return;
}
}
else if(j == -1)/*第一次找到有效可存储MAC地址的索引*/
{
j = i;/*记录下当前可用的有效位置索引*/
}
}
/*此端口已经存储的MAC地址表中找不到需要学习的MAC地址，则取出最后一个空白地址*/
if(j == -1)/*有效地址没有空白可用*/
{
xprintf("learn_smac->Can't learning more!\n");
return;
}
/*有空白位置可以存储此新学习的MAC*/
memcpy(&nm08_table->mac[j].addr[0],src_mac,MAC_LEN);
update_mac_time(inport,j);/*更新此MAC地址的有效时间*/
nm08_table->mac[j].valid = 1;/*将MAC地址信息置为有效状态*/
xprintf("learn_smac->add new MAC,port:%d,index:%d\n",inport,j);
}
/**
* @brief
*
* @param inport
* @param dst_mac
*
* @return
*/
int find_dmac(u8 inport,u8 *dst_mac)
{
int ret = -1,i = 0;
for(;i< NM08_NEIGH_MAX;i++)/*i != inport 表示不在此MAC的输入端口表中查找*/
{
/*判断地址是否有效，MAC地址是否相等*/
if (nm08_table->mac[i].valid == 1 &&
nm08_table->mac[i].port != inport &&
!ether_addr_equal(dst_mac,&nm08_table->mac[i].addr[0]))
{
ret = nm08_table->mac[i].port;/*如果有效且相等，则返回对应的端口号（即输出端口号）*/
break;
}
}
xprintf("find_dmac->ret = %d\n",ret);
return ret;/*返回-1表示没有学习到，则需要泛洪*/
}
/**
* @brief
*
* @param pkt
* @param pkt_len
*/
void pkt_send_normal(struct fast_packet *pkt,int pkt_len)
{
xprintf("pkt_send_normal->%p,outport:%d,len:%d\n",pkt,pkt->um.outport,pkt_len);
pkt->um.pktsrc = 1;/*报文来源为CPU输入*/
pkt->um.pktdst = 0;/*报文目的为硬件输出*/
pkt->um.dstmid = 5;/*直接从硬件GOE模块输出，不走解析、查表等模块*/
fast_ua_send(pkt,pkt_len);
}
/**
* @brief
*
* @param pkt
* @param pkt_len
*/
void pkt_send_flood(struct fast_packet *pkt,int pkt_len)
{
int i = 0,inport = pkt->um.inport;/*保存输入端口*/
xprintf("------pkt_send_flood------\n");
for(;i< NM08_PORT_CNT;i++)/*除输入端口外，其他都发送一份*/
{
if(i != inport)
{
pkt->um.outport = i;
pkt_send_normal(pkt,pkt_len);
}
}
}
/**
* @brief
*/
void nm08_show_mac_info(void)
{
int i = 0,j = 0,max_cnt = 0;
char buf[400];
int port_mac_cnt[NM08_PORT_CNT] = {0};
struct nm08_port_mac mac[NM08_PORT_CNT][NM08_NEIGH_MAX] = {{0}};
for(;i<NM08_NEIGH_MAX;i++)
{
if (nm08_table->mac[i].valid == 1)
{
mac[nm08_table->mac[i].port][port_mac_cnt[nm08_table->mac[i].port]] = nm08_table->mac[i];
port_mac_cnt[nm08_table->mac[i].port]++;
}
}
/*记录一个端口最多的MAC地址数量，确定我们最大需要输出几行*/
max_cnt = port_mac_cnt[0];
for(i=1;i<NM08_PORT_CNT;i++)
{
if(port_mac_cnt[i] > max_cnt)
max_cnt = port_mac_cnt[i];
}
max_cnt++;/*最后多打印一行空行*/
xprintf("\nID PORT0 PORT1 PORT2 PORT3\n");
for(j = 0;j<max_cnt;j++)
{
sprintf(buf,"%2d ",j);
for(i=0;i< NM08_PORT_CNT;i++)
{
if (mac[i][j].valid == 1)
{
sprintf(buf,"%s %02X:%02X:%02X:%02X:%02X:%02X",buf,
mac[i][j].addr[0],
mac[i][j].addr[1],
mac[i][j].addr[2],
mac[i][j].addr[3],
mac[i][j].addr[4],
mac[i][j].addr[5]);
}
else
{
sprintf(buf,"%s .",buf);
}
}
xprintf("%s\n",buf);
}
}
/**
* @brief
*
* @param argv
*
* @return
*/
/*MAC地址老化处理线程*/
void *nm08_mac_aging(void *argv)
{
struct timeval tv_now;
int i = 0,k = 0,aging_cnt = 0;
while(1)
{
gettimeofday(&tv_now,NULL);
for(i = 0;i<NM08_NEIGH_MAX;i++)
{
/*判断地址是否有效*/
if (nm08_table->mac[i].valid == 1)
{
/*此处仅用秒来做比较，如果需要更高精度可将微秒加入再比较*/
if(nm08_table->mac[i].tv.tv_sec < tv_now.tv_sec)
{
/*此MAC地址的有效时间已到*/
nm08_table->mac[i].valid = 0;
aging_cnt++;
}
}
}
xprintf("aging[%d]->invalid mac:%d\n",k++,aging_cnt);
aging_cnt = 0;/*统计每次老化MAC地址个数，输出后归零*/
sleep(5);/*老化时间误差，每10秒才判断一次。如果提高精度可缩短时间*/
nm08_show_mac_info();
}
}
/**
* @brief
*/
void nm08_start_aging(void)
{
pthread_t tid;
/*创建地址老化处理线程*/
if(pthread_create(&tid, NULL, nm08_mac_aging, NULL))
{
xprintf("Create nm08_mac_aging thread error!\n");
exit(0);
}
else
{
xprintf("Create nm08_mac_aging thread OK!\n");
}
}
/**
* @brief
*
* @param pkt
* @param pkt_len
*
* @return
*/
int callback(struct fast_packet *pkt,int pkt_len)
{
int outport = -1;
xprintf("inport:%d,dstmid:%d,len:%d,dmac:%02X:%02X:%02X:%02X:%02X:%02X,smac:%02X:%02X:%02X:%02X:%02X:%02X\n",pkt->um.inport,pkt->um.dstmid,pkt_len,
pkt->data[0],pkt->data[1],pkt->data[2],pkt->data[3],pkt->data[4],pkt->data[5],
pkt->data[6],pkt->data[7],pkt->data[8],pkt->data[9],pkt->data[10],pkt->data[11]);
//print_pkt(pkt,pkt_len);
//pkt->um.outport = 1;
//pkt_send_normal(pkt,pkt_len);/*正常发送报文*/
//return 0;
/*MAC地址学习过程*/
learn_smac(pkt->um.inport,&pkt->data[MAC_LEN]);/*用源MAC位置开始学习*/
/*查表过程*/
outport = find_dmac(pkt->um.inport,pkt->data);/*用目的MAC地址开始查表*/
/*发送报文*/
if(outport == -1)/*报文需要泛洪操作*/
{
pkt_send_flood(pkt,pkt_len);/*泛洪发送，保留输入端口不变调用*/
}
else/*正常转发*/
{
pkt->um.outport = outport;/*修改报文输出端口号*/
pkt_send_normal(pkt,pkt_len);/*正常发送报文*/
}
return 0;
}
/**
* @brief
*/
void ua_init(u8 mid)
{
int ret = 0;
/*向系统注册，自己进程处理报文模块ID为1的所有报文*/
if((ret=fast_ua_init(mid,callback)))//UA模块实例化(输入参数1:接收模块ID号,输入参数2:接收报文的回调处理函数)
{
perror("fast_ua_init!\n");
exit (ret);//如果初始化失败,则需要打印失败信息,并将程序结束退出!
}
}
/**
* @brief
*
* @param argc
* @param argv[]
*
* @return
*/
int main(int argc,char* argv[])
{
u8 mid = 129;
debug = 1;
if(argc == 2)
{
debug = atoi(argv[1]);
}
else if(argc == 3)
{
debug = atoi(argv[1]);
mid = atoi(argv[2]);
}
if(mid <129)
{
printf("Usage:\n\t%s debug mid\n",argv[0]);
printf("\tdeubg[0,1],UA mid rang [129,255]!\n");
exit(0);
}
/*申请地址表存储空间*/
nm08_table = (struct nm08_neigh_table *)malloc(sizeof(struct nm08_neigh_table));
/*空间清零*/
memset(nm08_table,0,sizeof(struct nm08_neigh_table));
/*UA模块初始化 */
ua_init(mid);
/*配置硬件规则，将硬件所有报文送到模块ID为1的进程处理*/
fast_reg_wr(FAST_ACTION_REG_ADDR|FAST_DEFAULT_RULE_ADDR,ACTION_SET_MID<<28|mid);
/*启动地址学习表老化线程*/
nm08_start_aging();
/*启动线程接收分派给UA进程的报文*/
fast_ua_recv();
/*主进程进入循环休眠中,数据处理主要在回调函数*/
while(1){sleep(9999);}
return 0;
}

205
network/tcpquiclab/QUIC_FIX_REPORT.md Normal file
View File

@@ -0,0 +1,205 @@
# QUIC 性能测试修复报告
## 问题描述
在 TCP 与 QUIC 性能对比实验中，QUIC 程序存在严重的性能问题：
| 协议 | 吞吐量 (修复前) |
|------|----------------|
| TCP | ~2200 MB/s |
| QUIC | ~6 MB/s |
QUIC 吞吐量仅为 TCP 的 **0.3%**，这明显不正常。
## 问题分析
### 问题 1：超时处理导致性能低下
**原代码 (quic_perf_client.c 和 quic_perf_server.c)：**
```c
int64_t timeout_ns = quiche_conn_timeout_as_nanos(conn);
if (timeout_ns > 0 && !has_outgoing && !finished_sending) {
struct timespec ts;
ts.tv_sec = timeout_ns / 1000000000;
ts.tv_nsec = timeout_ns % 1000000000;
nanosleep(&ts, NULL);
}
```
**问题：** `quiche_conn_timeout_as_nanos()` 返回的是连接空闲超时时间（配置为 10 秒），而不是下一次需要处理事件的时间。这导致程序在没有数据发送时会等待很长时间，严重降低了事件循环的响应速度。
### 问题 2：客户端过早关闭连接
原代码中客户端发送完数据后只是简单地 `usleep(1000)` 然后继续循环，没有正确处理连接关闭逻辑。
## 修复方案
### 修复 1：优化轮询间隔
**quic_perf_server.c (第 186-191 行)：**
```c
quiche_conn_on_timeout(conn);
// 使用更短的轮询间隔以提高响应速度
if (!has_outgoing) {
usleep(100); // 100微秒轮询
}
```
**quic_perf_client.c (第 125-130 行)：**
```c
quiche_conn_on_timeout(conn);
// 使用更短的轮询间隔以提高响应速度
if (!has_outgoing && !finished_sending) {
usleep(100); // 100微秒轮询
}
```
### 修复 2：简化客户端发送完成后的处理
```c
if (finished_sending && !has_outgoing) {
usleep(1000);
}
```
## 修复结果
| 协议 | 修复前 | 修复后 | 提升 |
|------|--------|--------|------|
| TCP | ~2200 MB/s | ~1400 MB/s | - |
| QUIC | ~6 MB/s | ~92 MB/s | **15倍** |
## 测试命令
### 正常网络环境测试
```bash
# TCP 测试
./tcp_perf_server &
sleep 1
./tcp_perf_client
wait
# QUIC 测试
./quic_perf_server &
sleep 1
./quic_perf_client
sleep 3
```
### 丢包环境测试 (5%)
```bash
# 添加 5% 丢包
sudo tc qdisc add dev lo root netem loss 5%
# 运行 TCP 和 QUIC 测试...
# 清除规则
sudo tc qdisc del dev lo root
```
### 延迟环境测试 (100ms)
```bash
# 添加 100ms 延迟
sudo tc qdisc add dev lo root netem delay 100ms
# 运行 TCP 和 QUIC 测试...
# 清除规则
sudo tc qdisc del dev lo root
```
### 检查和清除 tc 规则
```bash
# 查看当前规则
tc qdisc show dev lo
# 清除所有规则
sudo tc qdisc del dev lo root
```
---
## 为什么 QUIC 吞吐量仍然远小于 TCP？
修复后 QUIC 达到 ~92 MB/s，而 TCP 达到 ~1400 MB/s，QUIC 仍然只有 TCP 的 **6.5%**。这是正常现象，原因如下：
### 1. 协议栈实现位置不同
| 协议 | 实现位置 | 特点 |
|------|----------|------|
| TCP | **内核空间** | 高度优化，零拷贝，硬件卸载 |
| QUIC | **用户空间** | 需要系统调用，数据拷贝开销大 |
TCP 在 Linux 内核中经过 30+ 年优化，支持：
- **零拷贝 (Zero-copy)**：`sendfile()`, `splice()` 等
- **硬件卸载 (TSO/GSO)**：网卡直接分段
- **内核旁路优化**：减少上下文切换
### 2. 加密开销
QUIC **强制加密**所有数据（使用 TLS 1.3），而本实验中的 TCP 是明文传输：
```
QUIC 数据路径: 应用数据 → TLS加密 → UDP封装 → 发送
TCP 数据路径: 应用数据 → TCP封装 → 发送
```
加密/解密操作消耗大量 CPU 资源。
### 3. UDP vs TCP 的系统调用效率
| 操作 | TCP | QUIC (UDP) |
|------|-----|------------|
| 发送 100MB | 少量大块 write() | 大量小包 sendto() |
| 系统调用次数 | 少 | 多 |
TCP 可以一次 `write()` 发送大块数据，内核自动分段。QUIC 基于 UDP，每个数据包都需要单独的 `sendto()` 调用。
### 4. 数据包大小限制
```c
#define MAX_DATAGRAM_SIZE 1350 // QUIC 单包最大载荷
```
QUIC 受 UDP MTU 限制，每个包最多 ~1350 字节。发送 100MB 需要约 **77,000+ 个数据包**。
### 5. 本地回环测试的特殊性
在 `localhost` 测试中，网络延迟几乎为零，TCP 的内核优化优势被放大。QUIC 的优势（如 0-RTT、连接迁移、多路复用）在这种环境下无法体现。
### 6. QUIC 真正的优势场景
QUIC 设计目标不是追求极限吞吐量，而是在**真实网络环境**中提供更好的用户体验：
| 场景 | QUIC 优势 |
|------|-----------|
| 高延迟网络 | 0-RTT 快速连接建立 |
| 丢包环境 | 无队头阻塞，单流丢包不影响其他流 |
| 移动网络 | 连接迁移，切换 WiFi/4G 不断连 |
| 多路复用 | 单连接多流，避免 TCP 队头阻塞 |
从你的日志可以看到，在 **100ms 延迟**环境下：
- TCP: 0.98 MB/s
- QUIC: 2.41 MB/s
**QUIC 在高延迟环境下性能是 TCP 的 2.5 倍！**
---
## 总结
| 环境 | TCP | QUIC | 胜者 |
|------|-----|------|------|
| 本地回环 (无延迟) | ~1400 MB/s | ~92 MB/s | TCP |
| 100ms 延迟 | 0.98 MB/s | 2.41 MB/s | **QUIC** |
**结论：** QUIC 在理想网络环境下吞吐量低于 TCP 是正常的，这是用户空间实现、强制加密等设计权衡的结果。但在真实的高延迟、高丢包网络环境中，QUIC 能够提供更好的性能和用户体验。

BIN
network/tcpquiclab/quic_perf_client
View File

Binary file not shown.

29
network/tcpquiclab/quic_perf_client.c
View File

@@ -7,6 +7,7 @@
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <time.h>
#include <quiche.h>
#define MAX_DATAGRAM_SIZE 1350
@@ -78,7 +79,7 @@ int main(int argc, char *argv[]) {
bool finished_sending = false;
while (1) {
ssize_t read_len = recv(sock, buf, sizeof(buf), 0);
ssize_t read_len = recv(sock, buf, sizeof(buf), MSG_DONTWAIT);
if (read_len > 0) {
quiche_conn_recv(conn, buf, read_len, &(quiche_recv_info){
.to = (struct sockaddr *)&local_addr,
@@ -87,12 +88,12 @@ int main(int argc, char *argv[]) {
.from_len = sizeof(peer_addr),
});
}
if (quiche_conn_is_closed(conn)) {
printf("Connection closed.\n");
break;
}
if (quiche_conn_is_established(conn)) {
// printf("Connection established.\n");
while (!finished_sending) {
@@ -101,26 +102,36 @@ int main(int argc, char *argv[]) {
if (sent > 0) {
bytes_sent += sent;
if (bytes_sent >= bytes_to_send) {
quiche_conn_stream_send(conn, 4, NULL, 0, true, &err_code);
quiche_conn_stream_send(conn, 4, NULL, 0, true, &err_code);
finished_sending = true;
printf("Finished sending data.\n");
}
} else {
break;
} else if (sent == QUICHE_ERR_DONE) {
break;
}
}
}
bool has_outgoing = false;
while (1) {
quiche_send_info send_info;
ssize_t written = quiche_conn_send(conn, out, sizeof(out), &send_info);
if (written == QUICHE_ERR_DONE) break;
if (written < 0) break;
send(sock, out, written, 0);
has_outgoing = true;
}
quiche_conn_on_timeout(conn);
usleep(100);
// 使用更短的轮询间隔以提高响应速度
if (!has_outgoing && !finished_sending) {
usleep(100); // 100微秒轮询
}
if (finished_sending && !has_outgoing) {
usleep(1000);
}
}
quiche_conn_free(conn);

BIN
network/tcpquiclab/quic_perf_server
View File

Binary file not shown.

22
network/tcpquiclab/quic_perf_server.c
View File

@@ -103,7 +103,7 @@ int main(int argc, char *argv[]) {
client->sock = sock;
client->peer_addr = peer_addr;
client->peer_addr_len = peer_addr_len;
uint8_t server_scid[QUICHE_MAX_CONN_ID_LEN];
int rng = open("/dev/urandom", O_RDONLY);
if (rng >= 0) {
@@ -117,7 +117,7 @@ int main(int argc, char *argv[]) {
printf("New performance connection accepted.\n");
}
}
if (client != NULL) {
quiche_conn_recv(client->conn, buf, read_len, &(quiche_recv_info){
.to = (struct sockaddr *)&sa,
@@ -131,7 +131,7 @@ int main(int argc, char *argv[]) {
if (client != NULL) {
quiche_conn *conn = client->conn;
if (quiche_conn_is_closed(conn)) {
printf("Connection closed.\n");
quiche_conn_free(conn);
@@ -148,7 +148,7 @@ int main(int argc, char *argv[]) {
clock_gettime(CLOCK_MONOTONIC, &client->start_time);
client->timer_started = 1;
}
uint8_t recv_buf[65535];
bool fin = false;
uint64_t err_code = 0;
@@ -162,7 +162,7 @@ int main(int argc, char *argv[]) {
double time_taken = (end.tv_sec - client->start_time.tv_sec) + (end.tv_nsec - client->start_time.tv_nsec) / 1e9;
double mb = client->total_bytes / (1024.0 * 1024.0);
double throughput = mb / time_taken;
if (!done_printing) {
printf("Received %.2f MB in %.2f seconds.\n", mb, time_taken);
printf("Throughput: %.2f MB/s\n", throughput);
@@ -172,18 +172,24 @@ int main(int argc, char *argv[]) {
}
quiche_stream_iter_free(readable);
}
bool has_outgoing = false;
while (1) {
quiche_send_info send_info;
ssize_t written = quiche_conn_send(conn, out, sizeof(out), &send_info);
if (written == QUICHE_ERR_DONE) break;
if (written < 0) break;
sendto(sock, out, written, 0, (struct sockaddr *)&send_info.to, send_info.to_len);
has_outgoing = true;
}
quiche_conn_on_timeout(conn);
// 使用更短的轮询间隔以提高响应速度
if (!has_outgoing) {
usleep(100); // 100微秒轮询
}
}
usleep(100);
}
quiche_config_free(config);