第24周：阶段项目——高性能四层负载均衡器 (Full-NAT)

2026-06-20

字数统计: 3.3k字 | 阅读时长≈ 17分

第24周：阶段项目——高性能四层负载均衡器 (Full-NAT)

目标：基于 DPDK 实现线速 Full-NAT 模式的 L4 负载均衡器，掌握高性能网络编程的完整工程实践。

1. 项目架构

1.1 整体架构

              Client (10.0.0.100)
                     │
                     │ 请求 VIP=192.168.1.10:80
                     ▼
       ┌────────────────────────────┐
       │     LB (DPDK lcore)         │
       │   192.168.1.10:80 (VIP)     │
       │                            │
       │   ┌─────────────────────┐  │
       │   │  Connection Track   │  │ ← 5 元组会话表
       │   │  (rte_hash)         │  │  TCP 状态机
       │   └─────────────────────┘  │
       │   ┌─────────────────────┐  │
       │   │  Backend Pool       │  │ ← 调度算法
       │   │  (WRR / LC)         │  │  健康检查
       │   └─────────────────────┘  │
       │                            │
       │   Port 0: Client-facing    │
       │   Port 1: Backend-facing   │
       └────────┬───────────────────┘
                │ DNAT (改写目的 IP)
                ▼
    ┌──────────────┐   ┌──────────────┐   ┌──────────────┐
    │ Backend 1    │   │ Backend 2    │   │ Backend 3    │
    │ 10.0.1.10    │   │ 10.0.1.11    │   │ 10.0.1.12    │
    │:8080         │   │:8080         │   │:8080         │
    └──────────────┘   └──────────────┘   └──────────────┘

Full-NAT 模式：
  入口包（Client→LB→Backend）:
    src = 10.0.0.100:12345
    dst = 192.168.1.10:80  (VIP)
    ↓  DNAT
    src = 10.0.1.1:xxxxx  (LB 替换的源 IP)
    dst = 10.0.1.10:8080  (Backend)

  返回包（Backend→LB→Client）:
    src = 10.0.1.10:8080
    dst = 10.0.1.1:xxxxx  (LB 替换的源)
    ↓  SNAT
    src = 192.168.1.10:80
    dst = 10.0.0.100:12345

1.2 数据结构

// === 配置常量 ===
#define NB_MBUF          65536
#define MAX_BACKENDS     32
#define MAX_VIPS         16
#define MAX_SESSIONS     (1 << 20)  // 1M sessions
#define BURST_SIZE       32
#define RX_DESC          1024
#define TX_DESC          1024

// === 后端 ===
struct backend {
    uint32_t ip;            // 真实 IP
    uint16_t port;          // 真实端口
    uint16_t weight;        // 权重
    uint8_t  state;         // 0=DOWN, 1=UP
    uint32_t active_conn;   // 当前活跃连接数
    uint64_t total_conn;    // 历史总连接数
    uint64_t total_pkts;    // 历史总包数
};

// === VIP ===
struct vip {
    uint32_t vip_ip;
    uint16_t vip_port;
    uint16_t backend_port;  // 真实后端端口
    struct backend *backends[MAX_BACKENDS];
    int backend_count;
    int sched_algo;         // 0=RR, 1=WRR, 2=LC
    int current_rr;         // 轮询计数器
};

// === TCP 状态 ===
enum tcp_state {
    TCP_NEW,
    TCP_SYN_RCVD,
    TCP_ESTABLISHED,
    TCP_FIN_WAIT_1,
    TCP_FIN_WAIT_2,
    TCP_CLOSE_WAIT,
    TCP_CLOSING,
    TCP_LAST_ACK,
    TCP_TIME_WAIT,
    TCP_CLOSED
};

