1
┌──────────────────────────────────────────┐
2
│              ConnectX-7 ASIC             │
3
│  ┌─────────┐ ┌──────────┐ ┌──────────┐  │
4
│  │ MAC/PHY │→│ Parser   │→│ Match    │  │
5
│  │ (100G)  │ │ 解析器   │ │ Action   │  │
6
│  └─────────┘ └──────────┘ │ Engine    │  │
7
│                           │ 匹配动作  │  │
8
│  ┌─────────┐ ┌──────────┐ └──────────┘  │
9
│  │ Crypto  │ │ Tunnel   │               │
10
│  │ Engine  │ │ Engine   │               │
11
│  │ 加密引擎│ │ 隧道引擎 │               │
12
│  └─────────┘ └──────────┘               │
13
│  ┌─────────────────────────────────────┐ │
14
│  │         PCIe 5.0 x16               │ │
15
│  └─────────────────────────────────────┘ │
16
└──────────────────────────────────────────┘

1
┌──────────────────────────────────────────┐
2
│            FPGA SmartNIC                 │
3
│  ┌─────────┐ ┌──────────────────────┐   │
4
│  │ MAC/PHY │→│  FPGA Fabric         │   │
5
│  │ (100G)  │ │  ┌────┐ ┌────┐      │   │
6
│  └─────────┘ │  │ME 0│ │ME 1│ ...  │   │
7
│              │  └────┘ └────┘      │   │
8
│  ┌─────────┐ │  ┌──────────────┐   │   │
9
│  │ DDR4    │ │  │ Custom Logic │   │   │
10
│  │ Memory  │←→│  自定义逻辑   │   │   │
11
│  └─────────┘ │  └──────────────┘   │   │
12
│              └──────────────────────┘   │
13
│  ┌─────────────────────────────────────┐│
14
│  │         PCIe 4.0 x16               ││
15
│  └─────────────────────────────────────┘│
16
└──────────────────────────────────────────┘

1
┌──────────────────────────────────────────────────┐
2
│              Hybrid SmartNIC / DPU               │
3
│                                                  │
4
│  ┌────────────────────┐  ┌────────────────────┐  │
5
│  │   ASIC 快速路径    │  │   ARM CPU 子系统   │  │
6
│  │  ┌──────────────┐  │  │  ┌──────────────┐  │  │
7
│  │  │ Parser       │  │  │  │ Linux OS     │  │  │
8
│  │  │ Match-Action │  │  │  │ OVS / 控制面 │  │  │
9
│  │  │ Tunnel/Crypto│  │  │  │ 管理代理     │  │  │
10
│  │  └──────────────┘  │  │  └──────────────┘  │  │
11
│  │                    │  │                     │  │
12
│  └────────┬───────────┘  └──────────┬─────────┘  │
13
│           │     内部高速互连         │            │
14
│           └────────────┬────────────┘            │
15
│                        │                         │
16
│  ┌─────────────────────┴──────────────────────┐  │
17
│  │           MAC/PHY (100G / 200G)            │  │
18
│  └────────────────────────────────────────────┘  │
19
│  ┌────────────────────────────────────────────┐  │
20
│  │           PCIe 4.0/5.0 x16                 │  │
21
│  └────────────────────────────────────────────┘  │
22
└──────────────────────────────────────────────────┘

1
DPU 收益 = 释放的 CPU 核心数 × 单核成本 - DPU 成本

1
# 查看网卡上的 tc 规则（包括硬件卸载的规则）
2
tc filter show dev <interface> root
3

4
# 查看 ingress 方向的 tc 规则
5
tc filter show dev <interface> ingress
6

7
# 手动添加一条 tc 硬件卸载规则
8
# 匹配：源 IP 10.0.0.1，目的端口 80
9
# 动作：转发到端口 2
10
tc filter add dev <interface> protocol ip parent ffff: \
11
    flower \
12
        src_ip 10.0.0.1 \
13
        dst_port 80 \
14
        ip_proto tcp \
15
    action mirred egress redirect dev <interface2> \
16
    hw_offload 1
17

18
# 查看硬件卸载规则的统计
19
tc -s filter show dev <interface> root
20

21
# 删除所有 tc 规则
22
tc qdisc del dev <interface> clsact
23

24
# 查看网卡支持的 tc 卸载能力
25
ethtool -k <interface> | grep hw-tc-offload

1
# 查看硬件流表容量（以 ConnectX 为例）
2
devlink dev param show pci/0000:3b:00.0 name acl_max
3

