网络硬件相关知识

发表于 2021-01-01 更新于 2025-11-29 分类于 network

网络硬件相关知识

程序员很难有机会接触到底层的一些东西,尤其是偏硬件部分,所以记录下

光纤和普通网线的性能差异

以下都是在4.19内核的UOS，光纤交换机为锐捷，服务器是华为鲲鹏920的环境测试所得数据：

光纤稳定性好很多，平均rt是网线的三分之一，最大值则是网线的十分之一. 上述场景下光纤的带宽大约是网线的1.5倍. 实际光纤理论带宽一般都是万M, 网线是千M.

光纤接口：

单模光纤和多模光纤

下图绿色是多模光纤(Multi Mode Fiber),黄色是单模光纤(Single Mode Fiber), 因为光纤最好能和光模块匹配, 我们测试用的光模块都是多模的, 单模光纤线便宜,但是对应的光模块贵多了。

多模光模块工作波长为850nm，单模光模块工作波长为1310nm或1550nm, 从成本上来看，单模光模块所使用的设备多出多模光模块两倍，总体成本远高于多模光模块，但单模光模块的传输距离也要长于多模光模块，单模光模块最远传输距离为100km，多模光模块最远传输距离为2km。因单模光纤的传输原理为使光纤直射到中心，所以主要用作远距离数据传输，而多模光纤则为多通路传播模式，所以主要用于短距离数据传输。单模光模块适用于对距离和传输速率要求较高的大型网络中，多模光模块主要用于短途网路。

ping结果比较:

[aliyun@uos15 11:00 /home/aliyun]  以下88都是光口、89都是电口。
$ping -c 10 10.88.88.16 //光纤
PING 10.88.88.16 (10.88.88.16) 56(84) bytes of data.
64 bytes from 10.88.88.16: icmp_seq=1 ttl=64 time=0.058 ms
64 bytes from 10.88.88.16: icmp_seq=2 ttl=64 time=0.049 ms
64 bytes from 10.88.88.16: icmp_seq=3 ttl=64 time=0.053 ms
64 bytes from 10.88.88.16: icmp_seq=4 ttl=64 time=0.040 ms
64 bytes from 10.88.88.16: icmp_seq=5 ttl=64 time=0.053 ms
64 bytes from 10.88.88.16: icmp_seq=6 ttl=64 time=0.043 ms
64 bytes from 10.88.88.16: icmp_seq=7 ttl=64 time=0.038 ms
64 bytes from 10.88.88.16: icmp_seq=8 ttl=64 time=0.050 ms
64 bytes from 10.88.88.16: icmp_seq=9 ttl=64 time=0.043 ms
64 bytes from 10.88.88.16: icmp_seq=10 ttl=64 time=0.064 ms

--- 10.88.88.16 ping statistics ---
10 packets transmitted, 10 received, 0% packet loss, time 159ms
rtt min/avg/max/mdev = 0.038/0.049/0.064/0.008 ms

[aliyun@uos15 11:01 /home/aliyun]
$ping -c 10 10.88.89.16 //电口
PING 10.88.89.16 (10.88.89.16) 56(84) bytes of data.
64 bytes from 10.88.89.16: icmp_seq=1 ttl=64 time=0.087 ms
64 bytes from 10.88.89.16: icmp_seq=2 ttl=64 time=0.053 ms
64 bytes from 10.88.89.16: icmp_seq=3 ttl=64 time=0.095 ms
64 bytes from 10.88.89.16: icmp_seq=4 ttl=64 time=0.391 ms
64 bytes from 10.88.89.16: icmp_seq=5 ttl=64 time=0.051 ms
64 bytes from 10.88.89.16: icmp_seq=6 ttl=64 time=0.343 ms
64 bytes from 10.88.89.16: icmp_seq=7 ttl=64 time=0.045 ms
64 bytes from 10.88.89.16: icmp_seq=8 ttl=64 time=0.341 ms
64 bytes from 10.88.89.16: icmp_seq=9 ttl=64 time=0.054 ms
64 bytes from 10.88.89.16: icmp_seq=10 ttl=64 time=0.066 ms

--- 10.88.89.16 ping statistics ---
10 packets transmitted, 10 received, 0% packet loss, time 149ms
rtt min/avg/max/mdev = 0.045/0.152/0.391/0.136 ms

[aliyun@uos15 11:02 /u01]
$scp uos.tar aliyun@10.88.89.16:/tmp/
uos.tar                                  100% 3743MB 111.8MB/s   00:33    

[aliyun@uos15 11:03 /u01]
$scp uos.tar aliyun@10.88.88.16:/tmp/
uos.tar                                   100% 3743MB 178.7MB/s   00:20    

[aliyun@uos15 11:07 /u01]
$sudo ping -f 10.88.89.16
PING 10.88.89.16 (10.88.89.16) 56(84) bytes of data.
--- 10.88.89.16 ping statistics ---
284504 packets transmitted, 284504 received, 0% packet loss, time 702ms
rtt min/avg/max/mdev = 0.019/0.040/1.014/0.013 ms, ipg/ewma 0.048/0.042 ms

[aliyun@uos15 11:07 /u01]
$sudo ping -f 10.88.88.16
PING 10.88.88.16 (10.88.88.16) 56(84) bytes of data.
--- 10.88.88.16 ping statistics ---
299748 packets transmitted, 299748 received, 0% packet loss, time 242ms
rtt min/avg/max/mdev = 0.012/0.016/0.406/0.006 ms, pipe 2, ipg/ewma 0.034/0.014 ms

另外还要考虑网卡和光模块的带宽匹配，一般万兆网卡插上2.5万兆的光模块是无法联通的

多网卡bonding

#cat ifcfg-bond0
DEVICE=bond0
TYPE=Bond
ONBOOT=yes
BOOTPROTO=static
IPADDR=10.176.7.11
NETMASK=255.255.255.0

#cat /etc/sysconfig/network-scripts/ifcfg-eth0
DEVICE=eth0
TYPE=Ethernet
ONBOOT=yes
BOOTPROTO=none
MASTER=bond0
SLAVE=yes

#cat /etc/sysconfig/network-scripts/ifcfg-eth1
DEVICE=eth1
TYPE=Ethernet
ONBOOT=yes
BOOTPROTO=none
MASTER=bond0
SLAVE=yes

#cat /proc/net/bonding/bond0

----加载内核bonding模块, mode=0 是RR负载均衡模式
#cat /etc/modprobe.d/bonding.conf
# modprobe bonding
alias bond0 bonding
options bond0 mode=0 miimon=100  //这一行也可以放到bond0配置文件中,比如:BONDING_OPTS="miimon=100 mode=4 xmit_hash_policy=layer3+4" 用iperf 多连接测试bonding后的带宽发现，发送端能用上两张网卡，但是接收队列只能使用一张物理网卡

网卡绑定mode共有七种(0~6) bond0、bond1、bond2、bond3、bond4、bond5、bond6

常用的有三种

mode=0：平衡负载模式 (balance-rr)，有自动备援，两块物理网卡和bond网卡使用同一个mac地址，但需要”Switch”支援及设定。
mode=1：自动备援模式 (balance-backup)，其中一条线若断线，其他线路将会自动备援。
mode=6：平衡负载模式**(balance-alb)**，有自动备援，不必”Switch”支援及设定，两块网卡是使用不同的MAC地址
Mode 4 (802.3ad): This mode creates aggregation groups that share the same speed and duplex settings, and it requires a switch that supports an IEEE 802.3ad dynamic link. Mode 4 uses all interfaces in the active aggregation group. For example, you can aggregate three 1 GB per second (GBPS) ports into a 3 GBPS trunk port. This is equivalent to having one interface with 3 GBPS speed. It provides fault tolerance and load balancing.

需要说明的是如果想做成mode 0的负载均衡,仅仅设置这里options bond0 miimon=100 mode=0是不够的,与网卡相连的交换机必须做特殊配置（这两个端口应该采取聚合方式），因为做bonding的这两块网卡是使用同一个MAC地址.从原理分析一下（bond运行在mode 0下）：

mode 0下bond所绑定的网卡的IP都被修改成相同的mac地址，如果这些网卡都被接在同一个交换机，那么交换机的arp表里这个mac地址对应的端口就有多个，那么交换机接受到发往这个mac地址的包应该往哪个端口转发呢？正常情况下mac地址是全球唯一的，一个mac地址对应多个端口肯定使交换机迷惑了。所以 mode0下的bond如果连接到交换机，交换机这几个端口应该采取聚合方式（cisco称为 ethernetchannel，foundry称为portgroup），因为交换机做了聚合后，聚合下的几个端口也被捆绑成一个mac地址.我们的解决办法是，两个网卡接入不同的交换机即可。

mode6模式下无需配置交换机，因为做bonding的这两块网卡是使用不同的MAC地址。

mod=5，即：(balance-tlb) Adaptive transmit load balancing（适配器传输负载均衡）

特点：不需要任何特别的switch(交换机)支持的通道bonding。在每个slave上根据当前的负载（根据速度计算）分配外出流量。如果正在接受数据的slave出故障了，另一个slave接管失败的slave的MAC地址。

该模式的必要条件：ethtool支持获取每个slave的速率.

案例，两块万兆bonding后带宽翻倍

#ethtool bond0
Settings for bond0:
	Supported ports: [ ]
	Supported link modes:   Not reported
	Supported pause frame use: No
	Supports auto-negotiation: No
	Advertised link modes:  Not reported
	Advertised pause frame use: No
	Advertised auto-negotiation: No
	Speed: 20000Mb/s
	Duplex: Full
	Port: Other
	PHYAD: 0
	Transceiver: internal
	Auto-negotiation: off
	Link detected: yes

[root@phy 16:55 /root]
#cat /etc/sysconfig/network-scripts/ifcfg-bond0
DEVICE=bond0
BOOTPROTO=static
TYPE="ethernet"
IPADDR=100.1.1.2
NETMASK=255.255.255.192
ONBOOT=yes
USERCTL=no
PEERDNS=no
BONDING_OPTS="miimon=100 mode=4 xmit_hash_policy=layer3+4"

#cat /etc/modprobe.d/bonding.conf
alias netdev-bond0 bonding

#lsmod |grep bond
bonding               137339  0

#cat ifcfg-bond0
DEVICE=bond0
BOOTPROTO=static
TYPE="ethernet"
IPADDR=100.81.131.221
NETMASK=255.255.255.192
ONBOOT=yes
USERCTL=no
PEERDNS=no
BONDING_OPTS="miimon=100 mode=4 xmit_hash_policy=layer3+4"

#cat ifcfg-eth1
DEVICE=eth1
TYPE="Ethernet"
HWADDR=7C:D3:0A:E0:F7:81
BOOTPROTO=none
ONBOOT=yes
MASTER=bond0
SLAVE=yes
PEERDNS=no
RX_MAX=`ethtool -g "$DEVICE" | grep 'Pre-set' -A1 | awk '/RX/{print $2}'`
RX_CURRENT=`ethtool -g "$DEVICE" | grep "Current" -A1 | awk '/RX/{print $2}'`
[[ "$RX_CURRENT" -lt "$RX_MAX" ]] && ethtool -G "$DEVICE" rx "$RX_MAX"

网络中断和绑核

网络包的描述符的内存（RingBuffer）跟着设备走（设备在哪个Die/Node上，就近分配内存），数据缓冲区（Data Buffer–存放网络包）内存跟着队列(中断)走，如果队列绑定到DIE0，而设备在die1上，这样在做DMA通信时，会产生跨die的交织访问。

不管设备插在哪一个die上，只要描述符申请的内存和数据缓冲区的内存都在同一个die上（需要修改驱动源代码–非常规），就能避免跨die内存交织，性能能保持一致。

irqbalance服务不会将中断进行跨node迁移，只会在同一numa node中进行优化。

ethtool

#ethtool -i p1p1   //查询网卡bus-info
driver: mlx5_core
version: 5.0-0
firmware-version: 14.27.1016 (MT_2420110004)
expansion-rom-version:
bus-info: 0000:21:00.0
supports-statistics: yes
supports-test: yes
supports-eeprom-access: no
supports-register-dump: no
supports-priv-flags: yes

//根据bus-info找到中断id
#cat /proc/interrupts | grep 0000:21:00.0 | awk -F: '{print $1}' | wc -l

//修改网卡队列数
sudo ethtool -L eth0  combined 2 （不能超过网卡最大队列数）

然后检查是否生效了(不需要重启应用和机器，实时生效)：
sudo ethtool -l eth0

根据网卡bus-info可以找到对应的irq id

手工绑核脚本:

#!/bin/bash
#irq_list=(`cat /proc/interrupts | grep enp131s0 | awk -F: '{print $1}'`)
intf=$1
irq_list=(cat /proc/interrupts | grep `ethtool -i $intf |grep bus-info | awk  '{ print $2 }'` | awk -F: '{print $1}')
cpunum=48  # 修改为所在node的第一个Core
for irq in ${irq_list[@]}
do
echo $cpunum > /proc/irq/$irq/smp_affinity_list
echo `cat /proc/irq/$irq/smp_affinity_list`
(( cpunum+=1 ))
done

检查绑定结果: sh irqCheck.sh enp131s0

# 网卡名
intf=$1
irqID=`ethtool -i $intf |grep bus-info | awk  '{ print $2 }'`
log=irqSet-`date "+%Y%m%d-%H%M%S"`.log
# 可用的CPU数
cpuNum=$(cat /proc/cpuinfo |grep processor -c)
# RX TX中断列表
irqListRx=$(cat /proc/interrupts | grep ${irqID} | awk -F':' '{print $1}')
irqListTx=$(cat /proc/interrupts | grep ${irqID} | awk -F':' '{print $1}')
# 绑定接收中断rx irq
for irqRX in ${irqListRx[@]}
do
cat /proc/irq/${irqRX}/smp_affinity_list
done
# 绑定发送中断tx irq
for irqTX in ${irqListTx[@]}
do
cat /proc/irq/${irqTX}/smp_affinity_list
done

中断联合（Coalescing）

中断联合可供我们推迟向内核通告新事件的操作，将多个事件汇总在一个中断中通知内核。该功能的当前设置可通过ethtool -c查看：

$ ethtool -c eth0
Coalesce parameters for eth0:
...
rx-usecs: 50
tx-usecs: 50

此处可以设置固定上限，对每内核每秒处理中断数量的最大值进行硬性限制，或针对特定硬件根据吞吐率自动调整中断速率。

启用联合（使用 -C）会增大延迟并可能导致丢包，因此对延迟敏感的工作可能需要避免这样做。另外，彻底禁用该功能可能导致中断受到节流限制，进而影响性能。

多次在nginx场景下测试未发现这个值对TPS有什么明显的改善

How to achieve low latency with 10Gbps Ethernet 中有提到 Linux 3.11 added support for the SO_BUSY_POLL socket option. 也有类似的作用

irqbalance

irqbalance 是一个命令行工具，在处理器中分配硬件中断以提高系统性能。默认设置下在后台程序运行，但只可通过 --oneshot 选项运行一次。

以下参数可用于提高性能。

–powerthresh

CPU 进入节能模式之前，设定可空闲的 CPU 数量。如果有大于阀值数量的 CPU 是大于一个标准的偏差，该差值低于平均软中断工作负载，以及没有 CPU 是大于一个标准偏差，且该偏差高出平均，并有多于一个的 irq 分配给它们，一个 CPU 将处于节能模式。在节能模式中，CPU 不是 irqbalance 的一部分，所以它在有必要时才会被唤醒。
–hintpolicy

决定如何解决 irq 内核关联提示。有效值为 exact（总是应用 irq 关联提示）、subset （irq 是平衡的，但分配的对象是关联提示的子集）、或者 ignore（irq 完全被忽略）。
–policyscript

通过设备路径、当作参数的irq号码以及 irqbalance 预期的零退出代码，定义脚本位置以执行每个中断请求。定义的脚本能指定零或多键值对来指导管理传递的 irq 中 irqbalance。下列是为效键值对：ban有效值为 true（从平衡中排除传递的 irq）或 false（该 irq 表现平衡）。balance_level允许用户重写传递的 irq 平衡度。默认设置下，平衡度基于拥有 irq 设备的 PCI 设备种类。有效值为 none、package、cache、或 core。numa_node允许用户重写视作为本地传送 irq 的 NUMA 节点。如果本地节点的信息没有限定于 ACPI ，则设备被视作与所有节点距离相等。有效值为识别特定 NUMA 节点的整数（从0开始）和 -1，规定 irq 应被视作与所有节点距离相等。
–banirq

将带有指定中断请求号码的中断添加至禁止中断的列表。

也可以使用 IRQBALANCE_BANNED_CPUS 环境变量来指定被 irqbalance 忽略的 CPU 掩码。

//默认irqbalance绑定一个numa, -1指定多个numa
echo -1 >/sys/bus/pci/devices/`ethtool -i p1p1 |grep bus-info | awk  '{ print $2 }'`/numa_node ; 
// 目录 /sys/class/net/p1p1/ link到了 /sys/bus/pci/devices/`ethtool -i p1p1 |grep bus-info | awk  '{ print $2 }'` 

执行 irqbalance --debug 进行调试

irqbalance指定core

cat /etc/sysconfig/irqbalance
# IRQBALANCE_BANNED_CPUS
# 64 bit bitmask which allows you to indicate which cpu's should
# be skipped when reblancing irqs. Cpu numbers which have their
# corresponding bits set to one in this mask will not have any
# irq's assigned to them on rebalance
#绑定软中断到8-15core, 每位表示4core
#IRQBALANCE_BANNED_CPUS=ffffffff,ffff00ff
#绑定软中断到8-15core和第65core
IRQBALANCE_BANNED_CPUS=ffffffff,fffffdff,ffffffff,ffff00ff

#96core 鲲鹏920下绑前16core
IRQBALANCE_BANNED_CPUS=ffffffff,ffffffff,ffff0000

irqbalance的流程

初始化的过程只是建立链表的过程，暂不描述，只考虑正常运行状态时的流程
-处理间隔是10s
-清除所有中断的负载值
-/proc/interrupts读取中断，并记录中断数
-/proc/stat读取每个cpu的负载，并依次计算每个层次每个节点的负载以及每个中断的负载
-通过平衡算法找出需要重新分配的中断
-把需要重新分配的中断加入到新的节点中
-配置smp_affinity使处理生效

irqbalance服务不会将中断进行跨node迁移，只会在同一numa node中进行优化。

网卡软中断以及内存远近的测试结论

一般网卡中断会占用一些CPU，如果把网卡中断挪到其它node的core上，在鲲鹏920上测试（网卡插在node0上），业务跑在node3，网卡中断分别在node0和node3，QPS分别是：179000 VS 175000

如果将业务跑在node0上，网卡中断分别在node0和node1上得到的QPS分别是：204000 VS 212000

以上测试的时候业务进程分配的内存全限制在node0上

#/root/numa-maps-summary.pl </proc/123853/numa_maps
N0        :      5085548 ( 19.40 GB)
N1        :         4479 (  0.02 GB)
N2        :            1 (  0.00 GB)
active    :            0 (  0.00 GB)
anon      :      5085455 ( 19.40 GB)
dirty     :      5085455 ( 19.40 GB)
kernelpagesize_kB:         2176 (  0.01 GB)
mapmax    :          348 (  0.00 GB)
mapped    :         4626 (  0.02 GB)

从以上测试数据可以看到在这个内存分布场景下，如果就近访问内存性能有20%以上的提升

一般默认申请的data buffer也都在设备所在的numa节点上**，如果将队列的中断绑定到其他cpu上，那么**队列申请的data buffer的节点也会跟着中断迁移。

阿里云绑核脚本

通常情况下，Linux的网卡中断是由一个CPU核心来处理的，当承担高流量的场景下，会出现一些诡异的情况（网卡尚未达到瓶颈，但是却出现丢包的情况）

这种时候，我们最好看下网卡中断是不是缺少调优。

优化3要点：网卡多队列+irq affinity亲缘性设置+关闭irqbalance (systemctl stop irqbalance)

目前阿里云官方提供的centos和ubuntu镜像里面，已经自带了优化脚本，内容如下:

centos7的脚本路径在 /usr/sbin/ecs_mq_rps_rfs 具体内容如下：

#!/bin/bash
# This is the default setting of networking multiqueue and irq affinity
# 1. enable multiqueue if available
# 2. irq affinity optimization
# 3. stop irqbalance service
# set and check multiqueue

function set_check_multiqueue()
{
    eth=$1
    log_file=$2
    queue_num=$(ethtool -l $eth | grep -ia5 'pre-set' | grep -i combined | awk {'print $2'})
    if [ $queue_num -gt 1 ]; then
        # set multiqueue
        ethtool -L $eth combined $queue_num
        # check multiqueue setting
        cur_q_num=$(ethtool -l $eth | grep -iA5 current | grep -i combined | awk {'print $2'})
        if [ "X$queue_num" != "X$cur_q_num" ]; then
            echo "Failed to set $eth queue size to $queue_num" >> $log_file
            echo "after setting, pre-set queue num: $queue_num , current: $cur_q_num" >> $log_file
            return 1
        else
            echo "OK. set $eth queue size to $queue_num" >> $log_file
        fi
    else
        echo "only support $queue_num queue; no need to enable multiqueue on $eth" >> $log_file
    fi
}