// === 会话条目（5 元组 + 状态） ===
struct session {
    // 原始方向 key：client → LB → backend
    uint32_t client_ip;
    uint32_t lb_ip;           // LB 替换的源 IP
    uint32_t backend_ip;
    uint16_t client_port;
    uint16_t lb_port;         // LB 替换的源端口
    uint16_t backend_port;
    uint8_t  state;           // TCP 状态
    uint8_t  backend_idx;     // 选中的后端
    uint32_t seq_delta;       // Client 方向序列号偏移
    uint32_t ack_delta;       // Backend 方向序列号偏移
    uint64_t create_ts;       // 创建时间
    uint64_t last_active_ts;  // 最后活跃时间
};

// === 全局上下文 ===
struct lb_ctx {
    // 端口
    uint16_t client_port;     // 接 Client 的端口
    uint16_t backend_port;    // 接 Backend 的端口
    uint16_t vip_port;        // VIP 端口
    uint32_t vip_ip;          // VIP IP

    // 后端池
    struct vip vips[MAX_VIPS];
    int vip_count;

    // 会话表
    struct rte_hash *session_hash;
    struct rte_mempool *session_pool;

    // 健康检查
    uint64_t last_health_check;

    // 统计
    uint64_t total_packets;
    uint64_t total_sessions;
    uint64_t active_sessions;
    uint64_t total_dropped;
};

2. 主循环

2.1 包处理

// main_loop.c
#include <rte_eal.h>
#include <rte_ethdev.h>
#include <rte_mbuf.h>
#include <rte_ip.h>
#include <rte_tcp.h>
#include <rte_udp.h>
#include <rte_hash.h>
#include <rte_jhash.h>

// 全局上下文
static struct lb_ctx g_ctx;
static struct rte_mempool *mbuf_pool;

// 调度：选择后端
static struct backend *select_backend(struct vip *v) {
    struct backend *best = NULL;
    int best_idx = -1;

    if (v->sched_algo == 0) {
        // 轮询
        for (int i = 0; i < v->backend_count; i++) {
            v->current_rr = (v->current_rr + 1) % v->backend_count;
            if (v->backends[v->current_rr]->state == 1) {
                best = v->backends[v->current_rr];
                best_idx = v->current_rr;
                break;
            }
        }
    } else if (v->sched_algo == 1) {
        // 加权轮询
        int total_weight = 0;
        for (int i = 0; i < v->backend_count; i++)
            if (v->backends[i]->state == 1)
                total_weight += v->backends[i]->weight;
        if (total_weight == 0) return NULL;

        int target = v->current_rr % total_weight;
        v->current_rr++;
        int cumulative = 0;
        for (int i = 0; i < v->backend_count; i++) {
            if (v->backends[i]->state != 1) continue;
            cumulative += v->backends[i]->weight;
            if (target < cumulative) {
                best = v->backends[i];
                best_idx = i;
                break;
            }
        }
    } else if (v->sched_algo == 2) {
        // 最少连接
        int min_conn = INT_MAX;
        for (int i = 0; i < v->backend_count; i++) {
            if (v->backends[i]->state == 1 &&
                v->backends[i]->active_conn < min_conn) {
                min_conn = v->backends[i]->active_conn;
                best = v->backends[i];
                best_idx = i;
            }
        }
    }

    if (best) {
        v->backends[best_idx]->active_conn++;
        v->backends[best_idx]->total_conn++;
    }
    return best;
}

// 构建反向 key（用于返回包方向）
static inline void build_reverse_key(uint32_t sip, uint16_t sp,
                                      uint32_t dip, uint16_t dp,
                                      struct session *sess) {
    sess->backend_ip = sip;
    sess->lb_ip = dip;
    sess->lb_port = dp;
    sess->backend_port = sp;
    // Client 端信息暂存其他字段
}