4
# 设置 OVS 卸载优先级策略
5
ovs-vsctl set Open_vSwitch . other_config:tc-policy=skip_hw
6
# skip_hw: 优先软件规则，硬件规则作为加速
7
# skip_sw: 优先硬件规则，软件规则不安装
8
# none: 两者都安装（默认）

1
// ============================================
2
// P4₁₆ 程序骨架
3
// ============================================
4

5
// 1. 包含核心库
6
#include <core.p4>
7
#include <v1model.p4>
8

9
// 2. 定义头部格式
10
header ethernet_t {
11
    bit<48> dstAddr;
12
    bit<48> srcAddr;
13
    bit<16> etherType;
14
}
15

16
header ipv4_t {
17
    bit<4>  version;
18
    bit<4>  ihl;
19
    bit<8>  diffserv;
20
    bit<16> totalLen;
21
    bit<16> identification;
22
    bit<3>  flags;
23
    bit<13> fragOffset;
24
    bit<8>  ttl;
25
    bit<8>  protocol;
26
    bit<16> hdrChecksum;
27
    bit<32> srcAddr;
28
    bit<32> dstAddr;
29
}
30

31
// 3. 定义元数据结构
32
struct metadata_t {
33
    bit<16> ingress_port;
34
    bit<16> egress_port;
35
}
36

37
// 4. 定义头部集合
38
struct headers_t {
39
    ethernet_t ethernet;
40
    ipv4_t     ipv4;
41
}
42

43
// 5. 定义解析器（Parser）
44
parser MyParser(packet_in packet,
45
                out headers_t hdr,
46
                inout metadata_t meta,
47
                inout standard_metadata_t std_meta) {
48
    state start {
49
        packet.extract(hdr.ethernet);
50
        transition select(hdr.ethernet.etherType) {
51
            0x0800: parse_ipv4;
52
            default: accept;
53
        }
54
    }
55

56
    state parse_ipv4 {
57
        packet.extract(hdr.ipv4);
58
        transition accept;
59
    }
60
}
61

62
// 6. 定义动作（Action）
63
action forward(bit<9> port) {
64
    std_meta.egress_spec = port;
65
}
66

67
action drop() {
68
    mark_to_drop(std_meta);
69
}
70

71
action set_dst_mac(bit<48> mac) {
72
    hdr.ethernet.dstAddr = mac;
73
}
74

75
// 7. 定义匹配动作表（Table）
76
table ipv4_lpm_table {
77
    key = {
78
        hdr.ipv4.dstAddr: lpm;   // 最长前缀匹配
79
    }
80
    actions = {
81
        forward;
82
        drop;
83
        set_dst_mac;
84
    }
85
    size = 1024;
86
    default_action = drop;
87
}
88

89
// 8. 定义控制流（Apply）
90
control MyIngress(inout headers_t hdr,
91
                  inout metadata_t meta,
92
                  inout standard_metadata_t std_meta) {
93
    apply {
94
        ipv4_lpm_table.apply();
95
    }
96
}
97

98
// 9. 定义重组器（Deparser）
99
control MyDeparser(packet_out packet,
100
                   in headers_t hdr) {
101
    apply {
102
        packet.emit(hdr.ethernet);
103
        packet.emit(hdr.ipv4);
104
    }
105
}
106

107
// 10. 实例化架构（V1Model）
108
V1Switch(MyParser(), MyIngress(), MyIngress(), MyDeparser()) main;

1
#include <core.p4>
2
#include <v1model.p4>
3

4
// ============================================
5
// L2 MAC 转发 P4 程序
6
// ============================================
7

8
header ethernet_t {
9
    bit<48> dstAddr;
10
    bit<48> srcAddr;
11
    bit<16> etherType;
12
}
13

14
struct metadata_t {
15
    bit<16> ingress_port;
16
}
17

18
struct headers_t {
19
    ethernet_t ethernet;
20
}
21

22
// ---- Parser ----
23
parser L2Parser(packet_in packet,
24
                out headers_t hdr,
25
                inout metadata_t meta,
26
                inout standard_metadata_t std_meta) {
27
    state start {
28
        packet.extract(hdr.ethernet);
29
        meta.ingress_port = std_meta.ingress_port;
30
        transition accept;
31
    }
32
}
33

34
// ---- Actions ----
35
// 转发到指定端口
36
action forward(bit<9> egress_port) {
37
    std_meta.egress_spec = egress_port;
38
}
39

40
// 丢弃
41
action drop() {
42
    mark_to_drop(std_meta);
43
}
44