#set irq affinity
function set_irq_smpaffinity()
{
    log_file=$1
    node_dir=/sys/devices/system/node
    for i in $(ls -d $node_dir/node*); do
        i=${i/*node/}
    done
    
    echo "max node :$i" >> $log_file
    node_cpumax=$(cat /sys/devices/system/node/node${i}/cpulist |awk -F- '{print $NF}')
    irqs=($(cat /proc/interrupts |grep virtio |grep put | awk -F: '{print $1}'))
    core=0
    for irq in ${irqs[@]};do
        VEC=$core
        if [ $VEC -ge 32 ];then
            let "IDX = $VEC / 32"
            MASK_FILL=""
            MASK_ZERO="00000000"
            for ((i=1; i<=$IDX;i++))
                do
                    MASK_FILL="${MASK_FILL},${MASK_ZERO}"
                done
            let "VEC -= 32 * $IDX"
            MASK_TMP=$((1<<$VEC))
            MASK=$(printf "%X%s" $MASK_TMP $MASK_FILL)
        else
            MASK_TMP=$((1<<$VEC))
            MASK=$(printf "%X" $MASK_TMP)
        fi
        echo $MASK > /proc/irq/$irq/smp_affinity
        echo "mask:$MASK, irq:$irq" >> $log_file
        core=$(((core+1)%(node_cpumax+1)))
    done
}

# stop irqbalance service
function stop_irqblance()
{
    log_file=$1
    ret=0
    if [ "X" != "X$(ps -ef | grep irqbalance | grep -v grep)" ]; then
        if which systemctl;then
            systemctl stop irqbalance
        else
            service irqbalance stop
        fi
        if [ $? -ne 0 ]; then
            echo "Failed to stop irqbalance" >> $log_file
            ret=1
        fi
    else
       echo "OK. irqbalance stoped." >> $log_file
    fi
    return $ret
}
# main logic
function main()
{
    ecs_network_log=/var/log/ecs_network_optimization.log
    ret_value=0
    echo "running $0" > $ecs_network_log
    echo "========  ECS network setting starts $(date +'%Y-%m-%d %H:%M:%S') ========" >> $ecs_network_log
    # we assume your NIC interface(s) is/are like eth*
    eth_dirs=$(ls -d /sys/class/net/eth*)
    if [ "X$eth_dirs" = "X" ]; then
        echo "ERROR! can not find any ethX in /sys/class/net/ dir." >> $ecs_network_log
        ret_value=1
    fi
    for i in $eth_dirs
    do
        cur_eth=$(basename $i)
        echo "optimize network performance: current device $cur_eth" >> $ecs_network_log
        # only optimize virtio_net device
        driver=$(basename $(readlink $i/device/driver))
        if ! echo $driver | grep -q virtio; then
            echo "ignore device $cur_eth with driver $driver" >> $ecs_network_log
            continue
        fi
        echo "set and check multiqueue on $cur_eth" >> $ecs_network_log
        set_check_multiqueue $cur_eth $ecs_network_log
        if [ $? -ne 0 ]; then
            echo "Failed to set multiqueue on $cur_eth" >> $ecs_network_log
            ret_value=1
        fi
    done
    stop_irqblance  $ecs_network_log
    set_irq_smpaffinity $ecs_network_log
    echo "========  ECS network setting END $(date +'%Y-%m-%d %H:%M:%S')  ========" >> $ecs_network_log
    return $ret_value
}


# program starts here
main
exit $?

查询的rps绑定情况的脚本 get_rps.sh

#!/bin/bash
# 获取当前rps情况
for i in $(ls /sys/class/net/eth0/queues/rx-*/rps_cpus); do 
  echo $i
  cat $i
done

RSS 和 RPS

RSS：即receive side steering,利用网卡的多队列特性，将每个核分别跟网卡的一个首发队列绑定，以达到网卡硬中断和软中断均衡的负载在各个CPU上。他要求网卡必须要支持多队列特性。
RPS：receive packet steering，他把收到的packet依据一定的hash规则给hash到不同的CPU上去，以达到各个CPU负载均衡的目的。他只是把软中断做负载均衡，不去改变硬中断。因而对网卡没有任何要求。
RFS：receive flow steering，RFS需要依赖于RPS，他跟RPS不同的是不再简单的依据packet来做hash，而是根据flow的特性，即application在哪个核上来运行去做hash，从而使得有更好的数据局部性。

RSS

设置 RPS，首先内核要开启CONFIG_RPS编译选项，然后设置需要将中断分配到哪些CPU：

1 2	#cat /sys/class/net/eth3/queues/rx-[0-7]/rps_cpus #cat /sys/class/net/eth3/queues/tx-[0-7]/xps_cpus

我们可以看到很多案例，使用这些特性后提醒了网络包的处理能力，从而提升QPS，降低RT。

如上图所示，数据包在进入内核IP/TCP协议栈之前，经历了这些步骤：

网口（NIC）收到packets
网口通过DMA（Direct memeory access）将数据写入到内存（RAM）中。
网口通过RSS（网卡多队列）将收到的数据包分发给某个rx队列，并触发该队列所绑定核上的CPU中断。
收到中断的核，调用该核所在的内核软中断线程（softirqd）进行后续处理。
softirqd负责将数据包从RAM中取到内核中。
如果开启了RPS，RPS会选择一个目标cpu核来处理该包，如果目标核非当前正在运行的核，则会触发目标核的IPI（处理器之间中断），并将数据包放在目标核的backlog队列中。
软中断线程将数据包（数据包可能来源于第5步、或第6步），通过gro(generic receive offload，如果开启的话)等处理后，送往IP协议栈，及之后的TCP/UDP等协议栈。

查看网卡和numa的关系

#yum install lshw -y
#lshw -C network -short
H/W path               Device          Class      Description
=============================================================
/0/100/0/9/0           eth0            network    MT27710 Family [ConnectX-4 Lx]
/0/100/0/9/0.1         eth1            network    MT27710 Family [ConnectX-4 Lx]
/1                     e41358fae4ee_h  network    Ethernet interface
/2                     86b0637ef1e1_h  network    Ethernet interface
/3                     a6706e785f53_h  network    Ethernet interface
/4                     d351290e50a0_h  network    Ethernet interface
/5                     1a9e5df98dd1_h  network    Ethernet interface
/6                     766ec0dab599_h  network    Ethernet interface
/7                     bond0.11        network    Ethernet interface
/8                     ea004888c217_h  network    Ethernet interface

以及：

1
2
3

lscpu | grep -i numa
numactl --hardware
cat /proc/interrupts | egrep -i "CPU|rx"

Check if the network interfaces are tied to Numa (if -1 means not tied, if 0, then to numa0):

1	cat /sys/class/net/eth0/device/numa_node

You can see which NAMA the network card belongs to, for example, using lstopo:

yum install hwloc -y
lstopo
lstopo --logical
lstopo --logical --output-format png > lstopo.png

--
[root@hygon3 10:58 /root]  //hygon 7280 CPU
#lstopo --logical
Machine (503GB total)               //总内存大小
  NUMANode L#0 (P#0 252GB)          //socket0、numa0 的内存大小
    Package L#0
      L3 L#0 (8192KB)               //L3 cache，对应4个物理core，8个HT
        L2 L#0 (512KB) + L1d L#0 (32KB) + L1i L#0 (64KB) + Core L#0 // L1/L2
          PU L#0 (P#0)
          PU L#1 (P#64)
        L2 L#1 (512KB) + L1d L#1 (32KB) + L1i L#1 (64KB) + Core L#1
          PU L#2 (P#1)
          PU L#3 (P#65)
        L2 L#2 (512KB) + L1d L#2 (32KB) + L1i L#2 (64KB) + Core L#2
          PU L#4 (P#2)
          PU L#5 (P#66)
        L2 L#3 (512KB) + L1d L#3 (32KB) + L1i L#3 (64KB) + Core L#3
          PU L#6 (P#3)
          PU L#7 (P#67)
      L3 L#1 (8192KB)
      L3 L#2 (8192KB)
      L3 L#3 (8192KB)
      L3 L#4 (8192KB)
      L3 L#5 (8192KB)
      L3 L#6 (8192KB)
      L3 L#7 (8192KB)
    HostBridge L#0
      PCIBridge
        PCIBridge
          PCI 1a03:2000
            GPU L#0 "controlD64"
            GPU L#1 "card0"
      PCIBridge
        PCI 1d94:7901
          Block(Disk) L#2 "sdm"   //ssd系统盘，接在Node0上，绑核有优势
    HostBridge L#4
      PCIBridge
        PCI 1000:0097
      PCIBridge
        PCI 1c5f:000d
      PCIBridge
        PCI 1c5f:000d
    HostBridge L#8
      PCIBridge
        PCI 15b3:1015
          Net L#3 "p1p1"      //万兆网卡接在Node0上
        PCI 15b3:1015
          Net L#4 "p1p2"
    HostBridge L#10
      PCIBridge
        PCI 8086:1521
          Net L#5 "em1"       //千兆网卡接在Node0上
        PCI 8086:1521
          Net L#6 "em2"
  NUMANode L#1 (P#1 251GB)    //另外一个socket
    Package L#1
      L3 L#8 (8192KB)
        L2 L#32 (512KB) + L1d L#32 (32KB) + L1i L#32 (64KB) + Core L#32
        
----------- FT2500 两路共128core
#lstopo-no-graphics --logical
Machine (503GB total)
  Package L#0 + L3 L#0 (64MB)
    NUMANode L#0 (P#0 31GB)
      L2 L#0 (2048KB)         //4个物理core共享2M 
        L1d L#0 (32KB) + L1i L#0 (32KB) + Core L#0 + PU L#0 (P#0)
        L1d L#1 (32KB) + L1i L#1 (32KB) + Core L#1 + PU L#1 (P#1)
        L1d L#2 (32KB) + L1i L#2 (32KB) + Core L#2 + PU L#2 (P#2)
        L1d L#3 (32KB) + L1i L#3 (32KB) + Core L#3 + PU L#3 (P#3)
      L2 L#1 (2048KB)
        L1d L#4 (32KB) + L1i L#4 (32KB) + Core L#4 + PU L#4 (P#4)
        L1d L#5 (32KB) + L1i L#5 (32KB) + Core L#5 + PU L#5 (P#5)
        L1d L#6 (32KB) + L1i L#6 (32KB) + Core L#6 + PU L#6 (P#6)
        L1d L#7 (32KB) + L1i L#7 (32KB) + Core L#7 + PU L#7 (P#7)
      HostBridge L#0
        PCIBridge
          PCIBridge
            PCIBridge
              PCI 1000:00ac
                Block(Disk) L#0 "sdh"
                Block(Disk) L#1 "sdf"  // 磁盘挂在Node0上
            PCIBridge
              PCI 8086:1521
                Net L#13 "eth0"
              PCI 8086:1521
                Net L#14 "eth1"       //网卡挂在node0上
        PCIBridge
          PCIBridge
            PCI 1a03:2000
              GPU L#15 "controlD64"
              GPU L#16 "card0"
    NUMANode L#1 (P#1 31GB)
    NUMANode L#2 (P#2 31GB)
    NUMANode L#3 (P#3 31GB)
    NUMANode L#4 (P#4 31GB)
    NUMANode L#5 (P#5 31GB)
    NUMANode L#6 (P#6 31GB)
    NUMANode L#7 (P#7 31GB)
      L2 L#14 (2048KB)
        L1d L#56 (32KB) + L1i L#56 (32KB) + Core L#56 + PU L#56 (P#56)
        L1d L#57 (32KB) + L1i L#57 (32KB) + Core L#57 + PU L#57 (P#57)
        L1d L#58 (32KB) + L1i L#58 (32KB) + Core L#58 + PU L#58 (P#58)
        L1d L#59 (32KB) + L1i L#59 (32KB) + Core L#59 + PU L#59 (P#59)
      L2 L#15 (2048KB)
        L1d L#60 (32KB) + L1i L#60 (32KB) + Core L#60 + PU L#60 (P#60)
        L1d L#61 (32KB) + L1i L#61 (32KB) + Core L#61 + PU L#61 (P#61)
        L1d L#62 (32KB) + L1i L#62 (32KB) + Core L#62 + PU L#62 (P#62)
        L1d L#63 (32KB) + L1i L#63 (32KB) + Core L#63 + PU L#63 (P#63)
  Package L#1 + L3 L#1 (64MB)   //socket2
    NUMANode L#8 (P#8 31GB)
      L2 L#16 (2048KB)
        L1d L#64 (32KB) + L1i L#64 (32KB) + Core L#64 + PU L#64 (P#64)
        L1d L#65 (32KB) + L1i L#65 (32KB) + Core L#65 + PU L#65 (P#65)
        L1d L#66 (32KB) + L1i L#66 (32KB) + Core L#66 + PU L#66 (P#66)
        L1d L#67 (32KB) + L1i L#67 (32KB) + Core L#67 + PU L#67 (P#67)
      L2 L#17 (2048KB)
        L1d L#68 (32KB) + L1i L#68 (32KB) + Core L#68 + PU L#68 (P#68)
        L1d L#69 (32KB) + L1i L#69 (32KB) + Core L#69 + PU L#69 (P#69)
        L1d L#70 (32KB) + L1i L#70 (32KB) + Core L#70 + PU L#70 (P#70)
        L1d L#71 (32KB) + L1i L#71 (32KB) + Core L#71 + PU L#71 (P#71)
      HostBridge L#7
        PCIBridge
          PCIBridge
            PCIBridge
              PCI 15b3:1015
                Net L#17 "eth2"   //node8 上的网卡，eth2、eth3做了bonding
              PCI 15b3:1015
                Net L#18 "eth3"
            PCIBridge
              PCI 144d:a808
            PCIBridge
              PCI 144d:a808
              
 ---鲲鹏920 每路48core 2路共4node，网卡插在node0，磁盘插在node2
 #lstopo-no-graphics
Machine (755GB total)
  Package L#0
    NUMANode L#0 (P#0 188GB)
      L3 L#0 (24MB)
        L2 L#0 (512KB) + L1d L#0 (64KB) + L1i L#0 (64KB) + Core L#0 + PU L#0 (P#0)
        L2 L#1 (512KB) + L1d L#1 (64KB) + L1i L#1 (64KB) + Core L#1 + PU L#1 (P#1)
        L2 L#22 (512KB) + L1d L#22 (64KB) + L1i L#22 (64KB) + Core L#22 + PU L#22 (P#22)
        L2 L#23 (512KB) + L1d L#23 (64KB) + L1i L#23 (64KB) + Core L#23 + PU L#23 (P#23)
      HostBridge L#0
        PCIBridge
          PCI 15b3:1017
            Net L#0 "enp2s0f0"
          PCI 15b3:1017
            Net L#1 "eth1"
        PCIBridge
          PCI 19e5:1711
            GPU L#2 "controlD64"
            GPU L#3 "card0"
      HostBridge L#3
        2 x { PCI 19e5:a230 }
        PCI 19e5:a235
          Block(Disk) L#4 "sda"
      HostBridge L#4
        PCIBridge
          PCI 19e5:a222
            Net L#5 "enp125s0f0"
          PCI 19e5:a221
            Net L#6 "enp125s0f1"
          PCI 19e5:a222
            Net L#7 "enp125s0f2"
          PCI 19e5:a221
            Net L#8 "enp125s0f3"
    NUMANode L#1 (P#1 189GB) + L3 L#1 (24MB)
      L2 L#24 (512KB) + L1d L#24 (64KB) + L1i L#24 (64KB) + Core L#24 + PU L#24 (P#24)
  Package L#1
    NUMANode L#2 (P#2 189GB)
      L3 L#2 (24MB)
        L2 L#48 (512KB) + L1d L#48 (64KB) + L1i L#48 (64KB) + Core L#48 + PU L#48 (P#48)
      HostBridge L#6
        PCIBridge
          PCI 19e5:3714
        PCIBridge
          PCI 19e5:3714
        PCIBridge
          PCI 19e5:3714
        PCIBridge
          PCI 19e5:3714
      HostBridge L#11
        PCI 19e5:a230
        PCI 19e5:a235
        PCI 19e5:a230
    NUMANode L#3 (P#3 189GB) + L3 L#3 (24MB)
      L2 L#72 (512KB) + L1d L#72 (64KB) + L1i L#72 (64KB) + Core L#72 + PU L#72 (P#72)
  Misc(MemoryModule)

如果cpu core太多, interrupts 没法看的话，通过cut只看其中一部分core

1	cat /proc/interrupts \| grep -i 'eth4\\|CPU' \| cut -c -8,865-995,1425-

lspci

#lspci -s 21:00.0 -vvv
21:00.0 Ethernet controller: Mellanox Technologies MT27710 Family [ConnectX-4 Lx]
	Subsystem: Mellanox Technologies ConnectX-4 Lx Stand-up dual-port 10GbE MCX4121A-XCAT
	Control: I/O- Mem+ BusMaster+ SpecCycle- MemWINV- VGASnoop- ParErr+ Stepping- SERR+ FastB2B- DisINTx+
	Status: Cap+ 66MHz- UDF- FastB2B- ParErr- DEVSEL=fast >TAbort- <TAbort- <MAbort- >SERR- <PERR- INTx-
	Latency: 0, Cache Line Size: 64 bytes
	Interrupt: pin A routed to IRQ 105
	Region 0: Memory at 3249c000000 (64-bit, prefetchable) [size=32M]
	Expansion ROM at db300000 [disabled] [size=1M]
	Capabilities: [60] Express (v2) Endpoint, MSI 00
		DevCap:	MaxPayload 512 bytes, PhantFunc 0, Latency L0s unlimited, L1 unlimited
			ExtTag+ AttnBtn- AttnInd- PwrInd- RBE+ FLReset+ SlotPowerLimit 0.000W
		DevCtl:	CorrErr+ NonFatalErr+ FatalErr+ UnsupReq-
			RlxdOrd+ ExtTag+ PhantFunc- AuxPwr- NoSnoop+ FLReset-
			MaxPayload 512 bytes, MaxReadReq 512 bytes
		DevSta:	CorrErr+ NonFatalErr- FatalErr- UnsupReq+ AuxPwr- TransPend-
		LnkCap:	Port #0, Speed 8GT/s, Width x8, ASPM not supported
			ClockPM- Surprise- LLActRep- BwNot- ASPMOptComp+
		LnkCtl:	ASPM Disabled; RCB 64 bytes Disabled- CommClk+
			ExtSynch- ClockPM- AutWidDis- BWInt- AutBWInt-
		LnkSta:	Speed 8GT/s (ok), Width x8 (ok)
			TrErr- Train- SlotClk+ DLActive- BWMgmt- ABWMgmt-
		DevCap2: Completion Timeout: Range ABC, TimeoutDis+, LTR-, OBFF Not Supported
			 AtomicOpsCap: 32bit- 64bit- 128bitCAS-
		DevCtl2: Completion Timeout: 50us to 50ms, TimeoutDis-, LTR-, OBFF Disabled
			 AtomicOpsCtl: ReqEn-
		LnkCtl2: Target Link Speed: 8GT/s, EnterCompliance- SpeedDis-
			 Transmit Margin: Normal Operating Range, EnterModifiedCompliance- ComplianceSOS-
			 Compliance De-emphasis: -6dB
		LnkSta2: Current De-emphasis Level: -6dB, EqualizationComplete+, EqualizationPhase1+
			 EqualizationPhase2+, EqualizationPhase3+, LinkEqualizationRequest-
	Capabilities: [48] Vital Product Data
		Product Name: CX4121A - ConnectX-4 LX SFP28
		Read-only fields:
			[PN] Part number: MCX4121A-XCAT
			[EC] Engineering changes: AJ
			[SN] Serial number: MT2031J09199
			[V0] Vendor specific: PCIeGen3 x8
			[RV] Reserved: checksum good, 0 byte(s) reserved
		End
	Capabilities: [9c] MSI-X: Enable+ Count=64 Masked-
		Vector table: BAR=0 offset=00002000
		PBA: BAR=0 offset=00003000
	Capabilities: [c0] Vendor Specific Information: Len=18 <?>
	Capabilities: [40] Power Management version 3
		Flags: PMEClk- DSI- D1- D2- AuxCurrent=375mA PME(D0-,D1-,D2-,D3hot-,D3cold+)
		Status: D0 NoSoftRst+ PME-Enable- DSel=0 DScale=0 PME-
	Capabilities: [100 v1] Advanced Error Reporting
		UESta:	DLP- SDES- TLP- FCP- CmpltTO- CmpltAbrt- UnxCmplt- RxOF- MalfTLP- ECRC- UnsupReq- ACSViol-
		UEMsk:	DLP- SDES- TLP- FCP- CmpltTO- CmpltAbrt- UnxCmplt- RxOF- MalfTLP- ECRC- UnsupReq- ACSViol-
		UESvrt:	DLP+ SDES- TLP- FCP+ CmpltTO- CmpltAbrt- UnxCmplt- RxOF+ MalfTLP+ ECRC+ UnsupReq- ACSViol-
		CESta:	RxErr- BadTLP- BadDLLP- Rollover- Timeout- AdvNonFatalErr-
		CEMsk:	RxErr- BadTLP- BadDLLP- Rollover- Timeout- AdvNonFatalErr+
		AERCap:	First Error Pointer: 04, ECRCGenCap+ ECRCGenEn+ ECRCChkCap+ ECRCChkEn+
			MultHdrRecCap- MultHdrRecEn- TLPPfxPres- HdrLogCap-
		HeaderLog: 00000000 00000000 00000000 00000000
	Capabilities: [150 v1] Alternative Routing-ID Interpretation (ARI)
		ARICap:	MFVC- ACS-, Next Function: 1
		ARICtl:	MFVC- ACS-, Function Group: 0
	Capabilities: [180 v1] Single Root I/O Virtualization (SR-IOV)
		IOVCap:	Migration-, Interrupt Message Number: 000
		IOVCtl:	Enable- Migration- Interrupt- MSE- ARIHierarchy+
		IOVSta:	Migration-
		Initial VFs: 8, Total VFs: 8, Number of VFs: 0, Function Dependency Link: 00
		VF offset: 2, stride: 1, Device ID: 1016
		Supported Page Size: 000007ff, System Page Size: 00000001
		Region 0: Memory at 000003249e800000 (64-bit, prefetchable)
		VF Migration: offset: 00000000, BIR: 0
	Capabilities: [1c0 v1] Secondary PCI Express <?>
	Capabilities: [230 v1] Access Control Services
		ACSCap:	SrcValid- TransBlk- ReqRedir- CmpltRedir- UpstreamFwd- EgressCtrl- DirectTrans-
		ACSCtl:	SrcValid- TransBlk- ReqRedir- CmpltRedir- UpstreamFwd- EgressCtrl- DirectTrans-
	Kernel driver in use: mlx5_core
	Kernel modules: mlx5_core

如果有多个高速设备争夺带宽（例如将高速网络连接到高速存储），那么 PCIe 也可能成为瓶颈，因此可能需要从物理上将 PCIe 设备划分给不同 CPU，以获得最高吞吐率。

数据来源： https://en.wikipedia.org/wiki/PCI_Express#History_and_revisions

Intel 认为，有时候 PCIe 电源管理（ASPM）可能导致延迟提高，因进而导致丢包率增高。因此也可以为内核命令行参数添加pcie_aspm=off将其禁用。

Default 路由持久化

通过 ip route 可以添加默认路由，但是reboot就丢失了

1	route add default dev bond0

如果要持久化，在centos下可以创建 /etc/sysconfig/network-scripts/route-bond0 文件，内容如下

default dev bond0    ---默认路由，后面的可以省略
10.0.0.0/8 via 11.158.239.247 dev bond0
11.0.0.0/8 via 11.158.239.247 dev bond0
30.0.0.0/8 via 11.158.239.247 dev bond0
172.16.0.0/12 via 11.158.239.247 dev bond0
192.168.0.0/16 via 11.158.239.247 dev bond0
100.64.0.0/10 via 11.158.239.247 dev bond0
33.0.0.0/8 via 11.158.239.247 dev bond0

或者用sed在文件第一行添加

1 2	sed -i '/default /d' /etc/sysconfig/network-scripts/route-bond0 //先删除默认路由（如果有） sed -i '1 i\default dev bond0' /etc/sysconfig/network-scripts/route-bond0 //添加

Centos 7的话需要在 /etc/sysconfig/network 中添加创建默认路由的命令

1
2
3

# cat /etc/sysconfig/network
# Created by anaconda
ip route add default dev eth0

内核态启动并加载网卡的逻辑

运行Linux的机器在BIOS阶段之后，机器的boot loader根据我们预先定义好的配置文件，将intrd和linux kernel加载到内存。这个包含initrd和linux kernel的配置文件通常在/boot分区（从grub.conf中读取参数）
内核启动，运行当前根目录下面的init进程，init进程再运行其他必要的进程，其中跟网卡PCI设备相关的一个进程，就是udevd进程，udevd负责根据内核pci scan的pci设备，从initrd这个临时的根文件系统中加载内核模块，对于网卡来说，就是网卡驱动。(对应systemd-udevd 服务)
udevd，根据内核pci device scan出来的pci device，通过netlink消息机制通知udevd加载相应的内核驱动，其中，网卡驱动就是在这个阶段加载，如果initrd临时文件系统里面有这个网卡的驱动文件。通常upstream到linux内核的驱动，比如ixgbe，或者和内核一起编译的网卡驱动，会默认包含在initrd文件系统中。这些跟内核一起ship的网卡驱动会在这个阶段加载
udevd除了负责网卡驱动加载之外，还要负责为网卡命名。udevd在为网卡命名的时候，会首先check “/etc/udev/rules.d/“下的rule，如果hit到相应的rule，就会通过rule里面指定的binary为网卡命名。如果/etc/udev/rules.d/没有命名成功网卡，那么udevd会使用/usr/lib/udev/rule.d下面的rule，为网卡重命名。其中rule的文件经常以数字开头，数字越小，表示改rule的优先级越高。intrd init不会初始化network服务，所以/etc/sysconfig/network-scripts下面的诸如bond0，route的配置都不会生效。（内核启动先是 intrd init，然后执行一次真正的init）
在完成网卡driver load和name命名之后，initrd里面的init进程，会重启其他用户态进程，如udevd等，并且重新mount真正的根文件系统，启动network service。
重启udevd，会触发一次kernel的rescan device。这样第三方安装的网卡driver，由于其driver模块没有在initrd里面，会在这个阶段由udevd触发加载。同时，也会根据“/etc/udev/rules.d/”和“/usr/lib/udev/rule.d”的rule，重命名网卡设备。–用户态修改网卡名字的机会
1
2
kernel: ixgbe 0000:3b:00.1 eth1: renamed from enp59s0f1
kernel: i40e 0000:88:00.0 eth7: renamed from enp136s0

同时network service 会启动，进而遍历etc/sysconfig/network-scripts下面的脚本，我们配置的bond0，默认路由，通常会在这个阶段运行，创建

kernel: bond0: Enslaving eth0 as a backup interface with a down link
kernel: ixgbe 0000:3b:00.0 eth0: detected SFP+: 5
kernel: power_meter ACPI000D:00: Found ACPI power meter.
kernel: power_meter ACPI000D:00: Ignoring unsafe software power cap!
kernel: ixgbe 0000:3b:00.1: registered PHC device on eth1
kernel: ixgbe 0000:3b:00.0 eth0: NIC Link is Up 10 Gbps, Flow Control: RX/TX
kernel: bond0: Enslaving eth1 as a backup interface with a down link
kernel: bond0: Warning: No 802.3ad response from the link partner for any adapters in the bond
kernel: bond0: link status definitely up for interface eth0, 10000 Mbps full duplex
kernel: bond0: first active interface up!

由于我们系统的初始化有两个阶段，udevd会运行两次，所以内核态网卡driver的加载，网卡命名也有两次机会。

第一次网卡driver的加载和命名是在initrd运行阶段，这个阶段由于initrd文件系统比较小，只包括和kernel一起ship的内核module，所以这个阶段只能加载initrd里面有的内核模块。网卡的重命名也只能重命名加载了驱动的网卡。

第二个网卡driver的加载和命名，是在真正根文件系统加载后，内核再一次pci scan，这个时候，由于真的根文件系统包含了所有的driver，第一个阶段无法probe的网卡会在这个阶段probe，重命名也会在这个阶段进行。

内核默认命名规则有一定的局限性，往往不一定准确对应网卡接口的物理顺序，而且每次启动只根据内核发现网卡的顺序进行命名，因此并不固定；所以目前一般情况下会在用户态启用其他的方式去更改网卡名称，原则就是在内核命名ethx后将其在根据用户态的规则rename为其他的名字，这种规则往往是根据网卡的Mac地址以及其他能够唯一代表一块网卡的参数去命名，因此会一一对应；

内核自带的网卡驱动在initrd中的内核模块中。对于第三方网卡，我们通常通过rpm包的方式安装。这种第三方安装的rpm，通常不会在initrd里面，只存在disk上。这样这种内核模块就只会在第二次udevd启动的时候被加载。

不论第一次重命名还是第二次重命名，其都遵循一样的逻辑，也就是先check /etc/udev/rules.d/的rule，然后check /usr/lib/udev/rule.d中的rule，其中rule的优先级etc下最高，然后是usr下面。并且，rule的文件名中的数字表示该rule在同一文件夹中的优先级，数字越低，优先级越高。

network.service 根据network-script里面的脚本创建bond0，下发路由。这个过程和网卡重命名是同步进行，一般网卡重命名会超级快，单极端情况下重命名可能在network.service后会导致创建bond0失败（依赖网卡名来bonding），这里会依赖network.service retry机制来反复尝试确保network服务能启动成功

要想解决网卡加载慢的问题，可以考虑把安装后的网卡集成到initrd中。Linux系统提供的dracut可以做到这一点，我们只需要在安装完第三方网卡驱动后，执行：

dracut --forace

查看
udevadm info -q all -a /dev/nvme0

就可以解决这个问题，该命令会根据最新的内存中的module，重新下刷initrd。

其实在多数第三方网卡的rpm spec或者makefile里面通常也会加入这种强制重刷的逻辑，确保内核驱动在initrd里面，从而加快网卡驱动的加载。

用户态命名网卡流程

CentOS 7提供了在网络接口中使用一致且可预期的网络设备命名方法，目前默认使用的是net.ifnames规则。The device name procedure in detail is as follows:

A rule in /usr/lib/udev/rules.d/60-net.rules instructs the udev helper utility, /lib/udev/rename_device, to look into all /etc/sysconfig/network-scripts/ifcfg-*suffix* files. If it finds an ifcfg file with a HWADDR entry matching the MAC address of an interface it renames the interface to the name given in the ifcfg file by the DEVICE directive.（根据提前定义好的ifcfg-网卡名来命名网卡–依赖mac匹配，如果网卡的ifconfig文件中未加入HWADDR，则rename脚本并不会根据配置文件去重命名网卡）
A rule in /usr/lib/udev/rules.d/71-biosdevname.rules instructs biosdevname to rename the interface according to its naming policy, provided that it was not renamed in a previous step, biosdevname is installed, and biosdevname=0 was not given as a kernel command on the boot command line.
A rule in /lib/udev/rules.d/75-net-description.rules instructs udev to fill in the internal udev device property values ID_NET_NAME_ONBOARD, ID_NET_NAME_SLOT, ID_NET_NAME_PATH, ID_NET_NAME_MAC by examining the network interface device. Note, that some device properties might be undefined.
A rule in /usr/lib/udev/rules.d/80-net-name-slot.rules instructs udev to rename the interface, provided that it was not renamed in step 1 or 2, and the kernel parameter net.ifnames=0 was not given, according to the following priority: ID_NET_NAME_ONBOARD, ID_NET_NAME_SLOT, ID_NET_NAME_PATH. It falls through to the next in the list, if one is unset. If none of these are set, then the interface will not be renamed.

Steps 3 and 4 are implementing the naming schemes 1, 2, 3, and optionally 4, described in Section 11.1, “Naming Schemes Hierarchy”. Step 2 is explained in more detail in Section 11.6, “Consistent Network Device Naming Using biosdevname”.

以上重命名简要概述就是对于CentOS系统，一般有下面几个rule在/usr/lib/udev/rule.d来重命名网卡：

/usr/lib/udev/rules.d/60-net.rules 文件中的规则会让 udev 帮助工具/lib/udev/rename_device 查看所有 /etc/sysconfig/network-scripts/ifcfg-* 文件。如果发现包含 HWADDR 条目的 ifcfg 文件与某个接口的 MAC 地址匹配，它会将该接口重命名为ifcfg 文件中由 DEVICE 指令给出的名称。rename条件：如果网卡的ifconfig文件中未加入HWADDR，则rename脚本并不会根据配置文件去重命名网卡；
/usr/lib/udev/rules.d/71-biosdevname.rules 中的规则让 biosdevname 根据其命名策略重命名该接口，即在上一步中没有重命名该接口、安装biosdevname、且在 boot 命令行中将biosdevname=0 作为内核命令给出。（bisodevname规则，从CentOS 7 开始默认不使用，所以该条规则在不配置的情况下失效，直接去执行3；默认在cmdline中bisodevname=0，如果需要启用，则需要设置bisodevname=1）
/lib/udev/rules.d/75-net-description.rules 中的规则让 udev 通过检查网络接口设备，填写内部 udev 设备属性值 ID_NET_NAME_ONBOARD、ID_NET_NAME_SLOT、ID_NET_NAME_PATH、ID_NET_NAME_MAC。注：有些设备属性可能处于未定义状态。 –没有修改网卡名，只是取到了命名需要的一些属性值。查看：udevadm info -p /sys/class/net/enp125s0f0
/usr/lib/udev/rules.d/80-net-name-slot.rules 中的规则让 udev 重命名该接口，优先顺序如下：ID_NET_NAME_ONBOARD、ID_NET_NAME_SLOT、ID_NET_NAME_PATH。并提供如下信息：没有在步骤 1 或 2 中重命名该接口，同时未给出内核参数 net.ifnames=0。如果一个参数未设定，则会按列表的顺序设定下一个。如果没有设定任何参数，则不会重命名该接口 —- 目前主流CentOS流都是这个命名方式
network service起来后会遍历/etc/sysconfig/network-scripts下的脚本，配置bond0、默认路由、其它网卡等

其中60 rule会调用rename_device根据ifcfg-xxx脚本来命名，rule 71调用biosdevname来命名网卡。以上规则数字越小优先级越高，高优先级生效后跳过低优先级

总的来说网卡命名规则：grub启动参数 -> /etc/udev/rules.d/的rule -> /usr/lib/udev/rule.d

参考：

The following is an excerpt from Chapter 11 of the RHEL 7 “Networking Guide”:

Scheme 1: Names incorporating Firmware or BIOS provided index numbers for on-board devices (example: eno1), are applied if that information from the firmware or BIOS is applicable and available, else falling back to scheme 2.
Scheme 2: Names incorporating Firmware or BIOS provided PCI Express hotplug slot index numbers (example: ens1) are applied if that information from the firmware or BIOS is applicable and available, else falling back to scheme 3.
Scheme 3: Names incorporating physical location of the connector of the hardware (example: enp2s0), are applied if applicable, else falling directly back to scheme 5 in all other cases.
Scheme 4: Names incorporating interface’s MAC address (example: enx78e7d1ea46da), is not used by default, but is available if the user chooses.
Scheme 5: The traditional unpredictable kernel naming scheme, is used if all other methods fail (example: eth0).

网卡命名

最开始Linux对网卡的命名规范是 eth* , 后来随着PCIe插槽的普及开始有 eno/enp等命名

eno1: 代表由主板bios内置的网卡
Ens: 代表有主板bios内置的PCI-E网卡
Enp2s0: PCI-E独立网卡
Eth0: 如果以上都不使用回到默认的网卡名

En 代笔：ethernet

第3个字符根据设备类型选择

o<index>           on-board device index number
s<slot>            hotplug slot index number
x<MAC>             MAC address
p<bus>s<slot>      PCI geographical location
p<bus>s<slot>      USB port number chain

默认安装网卡所在位置来命名（enp131s0 等），按位置命名实例如下：

//name example  ---默认方式，按照 /usr/lib/udev/rules.d/80-net-name-slot.rules 来命名
enp4s10f1                        pci 0000:04:0a.1
| | |  |                                |  |  | |
| | |  |                   domain <- 0000  |  | |
| | |  |                                   |  | |
en| |  |  --> ethernet                     |  | |
  | |  |                                   |  | |
  p4|  |  --> prefix/bus number (4)   <-- 04  | |
    |  |                                      | |
    s10|  --> slot/device number (10) <--    10 |
       |                                        |
       f1 --> function number (1)     <--       1

可以关掉这种按位置命名的方式，在grub参数中添加： net.ifnames=0 biosdevname=0，关闭后默认命名方式是eth**，开启biosdevname=1后，默认网卡命名方式是p1p1/p1p2(麒麟默认开启；alios默认关闭，然后以eth来命名)

You have two options (as described in the new RHEL 7 Networking Guide) to disable the new naming scheme:

Run once: ln -s /dev/null /etc/udev/rules.d/80-net-name-slot.rules

or

Run once: echo 'GRUB_CMDLINE_LINUX="net.ifnames=0"' >>/etc/default/grub

Note that the biosdevname package is not installed by default, so unless it gets installed, you don’t need to add biosdevname=0 as a kernel argument.

也可以添加命名规则在 /etc/udev/rules.d/ 下(这种优先级挺高），比如

cat /etc/udev/rules.d/70-persistent-net.rules
# PCI device 21:00.0 (ixgbe)
SUBSYSTEM=="net", ACTION=="add", DRIVERS=="?*", ATTR{address}=="d4:5d:64:bb:06:32", PROGRAM="/lib/udev/rename_device", ATTR{type}=="1", KERNEL=="eth*", NAME="eth0"
# PCI device 0x8086:0x105e (e1000e)
SUBSYSTEM=="net", ACTION=="add", DRIVERS=="?*", ATTR{address}=="b8:59:9f:2d:48:2b", PROGRAM="/lib/udev/rename_device", ATTR{type}=="1", KERNEL=="eth*", NAME="eth1"

但是以上规则在麒麟下没有生效

网卡重命名方式：

1	/sbin/ip link set eth1 name eth123

校验

比如如下结构下因为通过xdp redirect来联通veth0、veth1，两边能ping通，但是TCP、UDP 都不通

正常走bridge ping/tcp/udp是不会有问题的, 这也是docker下常见用法

当前主流的网卡（包括虚拟网卡，如veth/tap）都支持一个叫做RX/TX Checksum Offload（RX和TX对应接收和发送两个方向）的特性，用于将传输层协议的校验和计算卸载到网卡硬件中（IP头的检验和会被操作系统用软件方式正确计算）。对于经过启用该功能的网卡的报文，操作系统不会对该报文进行校验和的计算，从而减少对系统CPU资源的占用。

1613803162582-ce09e9cc-36e4-4805-b968-98d8dd601f52

对于没有挂载XDP程序的且开启Checksum Offload功能的Veth设备，在接收到数据包时，会将ip_summed置为CHECKSUM_UNNECESSARY，因此上层L4协议栈在收到该数据包的时候不会再检查校验和，即使是数据包的校验和不正确也会正常被处理。但是若我们在veth设备上挂载了XDP程序，XDP程序运行时将网卡接收队列中的数据转换为结构struct xdp_buff时会丢失掉ip_summed信息，这就导致数据包被L4协议栈接收后由于校验和错误而被丢弃。

如上图因为veth挂载了XDP程序，导致包没有校验信息而丢掉，如果在同样环境下ping是可以通的，因为ping包提前计算好了正确的校验和

这种丢包可以通过 /proc/net/snmp 看到

通过命令ethtool -K <nic-name> tx off工具关闭Checksum Offload特性，强行让操作系统用软件方式计算校验和。

日志

网卡日志打开：

sysctl -w net.ipv4.conf.all.log_martians=1 //所有网卡
sysctl -w net.ipv4.conf.p1p1.log_martians=1 //特定网卡

/proc/sys/net/ipv4/conf/eth0.9/log_martians

/var/log/messages中：

messages-20120101:Dec 31 09:25:45 nixcraft-router kernel: martian source 74.xx.47.yy from 10.13.106.25, on dev eth1

修改mac地址

1
2
3

sudo ip link set dev eth1 down
sudo ip link set dev eth1 address e8:61:1f:33:c5:fd
sudo ip link set dev eth1 up

参考资料

高斯在鲲鹏下跑TPCC的优化

https://www.cyberciti.biz/faq/linux-log-suspicious-martian-packets-un-routable-source-addresses/

鲲鹏性能优化十板斧

如何用1分钱建站速度秒杀三大门户网站站

发表于 2021-01-01 更新于 2025-11-29 分类于技巧

如何用1分钱建站速度秒杀三大门户网站

如何快速又便宜地建立一个高质量的网站呢(高质量指的是访问速度快)，还能够双站热备(国内国外热备两份内容)，整个开支大概一分钱吧

核心就是用阿里云的OSS来提供高速的访问。

先看访问速度

同样是访问下面三个网站首页:

OSS托管，页面大小 96.6MB、242个GET，耗时2.21秒加载，价格不到1分钱

搜狐首页，页面大小16.6MB、555个GET，耗时3.6秒

新浪首页，页面大小17.8MB、404个GET，耗时9.63秒

OSS托管的网站

用OSS托管的网站加载速度，96MB页面（很大了）2.21秒加载完毕

访问搜狐首页

访问新浪首页

原因分析

OSS快的原因是：小网站并发不高，服务器、带宽资源充足，还不用花钱，没有机器、带宽维护成本以及人员成本

有专业的阿里云工程师负责运维，给的是最好的服务器、最大的带宽（你用的少就不用花钱，带宽资源费用超级便宜）

到底有多便宜呢？1.6万次GET请求才1分钱，0.52GB流量才0.25元，计价金额单位震惊我了

OSS托管网站方案

将所有内容静态化，然后上传到OSS就可以了

发布操作步骤：

markdown编辑器中编写要发布的页面
用hexo静态化全站（将markdown转换成html页面）
git commit到github或者ossutil 同步到aliyun oss中

比如下面就是我的网站发布脚本：

#静态化网站，并同步到github，多活；-d 表示 deploy
hexo g -d

#sync all pages to oss
ossutil --config-file=~/src/script/mac/.ossutilconfig sync ./public/ oss://mysite/ -u --output-dir=/tmp/

实际我的网站通过github和OSS都能访问到，内容完全一样，github免费，但是多图页面速度太慢, 比如我一个页面几十个图，github加载偶尔失败, 但是我把图片放到了OSS，因为OSS超级快这样github加载也变得超级快了。

hexo是一个node实现的网站生成工具

oss 托管网站介绍

感叹一下，个人建站现在真的是又便宜又方便，只是域名实名制恶心了点，那就干脆不要域名了。

update 20241120: 阿里云 OSS关闭了默认域名的静态托管，也就是会强制下载而不是在浏览器里展示静态页面：https://help.aliyun.com/zh/oss/user-guide/how-to-ensure-an-object-is-previewed-when-you-access-the-object，除非你绑定自己的域名

一些问题

themes/next

github page 当个人网站，main 分支对应源码，master 分支对应静态化后的页面，如果 main 分支 generate 静态页面都是空的，请注意 themes/next 文件夹内容要完整

#ls themes/next
LICENSE              _config.yml.bak      package.json
README.en.md         bower.json           scripts
README.md            gulpfile.coffee      source
_config-20200519.yml languages            test
_config.yml          layout

版本搭配

当前测试如下版本搭配能正常 generate 静态页面，如何这个 3.9 的 hexo 搭配 node 14/20 都会 generate 空页面，需要进一步升级 hexo 版本测试搭配更高的 node 版本

✗ hexo -v
hexo: 3.9.0
hexo-cli: 4.3.2
os: darwin 23.4.0 14.4.1

node: 12.22.12
v8: 7.8.279.23-node.57
uv: 1.40.0
zlib: 1.2.11
brotli: 1.0.9
ares: 1.18.1
modules: 72
nghttp2: 1.41.0
napi: 8
llhttp: 2.1.4
http_parser: 2.9.4
openssl: 1.1.1n
cldr: 37.0
icu: 67.1
tz: 2021a4
unicode: 13.0

//保持如下 link 才会使用 hexo 3.9，以及 3.9 依赖的 node 版本
/opt/homebrew/bin/hexo -> /opt/homebrew/lib/node_modules/hexo-cli/bin/hexo

升级 hexo 到 7.3 失败

hugo

更快，一来更少，所以问题更少

theme：DoIt

配置：https://niceram.xyz/2021/03/04/20210304_1125/

theme 配置：https://blog.csdiy.org/2023/02/23/depoly-hugo-theme-doit/

一个有意思的问题

发表于 2020-12-25 更新于 2026-02-06 分类于 Linux

一个有意思的问题

问题描述

$mysql -N -h127.0.0.1 -e "select id from sbtest1 limit 1"
+--------+
| 100024 |
+--------+

$mysql -N -h127.0.0.1 -e "select id from sbtest1 limit 1" | cat
100024

$mysql -t -N -h127.0.0.1 -e "select id from sbtest1 limit 1" | cat
+--------+
| 100024 |
+--------+

如上第一和第二个语句，为什么mysql client的输出重定向后就没有ascii制表符了呢？

语句三加上 -t后再经过管道，也有制表符了。

stackoverflow上也有很多人有同样的疑问，不过没有给出第三行的解法，更没有人讲清楚这个里面的原理。所以接下来我们来分析下这是为什么

-N 去掉表头

-B batch 模式，用tab键替换分隔符

分析

strace看看第一个语句：

再对比下第二个语句的strace：

从上面两个strace比较来看，似乎mysql client 能检测到要输出到命名管道（S_IFIFO ）还是character device（S_IFCHR），如果是命名管道的话就不要输出制表符了，如果是character device那么就输出ascii制表符。

fstats里面对不同输出目标的说明：

printf("File type:                ");
   switch (sb.st_mode & S_IFMT) {
    case S_IFBLK:  printf("block device\n");            break;
    case S_IFCHR:  printf("character device\n");        break;
    case S_IFDIR:  printf("directory\n");               break;
    case S_IFIFO:  printf("FIFO/pipe\n");               break;
    case S_IFLNK:  printf("symlink\n");                 break;
    case S_IFREG:  printf("regular file\n");            break;
    case S_IFSOCK: printf("socket\n");                  break;
    default:       printf("unknown?\n");                break;
    }

第4行和第6行两个类型就是导致mysql client选择了不同的输出内容

误解

所以这个问题不是：

为什么mysql client的输出重定向后就没有ascii制表符了呢？

而是：

mysql client 可以检测到不同的输出目标然后输出不同的内容吗？ 管道或者重定向是一个应用能感知的输出目标吗？

误解：觉得管道写在后面，mysql client不应该知道后面是管道，mysql client输出内容到stdout，然后os将stdout的内容重定向给管道。

实际上mysql是可以检测（detect）输出目标的，如果是管道类的非交互输出那么没必要徒增一些制表符；如果是交互式界面那么就输出一些制表符好看一些。

要是想想在Unix下一切皆文件就更好理解了，输出到管道这个管道也是个文件，所以mysql client是可以感知各种输出文件的属性的。

背后的实现大概是这样：

#include <stdio.h>
#include <io.h>
...    
if (isatty(fileno(stdout)))
    printf( "stdout is a terminal\n" );      // 输出制表符
else
    printf( "stdout is a file or a pipe\n"); // 不输出制表符

isatty的解释

结论就是 mysql client根据输出目标的不同（stdout、重定向）输出不同的内容，不过这种做法对用户体感上不是太好。

2026年大模型秒了这个问题

MySQL 客户端会检测输出是否为终端（TTY）：

输出到终端：使用 ASCII 制表符格式化，便于人类阅读
输出到管道/文件：自动切换为 tab 分隔的纯文本格式，便于程序处理

这是 MySQL 客户端的智能行为，类似于 ls 命令在终端显示多列，重定向后变成单列。

其它

Linux管道居然不是按顺序，而是并发执行的：https://unix.stackexchange.com/questions/37508/in-what-order-do-piped-commands-run 掉坑里了，并发问题就多了，实际测试也发现跑几千次 ps |grep 会出现，ps看不到后面的grep进程

参考资料

https://www.pyrosoft.co.uk/blog/2014/09/08/how-to-stop-mysql-ascii-tables-column-separators-from-being-lost-when-redirecting-bash-output/

https://www.oreilly.com/library/view/mysql-cookbook/0596001452/ch01s22.html

到底一台服务器上最多能创建多少个TCP连接

发表于 2020-11-30 更新于 2025-11-16 分类于 TCP

到底一台服务器上最多能创建多少个TCP连接

经常听到有同学说一台机器最多能创建65535个TCP连接，这其实是错误的理解，为什么会有这个错误的理解呢？

port range

我们都知道linux下本地随机端口范围由参数控制，也就是listen、connect时候如果没有指定本地端口，那么就从下面的port range 中随机取一个可用的

1 2	# cat /proc/sys/net/ipv4/ip_local_port_range 2000 65535

port range的上限是65535，所以也经常看到这个误解：一台机器上最多能创建65535个TCP连接

到底一台机器上最多能创建多少个TCP连接

先说结论：在内存、文件句柄足够的话可以创建的连接是没有限制的（每个TCP连接至少要消耗一个文件句柄）。

那么/proc/sys/net/ipv4/ip_local_port_range指定的端口范围到底是什么意思呢？

核心规则：一个TCP连接只要保证四元组(src-ip src-port dest-ip dest-port)唯一就可以了，而不是要求src port唯一

后面所讲都遵循这个规则，所以在心里反复默念：四元组唯一 五个大字，就能分析出来到底能创建多少TCP连接了。

比如如下这个机器上的TCP连接实际状态：

# netstat -ant |grep 18089
tcp        0      0 192.168.1.79:18089      192.168.1.79:22         ESTABLISHED
tcp        0      0 192.168.1.79:18089      192.168.1.79:18080      ESTABLISHED
tcp        0      0 192.168.0.79:18089      192.168.0.79:22         TIME_WAIT 
tcp        0      0 192.168.1.79:22         192.168.1.79:18089      ESTABLISHED
tcp        0      0 192.168.1.79:18080      192.168.1.79:18089      ESTABLISHED

从前三行可以清楚地看到18089被用了三次，第一第二行src-ip、dest-ip也是重复的，但是dest port不一样，第三行的src-port还是18089，但是src-ip变了。他们的四元组均不相同。

所以一台机器能创建的TCP连接是没有限制的，而ip_local_port_range是指没有bind的时候OS随机分配端口的范围，但是分配到的端口要同时满足五元组唯一，这样 ip_local_port_range 限制的是连同一个目标（dest-ip和dest-port一样）的port的数量（请忽略本地多网卡的情况，因为dest-ip为以后route只会选用一个本地ip）。

**那么为什么大家有这样的误解呢？**我总结了下，大概是以下两个原因让大家误解了：

如果是listen服务，那么肯定端口不能重复使用，这样就跟我们的误解对应上了，一个服务器上最多能监听65535个端口。比如nginx监听了80端口，那么tomcat就没法再监听80端口了，这里的80端口只能监听一次。
另外如果我们要连的server只有一个，比如：1.1.1.1:80 ，同时本机只有一个ip的话，那么这个时候即使直接调connect 也只能创建出65535个连接，因为四元组中的三个是固定的了。

我们在创建连接前，经常会先调bind，bind后可以调 listen当做服务端监听，也可以直接调connect当做client来连服务端。

bind(ip,port=0) 的时候是让系统绑定到某个网卡和自动分配的端口，此时系统没有办法确定接这个socket 是要去connect还是listen. 如果是listen的话，那么肯定是不能出现端口冲突的(得local port 唯一)，如果是connect的话，只要满足4元组唯一即可。在这种情况下，系统只能尽可能满足更强的要求，就是先要求端口不能冲突，即使之后去connect的时候四元组是唯一的。

比如 Nginx HaProxy envoy这些软件在创建到upstream的连接时，都会用 bind(0) 的方式, 导致到不同目的的连接无法复用同一个src port，这样后端的最大连接数受限于local_port_range。 nginx的修改 http://hg.nginx.org/nginx/rev/2c7b488a61fb

Linux 4.2后的内核增加了IP_BIND_ADDRESS_NO_PORT 这个socket option来解决这个问题，将src port的选择延后到connect的时候

IP_BIND_ADDRESS_NO_PORT (since Linux 4.2)
Inform the kernel to not reserve an ephemeral port when using bind(2) with a port number of 0. The port will later be automatically chosen at connect(2) time, in a way that allows sharing a source port as long as the 4-tuple is unique.

但如果我只是个client端，只需要连接server建立连接，也就不需要bind，直接调connect就可以了，这个时候只要保证四元组唯一就行。

bind()的时候内核是还不知道四元组的，只知道src_ip、src_port，所以这个时候单网卡下src_port是没法重复的，但是connect()的时候已经知道了四元组的全部信息，所以只要保证四元组唯一就可以了，那么这里的src_port完全是可以重复使用的。

是不是加上了 SO_REUSEADDR、SO_REUSEPORT 就能重用端口了呢？

TCP SO_REUSEADDR

文档描述：

SO_REUSEADDR Indicates that the rules used in validating addresses supplied in a bind(2) call should allow reuse of local addresses. For AF_INET sockets this means that a socket may bind, except when there is an active listening socket bound to the address. When the listening socket is bound to INADDR_ANY with a specific port then it is not possible to bind to this port for any local address. Argument is an integer boolean flag.

从这段文档中我们可以知道三个事：

使用这个参数后，bind操作是可以重复使用local address的，注意，这里说的是local address，即ip加端口组成的本地地址，如果机器有两个本地ip，那么任意ip或端口部分不一样，它们本身就是可以共存的，不需要使用这个参数。
当local address被一个处于listen状态的socket使用时，加上该参数也不能重用这个地址。
当处于listen状态的socket监听的本地地址的ip部分是INADDR_ANY，即表示监听本地的所有ip，即使使用这个参数，也不能再bind包含这个端口的任意本地地址，这个和 2 中描述的其实是一样的。

==SO_REUSEADDR 可以用本地相同的(sip, sport) 去连connect 远程的不同的（dip、dport）//而 SO_REUSEPORT主要是解决Server端的port重用==

SO_REUSEADDR 还可以重用TIME_WAIT状态的port, 在程序崩溃后之前的TCP连接会进入到TIME_WAIT状态，需要一段时间才能释放，如果立即重启就会抛出Address Already in use的错误导致启动失败。这时候可以通过在调用bind函数之前设置SO_REUSEADDR来解决。

What exactly does SO_REUSEADDR do?

This socket option tells the kernel that even if this port is busy (in the TIME_WAIT state), go ahead and reuse it anyway. If it is busy, but with another state, you will still get an address already in use error. It is useful if your server has been shut down, and then restarted right away while sockets are still active on its port. You should be aware that if any unexpected data comes in, it may confuse your server, but while this is possible, it is not likely.

It has been pointed out that “A socket is a 5 tuple (proto, local addr, local port, remote addr, remote port). SO_REUSEADDR just says that you can reuse local addresses. The 5 tuple still must be unique!” This is true, and this is why it is very unlikely that unexpected data will ever be seen by your server. The danger is that such a 5 tuple is still floating around on the net, and while it is bouncing around, a new connection from the same client, on the same system, happens to get the same remote port.

By setting SO_REUSEADDR user informs the kernel of an intention to share the bound port with anyone else, but only if it doesn’t cause a conflict on the protocol layer. There are at least three situations when this flag is useful:

Normally after binding to a port and stopping a server it’s neccesary to wait for a socket to time out before another server can bind to the same port. With SO_REUSEADDR set it’s possible to rebind immediately, even if the socket is in a TIME_WAIT state.
When one server binds to INADDR_ANY, say 0.0.0.0:1234, it’s impossible to have another server binding to a specific address like 192.168.1.21:1234. With SO_REUSEADDR flag this behaviour is allowed.
When using the bind before connect trick only a single connection can use a single outgoing source port. With this flag, it’s possible for many connections to reuse the same source port, given that they connect to different destination addresses.

TCP SO_REUSEPORT

SO_REUSEPORT主要用来解决惊群、性能等问题。通过多个进程、线程来监听同一端口，进来的连接通过内核来hash分发做到负载均衡，避免惊群。

SO_REUSEPORT is also useful for eliminating the try-10-times-to-bind hack in ftpd’s data connection setup routine. Without SO_REUSEPORT, only one ftpd thread can bind to TCP (lhost, lport, INADDR_ANY, 0) in preparation for connecting back to the client. Under conditions of heavy load, there are more threads colliding here than the try-10-times hack can accomodate. With SO_REUSEPORT, things work nicely and the hack becomes unnecessary.

SO_REUSEPORT使用场景：linux kernel 3.9 引入了最新的SO_REUSEPORT选项，使得多进程或者多线程创建多个绑定同一个ip:port的监听socket，提高服务器的接收链接的并发能力,程序的扩展性更好；此时需要设置SO_REUSEPORT（注意所有进程都要设置才生效）。

setsockopt(listenfd, SOL_SOCKET, SO_REUSEPORT,(const void *)&reuse , sizeof(int));

目的：每一个进程有一个独立的监听socket，并且bind相同的ip:port，独立的listen()和accept()；提高接收连接的能力。（例如nginx多进程同时监听同一个ip:port）

(a) on Linux SO_REUSEPORT is meant to be used purely for load balancing multiple incoming UDP packets or incoming TCP connection requests across multiple sockets belonging to the same app. ie. it’s a work around for machines with a lot of cpus, handling heavy load, where a single listening socket becomes a bottleneck because of cross-thread contention on the in-kernel socket lock (and state).

(b) set IP_BIND_ADDRESS_NO_PORT socket option for tcp sockets before binding to a specific source ip
with port 0 if you’re going to use the socket for connect() rather then listen() this allows the kernel
to delay allocating the source port until connect() time at which point it is much cheaper

The Ephemeral Port Range

Ephemeral Port Range就是我们前面所说的Port Range（/proc/sys/net/ipv4/ip_local_port_range）

A TCP/IPv4 connection consists of two endpoints, and each endpoint consists of an IP address and a port number. Therefore, when a client user connects to a server computer, an established connection can be thought of as the 4-tuple of (server IP, server port, client IP, client port).

Usually three of the four are readily known – client machine uses its own IP address and when connecting to a remote service, the server machine’s IP address and service port number are required.

What is not immediately evident is that when a connection is established that the client side of the connection uses a port number. Unless a client program explicitly requests a specific port number, the port number used is an ephemeral port number.

Ephemeral ports are temporary ports assigned by a machine’s IP stack, and are assigned from a designated range of ports for this purpose. When the connection terminates, the ephemeral port is available for reuse, although most IP stacks won’t reuse that port number until the entire pool of ephemeral ports have been used.

So, if the client program reconnects, it will be assigned a different ephemeral port number for its side of the new connection.

linux 如何选择Ephemeral Port

有资料说是随机从Port Range选择port，有的说是顺序选择，那么实际验证一下。

如下测试代码：

#include <stdio.h>      // printf
#include <stdlib.h>     // atoi
#include <unistd.h>     // close
#include <arpa/inet.h>  // ntohs
#include <sys/socket.h> // connect, socket

void sample() {
    // Create socket
    int sockfd;
    if (sockfd = socket(AF_INET, SOCK_STREAM, 0), -1 == sockfd) {
        perror("socket");
    }

    // Connect to remote. This does NOT actually send a packet.
    const struct sockaddr_in raddr = {
        .sin_family = AF_INET,
        .sin_port   = htons(8080),     // arbitrary remote port
        .sin_addr   = htonl(INADDR_ANY)  // arbitrary remote host
    };
    if (-1 == connect(sockfd, (const struct sockaddr *)&raddr, sizeof(raddr))) {
        perror("connect");
    }

    // Display selected ephemeral port
    const struct sockaddr_in laddr;
    socklen_t laddr_len = sizeof(laddr);
    if (-1 == getsockname(sockfd, (struct sockaddr *)&laddr, &laddr_len)) {
        perror("getsockname");
    }
    printf("local port: %i\n", ntohs(laddr.sin_port));

    // Close socket
    close(sockfd);
}

int main() {
    for (int i = 0; i < 5; i++) {
        sample();
    }

    return 0;
}

bind逻辑测试代码

#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <time.h>

void test_bind(){
    int listenfd = 0, connfd = 0;
    struct sockaddr_in serv_addr;
    char sendBuff[1025];
    time_t ticks;
	  socklen_t len;

    listenfd = socket(AF_INET, SOCK_STREAM, 0);
    memset(&serv_addr, '0', sizeof(serv_addr));
    memset(sendBuff, '0', sizeof(sendBuff));

    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr.sin_port = htons(0);

    bind(listenfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr));

  	len = sizeof(serv_addr);
	  if (getsockname(listenfd, (struct sockaddr *)&serv_addr, &len) == -1) {
		      perror("getsockname");
			    return;
	  }
	  printf("port number %d\n", ntohs(serv_addr.sin_port)); //只是挑选到了port，在系统层面保留，tcp连接还没有，netstat是看不到的
}

int main(int argc, char *argv[])
{
	    for (int i = 0; i < 5; i++) {
			         test_bind();
					     }
		    return 0;
}

3.10.0-327.ali2017.alios7.x86_64

编译后，执行(3.10.0-327.ali2017.alios7.x86_64)：

#date; ./client && echo "+++++++" ; ./client && sleep 0.1 ; echo "-------" && ./client && sleep 10; date; ./client && echo "+++++++" ; ./client && sleep 0.1 && echo "******"; ./client;
Fri Nov 27 10:52:52 CST 2020
local port: 17448
local port: 17449
local port: 17451
local port: 17452
local port: 17453
+++++++
local port: 17455
local port: 17456
local port: 17457
local port: 17458
local port: 17460
-------
local port: 17475
local port: 17476
local port: 17477
local port: 17478
local port: 17479
Fri Nov 27 10:53:02 CST 2020
local port: 17997
local port: 17998
local port: 17999
local port: 18000
local port: 18001
+++++++
local port: 18002
local port: 18003
local port: 18004
local port: 18005
local port: 18006
******
local port: 18010
local port: 18011
local port: 18012
local port: 18013
local port: 18014

从测试看起来linux下端口选择跟时间有关系，起始端口肯定是顺序增加，起始端口应该是在Ephemeral Port范围内并且和时间戳绑定的某个值（也是递增的），即使没有使用任何端口，起始端口也会随时间增加而增加。

4.19.91-19.1.al7.x86_64

换个内核版本编译后，执行(4.19.91-19.1.al7.x86_64)：

$date; ./client && echo "+++++++" ; ./client && sleep 0.1 ; echo "-------" && ./client && sleep 10; date; ./client && echo "+++++++" ; ./client && sleep 0.1 && echo "******"; ./client;
Fri Nov 27 14:10:47 CST 2020
local port: 7890
local port: 7892
local port: 7894
local port: 7896
local port: 7898
+++++++
local port: 7900
local port: 7902
local port: 7904
local port: 7906
local port: 7908
-------
local port: 7910
local port: 7912
local port: 7914
local port: 7916
local port: 7918
Fri Nov 27 14:10:57 CST 2020
local port: 7966
local port: 7968
local port: 7970
local port: 7972
local port: 7974
+++++++
local port: 7976
local port: 7978
local port: 7980
local port: 7982
local port: 7984
******
local port: 7988
local port: 7990
local port: 7992
local port: 7994
local port: 7996

以上测试时的参数

1 2	$cat /proc/sys/net/ipv4/ip_local_port_range 1024 65535

将1024改成1025后，分配出来的都是奇数端口了：

$cat /proc/sys/net/ipv4/ip_local_port_range
1025    1034

$./client
local port: 1033
local port: 1025
local port: 1027
local port: 1029
local port: 1031
local port: 1033
local port: 1025
local port: 1027
local port: 1029
local port: 1031
local port: 1033
local port: 1025

之所以都是偶数端口，是因为port_range 从偶数开始, 每次从++变到+2的原因，connect挑选随机端口时都是在起始端口的基础上+2，而bind挑选随机端口的起始端口是系统port_range起始端口+1（这样和connect错开），然后每次仍然尝试+2，这样connect和bind基本一个用偶数另外一个就用奇数，一旦不够了再尝试使用另外一组

$cat /proc/sys/net/ipv4/ip_local_port_range
1024    1047

$./bind &  ---bind程序随机挑选5个端口
port number 1039
port number 1043
port number 1045
port number 1041
port number 1047  --用完所有奇数端口

$./bind &    --继续挑选偶数端口
[8] 4170
port number 1044
port number 1042
port number 1046
port number 0    --实在没有了
port number 0

可见4.19内核下每次port是+2，在3.10内核版本中是+1. 并且都是递增的，同时即使port不使用，也会随着时间的变化这个起始port增大。

Port Range有点像雷达转盘数字，时间就像是雷达上的扫描指针，这个指针不停地旋转，如果这个时候刚好有应用要申请Port，那么就从指针正好指向的Port开始向后搜索可用port

tcp_max_tw_buckets

tcp_max_tw_buckets: 在 TIME_WAIT 数量等于 tcp_max_tw_buckets 时，新的连接断开不再进入TIME_WAIT阶段，而是直接断开，并打印warnning.

实际测试发现在 TIME_WAIT 数量等于 tcp_max_tw_buckets 时新的连接仍然可以不断地创建和断开，这个参数大小不会影响性能，只是影响TIME_WAIT 数量的展示（当然 TIME_WAIT 太多导致local port不够除外）, 这个值设置小一点会避免出现端口不够的情况

tcp_max_tw_buckets - INTEGER
Maximal number of timewait sockets held by system simultaneously.If this number is exceeded time-wait socket is immediately destroyed and warning is printed. This limit exists only to prevent simple DoS attacks, you must not lower the limit artificially, but rather increase it (probably, after increasing installed memory), if network conditions require more than default value.

监控指标：

1	netstat -s \| grep TCPTimeWaitOverflow

SO_LINGER

SO_LINGER选项用来设置延迟关闭的时间，等待套接字发送缓冲区中的数据发送完成。没有设置该选项时，在调用close() 后，在发送完FIN后会立即进行一些清理工作并返回。如果设置了SO_LINGER选项，并且等待时间为正值，则在清理之前会等待一段时间。

如果把延时设置为 0 时，Socket就丢弃数据，并向对方发送一个 RST 来终止连接，因为走的是 RST 包，所以就不会有 TIME_WAIT 了。

This option specifies how the close function operates for a connection-oriented protocol (for TCP, but not for UDP). By default, close returns immediately, but ==if there is any data still remaining in the socket send buffer, the system will try to deliver the data to the peer==.

SO_LINGER 有三种情况

l_onoff 为false（0），那么 l_linger 的值没有意义，socket主动调用close时会立即返回，操作系统会将残留在缓冲区中的数据发送到对端，并按照正常流程关闭(交换FIN-ACK），最后连接进入TIME_WAIT状态。这是默认情况
l_onoff 为true（非0）， l_linger 为0，主动调用close的一方也是立刻返回，但是这时TCP会丢弃发送缓冲中的数据，而且不是按照正常流程关闭连接（不发送FIN包），直接发送RST，连接不会进入 time_wait 状态，对端会收到 java.net.SocketException: Connection reset异常
l_onoff 为true（非0）， l_linger 也为非 0，这表示 SO_LINGER选项生效，并且超时时间大于零，这时调用close的线程被阻塞，TCP会发送缓冲区中的残留数据，这时有两种可能的情况：
- 数据发送完毕，收到对方的ACK，然后进行连接的正常关闭（交换FIN-ACK）
- 超时，未发送完(指没收到对端的 ACK)的数据被丢弃，发送RST进行非正常关闭

struct linger {
  int   l_onoff;        /* 0=off, nonzero=on */
  int   l_linger;       /* linger time, POSIX specifies units as seconds */
};

NIO下设置 SO_LINGER 的错误案例

在使用NIO时，最好不设置SO_LINGER。比如Tomcat服务端接收到请求创建新连接时，做了这样的设置：

1	SocketChannel.setOption(SocketOption.SO_LINGER, 1000)

SO_LINGER的单位为秒！在网络环境比较好的时候，例如客户端、服务器都部署在同一个机房，close虽然会被阻塞，但时间极短可以忽略。但当网络环境不那么好时，例如存在丢包、较长的网络延迟，buffer中的数据一直无法发送成功，那么问题就出现了：close会被阻塞较长的时间，从而直接或间接引起NIO的IO线程被阻塞，服务器会不响应，不能处理accept、read、write等任何IO事件。也就是应用频繁出现挂起现象。解决方法就是删掉这个设置，close时立即返回，由操作系统接手后面的工作。

被阻塞时会看到如下连接状态：

以及对应的堆栈

查看其中一个IO线程等待的锁，发现锁是被HTTP线程持有。这个线程正在执行preClose0，就是在这里等待连接的关闭

每次HTTP线程在关闭连接被阻塞时，同时持有了SocketChannelImpl的对象锁，而 IO线程在把这个连接移除出它的 selector管理队列时，也要获得同一个SocketChannelImpl的对象锁。IO 线程就这么一次次的被阻塞，悲剧的无以复加。有些 NIO框架会让 IO线程去做close，这时候就更加悲剧了。

总之这里的错误原因有两点：1）网络状态不好；2）错误理解了l_linger 的单位，是秒，不是毫秒。在这两个原因的共同作用下导致了数据迟迟不能发送完毕，l_linger 超时又需要很久，所以服务会出现一直阻塞的状态。

为什么要有 time_wait 状态

TIME-WAIT - represents waiting for enough time to pass to be sure the remote TCP received the acknowledgment of its connection termination request.

alt text

由Nginx SY CPU高负载引发内核探索之旅

这个案例来自腾讯7层网关团队，网关用的Nginx，请求转发给后面的被代理机器(RS:real server)，发现 sys CPU异常高，CPU都用在搜索可用端口.

Figure 4: This is a flame graph of the connect syscall in Linux.

local port 不够的时候inet_hash_connect 中的spin_lock 会消耗过高的 sys（特别注意4.6内核后 local port 分奇偶数，每次loop+2，所以更容易触发port不够的场景）

核心原因总结: 4.6后内核把本地端口分成奇偶数，奇数给connect, 偶数给listen，本来端口有6万，这样connect只剩下3万，当这3万用完后也不会报找不到本地可用端口的错误(这里报错可能更好)，而是在奇数里找不到就找偶数里的，每次都这样。没改以前，总共6万端口，用掉3万，不分奇偶的话那么每找两个端口就有一个能用，也就是50%的概率。但是改了新的实现方案后，每次先要找奇数的3万个，全部在用，然后到偶数里继续找到第30001个才是可用的，也就是找到的概率变成了3万分之一，一下子复杂度高了15000倍，不慢才怪

对这个把端口分成奇偶数我的看法：这个做法就是坑爹货，在内核里胡乱搞，为了一个小场景搞崩大多数正常场景，真没必要，当然我这是事后诸葛亮，如果当时这种feature拿给我看我也会认为很不错，想不到这个坑点！

从STGW流量下降探秘内核收包机制

listen port search消耗CPU异常高

在正常的情况下，服务器的listen port数量，大概就是几w个这样的量级。这种量级下，一个port对应一个socket，哈希桶大小为32是可以接受的。

然而在内核支持了reuseport并且被广泛使用后，情况就不一样了，**在多进程架构里，listen port对应的socket数量，是会被几十倍的放大的。*以应用层监听了5000个端口，reuseport 使用了50个cpu核心为例，500050/32约等于7812，意味着每次握手包到来时，光是查找listen socket，就需要遍历7800多次。随着机器硬件性能越来越强，应用层使用的cpu数量增多，这个问题还会继续加剧。

正因为上述原因，并且我们现网机器开启了reuseport，在端口数量较多的机器里，inet_lookup_listener的哈希桶大小太小，遍历过程消耗了cpu，导致出现了函数热点。

短连接的开销

用ab通过短连接走 lo 网卡压本机 nginx，CPU0是 ab 进程，CPU3/4 是 Nginx 服务，可以看到 si 非常高，QPS 2.2万

再将 ab 改用长连接来压，可以看到si、sy都有下降，并且 si 下降到短连接的20%，QPS 还能提升到 5.2万

一条连接的开销

主要是内存开销(如图，来源见水印)，另外就是每个连接都会占用一个文件句柄，可以通过参数来设置：fs.nr_open、nofile（其实 nofile 还分 soft 和 hard）和 fs.file-max

从上图可以看到：

没有收发数据的时候收发buffer不用提前分配，3K多点的内存是指一个连接的元信息数据空间，不包含传输数据的内存buffer
客户端发送数据后，会根据数据大小分配send buffer（一般不超过wmem，默认kernel会根据系统内存压力来调整send buffer大小)
server端kernel收到数据后存放在rmem中，应用读走后就会释放对应的rmem
rmem和wmem都不会重用，用时分配用完释放

可见，内核在 socket 内存开销优化上采取了不少方法:

内核会尽量及时回收发送缓存区、接收缓存区，但高版本做的更好
发送接收缓存区最小并一定不是 rmem 内核参数里的最小值，实际大部分时间都是0
其它状态下，例如对于TIME_WAIT还会回收非必要的 socket_alloc 等对象

或者看这篇分析：https://zhuanlan.zhihu.com/p/25241630

不同进程使用相同端口，设置SO_REUSEADDR后被bind 导致可用 local port 不够

A进程选择某个端口当local port 来connect，并设置了 reuseaddr opt（表示其它进程还能继续用这个端口），这时B进程选了这个端口，并且bind了，B进程用完后把这个bind的端口释放了，但是如果 A 进程一直不释放这个端口对应的连接，那么这个端口会一直在内核中记录被bind用掉了（能bind的端口是65535个，四元组不重复的连接你理解可以无限多），这样的端口越来越多后，剩下可供 A 进程发起连接的本地随机端口就越来越少了(也就是本来A进程选择端口是按四元组的，但因为前面所说的原因，导致不按四元组了，只按端口本身这个一元组来排重)，这时会造成新建连接的时候这个四元组高概率重复，一般这个时候对端大概率还在 time_wait 状态，会忽略掉握手 syn 包并回复 ack ，进而造成建连接卡顿的现象；超频繁的端口复用在LVS 场景下会产生问题，导致建连异常；或者syn包被 RST 触发1秒钟重传 syn

这个A、B进程共同跑在一台宿主机上很多年了，只因为之前是3.10内核，这次升级到了4.19后因为奇偶数放大了问题

当A进程已经开启了 SO_REUSEADDR 对外建联，此时 B 进程同样开启 SO_REUSEADDR 可以bind 此端口成功，当前端口就被设置为bind 状态，其他非 SO_REUSEADDR 的建联无法选到此端口

验证端口被connect 和 listen 同时使用

尝试先用 connect 把18181 端口用掉，然后在18181端口上起一个listen 服务，再从其他地方连这个listen的 18181端口

抓包，本机 ip 是 172.17.151.5 ：

抓包里的 stream 1 对应上图的connect to baidu.com:80

抓包里的 stream 2 对应其它客户端连listen 18181上的服务，对应的netstat 信息：

#netstat -anpo |grep 18181
0.0.0.0:18181           0.0.0.0:*               LISTEN      2732449/nc           off (0.00/0/0)
172.17.151.5:18181      19.12.59.7:56166        ESTABLISHED 2732449/nc           off (0.00/0/0) (stream2)
172.17.151.5:18181      110.242.68.66:80        ESTABLISHED 2732445/python       keepalive (4.96/0/0)（stream1）
172.17.151.5:18181      10.143.33.49:123        ESTABLISHED 624/chronyd          off (0.00/0/0)

可以得出如下结论：

两个TCP 连接四元组不一样，互相不干涉
先connect(SO_REUSEADDR) 用掉A端口后，还可以在上面继续使用A 端口来 listen(nc -l 18181)
先 listen 再connect 是不行的，报：Cannot assign requested address

结论

在内存、文件句柄足够的话一台服务器上可以创建的TCP连接数量是没有限制的
SO_REUSEADDR 主要用于快速重用 TIME_WAIT状态的TCP端口，避免服务重启就会抛出Address Already in use的错误
先起一个listen 的端口设置了 SO_REUSEADDR，在其它进程 connect 的时候也不会从 port range 里再被选出来重用
SO_REUSEPORT主要用来解决惊群、性能等问题
全局范围可以用 net.ipv4.tcp_max_tw_buckets = 50000 来限制总 time_wait 数量，但是会掩盖问题
local port的选择是递增搜索的，搜索起始port随时间增加也变大

参考资料

https://segmentfault.com/a/1190000002396411

linux中TCP的socket、bind、listen、connect和accept的实现

How Linux allows TCP introspection The inner workings of bind and listen on Linux.

https://idea.popcount.org/2014-04-03-bind-before-connect/

TCP连接中客户端的端口号是如何确定的？

对应4.19内核代码解析

How to stop running out of ephemeral ports and start to love long-lived connections

https://blog.cloudflare.com/how-to-stop-running-out-of-ephemeral-ports-and-start-to-love-long-lived-connections/

connect() why you so slow?https://blog.cloudflare.com/linux-transport-protocol-port-selection-performance https://lpc.events/event/17/contributions/1593/attachments/1208/2472/lpc-2023-connect-why-you-so-slow.pdf?file=lpc-2023-connect-why-you-so-slow.pdf

一次春节大促性能压测不达标的瓶颈推演

发表于 2020-11-23 更新于 2025-11-29 分类于 performance

一次春节大促性能压测不达标的瓶颈推演

本文示范了教科书式的在分布式应用场景下如何通过一个节点的状态来推演分析瓶颈出在上下游的哪个环节上。

场景描述

某客户通过PTS（一个打压力工具）来压选号业务(HTTP服务在9108端口上），一个HTTP请求对应一次select seq-id 和一次insert

PTS端看到RT900ms+，QPS大概5万（期望20万），数据库代理服务 rt 5ms，QPS 10万+

链路：

pts发起压力 -> 5个eip -> slb -> app(300个容器运行tomcat监听9108端口上） -> slb -> 数据库代理服务集群 -> RDS集群

性能不达标，怀疑数据库代理服务或者RDS性能不行，作为数据库需要自证清白，所以从RDS和数据库代理服务开始分析问题在哪里。

略过一系列在数据库代理服务、RDS上分析数据和监控图表都证明数据库代理服务和RDS没问题的过程。

在明确给出证据数据库代理服务和RDS都没问题后还是要解决问题，所以只能进一步帮助前面的app来分析为什么性能不达标。

在其中一个app应用上抓包（00:18秒到1:04秒），到数据库代理服务的一个连接分析：

数据库代理服务每个HTTP请求的响应时间都控制在15ms(一个前端HTTP请求对应一个select seq-id，一个 select readonly, 一个insert，这个响应时间符合预期）。一个连接每秒才收到20 tps（因为压力不够，压力加大的话这个单连接tps还可以增加）， 20*3000 = 6万，跟压测看到基本一致

300个容器，每个容器 10个连接到数据库代理服务

如果300个容器上的并发压力不够的话就没法将3000个连接跑满，所以看到的QPS是5万。

从300个容器可以计算得到这个集群能支持的tps： 300*10（10个连接）* 1000/15(每秒钟每个连接能处理的请求数）=20万个tps （关键分析能力）

也就是说通过单QPS 15ms，我们计算可得整个后端的吞吐能力在20万QPS。所以目前问题不在后端，而是压力没有打到后端就出现瓶颈了。

9108的HTTP服务端口上的抓包分析

9108服务的每个HTTP response差不多都是15ms（这个响应时间基本符合预期），一个HTTP连接上在45秒的抓包时间范围只收到23个HTTP Request。

或者下图：

统计9108端口在45秒总共收到的HTTP请求数量是6745（如下图），也就是每个app每秒钟收到的请求是150个，300*150=4.5万（理论值，300个app可能压力分布不一样？），从这里看app收到的压力还不够，所以压力还没有打到应用容器中的app，还在更前面

后来从容器app监控也确认了这个响应时间和抓包看到的一致，所以从抓包分析http响应时间也基本得到15ms的rt关键结论

从wireshark IO Graphs 也能看到RT 和 QPS

从应用容器上的netstat统计来看，也是压力端回复太慢

send-q表示回复从9108发走了，没收到对方的ack

ARMS监控分析9108端口上的RT

后来PTS的同学说ARMS可以捞到监控数据，如下是对rt时间降序排

中的rt平均时间，可以看到http的rt确实14.4ms，表现非常平稳，从这个监控也发现实际app是330个而不是用户自己描述的300个，这也就是为什么实际是tps是5万，但是按300个去算的话tps是4.5万（不要纠结客户为什么告诉你是300个容器而不是330个，有时候他们也搞不清楚，业务封装得太好了）

5分钟时间，QPS是5万+，HTTP的平均rt是15ms， HTTP的最大rt才79ms，和前面抓包分析一致。

从后端分析的总结

从9108端口响应时间15ms来看是符合预期的，为什么PTS看到的RT是900ms+，所以压力还没有打到APP上（也就是9108端口）

结论

最后发现是 eip 带宽不足，只有200M，调整到1G后 tps 也翻了5倍到了25万。

pts -> 5个eip(总带宽200M) -> slb -> app(330个HTTP容器） -> slb -> 数据库代理服务 -> RDS

这个案例有意思的地方是可以通过抓包就能分析出集群能扛的QPS20万（实际只有5万），那么可以把这个分析原则在每个角色上挨个分析一下，来看瓶颈出在了哪个环节。

应用端看到的rt是900ms，从后段开始往前面应用端来撸，看看每个环节的rt数据。

教训

搞清楚请求从发起端到DB的链路路径，比如 pts -> 5个eip(总带宽200M) -> slb -> app(330个HTTP容器） -> slb -> 数据库代理服务 -> RDS
压不上去得从发压力端开始往后端撸，撸每个产品的rt，每个产品给出自己的rt来自证清白
应用有arms的话学会看arms对平均rt和QPS的统计，不要纠结个别请求的rt抖动，看平均rt
通过抓包完全可以分析出来系统能扛多少并发，以及可能的瓶颈位置

一包在手万事无忧

活久见，TCP连接互串了

发表于 2020-11-18 更新于 2026-04-03 分类于 TCP

活久见，TCP连接互串了

背景

应用每过一段时间总是会抛出几个连接异常的错误，需要查明原因。

排查后发现是TCP连接互串了，这个案例实在是很珍惜，所以记录一下。

抓包

业务结构：应用->MySQL(10.112.61.163)

在应用机器上抓包这个异常连接如下（3269为MySQL服务端口）：

粗一看没啥奇怪的，就是应用发查询给3269，但是一直没收到3269的ack，所以一直重传。这里唯一的解释就是网络不通。最后MySQL的3269还回复了一个rst，这个rst的id是42889，引起了我的好奇，跟前面的16439不连贯，正常应该是16440才对。（请记住上图中的绿框中的数字）

于是我过滤了一下端口61902上的所有包：

可以看到绿框中的查询从61902端口发给3269后，很奇怪居然收到了一个来自别的IP+3306端口的reset，这个包对这个连接来说自然是不认识（这个连接只接受3269的回包），就扔掉了。但是也没收到3269的ack，所以只能不停地重传，然后每次都收到3306的reset，reset包的seq、id都能和上图的绿框对应上。

明明他们应该是两个连接：

61902->10.141.16.0:3306

61902->10.112.61.163:3269

他们虽然用的本地ip端口（61902）是一样的，但是根据四元组不一样，还是不同的TCP连接，所以应该是不会互相干扰的。但是实际看起来seq、id都重复了，不会有这么巧，非常像是TCP互串了。

分析原因

10.141.16.0 这个ip看起来像是lvs的ip，查了一下系统，果然是lvs，然后这个lvs 后面的rs就是10.112.61.163

那么这个连结构就是10.141.16.0:3306：

应用 -> lvs(10.141.16.0:3306)-> 10.112.61.163:3269 跟应用直接连MySQL是一回事了

所以这里的疑问就变成了：10.141.16.0 这个IP的3306端口为啥能知道 10.112.61.163:3269端口的seq和id，也许是TCP连接串了

接着往下排查

先打个岔，分析下这里的LVS的原理

这里使用的是 full NAT模型(full NetWork Address Translation-全部网络地址转换)

基本流程（类似NAT）：

client发出请求（sip 200.200.200.2 dip 200.200.200.1）
请求包到达lvs，lvs修改请求包为**（sip 200.200.200.1， dip rip）** 注意这里sip/dip都被修改了
请求包到达rs， rs回复（sip rip，dip 200.200.200.1）
这个回复包的目的IP是VIP(不像NAT中是 cip)，所以LVS和RS不在一个vlan通过IP路由也能到达lvs
lvs修改sip为vip， dip为cip，修改后的回复包（sip 200.200.200.1，dip 200.200.200.2）发给client

注意上图中绿色的进包和红色的出包他们的地址变化

本来这个模型下都是正常的，但是为了Real Server能拿到client ip，也就是Real Server记录来源ip的时候希望记录的是client ip而不是LVS ip。这个时候LVS会将client ip放在tcp的options里面，然后在RealServer机器的内核里面将options中的client ip取出替换掉 lvs ip。所以Real Server上感知到的对端ip就是client ip。

回包的时候RealServer上的内核模块同样将目标地址从client ip改成lvs ip，同时将client ip放入options中。

回到问题

看完理论，再来分析这两个连接的行为

fulnat模式下连接经过lvs到达mysql后，mysql上看到的连接信息是，cip+port，也就是在MySQL上的连接

**lvs-ip:port -> 10.112.61.163:3269 被修改成了 **client-ip:61902 **-> 10.112.61.163:3269

那么跟不走LVS的连接：

client-ip:61902 -> 10.112.61.163:3269 (直连) 完全重复了。

MySQL端看到的两个连接四元组一模一样了：

10.112.61.163:3269 -> client-ip:61902 (走LVS，本来应该是lvs ip的，但是被替换成了client ip)

10.112.61.163:3269 -> client-ip:61902 (直连)

这个时候应用端看到的还是两个连接：

client-ip:61902 -> 10.141.16.0:3306 （走LVS）

client-ip:61902 -> 10.112.61.163:3269 (直连)

总结下，也就是这个连接经过LVS转换后在服务端（MYSQL）跟直连MySQL的连接四元组完全重复了，也就是MySQL会认为这两个连接就是同一个连接，所以必然出问题了

这个时候用 netstat 看到的应该是两个连接(vtoa 没有替换), 一个是client->rs, 一个是lvs->rs, 内核层面看到的还是两个连接, 只是get_peername接口被toa hook修改后, 两个连接返回的srcip是同一个

实际两个连接建立的情况：

和mysqlserver的61902是04:22建起来的，和lvs的61902端口是42:10建起来的，和lvs的61902建起来之后马上就出问题了

问题出现的条件

fulnat模式的LVS，RS上装有ip转换模块（RS上会将LVS ip还原成client ip）
client端正好重用一个相同的本地端口分别和RS以及LVS建立了两个连接

这个时候这两个连接在MySQL端就会变成一个，然后两个连接的内容互串，必然导致rst

这个问题还挺有意思的，估计没几个程序员一辈子能碰上一次。推荐另外一个好玩的连接：如何创建一个自己连自己的TCP连接

在很多容器场景也容易出现同样的问题，比如同时暴露 Nodeport 和 Loadbalance IP

其他场景

比如在 HA 场景下，需要通过直连节点去做心跳检查(B链路)；同时又要走A链路去跨机房检测，这两个链路下连接的目标IP一直、端口不一样，但是经过转换后都是MySQL-Server+3306端口，容易出现两条连接转换后变成一条连接

参考资料

就是要你懂负载均衡–lvs和转发模式

https://idea.popcount.org/2014-04-03-bind-before-connect/

no route to host

另一种形式的tcp连接互串，新连接重用了time_wait的port，导致命中lvs内核表中的维护的旧连接发给了老的realserver

类似场景汇总

下面罗列所有会导致这种问题的场景。

 ---
 场景总览

 ┌─────┬─────────────────────┬────────────────────────────────┬──────────────┐
 │  #  │        场景         │              根因              │   文中提及   │
 ├─────┼─────────────────────┼────────────────────────────────┼──────────────┤
 │ 1   │ LVS FNAT + TOA +    │ TOA 还原 client                │      ✅      │
 │     │ 直连并存             │ IP，与直连四元组重复              │              │
 ├─────┼─────────────────────┼────────────────────────────────┼──────────────┤
 │     │ K8s NodePort +      │                                │              │
 │ 2   │ LoadBalancer        │ 不同入口经 DNAT 后落到同一 Pod │      ✅      │
 │     │ 同时暴露            │                                │              │
 ├─────┼─────────────────────┼────────────────────────────────┼──────────────┤
 │ 3   │ Cloud NLB Client IP │ 不同 NLB IP 路由到同一后端，源 │      ✅      │
 │     │  保留 + 跨 AZ       │  IP 保留                       │              │
 ├─────┼─────────────────────┼────────────────────────────────┼──────────────┤
 │ 4   │ HA 多链路探测 + NAT │ 直连心跳 +                     │      ✅      │
 │     │  转换               │ 跨机房链路转换后四元组重合     │              │
 ├─────┼─────────────────────┼────────────────────────────────┼──────────────┤
 │     │ TIME_WAIT           │ 新连接复用了 TIME_WAIT         │              │
 │ 5   │ 端口复用命中旧      │ 端口，LVS 按旧表项转发         │ ✅(参考链接) │
 │     │ conntrack           │                                │              │
 ├─────┼─────────────────────┼────────────────────────────────┼──────────────┤
 │ 6   │ Docker/容器 DNAT +  │ 同一服务既通过 ClusterIP DNAT  │              │
 │     │ HostNetwork 直连    │ 又被直连                       │              │
 ├─────┼─────────────────────┼────────────────────────────────┼──────────────┤
 │ 7   │ 多层代理 Proxy      │ 代理还原 client IP             │              │
 │     │ Protocol 还原源 IP  │ 后与直连路径冲突               │              │
 ├─────┼─────────────────────┼────────────────────────────────┼──────────────┤
 │ 8   │ VPN/隧道 + 直连并存 │ VPN 内网 NAT                   │              │
 │     │                     │ 转换后与直连四元组重合         │              │
 └─────┴─────────────────────┴────────────────────────────────┴──────────────┘

 ---
 场景 1：LVS FNAT + TOA + 直连并存（上文案例）

                           客户端看到的：两条不同连接
                     ┌──────────────────────────────────────┐
                     │  连接A: client:61902 → LVS:3306      │
                     │  连接B: client:61902 → MySQL:3269    │
                     └──────────────────────────────────────┘

   ┌──────────┐            ┌──────────┐            ┌──────────────┐
   │  Client   │──连接A──→│   LVS    │──FNAT──→│   MySQL      │
   │           │            │ FNAT     │            │ 10.112:3269  │
   │           │            │ 10.141   │   TOA还原   │              │
   │           │            │ :3306    │──client IP→│  看到的连接A: │
   │           │            └──────────┘            │  client:61902│
   │           │                                    │  → MySQL:3269│
   │           │──连接B（直连）────────────────────→│              │
   │           │                                    │  看到的连接B: │
   └──────────┘                                    │  client:61902│
                                                   │  → MySQL:3269│
                                                   │              │
                                                   │  ⚠ 四元组完全 │
                                                   │    一样！互串！│
                                                   └──────────────┘

 触发条件：FNAT + TOA 还原 client IP + client 恰好复用同一本地端口分别连 LVS 和
 RS

 ---
 场景 2：K8s NodePort + LoadBalancer 同时暴露

   ┌──────────┐     NodePort (Node:30080)      ┌──────────┐     ┌─────────┐
   │  Client   │──连接A──→ DNAT ──────────────→│  Node    │────→│  Pod    │
   │           │                                │ kube-    │     │ 10.0.1.5│
   │           │     LoadBalancer (VIP:80)      │ proxy    │     │ :8080   │
   │           │──连接B──→ NLB ──→ DNAT ──────→│ iptables │────→│         │
   └──────────┘                                └──────────┘     └─────────┘

   Pod 侧看到（externalTrafficPolicy=Cluster，SNAT 场景）：

     连接A: NodeIP:random_port → Pod:8080
     连接B: NodeIP:random_port → Pod:8080
                      ↑
               如果 random_port 恰好相同 → 互串

 触发条件：同一 Service 同时暴露 NodePort 和
 LoadBalancer，externalTrafficPolicy=Cluster 做 SNAT 时源 IP 都变成 Node IP

 ---
 场景 3：Cloud NLB Client IP 保留 + 跨 AZ（Robinhood 案例）

                     NLB-a]                       ┌──────────────┐
               ┌──→ 10.98.98.50 ──────────────┐   │  API Server  │
   ┌────────┐  │   (client IP 保留)           │   │ 10.98.72.61  │
   │  KCM   │──┤                              ├──→│   :443       │
   │ :42852 │  │                              │   │              │
   └────────┘  │   NLB-b                      │   │ 看到两条连接：│
               └──→ 10.98.66.200 ─────────────┘   │ 都是         │
                   (client IP 保留)                │ KCM:42852    │
                                                   │ → API:443   │
                   跨AZ路由到同一后端               │              │
                                                   │ ⚠ 四元组重复 │
                                                   └──────────────┘

   客户端视角（不同五元组，合法复用端口）：
     KCM:42852 → NLB-a:443  ✅ 五元组不同
     KCM:42852 → NLB-b:443  ✅ 五元组不同

   服务端视角（Client IP 保留，NLB IP 被透传为 Client IP）：
     KCM:42852 → API:443  ⚠ 完全相同
     KCM:42852 → API:443  ⚠ 完全相同

 触发条件：Client IP 保留 + 跨 AZ 负载均衡 + tcp_tw_reuse=1 复用端口 + GOAWAY
 触发重连到不同 NLB 节点

 ---
 场景 4：HA 多链路探测 + NAT 转换

   ┌──────────┐                                      ┌──────────────┐
   │  HA 探测  │──B链路（直连心跳）────────────────────→│  MySQL       │
   │  Client   │    client:P → MySQL:3306             │  Server      │
   │           │                                      │  :3306       │
   │           │──A链路（跨机房，经NAT/LB）─────────────→│              │
   │           │    client:P → VIP:3307               │  经 NAT 转换 │
   │           │         ↓                            │  后变成：    │
   │           │    NAT 转成 client:P → MySQL:3306    │  client:P    │
   └──────────┘                                      │  → MySQL:3306│
                                                     │              │
                                                     │ ⚠ 两条链路在 │
                                                     │   MySQL侧重合│
                                                     └──────────────┘

 触发条件：HA 架构中同时存在直连和经 NAT 转换的链路，转换后目标 IP:Port 一致

 ---
 场景 5：TIME_WAIT 端口复用命中旧 LVS conntrack

   时间线：
   ──────────────────────────────────────────────────────────────→

   T1: client:9527 → LVS → RS-A:3306    (连接正常关闭，进入 TIME_WAIT)

   T2: client:9527 → LVS → ???
       │
       ├─ 内核 tcp_tw_reuse=1，复用了 9527 端口
       ├─ LVS 调度应该分给 RS-B
       ├─ 但 LVS conntrack 表中还有旧条目：client:9527 → RS-A
       └─ LVS 按旧表项把包发给了 RS-A ← ⚠ 连接串到了错误的后端

   RS-A 收到一个 SYN，但 conntrack 里这条连接还在
   → Challenge ACK → RST → 连接异常

 触发条件：tcp_tw_reuse=1 + LVS conntrack 超时 > TCP TIME_WAIT 时间 +
 端口被快速复用

 ---
 场景 6：容器 DNAT + HostNetwork 直连

   ┌──────────┐    ClusterIP (DNAT)        ┌──────────┐     ┌─────────────┐
   │  Pod-A   │──连接1──→ kube-proxy ─────→│  Node    │────→│  Pod-B      │
   │ (同Node) │          iptables DNAT     │          │     │ HostNetwork │
   │          │                            │          │     │ NodeIP:8080 │
   │          │──连接2──→ 直连 HostNetwork──────────────────→│             │
   └──────────┘                                             └─────────────┘

   如果 DNAT 后目标变成 NodeIP:8080，与直连路径完全一致
   且源端口碰撞 → 四元组重复 → 互串

 触发条件：Pod-B 使用 HostNetwork，同 Node 上的 Pod-A 同时通过
 ClusterIP（DNAT）和直连访问

 ---
 场景 7：多层代理 Proxy Protocol 还原源 IP

   ┌──────────┐      ┌──────────┐      ┌──────────┐      ┌──────────┐
   │  Client  │─────→│ Proxy-A  │─────→│ Proxy-B  │─────→│  Server  │
   │  :P      │      │ HAProxy  │      │ Nginx    │      │  :80     │
   └──────────┘      │ Proxy    │      │ 还原      │      │          │
                     │ Protocol │      │ client IP│      │ 看到:    │
                     └──────────┘      └──────────┘      │client:P  │
                                                         │→Server:80│
   ┌──────────┐                                          │          │
   │  Client  │──直连（不经过代理）────────────────────────→│client:P  │
   │  :P      │                                          │→Server:80│
   └──────────┘                                          │ ⚠ 重复   │
                                                         └──────────┘

 触发条件：代理链使用 Proxy Protocol / TOA 还原了真实 client IP + client
 同时有直连路径

 ---
 场景 8：VPN/隧道 + 直连并存

   ┌──────────┐     VPN 隧道                  ┌──────────┐
   │  Client   │──连接1──→ VPN Gateway ──NAT──→│  Server  │
   │  办公网   │    经隧道封装,出口NAT            │  内网    │
   │  :P      │    变成 client_inner:P         │  :3306   │
   │          │                                │          │
   │          │──连接2──→ 直连内网 ────────────→│          │
   │          │    client_inner:P → Server:3306│          │
   └──────────┘                                └──────────┘

   如果 VPN NAT 后的源 IP 恰好是 client 的内网 IP（split tunnel 场景）
   + 端口碰撞 → 四元组重复

 触发条件：Split tunnel VPN + NAT 后源 IP 与直连内网 IP 相同 + 端口碰撞

 ---
 共性规律总结

 所有场景的本质都是同一个模式：

   Client ──路径1（经过中间层转换）──→ Server
   Client ──路径2（直连或经另一中间层）──→ Server

   路径1 在 Server 侧的四元组 ══ 路径2 在 Server 侧的四元组

   ⚠ 互串！

 触发三要素：
   ┌─────────────────────────────────────────────────┐
   │  1. 存在多条路径到达同一后端                      │
   │  2. 中间层做了地址转换（NAT/FNAT/DNAT/IP保留）    │
   │  3. 转换后的四元组与另一路径的四元组碰撞          │
   └─────────────────────────────────────────────────┘

附录一篇 k8s 场景下的同样的问题：

[GOAWAY Chance——客户端连接丢失始末](https://robinhood.com/us/en/newsroom/goaway-chance-chronicles-of-client-connection-lo
st/)

作者： Eric Ngo
编辑： Nick Turner 与 Sujith Katakam
发布日期： 2024 年 5 月 23 日

分布式系统本已十分复杂，而各系统之间的交互更是如此。Kubernetes 就是这样一个典型——其采用率正在快速上升。随着
我们向集群中引入越来越多的组件（也带来了更多的复杂性），理解变更所产生的下游影响变得愈加困难。在 Robinhood
的软件平台团队，我们作为 Kubernetes 从业者，必须深入排查那些由最细微的配置变更所引发的系统问题。在这篇博客中
，我们将回顾一个近期的案例——我们深入钻研了内核设置、NLB 配置和开源代码，最终定位了一个看似无害的 Kubernetes
API Server 配置项所导致的连接问题。

问题

使用 client-go 的 Kubernetes 客户端在连接 API Server 时，默认使用 HTTP/2。HTTP/2 利用持久 TCP
连接和”流”（stream）的概念，将多个 HTTP 请求复用到同一条 TCP 连接上。相较于 HTTP 1.1 每次请求都需要重新建立
TCP 与 TLS 握手，HTTP/2 通过减少 RTT 实现了更高的性能。

然而我们观察到一个现象：由于这些长期存活的持久连接，API Server 之间的负载出现了不均衡。这会导致某些 API
Server 承受不成比例的负载，并对系统可靠性产生级联影响。当我们对控制平面节点执行滚动更新时——这是更新控制平面
组件或修改配置时的常规操作——这种不均衡现象尤为明显。

为了解决客户端”粘性”问题，我们决定配置 Kubernetes API Server 的 –goaway-chance 参数。该参数在 k8s 1.18
中引入，是一个 API Server HTTP 过滤器，它以一定概率向 HTTP/2 客户端发送 RST_STREAM，强制客户端在新建立的 TCP
连接上重新发起请求。通过启用此设置，我们实现了显著改善的连接均衡和负载分发。

在将 –goaway-chance 推送到预生产环境后，我们开始偶发性地观察到集群中出现节点被标记为 NotReady 的现象。

node ip-10-241-33-82.us-west-2.compute.internal hasn’t been updated for 40.956376745s. Last Ready is: …

进一步检查后，我们发现是 kube-controller-manager 在将节点标记为不健康。每个节点上的 kubelet 负责更新节点的
kube-node-lease，这是一种心跳机制，用于表明节点能否与 API Server 正常通信。kube-controller-manager
运行一个名为 node_lifecycle_controller 的控制循环，负责在节点未能及时续约 kube-node-lease 时更新其 Ready
状态条件。默认情况下，kubelet 每隔 renewInterval（10 秒）更新一次 Lease 对象，而 kube-controller-manager
则检查 Lease 是否在 nodeMonitorGracePeriod（40 秒）内完成了续约。

因此，当收到少量节点报告为 NotReady 时，可能有两种原因：少数节点确实不健康（kubelet 无法执行心跳），或者
kube-controller-manager 的 lease informer 未能接收到更新。

检查了某个被标记为不健康节点的 kubelet 日志和心跳更新审计日志后，我们很快排除了 kubelet
的嫌疑。于是我们将注意力集中到 kube-controller-manager 上，发现了一条颇为奇特的日志：

W1215 09:45:02.898142 1 reflector.go:441] k8s.io/client-go/informers/factory.go:134: watch of
*v1.Lease ended with: an error on the server (“unable to decode an event from the watch stream: http2:
client connection lost”) has prevented the request from succeeding

client connection lost 是什么意思，它又是如何导致 informer 超过 40 秒未收到任何更新的呢？

客户端连接丢失（Client Connection Lost）

还记得 HTTP/2 使用持久 TCP 连接这一点。由于是互联网，客户端与服务器之间可能发生各种各样的情况。因此，HTTP/2
允许通过健康检查来检测远端是否存在问题。在 Kubernetes 的 golang
客户端库（k8s.io/client-go）中，这些健康检查由 net/http2 库以 HTTP/2 ping 的形式执行。

// closes the client connection immediately. In-flight requests are interrupted.
func (cc *ClientConn) closeForLostPing() {
err := errors.New(“http2: client connection lost”)
if f := cc.t.CountError; f != nil {
f(“conn_close_lost_ping”)
}
cc.closeForError(err)
}

这些 ping 会在连接上超过 ReadIdleTimeout 秒未收到任何帧后触发。超过 PingTimeout 秒后，连接将被关闭。

// ReadIdleTimeout 是在连接上未收到任何帧后，
// 使用 ping 帧执行健康检查的超时时间。
// 注意，ping 响应也被视为已收到帧，
// 因此如果连接上没有其他流量，
// 健康检查将每隔 ReadIdleTimeout 间隔执行一次。
// 如果为零，则不执行健康检查。
ReadIdleTimeout time.Duration

// PingTimeout 是在未收到 Ping 响应时关闭连接的超时时间。
// 默认为 15 秒。
PingTimeout time.Duration

Kubernetes 默认的传输配置将 ReadIdleTimeout 设为 30 秒，PingTimeout 设为 15 秒。

func readIdleTimeoutSeconds() int {
ret := 30
if s := os.Getenv(“HTTP2_READ_IDLE_TIMEOUT_SECONDS”); len(s) > 0 {
i, err := strconv.Atoi(s)
if err != nil {
klog.Warningf(“Illegal HTTP2_READ_IDLE_TIMEOUT_SECONDS(%q): %v.”+
“ Default value %d is used”, s, err, ret)
return ret
}
ret = i
}
return ret
}

func pingTimeoutSeconds() int {
ret := 15
if s := os.Getenv(“HTTP2_PING_TIMEOUT_SECONDS”); len(s) > 0 {
i, err := strconv.Atoi(s)
if err != nil {
klog.Warningf(“Illegal HTTP2_PING_TIMEOUT_SECONDS(%q): %v.”+
“ Default value %d is used”, s, err, ret)
return ret
}
ret = i
}
return ret
}

readIdleTimeout 与 pingTimeout 之和为 45 秒，这可以解释为什么 lease informer 会超过 40
秒未收到任何更新，从而导致 kube-controller-manager 认为节点已超过 40 秒的 leaseDuration
未续约，进而将节点标记为 NotReady。但问题依然存在：连接为何会挂起 45 秒？

我们的环境

NLB

每个集群都有一个 NLB 对 API Server 的连接进行负载均衡。这些 NLB 配置了客户端 IP 保留（client-ip
preservation）和跨 AZ 负载均衡（cross zone load balancing）。启用客户端 IP 保留，是为了让通过 NLB
的并发连接数能够超过 NLB 约 65000 个的临时端口范围限制。启用跨 AZ
负载均衡，则是为了提升可靠性并增强对部分控制平面故障的抗风险能力。

API Server 与 kube-controller-manager

我们使用 kOps（一款 Kubernetes 集群管理工具）来引导集群的创建。每个集群有 5
个控制平面节点。kube-controller-manager、kube-scheduler
等所有控制平面组件都运行在控制平面节点上，并配置为通过 NLB 与 API Server 通信。

节点

我们的节点配置了 net.ipv4.tcp_tw_reuse = 1，这允许处于 TIME_WAIT
状态的套接字被复用，以及将端口复用到不同的目标。只要连接的五元组（协议、源 IP、源端口、目标
IP、目标端口）不同，使内核能够区分新旧连接，未绑定的端口就可以被复用。

了解了环境后，我们来看如何复现这个问题。

复现过程

原生集群

最初，我们认为问题仅由 goaway-chance 引起，于是尝试创建一个原生集群来复现——其中 kube-controller-manager 通过
localhost 直接与 API Server 通信，网络路径如下：

设置 goaway-chance 后，我们无法复现该问题。我们的原生集群与生产集群环境的唯一区别，是控制平面组件通过 NLB
路由到 API Server。因此我们决定在测试环境中也加入一个 NLB。

参考配置

以下是所用 IP 的配置情况：

NLB 由以下各可用区的实例提供支持。注意，由于启用了跨 AZ 负载均衡，每个 NLB 实例都可以访问任意 API Server
目标。

┌──────────────┬────────────┐
│ NLB IP │ NLB 可用区 │
├──────────────┼────────────┤
│ 10.98.35.159 │ us-west-2a │
├──────────────┼────────────┤
│ 10.98.66.200 │ us-west-2b │
├──────────────┼────────────┤
│ 10.98.98.50 │ us-west-2c │
└──────────────┴────────────┘

由于我们只关心 kube-controller-manager 与 kube-apiserver 之间的交互，相关实例如下：

┌─────────────────┬─────────────────────────────────────────┐
│ 控制平面主机 IP │ 运行进程 │
├─────────────────┼─────────────────────────────────────────┤
│ 10.98.102.166 │ kube-controller-manager, kube-apiserver │
├─────────────────┼─────────────────────────────────────────┤
│ 10.98.72.61 │ kube-apiserver │
└─────────────────┴─────────────────────────────────────────┘

通过 NLB 通信

我们通过设置 –master 参数，将 kube-controller-manager 配置为与 NLB 通信，很快就复现了 client connection
lost 问题。但 NLB 与 client connection lost 有什么关系呢？

为了更好地理解 net/http 包底层的行为，并了解 TCP 连接的状态，我们采取了以下措施：

设置 GODEBUG=http2debug=2 以开启详细的 HTTP/2 日志并输出帧转储；
在 kube-controller-manager 的 manifest 的环境变量中，添加 key 为 GODEBUG、value 为 http2debug=2 的配置。

这样我们就可以将 net/http2 的活动与 TCP 抓包进行关联，从而精确定位问题中的 TCP 流并加以分析。

分析 HTTP/2 调试日志

启用 http2debug 日志后，我们捕获到了一次 client connection lost 发生时的 HTTP/2 活动：

{“log”:”I0125 01:56:38.494896 1 log.go:184] http2: Framer 0xc00151c1c0: read DATA stream=5 len=2535 …
{“log”:”I0125 01:56:38.494946 1 log.go:184] http2: Framer 0xc00151c1c0: wrote WINDOW_UPDATE stream=5 len=4
incr=5066\n”,…}
{“log”:”I0125 01:57:08.495926 1 log.go:184] http2: Framer 0xc00151c1c0: wrote PING len=8
ping="x\x85ex\xc5*\xd1\xd5"\n”,…}
{“log”:”I0125 01:57:23.496850 1 log.go:184] http2: Framer 0xc00151c1c0: wrote RST_STREAM stream=5 len=4
ErrCode=CANCEL\n”,…}
{“log”:”I0125 01:57:23.496896 1 log.go:184] http2: Framer 0xc00151c1c0: wrote RST_STREAM stream=1 len=4
ErrCode=CANCEL\n”,…}
{“log”:”W0125 01:57:23.496885 1 reflector.go:441] k8s.io/client-go/informers/factory.go:134: watch of
*v1.Pod ended with: an error on the server ("unable to decode an event from the watch stream: http2: client
connection lost") has prevented the request from succeeding\n”,…}

在 1:56:38，负责单条 TCP 连接上请求复用的 framer 0xc00151c1c0 从服务器读取了一些数据并执行了
WINDOW_UPDATE。此后连接在 readIdleTimeout（30 秒）内未收到任何更新，于是客户端向服务器写入了一个
PING。又过了 pingTimeout（15 秒），客户端最终写入了 RST_STREAM 终止流，并记录了 client connection lost。

kube-controller-manager TCP 抓包分析

分析 10.98.102.166:42852 <> 10.98.66.200:443

在一次 client connection lost 发生期间，我们进行了数据包捕获，找到了一条与 http2 调试日志高度吻合的 TCP
流（tcp.stream eq 1110）。我们看到 KCM 主机 10.98.102.166 正在与 NLB 之一 10.98.66.200 通信。

我们看到在 15:56:38 收到了一个帧，30 秒后，客户端 10.98.102.166 在 15:57:08 发送了
PING。看起来有响应返回，但仔细查看报文后发现，第 138783 帧的确认号（acknowledgement number）与第 138772
帧的序列号（Sequence number）并不匹配。在 15:57:23 经过 15 秒的 pingTimeout 后，我们看到客户端发送了
RST_STREAM，随后连接关闭。

继续分析该流的其余部分，发现了一些可疑之处：

出现了 TCP 端口号被复用（tcp port number reused）的警告。同一端口是否还有其他流在使用？

分析 10.98.102.166:42852 <> 10.98.98.50:443

我们看到了另一条 TCP 流，客户端 10.98.102.166 正在使用与前面相同的端口 42852，与另一个 NLB 10.98.98.50
通信（目标端口 443）。注意，由于我们的节点设置了 tcp_tw_reuse = 1，只要五元组字段（协议、源 IP、源端口、目标
IP、目标端口）不同，端口就允许被复用。这看起来是正常的，但这条流是否也存在异常呢？

这条流同样出现了相同的症状：在 15:56:08 最后一次收到数据，30 秒后的 15:56:38 发送
PING，在多次重传失败后，最终于 15:56:53 发送 RST_STREAM 并终止连接。这条流同样收到了前面提到的 client
connection lost 错误。接下来，让我们以端口 42852 为单位，过滤出所有相关流。

以端口 42852 为维度的全局分析

找到了！看来在 10.98.102.166:42852 <> 10.98.98.50:443 这条连接断开的同时，客户端尝试复用端口 42852 与另一个
NLB 10.98.66.200 建立新连接。在第 36711 帧，客户端发送了 SYN。然而，由于服务器认为旧连接仍然存在，它返回的是
Challenge ACK 而非 SYN-ACK。客户端随即发送了 TCP RST
报文，彻底断开了双端的连接并完全重置了连接状态。此后，客户端 10.98.102.166:42852 得以成功与 NLB
10.98.66.200:443 完成 TCP 三次握手。

这究竟是怎么回事？

让我们简要回顾一下 NLB 在这里的行为。NLB 是一种四层（TCP/IP
层）负载均衡器，接收连接并在客户端与服务器之间充当代理。

我们为 API Server 前置的 NLB 启用了一项名为客户端 IP 保留的功能。该功能实质上是将 TCP 数据包的源 IP
和端口替换为发送方的真实 IP 和端口，而不是 NLB 自身的。这使目标端能够接受更多连接，同时保留了 IP
信息，便于追踪和审计等用途。除客户端 IP 保留外，我们还启用了跨 AZ 负载均衡，允许 NLB 路由至任意后端目标。

这意味着：从客户端视角来看，即便路由到不同的 NLB IP（且复用同一端口），NLB
背后的目标节点也可能是同一台主机。从服务器视角来看，它会在一条已建立的 socket 上收到一个新的连接请求，并发送
Challenge ACK，这将触发连接重置（RST）。

在这个具体案例中，客户端（10.98.102.166）复用了同一端口（42852），经过不同的 NLB（10.98.98.50:443 和
10.98.66.200:443），但最终都落到了同一个目标（10.98.72.61:443）。这就解释了：为什么在使用相同端口向
10.98.66.200 建立第二条连接时，我们收到了 Challenge ACK；以及为何在发送 RST 报文后，发往 10.98.98.50
的原始连接被切断，而发往 10.98.66.200 的新连接则得以建立。

完整流程如下：

最初，kube-controller-manager 和 kube-apiserver 的 socket 状态均为空。kube-controller-manager 首先以五元组
(tcp, 10.98.102.166, 42852, 10.98.98.50, 443) 建立了一条 socket 连接。NLB 将该连接路由至 API Server
10.98.72.61，其”连接表”中记录了 socket 状态 (tcp, 10.98.102.166, 42852, 10.98.72.61, 443)。

不久后，客户端收到 GOAWAY，复用端口 42852 建立了一条新连接，五元组变为 (tcp, 10.98.102.166, 42852,
10.98.66.200, 443)——注意这是相同的客户端 IP，但是不同的 NLB IP。NLB
尝试将该连接路由至同一目标。此时，由于启用了客户端 IP 保留，kube API Server
发现连接表中已存在该连接（因为端口复用导致客户端端口相同）。在一条已建立的连接中途收到 SYN 后，它发送了
Challenge ACK。当客户端发回 RST 时，服务器彻底重置了客户端 IP 与端口对 10.98.102.166:42852
的连接状态，完全切断了原始连接，并允许以相同的客户端端口建立新连接。

为了更完整地说明，我们再次复现了该问题，并在服务器端进行了 tcpdump 抓包，精确捕获到了我们所推断的过程：

服务器在一条 TCP 流中途收到了一个序列号/确认号异常的 SYN。它回应了 Challenge ACK，客户端随后回复了
RST，将服务器端的 TCP 连接彻底切断。

总结：启用了客户端 IP 保留与跨 AZ 负载均衡，节点设置了 tcp_tw_reuse=1，同一客户端（相同的源 IP
和源端口）通过不同的 NLB IP 路由后，落到了同一目标（相同的目标 IP
和目标端口）。这导致负载均衡目标节点在已建立的 TCP 连接上收到了意外的 SYN，并发送了 Challenge
ACK；客户端回复 RST，将服务器端的连接切断。这使现有的长连接 HTTP/2 流（例如 informer Watch 连接）在超时 45
秒后收到 client connection lost 错误。

NLB 官方文档

但这不就是 NLB 的 bug 吗？其实，这与其说是 bug，不如说是 NLB 启用客户端 IP 保留与跨 AZ
负载均衡后的一个既定特性。正如 AWS 在其 NLB “要求和注意事项”中所述：

当启用客户端 IP 保留时，不支持 NAT 回路（也称为 hairpinning）。启用后，当客户端或其前端的 NAT
设备在同时连接多个负载均衡器节点时使用相同的源 IP 地址和源端口，您可能会遇到与目标节点上的 socket 复用相关的
TCP/IP 连接限制。如果负载均衡器将这些连接路由到同一目标，目标节点会认为它们来自相同的源
socket，从而导致连接错误。如果发生这种情况，客户端可以重试（如果连接失败）或重新连接（如果连接中断）。您可以
通过增加源端临时端口数或增加负载均衡器目标数来减少此类连接错误。也可以通过禁用客户端 IP 保留或禁用跨 AZ
负载均衡来完全避免此类连接错误。

这里主要有两种考量：

禁用客户端 IP 保留——代价是将并发连接数限制在约 65000 个临时端口范围之内；
禁用跨 AZ 负载均衡——这将防止不同的负载均衡实例将连接路由到同一后端。

考虑到 –goaway-chance 的使用场景，我们决定将其值设得足够低，使端口复用的触发概率低于 1%。

在测试过程中，我们还遇到了上面提到的 NLB 回路超时问题——当 NLB 目标节点本身也是客户端时（即源 IP == 目标
IP），可能会使数据包失效。我们的解决方案是：在 kube-apiserver 的 GOAWAY 过滤器中忽略特定的
userAgent，以避免在重新连接时触发这种回路超时。

总结

在处理分布式系统时，变更往往会产生意想不到的影响。对我们这些管理这些系统的人来说，熟悉工具并敢于深入挖掘那些
尚不理解的行为，至关重要。这样的机会在我的 Robinhood 团队中时常出现。如果你对 Kubernetes
充满热情、热爱深入钻研，欢迎申请加入！我们目前正在招聘一名高级软件工程师加入我们的容器编排团队。

特别感谢我的队友 Nick Turner、Madhu CS 和 Palash Agrawal 的全力支持！

MySQL针对秒杀场景的优化

发表于 2020-11-18 更新于 2025-11-29 分类于 MySQL

MySQL针对秒杀场景的优化

背景

对于秒杀热点场景，MySQL官方版本500 TPS每秒，在对MySQL优化前只能用redis来扛，redis没有事务能力，比如一个item下有多个sku就搞不定了。同时在前端搞限流、答题等让秒杀流量控制在可以承受的范围内。

过程

对于秒杀热点场景，MySQL官方版本扣减只能做到 500 TPS每秒，扛不住大促的流量，需要优化。从控制并发量将500优化到1400，再通过新语法来消除网络rtt对加锁时间的控制这样达到了 4000 TPS。最后合并多个扣减到一个，累积比如10ms提交，能将TPS 能升到4万以上这个能力。

排队控制并发

拍减模式在整个交易过程中只有一次扣减交互，所以是不需要付款减库存那样的判重逻辑，就是说，拍减的减库存sql只有一条update语句就搞定了。而付减有两条，一条insert判重+一条update减库存（双十一拍减接口在高峰的rt约为8ms，而付减接口在高峰的rt约为15ms）；

其次，当大量请求（线程）落到mysql的同一条记录上进行减库存时，线程之间会存在竞争关系，因为要争夺InnoDB的行锁，当一个线程获得了行锁，其他并发线程就只能等待（InnoDB内部还有死锁检测等机制会严重影响性能），当并发度越高时，等待的线程就越多，此时tps会急剧下降，rt会飙升，性能就不能满足要求了。那如何减少锁竞争？答案是：排队！库存中心从几个层面做了排队策略。

首先，在应用端进行排队，因为很多商品都是有sku的，当sku库存变化时item的库存也要做相应变化，所以需要根据itemId来进行排队，相同itemId的减库存操作会进入串行化排队处理逻辑，不过应用端的排队只能做到单机内存排队，当应用服务器数量过多时，落到db的并发请求仍然很多，所以最好的办法是在db端也加上排队策略，今年库存中心db部署了两个的排队patch，一个叫“并发控制”，是做在InnoDB层的，另一个叫“queue on pk”，是做在mysql的server层的，两个patch各有优缺点，前者不需要应用修改代码，db自动判断，后者需要应用程序写特殊的sql hint，前者控制的全局的sql，后者是根据hint来控制指定sql，两个patch的本质和应用端的排队逻辑是一致的，具体实现不同。双十一库存中心使用的是“并发控制”的patch。

2013年的单减库存TPS最高记录是1381次每秒。

对于秒杀热点场景，官方版本500tps每秒，问题在于同时涌入的请求太多，每次取锁都要检查其它等锁的线程（防止死锁），这个线程队列太长的话导致这个检查时间太长；继续在前面增加能够进入到后面的并发数的控制，通过增加线程池、控制并发能到1400（no deadlock list check）；

热点更新下的死锁检测(no deadlock list check)

由于热点更新是分布式的客户端并发的向单点的数据库进行了并行更新一条记录，到数据库最后是把并行的线程转行成串行的操作。但在串行操作的时候，由于对同一记录的锁申请列表过大，死锁检测的机制在检测锁队列的时候，反而拖慢了每一个更新。

原生版本的MySQL对于正常业务链接没有拒绝机制（除了TDDL的链接池或者MySQL的user_connnection不够用），对于同一行记录到innodb层修改的时候，凡是到innodb层的任务都必须拿到innodb_thread_concurrency的槽位才能执行(当然这里也有很多细节，这里就说最主要的代码改动点)，举例来说：开启一个事务，对于id=1的行记录更新，进到innodb层，占着1个innodb_thread_concurrency，等到id=1的事务结束，会释放innodb_thread_concurrency,从而达到innodb_thread_concurrency的平衡；

再进一步，开启一个事务，对id=1的行记录更新进到innodb层，占着1个innodb_thread_concurrency，事务不提交（假设innodb_thread_concurrency=32)，如果有下一个对id=1记录来更新的话，进到innodb层，又占着1个innodb_thread_concurrency，检测发现是对id=1的更新，排到第1个对id=1的队列的后面，同时释放innodb_thread_concurrency;以此类推这个链表有可能会很长比如1024；执行的时候又需要做死锁检测等一系列工作，都需要用到一个叫做kernel_mutex的mutex（这是一个全局互斥量用来管理锁系统，事务系统，MVCC多版本控制），对于大并发，整个链表非常长的时候，可想而知kernel_metex的竞争多么激烈，从而在链表检测的时间变长。

缩短锁时间

接下来的问题在于一个事务中有多条语句（最少也有一个update+一个commit），这样update(减库存，开始锁表），走网络，查询结果（走网络），commit，两次跨网络调用导致update锁行比较久，于是可以新造一个语法 select update一次搞定，继续优化 select update commit_on_success_or_fail_rollback，将所有操作一次网络操作全部搞定，能到4000；

比如库存扣减的业务逻辑可以简化为下面这个事务:

（1）begin;

（2）insert 交易流水表; – 交易流水对账

（3）update 库存明细表 where id in (sku_id，item_id);

（4）select 库存明细表;

（5）commit

SQL case：

4059550 Query   SET autocommit=0
4059550 Query   update ROLLBACK_ON_FAIL TARGET_AFFECT_ROW 1 trade set version = version+3 ,gmt_modified = now(), optype=2,feature =';abc;' where sub_biz_order_id='15' and biz_order_type =1 and id =5 and ti_id=1 and optype = 3 and root_id = 11
4059550 Query   select id,* from update COMMIT_ON_SUCCESS ROLLBACK_ON_FAIL TARGET_AFFECT_ROW 1 invetory set                     withholding_quantity = withholding_quantity + -1,  flag=flag &~ (1<<10) &~ (1<<11) , version=version+3,gmt_modified = now()         WHERE  root_id = 11 and status = 1 and id in    (     1    )  and (withholding_quantity + -1) >= 0
4059550 Query   commit

批量提交

其主要的核心思想是：针对应用层SQL做轻量化改造，带上”热点行SQL”的hint，当这种SQL进入内核后，在内存中维护一个hash表，将主键或唯一键相同的请求(一般也就是同一商品id)hash到同一个地方做请求的合并，经过一段时间后(默认100us)统一提交，从而实现了将串行处理变成了批处理，让每个热点行更新请求并不需要都去扫描和更新btree。

热点的自动识别:前面已经讲过了，库存的扣减SQL都会有commit on success标记。mysql内部分为普通通道和热点扣减通道。普通通道里是正常的事务。热点通道里收集带有commit on success标记的事务。在一定的时间区间段内(0.1ms)，将收集到的热点按照主键或者唯一键进行hash; hash到同一个桶中为相同的sku; 分批组提交这0.1ms收集到的热点商品。
轮询处理: 第一批进行提交时，第二批进行收集；当第一批完成了提交开始收集时，第二批就可以进行提交了。不断轮询，提高效率

通过内存合并库存减操作，干到100000（每个减库存操作生成一条独立的update binlog，不影响其他业务2016年双11），实际这里还可以调整批提交时间间隔来进一步提升扣减QPS

超卖：付款减库存会超卖，拍减库存要防止恶意拍不付款。拍减的话可以通过增加SQL新语法来进一步优化DB响应(select update)

innodb_buffer_pool_instance: 将buffer pool 分成几个（hash），避免高并发修改的时候一个大锁mutex导致性能不高

批量提交的压测效果：

业务优化

延迟扣减item，一般一个item下会有多个sku（比如 iPhone14 不同的颜色、配置就是一个不同的sku），而库存会有总库存（item），也有sku 库存，sku库存加起来就是item库存

导致扣减的时候 item库存更热

MySQL线程池导致的延时卡顿排查

发表于 2020-11-17 更新于 2025-11-16 分类于 MySQL

MySQL 线程池导致的卡顿

问题描述

简单小表的主键点查SQL，单条执行很快，但是放在业务端，有时快有时慢，取了一条慢sql，在MySQL侧查看，执行时间很短。

通过Tomcat业务端监控有显示慢SQL，取slow.log里显示有12秒执行时间的SQL，但是这次12秒的执行在MySQL上记录下来的执行时间都不到1ms。

所在节点的tsar监控没有异常，Tomcat manager监控上没有fgc，Tomcat实例规格 16C32g*8, MySQL 32c128g *32 。

5-28号现象复现，从监控图上CPU、内存、网络都没发现异常，MySQL侧查到的SQL依然执行很快，Tomcat侧记录12S执行时间，当时Tomcat节点的网络流量、CPU压力都很小。

所以客户怀疑Tomcat有问题或者Tomcat上的代码写得有问题导致了这个问题，需要排查和解决掉。

接下来我们会先分析这个问题出现的原因，然后会分析这类问题的共性同时拓展到其它场景下的类似问题。

Tomcat上抓包分析

慢的连接

经过抓包分析发现在慢的连接上，所有操作都很慢，包括set 命令，慢的时间主要分布在3秒以上，1-3秒的慢查询比较少，这明显不太符合分布规律。并且目前看慢查询基本都发生在MySQL的0库的部分连接上（后端有一堆MySQL组成的集群），下面抓包的4637端口是MySQL的服务端口：

以上两个连接都很慢，对应的慢查询在MySQL里面记录很快。

慢的SQL的response按时间排序基本都在3秒以上：

或者只看response time 排序，中间几个1秒多的都是 Insert语句。也就是1秒到3秒之间的没有，主要是3秒以上的查询

快的连接

同样一个查询SQL，发到同一个MySQL上(4637端口)，下面的连接上的所有操作都很快，下面是两个快的连接上的执行截图

别的MySQL上都比较快，比如5556分片上的所有response RT排序，只有偶尔极个别的慢SQL

MySQL相关参数

mysql> show variables like '%thread%';
+--------------------------------------------+-----------------+
| Variable_name                              | Value           |
+--------------------------------------------+-----------------+
| innodb_purge_threads                       | 1               |
| innodb_MySQL_thread_extra_concurrency        | 0               |
| innodb_read_io_threads                     | 16              |
| innodb_thread_concurrency                  | 0               |
| innodb_thread_sleep_delay                  | 10000           |
| innodb_write_io_threads                    | 16              |
| max_delayed_threads                        | 20              |
| max_insert_delayed_threads                 | 20              |
| myisam_repair_threads                      | 1               |
| performance_schema_max_thread_classes      | 50              |
| performance_schema_max_thread_instances    | -1              |
| pseudo_thread_id                           | 12882624        |
| MySQL_is_dump_thread                         | OFF             |
| MySQL_threads_running_ctl_mode               | SELECTS         |
| MySQL_threads_running_high_watermark         | 50000           |
| rocksdb_enable_thread_tracking             | OFF             |
| rocksdb_enable_write_thread_adaptive_yield | OFF             |
| rocksdb_signal_drop_index_thread           | OFF             |
| thread_cache_size                          | 100             |
| thread_concurrency                         | 10              |
| thread_handling                            | pool-of-threads |
| thread_pool_high_prio_mode                 | transactions    |
| thread_pool_high_prio_tickets              | 4294967295      |
| thread_pool_idle_timeout                   | 60              |
| thread_pool_max_threads                    | 100000          |
| thread_pool_oversubscribe                  | 10              |
| thread_pool_size                           | 96              |
| thread_pool_stall_limit                    | 30              |
| thread_stack                               | 262144          |
| threadpool_workaround_epoll_bug            | OFF             |
| tokudb_cachetable_pool_threads             | 0               |
| tokudb_checkpoint_pool_threads             | 0               |
| tokudb_client_pool_threads                 | 0               |
+--------------------------------------------+-----------------+
33 rows in set (0.00 sec)

综上结论

问题原因跟MySQL线程池比较相关，慢的连接总是慢，快的连接总是快。需要到MySQL Server下排查线程池相关参数。

同一个慢的连接上的回包，所有 ack 就很快（OS直接回，不需要进到MySQL），但是set就很慢，基本理解只要进到MySQL的就慢了，所以排除了网络原因（流量本身也很小，也没看到乱序、丢包之类的）

问题解决

18点的时候将4637端口上的MySQL thread_pool_oversubscribe 从10调整到20后，基本没有慢查询了：

当时从MySQL的观察来看，并发压力很小，很难抓到running thread比较高的情况（update: 可能是任务积压在队列中，只是96个thread pool中的一个thread全部running，导致整体running不高）

MySQL记录的执行时间是指SQL语句开始解析后统计，中间的等锁、等Worker都不会记录在执行时间中，所以当时对应的SQL在MySQL日志记录中很快。

thread_pool_stall_limit 会控制一个SQL过长时间（默认60ms）占用线程，如果出现stall_limit就放更多的SQL进入到thread pool中直到达到thread_pool_oversubscribe个

The thread_pool_stall_limit affects executing statements. The value is the amount of time a statement has to finish after starting to execute before it becomes defined as stalled, at which point the thread pool permits the thread group to begin executing another statement. The value is measured in 10 millisecond units, so the default of 6 means 60ms. Short wait values permit threads to start more quickly. Short values are also better for avoiding deadlock situations. Long wait values are useful for workloads that include long-running statements, to avoid starting too many new statements while the current ones execute.

类似案例

一个其它客户同样的问题的解决过程，最终发现是因为thread pool group中的active thread count 计数有泄漏，导致达到thread_pool_oversubscribe 的上限(实际没有任何线程运行)

问题：1）为什么调整到20后 active_thread_count 没变，但是不卡了？那以前卡着的10个 thread在干嘛？

2）卡住的根本原因是，升级能解决？

调整前的 thread pool 配置：

出问题时候的线程池 32个 group状态，有两个group queue count、active thread都明显到了瓶颈：select * from information_schema.THREAD_POOL_STATUS;

id 线程组id
thread_count // 当前线程组中的线程数量
active_thread_count //当前线程组中活跃线程数量，这个不包含dump线程
waiting_thread_count // 当前线程组中处于waiting状态的线程数量
dump_thread_count // dump类线程数量
slow_thread_timeout_count // 目前仅对DDL生效
connection_count // 当前线程组中的连接数量
low_queue_count // 低优先级队列中的请求数量
high_queue_count // 高优先级队列中的请求数量
waiting_thread_timeout_count // 处于waiting状态并且超时的线程数量

or: select sum(LOW_QUEUE_COUNT) from information_schema.thread_pool_status;

调整 thread_pool_oversubscribe由10到20后不卡了，这时的 pool status(重点注意 ACTIVE_THREAD_COUNT 数字没有任何变化)：

看起来像是 ACTIVE_THREAD 全假死了，没有跑任务也不去take新任务一直卡在那里，类似线程泄露。查看了一下所有MySQLD 线程都是 S 的正常状态，并无异常。

继续分析统计了一下mysqld线程数量(157)，远小于 thread pool 中的active线程数量(202)，看起来像是计数器在线程异常(磁盘故障时)忘记减减了，导致计数器虚高进而无法新创建新线程：

#top -H -b -n 1 -p 130650 |grep mysqld | wc -l
157

# mysql -e "select sum(THREAD_COUNT), sum(ACTIVE_THREAD_COUNT)  from information_schema.THREAD_POOL_STATUS"
+-------------------+--------------------------+
| sum(THREAD_COUNT) | sum(ACTIVE_THREAD_COUNT) |
+-------------------+--------------------------+
|                71 |                      206 |
+-------------------+--------------------------+
# mysql -e "select sum(THREAD_COUNT), sum(ACTIVE_THREAD_COUNT)  from information_schema.THREAD_POOL_STATUS"
+-------------------+--------------------------+
| sum(THREAD_COUNT) | sum(ACTIVE_THREAD_COUNT) |
+-------------------+--------------------------+
|                75 |                      202 |
+-------------------+--------------------------+
# mysql_secbox  --exe-path=mysql -A -uroot -h127.0.0.1 -P3054 -e  "select ID,THREAD_COUNT,ACTIVE_THREAD_COUNT AS ATC,CONNECTION_COUNT AS CC,LOW_QUEUE_COUNT,HIGH_QUEUE_COUNT  from information_schema.THREAD_POOL_STATUS"
+----+--------------+-----+----+-----------------+------------------+
| ID | THREAD_COUNT | ATC | CC | LOW_QUEUE_COUNT | HIGH_QUEUE_COUNT |
+----+--------------+-----+----+-----------------+------------------+
|  0 |            3 |   7 | 13 |               0 |                0 |
| 19 |            3 |  10 | 14 |               0 |                0 |
| 20 |            3 |   8 | 13 |               0 |                0 |
| 21 |            2 |   5 |  9 |               0 |                0 |
| 28 |            2 |   6 |  6 |               0 |                0 |
//增加了一个active count,执行完毕后active thread count会减下去
| 29 |            2 |  12 | 14 |               0 |                0 | 
| 30 |            2 |   4 | 11 |               0 |                0 | 
| 31 |            2 |   8 | 10 |               0 |                0 |
+----+--------------+-----+----+-----------------+------------------+

正常的thread_pool状态, ACTIVE_THREAD_COUNT极小且小于 THREAD_COUNT：

mysql> select ID,THREAD_COUNT,ACTIVE_THREAD_COUNT AS ATC,CONNECTION_COUNT AS CC,LOW_QUEUE_COUNT,HIGH_QUEUE_COUNT from information_schema.THREAD_POOL_STATUS;
+----+--------------+-----+----+-----------------+------------------+
| ID | THREAD_COUNT | ATC | CC | LOW_QUEUE_COUNT | HIGH_QUEUE_COUNT |
+----+--------------+-----+----+-----------------+------------------+
|  0 |            2 |   0 |  3 |               0 |                0 |
|  1 |            2 |   0 |  2 |               0 |                0 |
|  2 |            2 |   0 |  2 |               0 |                0 |
|  3 |            2 |   0 |  2 |               0 |                0 |
|  4 |            2 |   0 |  4 |               0 |                0 |
|  5 |            2 |   0 |  3 |               0 |                0 |
|  6 |            2 |   0 |  4 |               0 |                0 |
|  7 |            2 |   0 |  4 |               0 |                0 |
+----+--------------+-----+----+-----------------+------------------+

Thread Pool原理

MySQL 原有线程调度方式有每个连接一个线程(one-thread-per-connection)和所有连接一个线程（no-threads）。

no-threads一般用于调试，生产环境一般用one-thread-per-connection方式。one-thread-per-connection 适合于低并发长连接的环境，而在高并发或大量短连接环境下，大量创建和销毁线程，以及线程上下文切换，会严重影响性能。另外 one-thread-per-connection 对于大量连接数扩展也会影响性能。

为了解决上述问题，MariaDB、Percona、Aliyun RDS、Oracle MySQL 都推出了线程池方案，它们的实现方式大体相似，这里以 Percona 为例来简略介绍实现原理，同时会介绍我们在其基础上的一些改进。

线程池由一系列 worker 线程组成，这些worker线程被分为thread_pool_size个group。用户的连接按 round-robin 的方式映射到相应的group 中，一个连接可以由一个group中的一个或多个worker线程来处理。

thread_pool_oversubscribe 一个group中活跃线程和等待中的线程超过thread_pool_oversubscribe时，不会创建新的线程。此参数可以控制系统的并发数，同时可以防止调度上的死锁，考虑如下情况，A、B、C三个事务，A、B 需等待C提交。A、B先得到调度，同时活跃线程数达到了thread_pool_max_threads上限，随后C继续执行提交，此时已经没有线程来处理C提交，从而导致A、B一直等待。thread_pool_oversubscribe控制group中活跃线程和等待中的线程总数，从而防止了上述情况。

MySQL Thread Pool之所以分成多个小的Thread Group Pool而不是一个大的Pool，是为了分解锁（每个group中都有队列，队列需要加锁。类似ConcurrentHashMap提高并发的原理），提高并发效率。另外如果对每个Pool的 Worker做CPU 亲和性绑定也会对cache更友好、效果更高

group中又有多个队列，用来区分优先级的，事务中的语句会放到高优先队列（非事务语句和autocommit 都会在低优先队列）；等待太久的SQL也会挪到高优先队列，防止饿死。

比如启用Thread Pool后，如果出现多个慢查询，容易导致拨测类请求超时，进而出现Server异常的判断（类似Nginx 边缘触发问题）；或者某个group满后导致慢查询和拨测失败之类的问题

thread_pool_size 过小的案例

应用出现大量1秒超时报错：

分析代码，这个Druid报错堆栈是数据库连接池在创建到MySQL的连接后或者从连接池取一个连接给业务使用前会发送一个ping来验证下连接是否有效，有效后才给应用使用。说明TCP连接创建成功，但是MySQL 超过一秒钟都没有响应这个 ping，说明 MySQL处理指令缓慢。

继续分析MySQL的参数：

可以看到thread_pool_size是1，太小了，将所有MySQL线程都放到一个buffer里面来抢锁，锁冲突的概率太高。调整到16后可以明显看到MySQL的RT从原来的12ms下降到了3ms不到，整个QPS大概有8%左右的提升。这是因为pool size为1的话所有sql都在一个队列里面，多个worker thread加锁等待比较严重，导致rt延迟增加。

这个问题发现是因为压力一上来的时候要创建大量新的连接，这些连结创建后会去验证连接的有效性，也就是Druid给MySQL发一个ping指令，一般都很快，同时Druid对这个valid操作设置了1秒的超时时间，从实际看到大量超时异常堆栈，从而发现MySQL内部响应有问题。

MySQL ping 和 MySQL 协议相关知识

Ping use the JDBC method Connection.isValid(int timeoutInSecs). Digging into the MySQL Connector/J source, the actual implementation uses com.mysql.jdbc.ConnectionImpl.pingInternal() to send a simple ping packet to the DB and returns true as long as a valid response is returned.

MySQL ping protocol是发送了一个 0e 的byte标识给Server，整个包加上2byte的Packet Length（内容为：1），2byte的Packet Number（内容为：0），总长度为5 byte。Druid、DRDS默认都会 testOnBorrow，所以每个连接使用前都会先做ping。

public class MySQLPingPacket implements CommandPacket {
    private final WriteBuffer buffer = new WriteBuffer();
    public MySQLPingPacket() {
        buffer.writeByte((byte) 0x0e);
    }
    public int send(final OutputStream os) throws IOException {
        os.write(buffer.getLengthWithPacketSeq((byte) 0)); // Packet Number
        os.write(buffer.getBuffer(),0,buffer.getLength()); // Packet Length 固定为1
        os.flush();
        return 0;
    }
}

也就是一个TCP包中的Payload为 MySQL协议中的内容长度 + 4（Packet Length+Packet Number）：https://dev.mysql.com/doc/dev/mysql-server/8.4.2/page_protocol_com_ping.html

线程池卡死案例：show stats导致集群3406监控卡死

现象

应用用于获取监控信息的端口 3406卡死，监控脚本无法连接上3406，监控没有数据（需要从3406采集）、DDL操作、show processlist、show stats操作卡死（需要跟整个集群的3406端口同步）。

通过jstack看到应用进程的3406端口线程池都是这样:

"ManagerExecutor-1-thread-1" #47 daemon prio=5 os_prio=0 tid=0x00007fe924004000 nid=0x15c runnable [0x00007fe9034f4000]
   java.lang.Thread.State: RUNNABLE
    at java.net.SocketInputStream.socketRead0(Native Method)
    at java.net.SocketInputStream.socketRead(SocketInputStream.java:116)
    at java.net.SocketInputStream.read(SocketInputStream.java:171)
    at java.net.SocketInputStream.read(SocketInputStream.java:141)
    at com.mysql.jdbc.util.ReadAheadInputStream.fill(ReadAheadInputStream.java:101)
    at com.mysql.jdbc.util.ReadAheadInputStream.readFromUnderlyingStreamIfNecessary(ReadAheadInputStream.java:144)
    at com.mysql.jdbc.util.ReadAheadInputStream.read(ReadAheadInputStream.java:174)
    - locked <0x0000000722538b60> (a com.mysql.jdbc.util.ReadAheadInputStream)
    at com.mysql.jdbc.MysqlIO.readFully(MysqlIO.java:3005)
    at com.mysql.jdbc.MysqlIO.reuseAndReadPacket(MysqlIO.java:3466)
    at com.mysql.jdbc.MysqlIO.reuseAndReadPacket(MysqlIO.java:3456)
    at com.mysql.jdbc.MysqlIO.checkErrorPacket(MysqlIO.java:3897)
    at com.mysql.jdbc.MysqlIO.sendCommand(MysqlIO.java:2524)
    at com.mysql.jdbc.MysqlIO.sqlQueryDirect(MysqlIO.java:2677)
    at com.mysql.jdbc.ConnectionImpl.execSQL(ConnectionImpl.java:2545)
    - locked <0x00000007432e19c8> (a com.mysql.jdbc.JDBC4Connection)
    at com.mysql.jdbc.ConnectionImpl.execSQL(ConnectionImpl.java:2503)
    at com.mysql.jdbc.StatementImpl.executeQuery(StatementImpl.java:1369)
    - locked <0x00000007432e19c8> (a com.mysql.jdbc.JDBC4Connection)
    at com.alibaba.druid.pool.ValidConnectionCheckerAdapter.isValidConnection(ValidConnectionCheckerAdapter.java:44)
    at com.alibaba.druid.pool.DruidAbstractDataSource.testConnectionInternal(DruidAbstractDataSource.java:1298)
    at com.alibaba.druid.pool.DruidDataSource.getConnectionDirect(DruidDataSource.java:1057)
    at com.alibaba.druid.pool.DruidDataSource.getConnection(DruidDataSource.java:997)
    at com.alibaba.druid.pool.DruidDataSource.getConnection(DruidDataSource.java:987)
    at com.alibaba.druid.pool.DruidDataSource.getConnection(DruidDataSource.java:103)
    at com.taobao.tddl.atom.AbstractTAtomDataSource.getConnection(AbstractTAtomDataSource.java:32)
    at com.alibaba.cobar.ClusterSyncManager$1.run(ClusterSyncManager.java:60)
    at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511)
    at java.util.concurrent.FutureTask.run(FutureTask.java:266)
    at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511)
    at java.util.concurrent.FutureTask.run(FutureTask.java:266)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1152)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:627)
    at java.lang.Thread.run(Thread.java:882)