static int lb_process_client_to_backend(struct rte_mbuf *m) {
    struct rte_ether_hdr *eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
    struct rte_ipv4_hdr *ip = (struct rte_ipv4_hdr *)(eth + 1);

    if (eth->ether_type != rte_cpu_to_be_16(RTE_ETHER_TYPE_IPv4))
        return -1;
    if (ip->next_proto_id != IPPROTO_TCP)
        return -1;

    struct rte_tcp_hdr *tcp = (struct rte_tcp_hdr *)((uint8_t *)ip + rte_ipv4_hdr_len(ip));

    // 1. 匹配会话（已建立连接）
    struct session key = {0};
    key.client_ip = ip->src_addr;
    key.backend_ip = ip->dst_addr;
    key.client_port = tcp->src_port;
    key.backend_port = tcp->dst_port;

    struct session **sess;
    int ret = rte_hash_lookup_data(g_ctx.session_hash, &key, (void **)&sess);
    if (ret >= 0) {
        // 命中会话，直接转发
        (*sess)->last_active_ts = rte_rdtsc();
        (*sess)->state = TCP_ESTABLISHED;
        return forward_to_backend(m, *sess);
    }

    // 2. 新连接（SYN 包）
    if (!(tcp->tcp_flags & RTE_TCP_SYN_FLAG))
        return -1;  // 非 SYN 新建连接 = 丢弃

    // 3. 查找 VIP 配置
    struct vip *v = find_vip(ip->dst_addr, tcp->dst_port);
    if (!v) return -1;

    // 4. 选择后端
    struct backend *b = select_backend(v);
    if (!b) return -1;  // 没有可用后端

    // 5. 创建会话
    struct session *new_sess = rte_mempool_get(g_ctx.session_pool, NULL);
    if (!new_sess) return -1;  // 会话表满

    new_sess->client_ip = ip->src_addr;
    new_sess->client_port = tcp->src_port;
    new_sess->backend_ip = b->ip;
    new_sess->backend_port = b->port;
    new_sess->lb_port = get_lb_port();  // 分配 LB 端口
    new_sess->lb_ip = g_ctx.backend_port == 0 ? 0 : g_ctx.vip_ip;
    new_sess->state = TCP_SYN_RCVD;
    new_sess->backend_idx = b - v->backends[0];
    new_sess->create_ts = rte_rdtsc();
    new_sess->last_active_ts = new_sess->create_ts;

    // 添加正向 key → session
    rte_hash_add_key_data(g_ctx.session_hash, &key, new_sess);

    // 同时添加反向 key → session（用于返回包方向）
    struct session reverse_key = {0};
    reverse_key.backend_ip = b->ip;
    reverse_key.backend_port = b->port;
    reverse_key.lb_ip = new_sess->lb_ip;
    reverse_key.lb_port = new_sess->lb_port;
    rte_hash_add_key_data(g_ctx.session_hash, &reverse_key, new_sess);

    // 6. Full-NAT 转换
    //    源 IP: client → lb
    //    目的 IP: VIP → backend
    uint32_t orig_src_ip = ip->src_addr;
    uint16_t orig_src_port = tcp->src_port;
    uint32_t orig_dst_ip = ip->dst_addr;
    uint16_t orig_dst_port = tcp->dst_port;

    // SNAT: src = LB
    ip->src_addr = new_sess->lb_ip;
    tcp->src_port = new_sess->lb_port;

    // DNAT: dst = Backend
    ip->dst_addr = b->ip;
    tcp->dst_port = b->port;

    // 重新计算校验和
    tcp->cksum = 0;
    tcp->cksum = rte_ipv4_udptcp_cksum(ip, tcp);
    ip->hdr_checksum = 0;
    ip->hdr_checksum = rte_ipv4_cksum(ip);

    // 7. 修改 MAC（出接口 + 下一跳）
    struct rte_ether_addr out_mac;
    rte_eth_macaddr_get(g_ctx.backend_port, &out_mac);
    rte_memcpy(&eth->src_addr, &out_mac, sizeof(struct rte_ether_addr));

    // TODO: 查 ARP 找 backend 的 MAC
    struct arp_entry *be_mac = arp_find(b->ip);
    if (!be_mac) {
        // 发送 ARP 请求，等待...
        return -1;
    }
    rte_memcpy(&eth->dst_addr, &be_mac->mac, sizeof(struct rte_ether_addr));

    // 8. 发送
    return rte_eth_tx_burst(g_ctx.backend_port, 0, &m, 1);
}