45
// 学习源 MAC 地址（控制面通过 clone 完成）
46
action learn_src_mac() {
47
    // 触发 CPU 学习源 MAC → ingress_port 映射
48
    // 实际由控制面完成
49
    clone3(CloneType.I2E, 0, meta);
50
}
51

52
// ---- Tables ----
53
// 目的 MAC 查找表（精确匹配）
54
table dst_mac_table {
55
    key = {
56
        hdr.ethernet.dstAddr: exact;
57
    }
58
    actions = {
59
        forward;
60
        drop;
61
    }
62
    size = 4096;    // 支持 4K MAC 条目
63
    default_action = drop;
64
}
65

66
// ---- Ingress Control ----
67
control L2Ingress(inout headers_t hdr,
68
                  inout metadata_t meta,
69
                  inout standard_metadata_t std_meta) {
70
    apply {
71
        // 1. 学习源 MAC（首包触发 CPU 学习）
72
        learn_src_mac();
73

74
        // 2. 查找目的 MAC 转发表
75
        dst_mac_table.apply();
76
    }
77
}
78

79
// ---- Egress Control ----
80
control L2Egress(inout headers_t hdr,
81
                 inout metadata_t meta,
82
                 inout standard_metadata_t std_meta) {
83
    apply {
84
        // L2 转发不需要额外 egress 处理
85
    }
86
}
87

88
// ---- Deparser ----
89
control L2Deparser(packet_out packet,
90
                   in headers_t hdr) {
91
    apply {
92
        packet.emit(hdr.ethernet);
93
    }
94
}
95

96
// ---- Instantiation ----
97
V1Switch(L2Parser(), L2Ingress(), L2Egress(), L2Deparser()) main;

1
# 使用 P4Runtime 客户端下发规则示例
2
import p4runtime_pb2 as p4rt
3