原因

用户监控采集数据通过访问3306端口上的show stats，这个show stats命令要访问集群下所有节点的3406端口来执行show stats，3406端口上是一个大小为8个的Manager 线程池在执行这些show stats命令，导致占满了manager线程池的8个线程，每个3306的show stats线程都在wait 所有节点3406上的子任务的返回
每个子任务的线程，都在等待向集群所有节点3406端口的manager建立连接，建连接后会先执行testValidatation操作验证连接的有效性，这个验证操作会执行SQL Query：select 1，这个query请求又要申请一个manager线程才能执行成功
默认isValidConnection操作没有超时时间，如果Manager线程池已满后需要等待至socketTimeout后才会返回，导致这里出现卡死，还不如快速返回错误，可以增加超时来改进

从线程栈来说，就是出现了活锁

解决方案

增加manager线程池大小
代码逻辑上优化3406 jdbc连接池参数，修改jdbc默认的socketTimeout超时时间以及替换默认checker（一般增加一个1秒超时的checker）

对于checker，参考druid的实现，com/alibaba/druid/pool/vendor/MySqlValidConnectionChecker.java：

//druid的MySqlValidConnectionChecker设定了valid超时时间为1秒
    public boolean isValidConnection(Connection conn, String validateQuery, int validationQueryTimeout) throws Exception {
        if (conn.isClosed()) {
            return false;
        }

        if (usePingMethod) {
            if (conn instanceof DruidPooledConnection) {
                conn = ((DruidPooledConnection) conn).getConnection();
            }

            if (conn instanceof ConnectionProxy) {
                conn = ((ConnectionProxy) conn).getRawObject();
            }

            if (clazz.isAssignableFrom(conn.getClass())) {
                if (validationQueryTimeout <= 0) {
                    validationQueryTimeout = DEFAULT_VALIDATION_QUERY_TIMEOUT;// 默认值1ms
                }

                try {
                    ping.invoke(conn, true, validationQueryTimeout * 1000); //1秒
                } catch (InvocationTargetException e) {
                    Throwable cause = e.getCause();
                    if (cause instanceof SQLException) {
                        throw (SQLException) cause;
                    }
                    throw e;
                }
                return true;
            }
        }

        String query = validateQuery;
        if (validateQuery == null || validateQuery.isEmpty()) {
            query = DEFAULT_VALIDATION_QUERY;
        }

        Statement stmt = null;
        ResultSet rs = null;
        try {
            stmt = conn.createStatement();
            if (validationQueryTimeout > 0) {
                stmt.setQueryTimeout(validationQueryTimeout);
            }
            rs = stmt.executeQuery(query);
            return true;
        } finally {
            JdbcUtils.close(rs);
            JdbcUtils.close(stmt);
        }

    }