static int lb_process_backend_to_client(struct rte_mbuf *m) {
    struct rte_ether_hdr *eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *);
    struct rte_ipv4_hdr *ip = (struct rte_ipv4_hdr *)(eth + 1);
    struct rte_tcp_hdr *tcp = (struct rte_tcp_hdr *)((uint8_t *)ip + rte_ipv4_hdr_len(ip));

    // 1. 匹配反向会话
    struct session key = {0};
    key.backend_ip = ip->src_addr;
    key.backend_port = tcp->src_port;
    key.lb_ip = ip->dst_addr;
    key.lb_port = tcp->dst_port;

    struct session **sess;
    int ret = rte_hash_lookup_data(g_ctx.session_hash, &key, (void **)&sess);
    if (ret < 0) return -1;  // 没有匹配会话

    (*sess)->last_active_ts = rte_rdtsc();

    // 2. SNAT 转换（将 LB 替换的源还原为 VIP）
    ip->src_addr = g_ctx.vip_ip;
    tcp->src_port = g_ctx.vip_port;

    // DNAT 转换（将 LB 替换的目的还原为 Client）
    ip->dst_addr = (*sess)->client_ip;
    tcp->dst_port = (*sess)->client_port;

    // 重新计算校验和
    tcp->cksum = 0;
    tcp->cksum = rte_ipv4_udptcp_cksum(ip, tcp);
    ip->hdr_checksum = 0;
    ip->hdr_checksum = rte_ipv4_cksum(ip);

    // 3. 处理 TCP 状态
    if (tcp->tcp_flags & RTE_TCP_FIN_FLAG) {
        (*sess)->state = TCP_FIN_WAIT_1;
    }
    if ((*sess)->state == TCP_FIN_WAIT_1 &&
        (tcp->tcp_flags & RTE_TCP_ACK_FLAG)) {
        (*sess)->state = TCP_FIN_WAIT_2;
    }

    // 4. 修改 MAC
    struct rte_ether_addr out_mac;
    rte_eth_macaddr_get(g_ctx.client_port, &out_mac);
    rte_memcpy(&eth->src_addr, &out_mac, sizeof(struct rte_ether_addr));

    // 查找 Client 的 MAC
    // ... (类似 ARP 查找)

    return rte_eth_tx_burst(g_ctx.client_port, 0, &m, 1);
}

// === 主循环 ===
void lb_main_loop(void) {
    struct rte_mbuf *pkts_c2b[BURST_SIZE];  // client → backend
    struct rte_mbuf *pkts_b2c[BURST_SIZE];  // backend → client
    uint16_t nb_rx;

    printf("LB running on lcore %u\n", rte_lcore_id());

    while (1) {
        // 接收 Client 流量
        nb_rx = rte_eth_rx_burst(g_ctx.client_port, 0,
                                  pkts_c2b, BURST_SIZE);
        if (nb_rx > 0) {
            int processed = 0;
            struct rte_mbuf *to_send[BURST_SIZE];

            for (int i = 0; i < nb_rx; i++) {
                if (lb_process_client_to_backend(pkts_c2b[i]) == 0) {
                    to_send[processed++] = pkts_c2b[i];
                } else {
                    rte_pktmbuf_free(pkts_c2b[i]);
                }
            }

            if (processed > 0) {
                rte_eth_tx_burst(g_ctx.backend_port, 0,
                                  to_send, processed);
            }
        }

        // 接收 Backend 流量
        nb_rx = rte_eth_rx_burst(g_ctx.backend_port, 0,
                                  pkts_b2c, BURST_SIZE);
        if (nb_rx > 0) {
            for (int i = 0; i < nb_rx; i++) {
                if (lb_process_backend_to_client(pkts_b2c[i]) < 0)
                    rte_pktmbuf_free(pkts_b2c[i]);
            }
        }

        // 定期清理过期会话
        cleanup_expired_sessions();
    }
}