4
# 添加一条 MAC 转发规则：dst MAC aa:bb:cc:dd:ee:ff → 端口 3
5
entry = p4rt.TableEntry()
6
entry.table_id = dst_mac_table_id
7
entry.match.append(
8
    p4rt.FieldMatch(
9
        field_id=1,  # dstAddr
10
        exact=p4rt.FieldMatch.Exact(
11
            value=b'\xaa\xbb\xcc\xdd\xee\xff'
12
        )
13
    )
14
)
15
entry.action.action_id = forward_action_id
16
entry.action.params.append(
17
    p4rt.Action.Param(
18
        param_id=1,  # egress_port
19
        value=b'\x00\x03'  # port 3
20
    )
21
)
22
client.Write(p4rt.WriteRequest(
23
    updates=[p4rt.Update(type=1, entity=p4rt.Entity(table_entry=entry))]
24
)

1
# 查看网卡的所有卸载能力
2
ethtool -k <interface>
3

4
# 重点关注以下卸载特性：
5
# tcp-segmentation-offload: on     # TSO
6
# generic-receive-offload: on      # GRO
7
# rx-checksumming: on              # RX 校验和卸载
8
# tx-checksumming: on              # TX 校验和卸载
9
# hw-tc-offload: on                # tc 硬件卸载（OVS 卸载必需）
10
# rx-vlan-offload: on              # VLAN 卸载
11
# tx-vlan-offload: on              # VLAN 卸载
12

13
# 启用/禁用特定卸载
14
sudo ethtool -K <interface> hw-tc-offload on
15
sudo ethtool -K <interface> tso on
16
sudo ethtool -K <interface> gro on
17

18
# 查看网卡统计（包括硬件卸载的统计）
19
ethtool -S <interface> | grep -i offload
20

21
# 查看 NVIDIA/Mellanox 网卡的加速统计
22
ethtool -S <interface> | grep -i "tc_offload\|rx_steer\|flow"

1
# ===== 环境准备 =====
2
# 确保网卡支持 hw-tc-offload
3
ethtool -k <interface> | grep hw-tc-offload
4

5
# 启用网卡的 tc 硬件卸载
6
sudo ethtool -K <interface> hw-tc-offload on
7

8
# ===== OVS 配置 =====
9
# 启用 OVS 硬件卸载
10
sudo ovs-vsctl set Open_vSwitch . other_config:hw-offload=true
11

12
# 重启 OVS 使配置生效
13
sudo systemctl restart openvswitch-switch
14

15
# 创建 OVS 网桥并添加端口
16
sudo ovs-vsctl add-br br0
17
sudo ovs-vsctl add-port br0 <interface>
18

19
# ===== 验证 =====
20
# 生成流量后，查看是否有规则被卸载到硬件
21
sudo ovs-dpctl dump-flows -m type=tc
22

23
# 输出示例（注意 offloaded:yes）：
24
# recirc_id(0),in_port(1),eth(src=aa:bb:cc:dd:ee:ff,dst=11:22:33:44:55:66),
25
# eth_type(0x0800),ipv4(src=10.0.0.1/0.0.0.0,dst=10.0.0.2/0.0.0.0,
26
# proto=6,tos=0/0,ttl=64,frag=no),tcp(src=12345/0,dst=80/0),
27
# packets=1000000,bytes=64000000,offloaded:yes,used:0.001s
28

29
# 查看硬件卸载统计
30
sudo ovs-dpctl show -s
31
# 关注 offloads 字段
32

33
# ===== 调试 =====
34
# 如果规则没有被卸载，检查 OVS 日志
35
sudo journalctl -u openvswitch-switch | grep -i offload
36

37
# 查看网卡上的 tc 规则
38
sudo tc filter show dev <interface> ingress
39

40
# 检查规则是否在硬件中
41
sudo tc -s filter show dev <interface> ingress
42
# 如果看到 "in hw" 标记，说明规则已卸载到硬件

1
# ===== 安装 P4 开发工具 =====
2
# 安装依赖
3
sudo apt install cmake g++ git automake libtool libboost-dev \
4
    libboost-filesystem-dev libboost-program-options-dev \
5
    libboost-system-dev libgrpc++-dev libprotobuf-dev \
6
    protobuf-compiler libgmp-dev libpcap-dev
7

8
# 编译安装 BMv2
9
git clone https://github.com/p4lang/behavioral-model.git
10
cd behavioral-model
11
git submodule update --init --recursive
12
./autogen.sh
13
./configure
14
make -j$(nproc)
15
sudo make install
16

17
# 编译安装 p4c（P4 编译器）
18
git clone https://github.com/p4lang/p4c.git
19
cd p4c
20
git submodule update --init --recursive
21
mkdir build && cd build
22
cmake ..
23
make -j$(nproc)
24
sudo make install
25

26
# ===== 编译 P4 程序 =====
27
# 编译 L2 转发程序为 BMv2 JSON
28
p4c --target bmv2 --arch v1model l2_forward.p4 -o l2_forward.json
29

30
# ===== 运行 BMv2 =====
31
# 启动 BMv2 交换机（简单交换机）
32
simple_switch --interface 0@veth0 --interface 1@veth1 \
33
    l2_forward.json &
34

35
# 使用 CLI 下发规则
36
simple_switch_CLI
37
# 在 CLI 中：
38
# table_add dst_mac_table forward aa:bb:cc:dd:ee:ff => 1
39
# table_add dst_mac_table forward 11:22:33:44:55:66 => 0
40

41
# ===== 发送测试流量 =====
42
# 在 veth0 上发送包
43
sudo python3 send_packet.py --interface veth0 \
44
    --src-mac aa:bb:cc:dd:ee:ff \
45
    --dst-mac 11:22:33:44:55:66
46

47
# 在 veth1 上抓包验证
48
sudo tcpdump -i veth1 -nn

1
# ===== 测试环境 =====
2
# 发送端：使用 pktgen-dpdk 或 MoonGen 生成流量
3
# 接收端：运行 OVS（分别测试软件转发和硬件卸载）
4

5
# ===== 软件转发基准 =====
6
# 禁用硬件卸载
7
sudo ovs-vsctl set Open_vSwitch . other_config:hw-offload=false
8
sudo systemctl restart openvswitch-switch
9

10
# 生成 64B 小包流量，测量吞吐量
11
# 预期：~2-5 Mpps（取决于 CPU 核心数和频率）
12

13
# 记录 CPU 使用率
14
mpstat -P ALL 1 10 > software_cpu.txt
15

16
# ===== 硬件卸载基准 =====
17
# 启用硬件卸载
18
sudo ovs-vsctl set Open_vSwitch . other_config:hw-offload=true
19
sudo systemctl restart openvswitch-switch
20

21
# 生成相同流量，测量吞吐量
22
# 预期：~50-100 Mpps（线速，取决于网卡型号）
23

24
# 记录 CPU 使用率
25
mpstat -P ALL 1 10 > hardware_cpu.txt
26

27
# ===== 对比分析 =====
28
# 对比两个场景的：
29
# 1. 吞吐量（Mpps）
30
# 2. CPU 使用率（%）
31
# 3. 延迟（P50/P99）
32
# 4. 功耗（如果可测量）
33

34
# 使用 dpdk-procinfo 查看硬件统计
35
dpdk-procinfo -- --stats