//使用如上validation
public final static String DEFAULT_DRUID_MYSQL_VALID_CONNECTION_CHECKERCLASS =
        "com.alibaba.druid.pool.vendor.MySqlValidConnectionChecker";

 String validConnnectionCheckerClassName =
                    TAtomConstants.DEFAULT_DRUID_MYSQL_VALID_CONNECTION_CHECKERCLASS;
                try {
                    Class.forName(validConnnectionCheckerClassName);
                    localDruidDataSource.setValidConnectionCheckerClassName(validConnnectionCheckerClassName);

这种线程池打满特别容易在分布式环境下出现，除了以上案例比如还有:

分库分表业务线程池，接收一个逻辑 SQL，如果需要查询1024分片的sort merge join，相当于派生了一批子任务，每个子任务占用一个线程，父任务等待子任务执行后返回数据。如果这样的逻辑SQL同时来一批并发，就会出现父任务都在等子任务，子任务又因为父任务占用了线程，导致子任务也在等着从线程池中取线程，这样父子任务就进入了死锁

比如并行执行的SQL MPP线程池也有这个问题，多个查询节点收到SQL，拆分出子任务做并行，互相等待资源

X应用对分布式任务打挂线程池的优化

对如下这种案例：

X 应用通过线程池来接收一个逻辑SQL并处理，如果需要查询1024分片的sort merge join，相当于派生了1024个子任务，每个子任务占用一个线程，父任务等待子任务执行后返回数据。如果这样的逻辑SQL同时来一批并发，就会出现父任务都在等子任务，子任务又因为父任务占用了线程，导致子任务也在等着从线程池中取线程，这样父子任务就进入了死锁

首先X对执行SQL 的线程池分成了多个bucket，每个SQL只跑在一个bucket里面的线程上，同时通过滑动窗口向线程池提交任务数，来控制并发量，进而避免线程池的死锁、活锁问题。

public static final ServerThreadPool create(String name, int poolSize, int deadLockCheckPeriod, int bucketSize) {
    return new ServerThreadPool(name, poolSize, deadLockCheckPeriod, bucketSize); //bucketSize可以设置
}

public ServerThreadPool(String poolName, int poolSize, int deadLockCheckPeriod, int bucketSize) {
    this.poolName = poolName;
    this.deadLockCheckPeriod = deadLockCheckPeriod;

    this.numBuckets = bucketSize;
    this.executorBuckets = new ThreadPoolExecutor[bucketSize];
    int bucketPoolSize = poolSize / bucketSize; //将整个pool分成多个bucket
    this.poolSize = bucketPoolSize;
    for (int bucketIndex = 0; bucketIndex < bucketSize; bucketIndex++) {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(bucketPoolSize,
            bucketPoolSize,
            0L,
            TimeUnit.MILLISECONDS,
            new LinkedBlockingQueue<Runnable>(),
            new NamedThreadFactory(poolName + "-bucket-" + bucketIndex, true));

        executorBuckets[bucketIndex] = executor;
    }

    this.lastCompletedTaskCountBuckets = new long[bucketSize];
    // for check thread
    if (deadLockCheckPeriod > 0) {
        this.timer = new Timer(SERVER_THREAD_POOL_TIME_CHECK, true);
        buildCheckTask();
        this.timer.scheduleAtFixedRate(checkTask, deadLockCheckPeriod, deadLockCheckPeriod);
    }
}

通过bucketSize将一个大的线程池分成多个小的线程池，每个SQL 控制跑在一个小的线程池中，这里和MySQL的thread_pool是同样的设计思路，当然MySQL 的thread_pool主要是为了改进大锁的问题。

另外DRDS上线程池拆分后性能也有提升：

测试结果说明：(以全局线程池为基准，分别关注：关日志、分桶线程池、协程)

关日志，整体性能提升在20%左右 (8core最好成绩在6.4w qps)

协程，整体性能15%左右

关日志+协程，整体提升在35%左右 (8core最好成绩在7w qps)

分桶，整体性能提升在18%左右

分桶+关日志，整体提升在39%左右 (8core最好成绩在7.4w qps)

分桶+协程，整体提升在36%左右

分桶+关日志+协程，整体提升在60%左右 (8core最好成绩在8.3w qps)

线程池拆成多个bucket优化分析

拆分前锁主要是：

Started [lock] profiling
--- Execution profile ---
Total samples:         496

Frame buffer usage:    0.0052%

--- 352227700 ns (53.09%), 248 samples
  [ 0] java.util.Properties
  [ 1] java.util.Hashtable.get
  [ 2] java.util.Properties.getProperty
  [ 3] com.taobao.tddl.common.properties.SystemPropertiesHelper.getPropertyValue
  [ 4] com.taobao.tddl.executor.MatrixExecutor.configMppExecutionContext
  [ 5] com.taobao.tddl.executor.MatrixExecutor.optimize
  [ 6] com.taobao.tddl.matrix.jdbc.TConnection.optimizeThenExecute
  [ 7] com.taobao.tddl.matrix.jdbc.TConnection.executeSQL
  [ 8] com.taobao.tddl.matrix.jdbc.TPreparedStatement.executeSQL
  [ 9] com.taobao.tddl.matrix.jdbc.TStatement.executeInternal
  [10] com.taobao.tddl.matrix.jdbc.TPreparedStatement.execute
  [11] com.alibaba.cobar.server.ServerConnection.innerExecute
  [12] com.alibaba.cobar.server.ServerConnection.innerExecute
  [13] com.alibaba.cobar.server.ServerConnection$1.run
  [14] com.taobao.tddl.common.utils.thread.FlowControlThreadPool$RunnableAdapter.run
  [15] java.util.concurrent.Executors$RunnableAdapter.call
  [16] java.util.concurrent.FutureTask.run
  [17] java.util.concurrent.ThreadPoolExecutor.runWorker
  [18] java.util.concurrent.ThreadPoolExecutor$Worker.run
  [19] java.lang.Thread.run

--- 307781689 ns (46.39%), 243 samples
  [ 0] java.util.Properties
  [ 1] java.util.Hashtable.get
  [ 2] java.util.Properties.getProperty
  [ 3] com.taobao.tddl.common.properties.SystemPropertiesHelper.getPropertyValue
  [ 4] com.taobao.tddl.config.ConfigDataMode.isDrdsMasterMode
  [ 5] com.taobao.tddl.matrix.jdbc.TConnection.updatePlanManagementInfo
  [ 6] com.alibaba.cobar.server.ServerConnection.innerExecute
  [ 7] com.alibaba.cobar.server.ServerConnection.innerExecute
  [ 8] com.alibaba.cobar.server.ServerConnection$1.run
  [ 9] com.taobao.tddl.common.utils.thread.FlowControlThreadPool$RunnableAdapter.run
  [10] java.util.concurrent.Executors$RunnableAdapter.call
  [11] java.util.concurrent.FutureTask.run
  [12] java.util.concurrent.ThreadPoolExecutor.runWorker
  [13] java.util.concurrent.ThreadPoolExecutor$Worker.run
  [14] java.lang.Thread.run

--- 3451038 ns (0.52%), 4 samples
  [ 0] java.lang.Object
  [ 1] sun.nio.ch.SocketChannelImpl.ensureReadOpen
  [ 2] sun.nio.ch.SocketChannelImpl.read
  [ 3] com.alibaba.cobar.net.AbstractConnection.read
  [ 4] com.alibaba.cobar.net.NIOReactor$R.read
  [ 5] com.alibaba.cobar.net.NIOReactor$R.run
  [ 6] java.lang.Thread.run

--- 4143 ns (0.00%), 1 sample
  [ 0] com.taobao.tddl.common.IdGenerator
  [ 1] com.taobao.tddl.common.IdGenerator.nextId
  [ 2] com.alibaba.cobar.server.ServerConnection.genTraceId
  [ 3] com.alibaba.cobar.server.ServerQueryHandler.query
  [ 4] com.alibaba.cobar.net.FrontendConnection.query
  [ 5] com.alibaba.cobar.net.handler.FrontendCommandHandler.handle
  [ 6] com.alibaba.cobar.net.FrontendConnection$1.run
  [ 7] java.util.concurrent.ThreadPoolExecutor.runWorker
  [ 8] java.util.concurrent.ThreadPoolExecutor$Worker.run
  [ 9] java.lang.Thread.run

          ns  percent  samples  top
  ----------  -------  -------  ---
   660009389   99.48%      491  java.util.Properties
     3451038    0.52%        4  java.lang.Object
        4143    0.00%        1  com.taobao.tddl.common.IdGenerator

com.taobao.tddl.matrix.jdbc.TConnection.optimizeThenExecute调用对应代码逻辑：

if (InsertSplitter.needSplit(sql, policy, extraCmd)) {
             executionContext.setDoingBatchInsertBySpliter(true);
             InsertSplitter insertSplitter = new InsertSplitter(executor);
                        // In batch insert, update transaction policy in writing
                        // broadcast table is also needed.
     resultCursor = insertSplitter.execute(sql,executionContext,policy,
         (String insertSql) -> optimizeThenExecute(insertSql, executionContext,trxPolicyModified));
                    } else {
       resultCursor = optimizeThenExecute(sql, executionContext,trxPolicyModified);
                    }
                    
 最终会访问到：
 protected void configMppExecutionContext(ExecutionContext executionContext) {

        String instRole = (String) SystemPropertiesHelper.getPropertyValue(SystemPropertiesHelper.INST_ROLE);
        SqlType sqlType = executionContext.getSqlType();
        
 相当于执行每个SQL都要加锁访问HashMap(SystemPropertiesHelper.getPropertyValue)，这里排队比较厉害

实际以上测试结果显示bucket对性能有提升这么大是不对的，刚好这个版本把对HashMap的访问去掉了，这才是提升的主要原因，当然如果线程池入队出队有等锁的话改成多个肯定是有帮助的，但是从等锁观察是没有这个问题的。

在这个代码基础上将bucket改成1，在4core机器下经过反复对比测试性能基本没有明显的差异，可能core越多这个问题会更明显些。总结

回到最开始部分查询卡顿这个问题，本质在于 MySQL线程池开启后，因为会将多个连接分配在一个池子中共享这个池子中的几个线程。导致一个池子中的线程特别慢的时候会影响这个池子中所有的查询都会卡顿。即使别的池子很空闲也不会将任务调度过去。

MySQL线程池设计成多个池子（Group）的原因是为了将任务队列拆成多个，这样每个池子中的线程只是内部竞争锁，跟其他池子不冲突，类似ConcurrentHashmap的实现，当然这个设计带来的问题就是多个池子中的任务不能均衡了。

同时从案例我们也可以清楚地看到这个池子太小会造成锁冲突严重的卡顿，池子太大（每个池子中的线程数量就少）容易造成等线程的卡顿。

**类似地这个问题也会出现在Nginx的多worker中，一旦一个连接分发到了某个worker，就会一直在这个worker上处理，如果这个worker上的某个连接有一些慢操作，会导致这个worker上的其它连接的所有操作都受到影响，特别是会影响一些探活任务的误判。**Nginx的worker这么设计也是为了将单worker绑定到固定的cpu，然后避免多核之间的上下文切换。

如果池子卡顿后，调用方有快速fail，比如druid的MySqlValidConnectionChecker，那么调用方从堆栈很快能发现这个问题，如果没有异常一直死等的话对问题的排查不是很友好。

另外可以看到分布式环境下死锁、活锁还是很容易产生的，想要一次性提前设计好比较难，需要不断踩坑爬坑。

参考文章

记一次诡异的数据库故障的排查过程

http://mysql.taobao.org/monthly/2016/02/09/

https://dbaplus.cn/news-11-1989-1.html

慢查询触发kill后导致集群卡死 把queryTimeout换成socketTimeout，这个不会发送kill，只会断开连接

青海湖、天津医保 RDS线程池过小导致DRDS查询卡顿问题排查

Linux内存--HugePage

发表于 2020-11-15 更新于 2025-11-16 分类于 Memory

Linux内存–HugePage

本系列有如下几篇

[Linux 内存问题汇总](/2020/01/15/Linux 内存问题汇总/)

/proc/buddyinfo

/proc/buddyinfo记录了内存的详细碎片情况。

#cat /proc/buddyinfo 
Node 0, zone      DMA      1      1      1      0      2      1      1      0      1      1      3 
Node 0, zone    DMA32      2      5      3      6      2      0      4      4      2      2    404 
Node 0, zone   Normal 243430 643847 357451  32531   9508   6159   3917   2960  17172   2633  22854

Normal行的第二列表示： 643847*2^1*Page_Size(4K) ; 第三列表示： 357451*2^2*Page_Size(4K) ，高阶内存指的是2^3及更大的内存块。

应用申请大块连续内存（高阶内存，一般之4阶及以上, 也就是64K以上–2^4*4K）时，容易导致卡顿。这是因为大块连续内存确实系统需要触发回收或者碎片整理，需要一定的时间。

slabtop和/proc/slabinfo

slabtop和/proc/slabinfo 查看cached使用情况主要是：pagecache（页面缓存）， dentries（目录缓存）， inodes

关于hugetlb

This is an entry in the TLB that points to a HugePage (a large/big page larger than regular 4K and predefined in size). HugePages are implemented via hugetlb entries, i.e. we can say that a HugePage is handled by a “hugetlb page entry”. The ‘hugetlb” term is also (and mostly) used synonymously with a HugePage.

hugetlb 是TLB中指向HugePage的一个entry(通常大于4k或预定义页面大小)。 HugePage 通过hugetlb entries来实现，也可以理解为HugePage 是hugetlb page entry的一个句柄。

Linux下的大页分为两种类型：标准大页（Huge Pages）和透明大页（Transparent Huge Pages）

标准大页管理是预分配的方式，而透明大页管理则是动态分配的方式

目前透明大页与传统HugePages联用会出现一些问题，导致性能问题和系统重启。Oracle 建议禁用透明大页（Transparent Huge Pages）

hugetlbfs比THP要好，开thp的机器碎片化严重（不开THP会有更严重的碎片化问题），最后和没开THP一样 https://www.atatech.org/articles/152660

Linux 中的 HugePages 都被锁定在内存中，所以哪怕是在系统内存不足时，它们也不会被 Swap 到磁盘上，这也就能从根源上杜绝了重要内存被频繁换入和换出的可能。

Transparent Hugepages are similar to standard HugePages. However, while standard HugePages allocate memory at startup, Transparent Hugepages memory uses the khugepaged thread in the kernel to allocate memory dynamically during runtime, using swappable HugePages.

HugePage要求OS启动的时候提前分配出来，管理难度比较大，所以Enterprise Linux 6增加了一层抽象层来动态创建管理HugePage，这就是THP，而这个THP对应用透明，由khugepaged thread在后台动态将小页组成大页给应用使用，这里会遇上碎片问题导致需要compact才能得到大页，应用感知到的就是SYS CPU飙高，应用卡顿了。

虽然 HugePages 的开启大都需要开发或者运维工程师的额外配置，但是在应用程序中启用 HugePages 却可以在以下几个方面降低内存页面的管理开销：

更大的内存页能够减少内存中的页表层级，这不仅可以降低页表的内存占用，也能降低从虚拟内存到物理内存转换的性能损耗；
更大的内存页意味着更高的缓存命中率，CPU 有更高的几率可以直接在 TLB（Translation lookaside buffer）中获取对应的物理地址；
更大的内存页可以减少获取大内存的次数，使用 HugePages 每次可以获取 2MB 的内存，是 4KB 的默认页效率的 512 倍；

HugePage

为什么需要Huge Page 了解CPU Cache大致架构的话，一定听过TLB Cache。Linux系统中，对程序可见的，可使用的内存地址是Virtual Address。每个程序的内存地址都是从0开始的。而实际的数据访问是要通过Physical Address进行的。因此，每次内存操作，CPU都需要从page table中把Virtual Address翻译成对应的Physical Address，那么对于大量内存密集型程序来说page table的查找就会成为程序的瓶颈。

所以现代CPU中就出现了TLB(Translation Lookaside Buffer) Cache用于缓存少量热点内存地址的mapping关系。然而由于制造成本和工艺的限制，响应时间需要控制在CPU Cycle级别的Cache容量只能存储几十个对象。那么TLB Cache在应对大量热点数据Virual Address转换的时候就显得捉襟见肘了。我们来算下按照标准的Linux页大小(page size) 4K，一个能缓存64元素的TLB Cache只能涵盖4K*64 = 256K的热点数据的内存地址，显然离理想非常遥远的。于是Huge Page就产生了。

Huge pages require contiguous areas of memory, so allocating them at boot is the most reliable method since memory has not yet become fragmented. To do so, add the following parameters to the kernel boot command line:

Huge pages kernel options

hugepages

Defines the number of persistent huge pages configured in the kernel at boot time. The default value is 0. It is only possible to allocate (or deallocate) huge pages if there are sufficient physically contiguous free pages in the system. Pages reserved by this parameter cannot be used for other purposes.

Default size huge pages can be dynamically allocated or deallocated by changing the value of the /proc/sys/vm/nr_hugepages file.

In a NUMA system, huge pages assigned with this parameter are divided equally between nodes. You can assign huge pages to specific nodes at runtime by changing the value of the node’s /sys/devices/system/node/node_id/hugepages/hugepages-1048576kB/nr_hugepages file.

For more information, read the relevant kernel documentation, which is installed in /usr/share/doc/kernel-doc-kernel_version/Documentation/vm/hugetlbpage.txt by default. This documentation is available only if the kernel-doc package is installed.
hugepagesz

Defines the size of persistent huge pages configured in the kernel at boot time. Valid values are 2 MB and 1 GB. The default value is 2 MB.
default_hugepagesz

Defines the default size of persistent huge pages configured in the kernel at boot time. Valid values are 2 MB and 1 GB. The default value is 2 MB.

应用程序想要利用大页优势，需要通过hugetlb文件系统来使用标准大页。操作步骤

1.预留大页

echo 20 > /sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages

2.挂载hugetlb文件系统

mount hugetlbfs /mnt/huge -t hugetlbfs

3.映射hugetbl文件

fd = open(“/mnt/huge/test.txt”, O_CREAT|O_RDWR);

addr = mmap(0, MAP_LENGTH, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);

4.hugepage统计信息

通过hugepage提供的sysfs接口，可以了解大页使用情况

HugePages_Total: 预先分配的大页数量

HugePages_Free：空闲大页数量

HugePages_Rsvd: mmap申请大页数量(还没有产生缺页)

HugePages_Surp: 多分配的大页数量(由nr_overcommit_hugepages决定)

5 hugpage优缺点

缺点:

1.需要提前预估大页使用量，并且预留的大页不能被其他内存分配接口使用。

2.兼容性不好，应用使用标准大页，需要对代码进行重构才能有效的使用标准大页。

优点:因为内存是预留的，缺页延时非常小

针对Hugepage的不足，内核又衍生出了THP大页(Transparent Huge pages)

工具

yum install libhugetlbfs-utils -y

//列出
hugeadm --pool-list
      Size  Minimum  Current  Maximum  Default
   2097152    12850    12850    12850        *
1073741824        0        0        0

hugeadm --list-all-mounts
Mount Point          Options
/dev/hugepages       rw,relatime,pagesize=2M

大页和 MySQL 性能 case

MySQL的页都是16K, 当查询的行不在内存中时需要按照16K为单位从磁盘读取页,而文件系统中的页是4k，也就是一次数据库请求需要有4次磁盘IO，如过查询比较随机，每次只需要一个页中的几行数据，存在很大的读放大。

那么我们是否可以把MySQL的页设置为4K来减少读放大呢？

在5.7里收益不大，因为每次IO存在 fil_system 的锁，导致IO的并发上不去

8.0中总算优化了这个场景，测试细节可以参考这篇

16K VS 4K 性能对比（4K接近翻倍）

4K会带来的问题：顺序insert慢了10%（因为fsync更多了）；DDL更慢；二级索引更多的场景下4K性能较差；大BP下，刷脏代价大。

HugePage 带来的问题

CPU对同一个Page抢占增多

对于写操作密集型的应用，Huge Page会大大增加Cache写冲突的发生概率。由于CPU独立Cache部分的写一致性用的是MESI协议，写冲突就意味：

通过CPU间的总线进行通讯，造成总线繁忙
同时也降低了CPU执行效率。
CPU本地Cache频繁失效

类比到数据库就相当于，原来一把用来保护10行数据的锁，现在用来锁1000行数据了。必然这把锁在线程之间的争抢概率要大大增加。

连续数据需要跨CPU读取

Page太大，更容易造成Page跨Numa/CPU 分布。

从下图我们可以看到，原本在4K小页上可以连续分配，并因为较高命中率而在同一个CPU上实现locality的数据。到了Huge Page的情况下，就有一部分数据为了填充统一程序中上次内存分配留下的空间，而被迫分布在了两个页上。而在所在Huge Page中占比较小的那部分数据，由于在计算CPU亲和力的时候权重小，自然就被附着到了其他CPU上。那么就会造成：本该以热点形式存在于CPU2 L1或者L2 Cache上的数据，不得不通过CPU inter-connect去remote CPU获取数据。假设我们连续申明两个数组，Array A和Array B大小都是1536K。内存分配时由于第一个Page的2M没有用满，因此Array B就被拆成了两份，分割在了两个Page里。而由于内存的亲和配置，一个分配在Zone 0，而另一个在Zone 1。那么当某个线程需要访问Array B时就不得不通过代价较大的Inter-Connect去获取另外一部分数据。

Java进程开启HugePage

从perf数据来看压满后tlab miss比较高，得想办法降低这个值

修改JVM启动参数

JVM启动参数增加如下三个(-XX:LargePageSizeInBytes=2m, 这个一定要，有些资料没提这个，在我的JDK8.0环境必须要)：

-XX:+UseLargePages -XX:LargePageSizeInBytes=2m -XX:+UseHugeTLBFS

修改机器系统配置

设置HugePage的大小

cat /proc/sys/vm/nr_hugepages

nr_hugepages设置多大参考如下计算方法：

If you are using the option -XX:+UseSHM or -XX:+UseHugeTLBFS, then specify the number of large pages. In the following example, 3 GB of a 4 GB system are reserved for large pages (assuming a large page size of 2048kB, then 3 GB = 3 * 1024 MB = 3072 MB = 3072 * 1024 kB = 3145728 kB and 3145728 kB / 2048 kB = 1536):

echo 1536 > /proc/sys/vm/nr_hugepages

透明大页是没有办法减少系统tlab，tlab是对应于进程的，系统分给进程的透明大页还是由物理上的4K page组成。

对于c++来说，他malloc经常会散落得全地址都是，因为会触发各种mmap，冷热区域。所以THP和hugepage都可能导致大量内存被浪费了，进而导致内存紧张，性能下滑。jvm的连续内存布局，加上gc会使得内存密度很紧凑。THP的问题是，他是逻辑页，不是物理页，tlb依旧要N份，所以他的收益来自page fault减少，是一次性的收益。

hugepage的在减少page_fault上和thp效果一样第二个作用是，他只需要一份TLB了，hugepage是真正的大页内存，thp是逻辑上的，物理上还是需要很多小的page。

如果TLB miss，则可能需要额外三次内存读取操作才能将线性地址翻译为物理地址。

code_hugepage 代码大页

代码大页特性主要为大代码段业务服务，可以降低程序的iTLB miss，从而提升程序性能。针对倚天这一类跨numa访存开销大的芯片有比较好的性能提升效果

1 2	// 1 表示仅打开二进制和动态库大页 2 仅打开可执行匿名大页 3 相当于1+2，0 表示关闭 echo 1 > /sys/kernel/mm/transparent_hugepage/hugetext_enabled //1 可以改成2/3

是否启用代码大页，可以查看/proc//smaps中FilePmdMapped字段可确定是否使用了代码大页。扫描进程代码大页使用数量（单位KB）：

1	cat /proc/<pid>/smaps \| grep FilePmdMapped \| awk '{sum+=$2}END{print"Sum= ",sum}'

THP

Linux kernel在2.6.38内核增加了Transparent Huge Pages (THP)特性，支持大内存页(2MB)分配，默认开启。当开启时可以降低fork子进程的速度，但fork之后，每个内存页从原来4KB变为2MB，会大幅增加重写期间父进程内存消耗。同时每次写命令引起的复制内存页单位放大了512倍，会拖慢写操作的执行时间，导致大量写操作慢查询。例如简单的incr命令也会出现在慢查询中。因此Redis日志中建议将此特性进行禁用。

THP 的目的是用一个页表项来映射更大的内存（大页），这样可以减少 Page Fault，因为需要的页数少了。当然，这也会提升 TLB（Translation Lookaside Buffer，由存储器管理单元用于改进虚拟地址到物理地址的转译速度）命中率，因为需要的页表项也少了。如果进程要访问的数据都在这个大页中，那么这个大页就会很热，会被缓存在 Cache 中。而大页对应的页表项也会出现在 TLB 中，从上一讲的存储层次我们可以知道，这有助于性能提升。但是反过来，假设应用程序的数据局部性比较差，它在短时间内要访问的数据很随机地位于不同的大页上，那么大页的优势就会消失。

大页在使用的时候需要清理512个4K页面，再返回给用户，这里的清理动作可能会导致卡顿。另外碎片化严重的时候触发内存整理造成卡顿

大页分配: 在缺页处理函数__handle_mm_fault中判断是否使用大页大页生成: 主要通过在分配大页内存时是否带__GFP_DIRECT_RECLAIM 标志来控制大页的生成.

1.异步生成大页: 在缺页处理中，把需要异步生成大页的VMA注册到链表，内核态线程khugepaged 动态为vma分配大页(内存回收，内存归整)

2.madvise系统调用只是给VMA加了VM_HUGEPAGE,用来标记这段虚拟地址需要使用大页

THP 原理

大页分配: 在缺页处理函数__handle_mm_fault中判断是否使用大页大页生成: 主要通过在分配大页内存时是否带__GFP_DIRECT_RECLAIM 标志来控制大页的生成.

1.异步生成大页: 在缺页处理中，把需要异步生成大页的VMA注册到链表，内核态线程khugepaged 动态为vma分配大页(内存回收，内存归整)

2.madvise系统调用只是给VMA加了VM_HUGEPAGE,用来标记这段虚拟地址需要使用大页

THP 对redis、mongodb 这种cache类推荐关闭，对drds这种java应用最好打开

#cat /sys/kernel/mm/transparent_hugepage/enabled
[always] madvise never

grep "Huge" /proc/meminfo
AnonHugePages:   1286144 kB
ShmemHugePages:        0 kB
HugePages_Total:       0
HugePages_Free:        0
HugePages_Rsvd:        0
HugePages_Surp:        0
Hugepagesize:       2048 kB
Hugetlb:               0 kB

$grep -e AnonHugePages  /proc/*/smaps | awk  '{ if($2>4) print $0} ' |  awk -F "/"  '{print $0; system("ps -fp " $3)} '

$grep -e AnonHugePages  /proc/*/smaps | awk  '{ if($2>4) print $0} ' |  awk -F "/"  '{print $0; system("ps -fp " $3)} '

//查看pagesize（默认4K） 
$getconf PAGESIZE

在透明大页功能打开时，造成系统性能下降的主要原因可能是 khugepaged 守护进程。该进程会在（它认为）系统空闲时启动，扫描系统中剩余的空闲内存，并将普通 4k 页转换为大页。该操作会在内存路径中加锁，而该守护进程可能会在错误的时间启动扫描和转换大页的操作，从而影响应用性能。

此外，当缺页异常(page faults)增多时，透明大页会和普通 4k 页一样，产生同步内存压缩(direct compaction)操作，以节省内存。该操作是一个同步的内存整理操作，如果应用程序会短时间分配大量内存，内存压缩操作很可能会被触发，从而会对系统性能造成风险。https://yq.aliyun.com/articles/712830

#查看系统级别的 THP 使用情况，执行下列命令：
cat /proc/meminfo  | grep AnonHugePages
#类似地，查看进程级别的 THP 使用情况，执行下列命令：
cat /proc/1730/smaps | grep AnonHugePages |grep -v "0 kB"
#是否开启了hugepage
$cat /sys/kernel/mm/transparent_hugepage/enabled
always [madvise] never

/proc/sys/vm/nr_hugepages 中存储的数据就是大页面的数量，虽然在默认情况下它的值都是 0，不过我们可以通过更改该文件的内容申请或者释放操作系统中的大页：

$ echo 1 > /proc/sys/vm/nr_hugepages
$ cat /proc/meminfo | grep HugePages_
HugePages_Total:       1
HugePages_Free:        1

THP和perf

thp on后比off性能稳定好 10-15%，开启THP最显著的指标是 iTLB命中率显著提升了

//on 419+E5-2682， thp never
9,145,128,732      branch-instructions       #  229.068 M/sec                    (10.65%)
       555,518,878      branch-misses             #    6.07% of all branches          (14.24%)
     3,951,535,475      bus-cycles                #   98.979 M/sec                    (14.29%)
       372,477,068      cache-misses              #    7.733 % of all cache refs      (14.34%)
     4,816,702,013      cache-references          #  120.649 M/sec                    (14.36%)
   114,521,174,305      cpu-cycles                #    2.869 GHz                      (14.36%)
    48,969,565,344      instructions              #    0.43  insn per cycle           (17.93%)
    98,728,666,922      ref-cycles                # 2472.967 M/sec                    (21.52%)
         39,922.47 msec cpu-clock                 #    7.898 CPUs utilized
     1,848,336,574      L1-dcache-load-misses     #   13.31% of all L1-dcache hits    (21.51%)
    13,889,399,043      L1-dcache-loads           #  347.903 M/sec                    (21.51%)
     7,055,617,648      L1-dcache-stores          #  176.730 M/sec                    (21.50%)
     2,017,950,458      L1-icache-load-misses                                         (21.50%)
        88,802,885      LLC-load-misses           #    9.86% of all LL-cache hits     (14.35%)
       900,379,398      LLC-loads                 #   22.553 M/sec                    (14.33%)
       162,711,813      LLC-store-misses          #    4.076 M/sec                    (7.13%)
       419,869,955      LLC-stores                #   10.517 M/sec                    (7.14%)
       553,257,955      branch-load-misses        #   13.858 M/sec                    (10.71%)
     9,195,874,519      branch-loads              #  230.339 M/sec                    (14.29%)
       176,112,524      dTLB-load-misses          #    1.28% of all dTLB cache hits   (14.29%)
    13,739,965,115      dTLB-loads                #  344.160 M/sec                    (14.28%)
        33,087,849      dTLB-store-misses         #    0.829 M/sec                    (14.28%)
     6,992,863,588      dTLB-stores               #  175.158 M/sec                    (14.26%)
       170,555,902      iTLB-load-misses          #  107.90% of all iTLB cache hits   (14.24%)
       158,070,998      iTLB-loads                #    3.959 M/sec                    (14.24%)

//on 419+E5-2682， thp always
    12,958,974,094      branch-instructions       #  227.392 M/sec                    (10.68%)
       850,468,837      branch-misses             #    6.56% of all branches          (14.27%)
     5,639,495,284      bus-cycles                #   98.957 M/sec                    (14.29%)
       526,744,798      cache-misses              #    7.324 % of all cache refs      (14.32%)
     7,192,328,925      cache-references          #  126.204 M/sec                    (14.34%)
   163,419,436,811      cpu-cycles                #    2.868 GHz                      (14.33%)
    68,638,583,038      instructions              #    0.42  insn per cycle           (17.90%)
   140,882,455,768      ref-cycles                # 2472.076 M/sec                    (21.48%)
         56,987.52 msec cpu-clock                 #    7.932 CPUs utilized
     2,471,392,118      L1-dcache-load-misses     #   12.69% of all L1-dcache hits    (21.47%)
    19,480,914,771      L1-dcache-loads           #  341.833 M/sec                    (21.48%)
    10,059,893,871      L1-dcache-stores          #  176.522 M/sec                    (21.46%)
     3,184,073,065      L1-icache-load-misses                                         (21.46%)
       128,467,945      LLC-load-misses           #   10.83% of all LL-cache hits     (14.31%)
     1,186,653,892      LLC-loads                 #   20.822 M/sec                    (14.30%)
       224,877,539      LLC-store-misses          #    3.946 M/sec                    (7.15%)
       628,574,746      LLC-stores                #   11.030 M/sec                    (7.15%)
       848,830,289      branch-load-misses        #   14.894 M/sec                    (10.71%)
    13,074,297,582      branch-loads              #  229.416 M/sec                    (14.28%)
       109,223,171      dTLB-load-misses          #    0.56% of all dTLB cache hits   (14.27%)
    19,418,657,165      dTLB-loads                #  340.741 M/sec                    (14.29%)
        13,930,402      dTLB-store-misses         #    0.244 M/sec                    (14.28%)
    10,047,511,003      dTLB-stores               #  176.305 M/sec                    (14.28%)
       194,902,860      iTLB-load-misses          #   61.23% of all iTLB cache hits   (14.27%)
       318,292,771      iTLB-loads                #    5.585 M/sec                    (14.26%)

//on 310+8269 thp never
        90,790,778      dTLB-load-misses          #    0.67% of all dTLB cache hits   (16.66%)
    13,639,069,352      dTLB-loads                                                    (16.66%)
         6,553,693      dTLB-store-misses                                             (16.63%)
     6,494,274,815      dTLB-stores                                                   (20.28%)
        76,175,883      iTLB-load-misses          #   40.53% of all iTLB cache hits   (20.80%)
       187,932,292      iTLB-loads                                                    (20.76%)

//on 310+8269 thp always
     7,199,483,512      branch-instructions       #  338.269 M/sec                    (11.46%)
        81,893,729      branch-misses             #    1.14% of all branches          (14.95%)
       532,919,206      bus-cycles                #   25.039 M/sec                    (14.85%)
       253,267,167      cache-misses              #   11.507 % of all cache refs      (14.81%)
     2,201,001,946      cache-references          #  103.414 M/sec                    (14.15%)
    63,971,073,336      cpu-cycles                #    3.006 GHz                      (14.55%)
    37,214,341,673      instructions              #    0.58  insns per cycle          (18.09%)
    52,209,823,072      ref-cycles                # 2453.086 M/sec                    (17.23%)
     1,098,964,315      L1-dcache-load-misses     #   10.17% of all L1-dcache hits    (14.22%)
    10,808,109,191      L1-dcache-loads           #  507.820 M/sec                    (14.31%)
     5,092,652,478      L1-dcache-stores          #  239.279 M/sec                    (14.38%)
     4,338,580,209      L1-icache-load-misses     #  203.849 M/sec                    (14.40%)
        60,262,584      LLC-load-misses           #   21.81% of all LL-cache hits     (14.35%)
       276,321,779      LLC-loads                 #   12.983 M/sec                    (14.31%)
        62,982,184      LLC-store-misses          #    2.959 M/sec                    (10.76%)
       105,448,227      LLC-stores                #    4.954 M/sec                    (8.08%)
        81,163,187      branch-load-misses        #    3.813 M/sec                    (11.67%)
     7,111,481,940      branch-loads              #  334.134 M/sec                    (14.37%)
         4,527,406      dTLB-load-misses          #    0.04% of all dTLB cache hits   (14.30%)
    10,726,725,791      dTLB-loads                #  503.997 M/sec                    (17.33%)
         1,066,097      dTLB-store-misses         #    0.050 M/sec                    (17.37%)
     5,090,008,144      dTLB-stores               #  239.155 M/sec                    (17.34%)
        18,715,797      iTLB-load-misses          #   18.97% of all iTLB cache hits   (17.33%)
        98,684,189      iTLB-loads                #    4.637 M/sec                    (14.29%)

MySQL 场景下代码大页对性能的影响

不只是数据可以用HugePage，代码段也可以开启HugePage, 无论在x86还是arm（arm下提升更明显）下，都可以得到大页优于透明大页，透明大页优于正常的4K page

收益：代码大页 > anon THP > 4k

arm下，对32core机器用32并发的sysbench来对比，代码大页带来的性能提升大概有11%，iTLB miss下降了10倍左右。

x86下，性能提升只有大概3-5%之间，iTLB miss下降了1.5-3倍左右。

TLAB miss高的案例

程序运行久了之后会变慢大概10%

刚开始运行的时候perf各项数据:

长时间运行后：

内存的利用以页为单位，当时分析认为，在此4k连续的基础上，页的碎片不应该对64 byte align的cache有什么影响。当时guest和host都没有开THP。

既然无法理解这个结果，那就只有按部就班的查看内核执行路径上各个函数的差别了，祭出ftrace:

echo kerel_func_name1 > /sys/kernel/debug/tracing/set_ftrace_filter

echo kerel_func_name2 > /sys/kernel/debug/tracing/set_ftrace_filter

echo kerel_func_name3 > /sys/kernel/debug/tracing/set_ftrace_filter
echo 1 > /sys/kernel/debug/tracing/function_profile_enabled

在CPU#20上执行代码:

taskset -c 20 ./b

代码执行完后:

1 2	echo 0 > /sys/kernel/debug/tracing/function_profile_enabled cat /sys/kernel/debug/tracing/trace_stat/function20

这个时候就会打印出在各个函数上花费的时间，比如:

经过调试后，逐步定位到主要时间差距在 __mem_cgroup_commit_charge() (58%).

在阅读代码的过程中，注意到当前内核使能了CONFIG_SPARSEMEM_VMEMMAP=y

原因就是机器运行久了之后内存碎片化严重，导致TLAB Miss严重。

解决：开启THP后，性能稳定

碎片化

内存碎片严重的话会导致系统hang很久(回收、压缩内存）

尽量让系统的free多一点(比例高一点）可以调整 vm.min_free_kbytes(128G 以内 2G，256G以内 4G/8G), 线上机器直接修改vm.min_free_kbytes会触发回收，导致系统hang住 https://www.atatech.org/articles/163233 https://www.atatech.org/articles/97130

compact: 在进行 compcation 时，线程会从前往后扫描已使用的 movable page，然后从后往前扫描 free page，扫描结束后会把这些 movable page 给迁移到 free page 里，最终规整出一个 2M 的连续物理内存，这样 THP 就可以成功申请内存了。

一次THP compact堆栈：

java          R  running task        0 144305 144271 0x00000080
 ffff88096393d788 0000000000000086 ffff88096393d7b8 ffffffff81060b13
 ffff88096393d738 ffffea003968ce50 000000000000000e ffff880caa713040
 ffff8801688b0638 ffff88096393dfd8 000000000000fbc8 ffff8801688b0640

Call Trace:
 [<ffffffff81060b13>] ? perf_event_task_sched_out+0x33/0x70
 [<ffffffff8100bb8e>] ? apic_timer_interrupt+0xe/0x20
 [<ffffffff810686da>] __cond_resched+0x2a/0x40
 [<ffffffff81528300>] _cond_resched+0x30/0x40
 [<ffffffff81169505>] compact_checklock_irqsave+0x65/0xd0
 [<ffffffff81169862>] compaction_alloc+0x202/0x460
 [<ffffffff811748d8>] ? buffer_migrate_page+0xe8/0x130
 [<ffffffff81174b4a>] migrate_pages+0xaa/0x480
 [<ffffffff81169660>] ? compaction_alloc+0x0/0x460                 //compact and migrate
 [<ffffffff8116a1a1>] compact_zone+0x581/0x950
 [<ffffffff8116a81c>] compact_zone_order+0xac/0x100
 [<ffffffff8116a951>] try_to_compact_pages+0xe1/0x120
 [<ffffffff8112f1ba>] __alloc_pages_direct_compact+0xda/0x1b0
 [<ffffffff8112f80b>] __alloc_pages_nodemask+0x57b/0x8d0
 [<ffffffff81167b9a>] alloc_pages_vma+0x9a/0x150
 [<ffffffff8118337d>] do_huge_pmd_anonymous_page+0x14d/0x3b0        //huge page
 [<ffffffff8152a116>] ? rwsem_down_read_failed+0x26/0x30
 [<ffffffff8114b350>] handle_mm_fault+0x2f0/0x300
 [<ffffffff810ae950>] ? wake_futex+0x40/0x60
 [<ffffffff8104a8d8>] __do_page_fault+0x138/0x480
 [<ffffffff810097cc>] ? __switch_to+0x1ac/0x320
 [<ffffffff81527910>] ? thread_return+0x4e/0x76e
 [<ffffffff8152d45e>] do_page_fault+0x3e/0xa0                       //page fault
 [<ffffffff8152a815>] page_fault+0x25/0x30

查看pagetypeinfo

#cat /proc/pagetypeinfo
Page block order: 9
Pages per block:  512

Free pages count per migrate type at order       0      1      2      3      4      5      6      7      8      9     10
Node    0, zone      DMA, type    Unmovable      1      1      1      0      2      1      1      0      1      0      0
Node    0, zone      DMA, type  Reclaimable      0      0      0      0      0      0      0      0      0      0      0
Node    0, zone      DMA, type      Movable      0      0      0      0      0      0      0      0      0      1      3
Node    0, zone      DMA, type      Reserve      0      0      0      0      0      0      0      0      0      0      0
Node    0, zone      DMA, type          CMA      0      0      0      0      0      0      0      0      0      0      0
Node    0, zone      DMA, type      Isolate      0      0      0      0      0      0      0      0      0      0      0
Node    0, zone    DMA32, type    Unmovable     89    144     98     42     21     14      5      2      1      0      1
Node    0, zone    DMA32, type  Reclaimable     28     22      9      8      0      0      0      0      0      1      7
Node    0, zone    DMA32, type      Movable    402     50     21      8    880    924    321     51      4      1    227
Node    0, zone    DMA32, type      Reserve      0      0      0      0      0      0      0      0      0      0      1
Node    0, zone    DMA32, type          CMA      0      0      0      0      0      0      0      0      0      0      0
Node    0, zone    DMA32, type      Isolate      0      0      0      0      0      0      0      0      0      0      0
Node    0, zone   Normal, type    Unmovable  13709  15231   6637   2646    816    181     46      4      4      1      0
Node    0, zone   Normal, type  Reclaimable      1      5      6   3293   1295    128     29      7      5      0      0
Node    0, zone   Normal, type      Movable   6396 1383350 1301956 1007627 670102 366248 160232  54894  13126   1482     37
Node    0, zone   Normal, type      Reserve      0      0      0      2      1      1      0      0      0      0      0
Node    0, zone   Normal, type          CMA      0      0      0      0      0      0      0      0      0      0      0
Node    0, zone   Normal, type      Isolate      0      0      0      0      0      0      0      0      0      0      0

Number of blocks type     Unmovable  Reclaimable      Movable      Reserve          CMA      Isolate
Node 0, zone      DMA            1            0            7            0            0            0
Node 0, zone    DMA32           24           38          889            1            0            0
Node 0, zone   Normal         1568          795       127683            2            0            0
Page block order: 9
Pages per block:  512

Free pages count per migrate type at order       0      1      2      3      4      5      6      7      8      9     10
Node    1, zone   Normal, type    Unmovable   3938   8735   5469   3221   2097    989    202      6      0      0      0
Node    1, zone   Normal, type  Reclaimable      1      7      7      8      7      2      2      2      1      0      0
Node    1, zone   Normal, type      Movable  18623 1001037 2084894 1261484 631159 276096  87272  17169   1389    797      0
Node    1, zone   Normal, type      Reserve      0      0      0      8      0      0      0      0      0      0      0
Node    1, zone   Normal, type          CMA      0      0      0      0      0      0      0      0      0      0      0
Node    1, zone   Normal, type      Isolate      0      0      0      0      0      0      0      0      0      0      0

Number of blocks type     Unmovable  Reclaimable      Movable      Reserve          CMA      Isolate
Node 1, zone   Normal         1530          637       128903            2            0            0

每个zone都有自己的min low high,如下，但是单位是page, 计算案例：

[root@jiangyi01.sqa.zmf /home/ahao.mah]
#cat /proc/zoneinfo  |grep "Node"
Node 0, zone      DMA
Node 0, zone    DMA32
Node 0, zone   Normal
Node 1, zone   Normal

[root@jiangyi01.sqa.zmf /home/ahao.mah]
#cat /proc/zoneinfo  |grep "Node 0, zone" -A10
Node 0, zone      DMA
  pages free     3975
        min      20
        low      25
        high     30
        scanned  0
        spanned  4095
        present  3996
        managed  3975
    nr_free_pages 3975
    nr_alloc_batch 5
--
Node 0, zone    DMA32
  pages free     382873
        min      2335
        low      2918
        high     3502
        scanned  0
        spanned  1044480
        present  513024
        managed  450639
    nr_free_pages 382873
    nr_alloc_batch 584
--
Node 0, zone   Normal
  pages free     11105097
        min      61463
        low      76828
        high     92194
        scanned  0
        spanned  12058624
        present  12058624
        managed  11859912
    nr_free_pages 11105097
    nr_alloc_batch 12344
    
    low = 5/4 * min
high = 3/2 * min

[root@jiangyi01.sqa.zmf /home/ahao.mah]
#T=min;sum=0;for i in `cat /proc/zoneinfo  |grep $T | awk '{print $NF}'`;do sum=`echo "$sum+$i" |bc`;done;sum=`echo "$sum*4/1024" |bc`;echo "sum=${sum} MB"
sum=499 MB

[root@jiangyi01.sqa.zmf /home/ahao.mah]
#T=low;sum=0;for i in `cat /proc/zoneinfo  |grep $T | awk '{print $NF}'`;do sum=`echo "$sum+$i" |bc`;done;sum=`echo "$sum*4/1024" |bc`;echo "sum=${sum} MB"
sum=624 MB

[root@jiangyi01.sqa.zmf /home/ahao.mah]
#T=high;sum=0;for i in `cat /proc/zoneinfo  |grep $T | awk '{print $NF}'`;do sum=`echo "$sum+$i" |bc`;done;sum=`echo "$sum*4/1024" |bc`;echo "sum=${sum} MB"
sum=802 MB

内存碎片化导致rt升高的诊断

判定方法如下：

运行 sar -B 观察 pgscand/s，其含义为每秒发生的直接内存回收次数，当在一段时间内持续大于 0 时，则应继续执行后续步骤进行排查；
运行 cat /sys/kernel/debug/extfrag/extfrag_index 观察内存碎片指数，重点关注 order >= 3 的碎片指数，当接近 1.000 时，表示碎片化严重，当接近 0 时表示内存不足；
运行 cat /proc/buddyinfo, cat /proc/pagetypeinfo 查看内存碎片情况，指标含义参考（https://man7.org/linux/man-pages/man5/proc.5.html），同样关注 order >= 3 的剩余页面数量，pagetypeinfo 相比 buddyinfo 展示的信息更详细一些，根据迁移类型（伙伴系统通过迁移类型实现反碎片化）进行分组，需要注意的是，当迁移类型为 Unmovable 的页面都聚集在 order < 3 时，说明内核 slab 碎片化严重，我们需要结合其他工具来排查具体原因，在本文就不做过多介绍了；
对于 CentOS 7.6 等支持 BPF 的 kernel 也可以运行我们研发的 drsnoop，compactsnoop 工具对延迟进行定量分析，使用方法和解读方式请参考对应文档；
(Opt) 使用 ftrace 抓取 mm_page_alloc_extfrag 事件，观察因内存碎片从备用迁移类型“盗取”页面的信息。

参考资料

https://www.atatech.org/articles/66885

https://cloud.tencent.com/developer/article/1087455

https://www.cnblogs.com/xiaolincoding/p/13719610.html

Linux内存--PageCache

发表于 2020-11-15 更新于 2025-11-16 分类于 Memory

Linux内存–PageCache

本系列有如下几篇

[Linux 内存问题汇总](/2020/01/15/Linux 内存问题汇总/)

read/write

read(2)/write(2) 是 Linux 系统中最基本的 I/O 读写系统调用，我们开发操作 I/O 的程序时必定会接触到它们，而在这两个系统调用和真实的磁盘读写之间存在一层称为 Kernel buffer cache 的缓冲区缓存。在 Linux 中 I/O 缓存其实可以细分为两个：Page Cache 和 Buffer Cache，这两个其实是一体两面，共同组成了 Linux 的内核缓冲区（Kernel Buffer Cache），Page Cache 是在应用程序读写文件的过程中产生的：

读磁盘：内核会先检查 Page Cache 里是不是已经缓存了这个数据，若是，直接从这个内存缓冲区里读取返回，若否，则穿透到磁盘去读取，然后再缓存在 Page Cache 里，以备下次缓存命中；
写磁盘：内核直接把数据写入 Page Cache，并把对应的页标记为 dirty，添加到 dirty list 里，然后就直接返回，内核会定期把 dirty list 的页缓存 flush 到磁盘，保证页缓存和磁盘的最终一致性。

在 Linux 还不支持虚拟内存技术之前，还没有页的概念，因此 Buffer Cache 是基于操作系统读写磁盘的最小单位 – 块（block）来进行的，所有的磁盘块操作都是通过 Buffer Cache 来加速，Linux 引入虚拟内存的机制来管理内存后，页成为虚拟内存管理的最小单位，因此也引入了 Page Cache 来缓存 Linux 文件内容，主要用来作为文件系统上的文件数据的缓存，提升读写性能，常见的是针对文件的 read()/write() 操作，另外也包括了通过 mmap() 映射之后的块设备，也就是说，事实上 Page Cache 负责了大部分的块设备文件的缓存工作。而 Buffer Cache 用来在系统对块设备进行读写的时候，对块进行数据缓存的系统来使用。

在 Linux 2.4 版本之后，kernel 就将两者进行了统一，Buffer Cache 不再以独立的形式存在，而是以融合的方式存在于 Page Cache 中

融合之后就可以统一操作 Page Cache 和 Buffer Cache：处理文件 I/O 缓存交给 Page Cache，而当底层 RAW device 刷新数据时以 Buffer Cache 的块单位来实际处理。

pagecache 的产生和释放

标准 I/O 是写的 (write(2)) 用户缓冲区 (Userpace Page 对应的内存)，然后再将用户缓冲区里的数据拷贝到内核缓冲区 (Pagecache Page 对应的内存)；如果是读的 (read(2)) 话则是先从内核缓冲区拷贝到用户缓冲区，再从用户缓冲区读数据，也就是 buffer 和文件内容不存在任何映射关系。
对于存储映射 I/O（Memory-Mapped I/O）而言，则是直接将 Pagecache Page 给映射到用户地址空间，用户直接读写 Pagecache Page 中内容，效率相对标准IO更高一些

当 将用户缓冲区里的数据拷贝到内核缓冲区 (Pagecache Page 对应的内存) 最容易发生缺页中断，OS需要先分配Page（应用感知到的就是卡顿了）

Page Cache 是在应用程序读写文件的过程中产生的，所以在读写文件之前你需要留意是否还有足够的内存来分配 Page Cache；
Page Cache 中的脏页很容易引起问题，你要重点注意这一块；
在系统可用内存不足的时候就会回收 Page Cache 来释放出来内存，可以通过 sar 或者 /proc/vmstat 来观察这个行为从而更好的判断问题是否跟回收有关

缺页后kswapd在短时间内回收不了足够多的 free 内存，或kswapd 还没有触发执行，操作系统就会进行内存页直接回收。这个过程中，应用会进行自旋等待直到回收的完成，从而产生巨大的延迟。

如果page被swapped，那么恢复进内存的过程也对延迟有影响，当匿名内存页被回收后，如果下次再访问就会产生IO的延迟。

min 和 low的区别

min下的内存是保留给内核使用的；当到达min，会触发内存的direct reclaim （vm.min_free_kbytes）
low水位比min高一些，当内存可用量小于low的时候，会触发 kswapd回收内存，当kswapd慢慢的将内存回收到high水位，就开始继续睡眠

内存回收方式

内存回收方式有两种，主要对应low ，min

kswapd reclaim : 达到low水位线时执行 – 异步（实际还有，只是比较危险了，后台kswapd会回收，不会卡顿应用）
direct reclaim : 达到min水位线时执行 – 同步

为了减少缺页中断，首先就要保证我们有足够的内存可以使用。由于Linux会尽可能多的使用free的内存，运行很久的应用free的内存是很少的。下面的图中，紫色表示已经使用的内存，白色表示尚未分配的内存。当我们的内存使用达到水位的low值的时候，kswapd就会开始回收工作，而一旦内存分配超过了min，就会进行内存的直接回收。

针对这种情况，需要采用预留内存的手段，系统参数vm.extra_free_kbytes就是用来做这个事情的。这个参数设置了系统预留给应用的内存，可以避免紧急需要内存时发生内存回收不及时导致的高延迟。从下面图中可以看到，通过vm.extra_free_kbytes的设置，预留内存可以让内存的申请处在一个安全的水位。需要注意的是，因为内核的优化，在3.10以上的内核版本这个参数已经被取消。

三个watermark的计算方法：

watermark[min] = vm.min_free_kbytes换算为page单位即可，假设为vm.min_free_kbytes。

watermark[low] = watermark[min] * 5 / 4

watermark[high] = watermark[min] * 3 / 2

比如默认 vm.min_free_kbytes = 65536是64K，很容易导致应用的毛刺，可以适当改大

或者禁止： vm.swappiness 来避免swapped来减少延迟

direct IO

绕过page cache，直接读写硬盘

cache回收

系统内存大体可分为三块，应用程序使用内存、系统Cache 使用内存（包括page cache、buffer，内核slab 等）和Free 内存。

应用程序使用内存：应用使用都是虚拟内存，应用申请内存时只是分配了地址空间，并未真正分配出物理内存，等到应用真正访问内存时会触发内核的缺页中断，这时候才真正的分配出物理内存，映射到用户的地址空间，因此应用使用内存是不需要连续的，内核有机制将非连续的物理映射到连续的进程地址空间中（mmu），缺页中断申请的物理内存，内核优先给低阶碎内存。
系统Cache 使用内存：使用的也是虚拟内存，申请机制与应用程序相同。
Free 内存，未被使用的物理内存，这部分内存以4k 页的形式被管理在内核伙伴算法结构中，相邻的2^n 个物理页会被伙伴算法组织到一起，形成一块连续物理内存，所谓的阶内存就是这里的n (0<= n <=10)，高阶内存指的就是一块连续的物理内存，在OSS 的场景中，如果3阶内存个数比较小的情况下，如果系统有吞吐burst 就会触发Drop cache 情况。

echo 1/2/3 >/proc/sys/vm/drop_caches

查看回收后：

cat /proc/meminfo

当我们执行 echo 2 来 drop slab 的时候，它也会把 Page Cache(inode可能会有对应的pagecache，inode释放后对应的pagecache也释放了)给 drop 掉

在系统内存紧张的时候，运维人员或者开发人员会想要通过 drop_caches 的方式来释放一些内存，但是由于他们清楚 Page Cache 被释放掉会影响业务性能，所以就期望只去 drop slab 而不去 drop pagecache。于是很多人这个时候就运行 echo 2 > /proc/sys/vm/drop_caches，但是结果却出乎了他们的意料：Page Cache 也被释放掉了，业务性能产生了明显的下降。

查看 drop_caches 是否执行过释放：

$ grep drop /proc/vmstat
drop_pagecache 1
drop_slab 0

$ grep inodesteal /proc/vmstat 
pginodesteal 114341
kswapd_inodesteal 1291853

在内存紧张的时候会触发内存回收，内存回收会尝试去回收 reclaimable（可以被回收的）内存，这部分内存既包含 Page Cache 又包含 reclaimable kernel memory(比如 slab)。inode被回收后可以通过 grep inodesteal /proc/vmstat 观察到

kswapd_inodesteal 是指在 kswapd 回收的过程中，因为回收 inode 而释放的 pagecache page 个数；

pginodesteal 是指 kswapd 之外其他线程在回收过程中，因为回收 inode 而释放的 pagecache page 个数;

Page回收–缺页中断

从图里你可以看到，在开始内存回收后，首先进行后台异步回收（上图中蓝色标记的地方），这不会引起进程的延迟；如果后台异步回收跟不上进程内存申请的速度，就会开始同步阻塞回收，导致延迟（上图中红色和粉色标记的地方，这就是引起 load 高的地址 – Sys CPU 使用率飙升/Sys load 飙升）。

那么，针对直接内存回收引起 load 飙高或者业务 RT 抖动的问题，一个解决方案就是及早地触发后台回收来避免应用程序进行直接内存回收，那具体要怎么做呢？

它的意思是：当内存水位低于 watermark low 时，就会唤醒 kswapd 进行后台回收，然后 kswapd 会一直回收到 watermark high。

那么，我们可以增大 min_free_kbytes 这个配置选项来及早地触发后台回收，该选项最终控制的是内存回收水位，不过，内存回收水位是内核里面非常细节性的知识点，我们可以先不去讨论。

对于大于等于 128G 的系统而言，将 min_free_kbytes 设置为 4G 比较合理，这是我们在处理很多这种问题时总结出来的一个经验值，既不造成较多的内存浪费，又能避免掉绝大多数的直接内存回收。

该值的设置和总的物理内存并没有一个严格对应的关系，我们在前面也说过，如果配置不当会引起一些副作用，所以在调整该值之前，我的建议是：你可以渐进式地增大该值，比如先调整为 1G，观察 sar -B 中 pgscand 是否还有不为 0 的情况；如果存在不为 0 的情况，继续增加到 2G，再次观察是否还有不为 0 的情况来决定是否增大，以此类推。

sar -B : Report paging statistics.

pgscand/s Number of pages scanned directly per second.

系统中脏页过多引起 load 飙高

直接回收过程中，如果存在较多脏页就可能涉及在回收过程中进行回写，这可能会造成非常大的延迟，而且因为这个过程本身是阻塞式的，所以又可能进一步导致系统中处于 D 状态的进程数增多，最终的表现就是系统的 load 值很高。

可以通过 sar -r 来观察系统中的脏页个数：

$ sar -r 1
07:30:01 PM kbmemfree kbmemused  %memused kbbuffers  kbcached  kbcommit   %commit  kbactive   kbinact   kbdirty
09:20:01 PM   5681588   2137312     27.34         0   1807432    193016      2.47    534416   1310876         4
09:30:01 PM   5677564   2141336     27.39         0   1807500    204084      2.61    539192   1310884        20
09:40:01 PM   5679516   2139384     27.36         0   1807508    196696      2.52    536528   1310888        20
09:50:01 PM   5679548   2139352     27.36         0   1807516    196624      2.51    536152   1310892        24

kbdirty 就是系统中的脏页大小，它同样也是对 /proc/vmstat 中 nr_dirty 的解析。你可以通过调小如下设置来将系统脏页个数控制在一个合理范围:

vm.dirty_background_bytes = 0

vm.dirty_background_ratio = 10

vm.dirty_bytes = 0

vm.dirty_expire_centisecs = 3000

vm.dirty_ratio = 20

至于这些值调整大多少比较合适，也是因系统和业务的不同而异，我的建议也是一边调整一边观察，将这些值调整到业务可以容忍的程度就可以了，即在调整后需要观察业务的服务质量 (SLA)，要确保 SLA 在可接受范围内。调整的效果可以通过 /proc/vmstat 来查看：

1
2
3

#grep "nr_dirty_" /proc/vmstat
nr_dirty_threshold 3071708
nr_dirty_background_threshold 1023902

在4.20的内核并且sar 的版本为12.3.3可以看到PSI（Pressure-Stall Information）

1 2	some avg10=45.49 avg60=10.23 avg300=5.41 total=76464318 full avg10=40.87 avg60=9.05 avg300=4.29 total=58141082

重点关注 avg10 这一列，它表示最近 10s 内存的平均压力情况，如果它很大（比如大于 40）那 load 飙高大概率是由于内存压力，尤其是 Page Cache 的压力引起的。

通过tracepoint分析内存卡顿问题

我们继续以内存规整 (memory compaction) 为例，来看下如何利用 tracepoint 来对它进行观察：

#首先来使能compcation相关的一些tracepoing
$ echo 1 >
/sys/kernel/debug/tracing/events/compaction/mm_compaction_begin/enable
$ echo 1 >
/sys/kernel/debug/tracing/events/compaction/mm_compaction_end/enable 

#然后来读取信息，当compaction事件触发后就会有信息输出
$ cat /sys/kernel/debug/tracing/trace_pipe
           <...>-49355 [037] .... 1578020.975159: mm_compaction_begin: 
zone_start=0x2080000 migrate_pfn=0x2080000 free_pfn=0x3fe5800 
zone_end=0x4080000, mode=async
           <...>-49355 [037] .N.. 1578020.992136: mm_compaction_end: 
zone_start=0x2080000 migrate_pfn=0x208f420 free_pfn=0x3f4b720 
zone_end=0x4080000, mode=async status=contended

从这个例子中的信息里，我们可以看到是 49355 这个进程触发了 compaction，begin 和 end 这两个 tracepoint 触发的时间戳相减，就可以得到 compaction 给业务带来的延迟，我们可以计算出这一次的延迟为 17ms。

或者用 perf script 脚本来分析, 基于 bcc(eBPF) 写的direct reclaim snoop来观察进程因为 direct reclaim 而导致的延迟。

参考资料

https://www.atatech.org/articles/66885

https://cloud.tencent.com/developer/article/1087455

https://www.cnblogs.com/xiaolincoding/p/13719610.html