3. 会话表管理

3.1 会话老化

// 清理超过 60 秒无活动的会话
#define SESSION_TIMEOUT 60000000000ULL  // 60 秒（TSC）

void cleanup_expired_sessions(void) {
    static uint64_t last_check = 0;
    uint64_t now = rte_rdtsc();

    // 每秒检查一次
    if (now - last_check < rte_get_timer_hz()) return;
    last_check = now;

    // 遍历所有会话（需要遍历 hash 表的所有条目）
    const void *next_key;
    void *next_data;
    uint32_t iter = 0;

    while (rte_hash_iterate(g_ctx.session_hash, &next_key, &next_data, &iter) >= 0) {
        struct session *sess = (struct session *)next_data;

        if (now - sess->last_active_ts > SESSION_TIMEOUT) {
            // 删除（同时删除两个方向）
            // ... 删除正向 key
            // ... 删除反向 key
            rte_mempool_put(g_ctx.session_pool, sess);
            g_ctx.active_sessions--;
        }
    }
}

3.2 TCP 状态跟踪

// TCP 状态机处理
void update_tcp_state(struct session *sess,
                      uint8_t flags,
                      struct rte_tcp_hdr *tcp) {
    switch (sess->state) {
        case TCP_SYN_RCVD:
            if (flags & RTE_TCP_SYN_FLAG && flags & RTE_TCP_ACK_FLAG) {
                // SYN+ACK 来自 Backend
                // 等待 Client 发 ACK 完成三次握手
                sess->state = TCP_ESTABLISHED;
            }
            break;

        case TCP_ESTABLISHED:
            if (flags & RTE_TCP_FIN_FLAG) {
                sess->state = TCP_FIN_WAIT_1;
            } else if (flags & RTE_TCP_RST_FLAG) {
                sess->state = TCP_CLOSED;
                // 立即删除会话
            }
            break;

        case TCP_FIN_WAIT_1:
            if (flags & RTE_TCP_ACK_FLAG) {
                sess->state = TCP_FIN_WAIT_2;
            }
            break;

        case TCP_FIN_WAIT_2:
            if (flags & RTE_TCP_FIN_FLAG) {
                sess->state = TCP_TIME_WAIT;
            }
            break;

        case TCP_TIME_WAIT:
            // 等待 2*MSL 后关闭
            break;
    }
}

4. 健康检查

// health_check.c
#include <rte_timer.h>

static void health_check_timer(struct rte_timer *tim, void *arg) {
    (void)tim; (void)arg;

    uint64_t now = rte_rdtsc();
    if (now - g_ctx.last_health_check < rte_get_timer_hz() * 5)
        return;
    g_ctx.last_health_check = now;

    for (int v = 0; v < g_ctx.vip_count; v++) {
        struct vip *vip = &g_ctx.vips[v];
        for (int b = 0; b < vip->backend_count; b++) {
            struct backend *be = vip->backends[b];

            if (be->state == 0) {
                // 检查 DOWN 节点是否可以恢复
                if (tcp_probe_backend(be)) {
                    be->state = 1;
                    printf("Backend %u.%u.%u.%u:%u RECOVERED\n",
                           (be->ip >> 24) & 0xFF,
                           (be->ip >> 16) & 0xFF,
                           (be->ip >> 8) & 0xFF,
                           be->ip & 0xFF,
                           be->port);
                }
            } else {
                // 检查 UP 节点是否仍然可用
                if (!tcp_probe_backend(be)) {
                    be->state = 0;
                    printf("Backend %u.%u.%u.%u:%u DOWN\n",
                           (be->ip >> 24) & 0xFF,
                           (be->ip >> 16) & 0xFF,
                           (be->ip >> 8) & 0xFF,
                           be->ip & 0xFF,
                           be->port);
                }
            }
        }
    }
}

// TCP 探测（发送 SYN，3 秒超时）
int tcp_probe_backend(struct backend *be) {
    // 1. 发送 TCP SYN 包
    // 2. 等待 SYN+ACK
    // 3. 收到 → 后端正常
    // 4. 超时或 RST → 后端不可用
    // (实现略)
    return 1;
}

5. 性能测试

5.1 压测工具

# === pktgen 压测 ===
sudo ./build/app/dpdk-pktgen -l 0-3 --socket-mem 1024 \
    -- -p 0x3 -T 1 -t -m "[0:1].0" \
    -d /tmp/udp.pcap -s 192.168.1.10:80 \
    -D 00:11:22:33:44:55

# === wrk 压测（通过 NIC 接口）===
# 在另一台机器上运行 wrk
wrk -t4 -c1000 -d60s http://192.168.1.10:8080/

# === testpmd 模拟流量 ===
# 启动 testpmd 测试发包
testpmd> set fwd io
testpmd> start tx_first

5.2 性能指标

# === 在 LB 控制台上观察 ===

# 实时统计
LB> show stats

=== LB Statistics ===
Total packets:    12345678
Active sessions:  23456
Total sessions:   56789012
Dropped packets:  1234

=== Per-Backend ===
Backend 10.0.1.10:8080  conn=10234  total=23456789  state=UP
Backend 10.0.1.11:8080  conn=9876   total=21234567  state=UP
Backend 10.0.1.12:8080  conn=4346   total=12097556  state=UP

=== Latency ===
min=200ns avg=350ns max=850ns p99=600ns

5.3 性能基准目标

10GbE 线速（64B 包）：
  目标: 14.88 Mpps（线速）
  实际: 12-14 Mpps（受限于各种开销）

延迟（DPDK + Full-NAT）：
  入口→查找会话→重写→发送: < 500ns
  平均延迟: 300-500ns
  P99 延迟: < 1μs

CPU 占用：
  1 个 lcore 处理 10GbE 小包：80-90% CPU
  2 个 lcore：45-50% CPU（线性扩展）
  4 个 lcore：25-30% CPU

会话表容量：
  1M 条目占用: 约 200MB
  查找性能: O(1) hash 查找
  支持并发连接: 100-500K（取决于超时配置）

6. 配置文件

# lb.conf

# === VIP 配置 ===
[vip]
ip = 192.168.1.10
port = 80
backend_port = 8080
sched_algo = wrr           ; rr, wrr, lc

# === 后端列表 ===
[[backends]]
ip = 10.0.1.10
port = 8080
weight = 5

[[backends]]
ip = 10.0.1.11
port = 8080
weight = 3

[[backends]]
ip = 10.0.1.12
port = 8080
weight = 2

# === 端口 ===
[ports]
client_port = 0            ; NIC port 0 接 Client
backend_port = 1           ; NIC port 1 接 Backend

# === 会话表 ===
[session]
max_sessions = 1048576     ; 1M
timeout_sec = 60

# === 健康检查 ===
[health]
interval_sec = 5
timeout_sec = 3

7. 项目结构

lb_dpdk/
├── Makefile
├── README.md
├── config/
│   └── lb.conf
├── src/
│   ├── main.c                # 入口
│   ├── init.c                # EAL 初始化、端口配置
│   ├── vip.c                 # VIP 管理
│   ├── backend.c             # 后端池、调度
│   ├── session.c             # 会话表
│   ├── health.c              # 健康检查
│   ├── arp.c                 # ARP 处理
│   ├── lb_fwd.c              # 转发主循环
│   ├── stats.c               # 统计
│   └── tcp_state.c           # TCP 状态机
├── include/
│   ├── lb.h
│   ├── session.h
│   ├── backend.h
│   └── ...
├── tools/
│   ├── config_parser.c
│   └── stats_print.c
└── docs/
    ├── design.md
    └── perf_report.md

8. 性能测试报告模板

========================================
   L4 Load Balancer 性能测试报告
========================================

测试环境：
  CPU:     Intel Xeon Gold 6248R @ 3.0GHz, 24 核
  网卡:    Intel XL710 10GbE SFP+ x 2
  内核:    Linux 5.15
  DPDK:    22.11
  Hugepage: 2MB × 4096

软件配置：
  VIP: 192.168.1.10:80
  后端: 3 个 10.0.1.x:8080
  调度: WRR
  会话表: 1M

测试结果（10GbE 线速）:
  ┌──────────┬────────────┬────────────┬──────────┐
  │ 包大小   │   PPS      │  吞吐      │  CPU 占用 │
  ├──────────┼────────────┼────────────┼──────────┤
  │ 64B      │ 14.88 Mpps │ 9.5 Gbps   │ 1.5 核   │
  │ 128B     │ 10.5 Mpps  │ 10.5 Gbps  │ 1.0 核   │
  │ 256B     │ 5.8 Mpps   │ 11.6 Gbps  │ 0.7 核   │
  │ 512B     │ 3.0 Mpps   │ 12.0 Gbps  │ 0.5 核   │
  │ 1024B    │ 1.5 Mpps   │ 12.0 Gbps  │ 0.3 核   │
  └──────────┴────────────┴────────────┴──────────┘

延迟（线速 64B 包）:
  ┌──────────┬──────────┬──────────┬──────────┐
  │ 操作     │ min      │ avg      │ p99      │
  ├──────────┼──────────┼──────────┼──────────┤
  │ 收包     │ 50 ns    │ 80 ns    │ 120 ns   │
  │ 会话查找 │ 30 ns    │ 50 ns    │ 90 ns    │
  │ NAT 转换 │ 40 ns    │ 60 ns    │ 90 ns    │
  │ 发包     │ 50 ns    │ 80 ns    │ 120 ns   │
  │ 合计     │ 170 ns   │ 270 ns   │ 420 ns   │
  └──────────┴──────────┴──────────┴──────────┘

调度性能:
  RR 调度: ~ 5 ns
  WRR 调度: ~ 15 ns
  LC 调度: ~ 30 ns

会话表性能:
  1M 条目: 220 MB 内存
  查找延迟: ~ 50 ns
  插入延迟: ~ 200 ns

优化建议:
  - 启用 SR-IOV 让 LB 独享虚拟网卡
  - 使用 1GB hugepage 减少 TLB miss
  - 启用 Vector Instructions (SSE/AVX) 优化校验和
  - 进一步减少 NAT 转换中的分支预测失败

9. 优化方向

1. SIMD 向量化
   - 校验和：rte_ipv4_udptcp_cksum 已使用 SSE
   - 批量 IP/MAC 比较

2. 多核扩展
   - 按 5 元组 hash 分配到不同 lcore
   - 每个 lcore 独立处理一部分会话
   - 使用 8 个 lcore 处理 80Gbps

3. 内存优化
   - 预取：rte_prefetch0 预取下一个 mbuf
   - 对齐：会话表 cache line 对齐
   - NUMA：mbuf pool 在本地 socket

4. 减少分支
   - 用查找表替代 if-else
   - 关键路径用 __builtin_expect 提示分支
   - TCP 状态用 switch 而不是查表

5. 高级优化
   - TCP 序列号优化（避免每包重新计算 cksum）
   - 批量发送（更大 BURST_SIZE）
   - DPDK RSS 多队列分流

10. 扩展功能

□ TCP 序列号调整（用于透明模式）
□ UDP 负载均衡
□ SSL/TLS 卸载
□ 健康检查增强（HTTP GET /health）
□ 会话保持（基于 Cookie 或 IP）
□ 持久化连接（避免每包 NAT）
□ 多 VIP 支持
□ IPv6 支持
□ Telemetry 接口（实时导出统计）

本文作者： CoderSong
本文链接： https://jack-song-gif.github.io/2026/06/20/第24周：阶段项目——高性能四层负载均衡器 (Full-NAT)/
版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！