tcpreplay 发包速率控制算法研究
一. 序
1.1 tcpreplay历史
Tcpreplay 的作者是Aaron Turner，该项目开始于2000年，早期的功能是对tcpdump等抓包工具生成的网络包（即pcap文件）的回放，并加入了一些控制，比方说控制回放的速率，以及拆分客户端和服务端的流量，控制它们从不同网络接口回放。稍后的版本加入了网络包编辑的功能，允许对pcap文件进行各个协议层的修改然后再发送。
Tcpreplay主要的应用场景是各种设备的测试，用户将某些现实场景或实验室场景下产生的流量抓下来，以pcap文件的形式存储，需要的时候就可以使用tcpreplay重现当时的场景，通使用包编辑功能可以让重现场景的应用范围更广。
截至2011年发布的tcpreplay3.4.4，该项目已历经68个版本。但是，主要算法思想变动不大，在前面10个版本的时候已经定下，后面的版本修改工作主要集中于系统兼容性、算法优化、自动编译工具支持、三方库选择等这些方面。更多内容请见：
官网：http://tcpreplay.synfin.net/
1.2 本文目的
由序可知，tcpreplay的主要算法思想在众多版本中具有稳定性，本文从中挑选了3种算法，通过不同版本对比，结合实际项目使用情况，对其进行研究、归纳、总结。这3个算法分别是：速率控制算法、流量拆分算法、缓存算法
名称说明：tcpdump抓取的网络包统一以 ‘pcap包’或者‘pcap文件’描述，一个pcap文件里包含的小包用‘packet’或者‘包’描述。
一. 速率控制算法
1.1 算法目的
Tcpreplay在最早的版本就加入了包回放速率控制的功能。可以让pcap包以抓取时候速率的特定倍数回放，或者以Mb/秒或packet/秒的速率发送出去。
Tcpreplay3.4.4 已经能支持以下速率控制
-x, --multiplier=str 以抓包速率的一定比率发packet
-p, --pps=num 每秒packet
-M, --mbps=str 每秒兆比特
-t, --topspeed 全速（不做任何时间调整）
-o, --oneatatime 终端点击一次发一个packet
--pps-multi=num 相隔特定时间发多少packet
此外，下面几个命令本质上也是速率控制用的
-T, --timer=str 睡眠函数: select, ioport, rdtsc, gtod, nano, abstime
--sleep-accel=num 睡眠调整参数
--rdtsc-clicks=num Specify the RDTSC clicks/usec 特定调整参数
1.2 算法思想
我们考虑一个问题，如何才能让一个网络流量包以特定速率发送出去？
这个问题可以这么考虑，这里的‘速率’是从用户角度出发考虑的，不是机器真正的速率！机器的发包速率是包的长度除以发包耗费时间，包的长度可以理解为内存的大小，时间可以理解为这块内存的内容写到网络接口的时间。从‘用户角度’而言，内存的大小是不可改的，时间却是可以增加的，可以通过简单的sleep 函数做到这点。
速率控制算法的大体思路就是，通过适当的sleep，增加包发送的时间，从而减小算出来的速率，以达到用户设定的（小于机器最大速率）的某个速率。这个算法关键是两点，一是时间，包括承载时间值的变量，以及在这些变量上的运算，tcpreplay在时间变量的精度和运算上都有一些自己的做法，以保证算出来的速率更符合‘从用户角度出发’这个最终目的，--sleep-accel 参数就是这种作用的一个例子，用于在正常运算之外做微调。二是睡眠，睡眠
的实现有多种，而且不同实现方式跟操作系统有很大关系。用户可以通过 –timer 参数选择具体的睡眠方式。
1.1 算法流程
1.1.1 说明
下面流程主要针对以下模式：
-x, --multiplier=str 以抓包速率的一定比率发包
-p, --pps=num 每秒包
-M, --mbps=str 每秒兆比特
-t, --topspeed 全速（不做任何时间调整）
对于以下模式这里没有描述出来：
-o, --oneatatime 终端点击发一次
--pps-multi=num 相隔特定时间发多少包
1.1.2 流程描述
1.1.1 流程图
1.1 算法实现
1.1.1 数据结构
/* 包回放运行时控制结构*/
struct tcpreplay_opt_s {
char *intf1_name; /*端口1名字*/
char *intf2_name;/*端口2名字*/
sendpacket_t *intf1; /*发包子控制结构*/
sendpacket_t *intf2;
tcpr_speed_t speed;
u_int32_t loop; /*循环次数*/
int sleep_accel; /*睡眠调整函数*/
int stats;
/* tcpprep 缓存数据控制结构*/
COUNTER cache_packets;
char *cachedata;
char *comment; /* tcpprep comment */
/* deal with MTU/packet len issues */
int mtu;
int truncate;
/* 睡眠模式，对应不同的睡眠函数实现*/
int accurate;
#define ACCURATE_NANOSLEEP 0
#define ACCURATE_SELECT 1
#define ACCURATE_RDTSC 2
#define ACCURATE_IOPORT 3
#define ACCURATE_GTOD 4
#define ACCURATE_ABS_TIME 5
char *files[MAX_FILES];
COUNTER limit_send;
/* 文件缓存控制结构 */
int enable_file_cache;
file_cache_t *file_cache; /*文件缓存子数据结构*/
int preload_pcap;
};
typedef struct tcpreplay_opt_s tcpreplay_opt_t;
struct packet_cache_s { /*packet 数据结构*/
struct pcap_pkthdr pkthdr; /*包头*/
u_char *pktdata;/*包身*/
struct packet_cache_s *next;
};
typedef struct packet_cache_s packet_cache_t;
typedef struct {/*文件缓存子数据结构*/
int index;
int cached;
packet_cache_t *packet_cache; /*packet 控制结构指针*/
} file_cache_t;
struct sendpacket_s {/*发包子控制结构*/
tcpr_dir_t cache_dir;
int open;
char device[20];
char errbuf[SENDPACKET_ERRBUF_SIZE];
COUNTER retry_enobufs;/*这几个COUNTER变量都是发包结果统计信息*/
COUNTER retry_eagain;
COUNTER failed;
COUNTER sent;
COUNTER bytes_sent;
COUNTER attempt;
enum sendpacket_type_t handle_type; /*发送包使用的三方库类型*/
union sendpacket_handle handle; /*句柄 */
struct tcpr_ether_addr ether;
};
typedef struct sendpacket_s sendpacket_t;
enum sendpacket_type_t { /*发送包使用的三方库类型*/
SP_TYPE_LIBNET,
SP_TYPE_LIBDNET,
SP_TYPE_LIBPCAP,
SP_TYPE_BPF,
SP_TYPE_PF_PACKET
};
union sendpacket_handle {
pcap_t *pcap;
int fd;
#ifdef HAVE_LIBDNET
eth_t *ldnet;
#endif
};
1.1.1 主要函数
/**
*发包主函数，速率控制部分主要是时间的控制。将与
*速率控制无关的部分代码省去了，用 。。。。。。。。。 表示
*/
void
send_packets(pcap_t *pcap, int cache_file_idx)
{
struct timeval last = { 0, 0 }, last_print_time = { 0, 0 }, print_delta, now;
COUNTER packetnum = 0;
struct pcap_pkthdr pkthdr; /*包头控制结构*/
const u_char *pktdata = NULL;/*包身数据结构*/
sendpacket_t *sp = options.intf1;/* 发包子控制结构*/
u_int32_t pktlen; /*包长度*/
。。。。。。。。。。。。。。。。
delta_t delta_ctx;
init_delta_time(&delta_ctx);/*存放当前时间*/
didsig = 0; /*为ONEATATIME模式注册信号*/
if (options.speed.mode != SPEED_ONEATATIME) {/*注册信号*/
(void)signal(SIGINT, catcher);
} else {
(void)signal(SIGINT, break_now);
}
。。。。。。。。。。。。。。。。。。。
/* 主循环
*/
while ((pktdata = get_next_packet(pcap, &pkthdr, cache_file_idx, prev_packet)) != NULL) {
/*为ONEATATIME模式注册信号*/
if (didsig)
break_now(0);
。。。。。。。。。。。。。。。。
packetnum++;
。。。。。。。。。。。。。。。
if (options.speed.mode != SPEED_TOPSPEED)
do_sleep((struct timeval *)&pkthdr.ts, &last, pktlen, options.accurate, sp, packetnum, &delta_ctx); /*各种速率控制的实现，在这个函数里完成*/
/* 获取当前时间*/
start_delta_time(&delta_ctx);
/*真正的发包在这里，通过调用第三方库实现 */
if (sendpacket(sp, pktdata, pktlen) < (int)pktlen)
warnx("Unable to send packet: %s", sendpacket_geterr(sp));
/*last变量存放上个packet的抓取时间*/
if (timercmp(&last, &pkthdr.ts, <))
memcpy(&last, &pkthdr.ts, sizeof(struct timeval));
pkts_sent ++; /*packets 数目累计*/
bytes_sent += pktlen;/*packets 字节数累计*/
}
从上面的函数看到，各种速率控制模式都是在时间调整函数 dosleep 里边实现。主函数在调整函数运行后才发packet,下面是时间调整函数do_sleep
static void
do_sleep(struct timeval *time, struct timeval *last, int len, int accurate,
sendpacket_t *sp, COUNTER counter, delta_t *delta_ctx)
{
/* 参数说明：
time: 当前packet抓取时的系统时间,与last的差就是前一个packet抓取的使用时间
Last: 前一个packet抓取时的系统时间
Len: 当前packet 的长度
Accurate: 睡眠模式
Sp: 发包子控制结构
Counter:当前packet 的 id
Delta_ctx: 存放系统时间的变量
*/
static struct timeval didsleep = { 0, 0 };
static struct timeval start = { 0, 0 };
struct timespec adjuster = { 0, 0 };
static struct timespec nap = { 0, 0 }, delta_time = {0, 0};
struct timeval nap_for, now, sleep_until;
struct timespec nap_this_time;
/*以上timeval 和 timespec 变量都是时间控制需要的，特别注意的是有些变量是timeval,有些是timespec,也就是精度更高，实际上，在最初的版本，时间控制变量都是timeval类型的，现在的版本部分换成了timespec进行计算以提高精度。同时两种不同精度的时间变量同时存在，导致本算法有一部分专门是用来在两种精度之间做转换和调整的，比如，pps模式下的时间微调，就是这个考虑*/
static int32_t nsec_adjuster = -1, nsec_times = -1;
float n;
static u_int32_t send = 0; /* accellerator. # of packets to send w/o sleeping */
u_int32_t ppnsec; /* packets per usec */
static int first_time = 1; /* need to track the first time through for the pps accelerator */
/*下面这个就是根据用户设置的值设定微调的时间值*/
#ifdef TCPREPLAY
adjuster.tv_nsec = options.sleep_accel * 1000;
#else
adjuster.tv_nsec = 0;
#endif
/* acclerator time? */
if (send > 0) {
send --;
return;
}
*/
/* 下面是第一个packet的处理*/
if (options.speed.mode == SPEED_PACKETRATE && options.speed.pps_multi) {
send = options.speed.pps_multi - 1;
if (first_time) {
first_time = 0;
return;
}
}
if (gettimeofday(&now, NULL) < 0)
/* 下面是第一个packet的时间变量初始化*/
if (pkts_sent == 0 || ((options.speed.mode != SPEED_MBPSRATE) && (counter == 0))) {
start = now;
timerclear(&sleep_until);
timerclear(&didsleep);
}
else { /*如果不是第一个packet,算出前面N-1个包使用的时间*/
timersub(&now, &start, &sleep_until);
}
/*下面根据不同模式算出用户指定速率换算成的时间*/
switch(options.speed.mode) {
case SPEED_MULTIPLIER:
/*以该packet抓取的时间的一定倍数去回放
*/
if (timerisset(last)) {
if (timercmp(time, last, <)) { /*这种情况一般是不可能发生的*/
timesclear(&nap);
} else {
/* time-last 就得到该packet 的抓取时间*/
timersub(time, last, &nap_for);
TIMEVAL_TO_TIMESPEC(&nap_for, &nap);
timesdiv(&nap, options.speed.speed);/*除以倍数，得到需要的速率*/
}
} else { /* last 是空，说明是第一个packet，清空nap就行了*/
timesclear(&nap);
}
break;
case SPEED_MBPSRATE:
/* 以 Mbps 的用户设定速率去发
*/
if (pkts_sent != 0) {
n = (float)len / (options.speed.speed * 1024 * 1024 / 8);
nap.tv_sec = n;
nap.tv_nsec = (n - nap.tv_sec) * 1000000000;
nap.tv_sec, nap.tv_nsec);
}
else { /* pkts_sent 是空，说明是第一个packet，清空nap就行了*/
timesclear(&nap);
}
break;
case SPEED_PACKETRATE:
/* 每秒发多少packet
*/
if (! timesisset(&nap)) {
ppnsec = 1000000000 / options.speed.speed * (options.speed.pps_multi > 0 ? options.speed.pps_multi : 1);
NANOSEC_TO_TIMESPEC(ppnsec, &nap);
}
break;
case SPEED_ONEATATIME:
/* 点击一下终端发送一个 packet
*/
/* do we skip prompting for a key press? */
if (send == 0) {
send = get_user_count(sp, counter);
}
/* decrement our send counter */
send --
return; /* leave do_sleep() */
break;
default: /*不是上面任一模式，报错退出*/
errx(-1, "Unknown/supported speed mode: %d", options.speed.mode);
break;
}
/*下面算 pps 模式下的微调时间,大概思路是将上面算出的睡眠时间变量的nsec 精度级别上进行微调，方法是与一个随机数比较，大于它则 nsec 部分取整并增加一个单位，否则取整*/
/*
* since we apply the adjuster to the sleep time, we can't modify nap
*/
memcpy(&nap_this_time, &nap, sizeof(nap_this_time));
if (accurate != ACCURATE_ABS_TIME) {
switch (options.speed.mode) {
case SPEED_MBPSRATE:
case SPEED_MULTIPLIER:/*这两种模式不微调*/
break;
/* Packets/sec is static, so we weight packets for .1usec accuracy */
case SPEED_PACKETRATE: /*这种模式才进行微调*/
if (nsec_adjuster < 0)
nsec_adjuster = (nap_this_time.tv_nsec % 10000) / 1000;
/* update in the range of 0-9 */
nsec_times = (nsec_times + 1) % 10;
if (nsec_times < nsec_adjuster) {
/* sorta looks like a no-op, but gives us a nice round usec number */
nap_this_time.tv_nsec = (nap_this_time.tv_nsec / 1000 * 1000) + 1000;
} else {
nap_this_time.tv_nsec -= (nap_this_time.tv_nsec % 1000);
}
break;
default:
errx(-1, "Unknown/supported speed mode: %d", options.speed.mode);
}
}
/*下面获取系统在发第N-1个packet的使用时间，并与用户设置速率换算成
的时间对比做差，如果用户速率换算成的时间更大，则它们的差就是需要睡眠的时间*/
get_delta_time(delta_ctx, &delta_time);/*第N-1个包实发时间*/
if (timesisset(&delta_time)) {
if (timescmp(&nap_this_time, &delta_time, >)) {/*比较实发时间和用户设置时间*/
timessub(&nap_this_time, &delta_time, &nap_this_time);
} else {
timesclear(&nap_this_time);
}
}
/*根据用户指定速率算出睡眠时间后，别忘了还需要通过adjuster进行微调*/
if (timesisset(&adjuster)) {
if (timescmp(&nap_this_time, &adjuster, >)) {
timessub(&nap_this_time, &adjuster, &nap_this_time);
} else {
timesclear(&nap_this_time);
}
}
/*下面根据用户参数指定的睡眠模式进行睡眠*/
if (!timesisset(&nap_this_time)) return; /* nap_this_time = {0, 0} 不睡眠，直接返回*/
switch (accurate) { /* 否则，根据accurate 进行睡眠 */
#ifdef HAVE_SELECT
case ACCURATE_SELECT:
select_sleep(nap_this_time);
break;
#endif
#ifdef HAVE_IOPERM
case ACCURATE_IOPORT:
ioport_sleep(nap_this_time);
break;
#endif
#ifdef HAVE_RDTSC
case ACCURATE_RDTSC:
rdtsc_sleep(nap_this_time);
break;
#endif
#ifdef HAVE_ABSOLUTE_TIME
case ACCURATE_ABS_TIME:
absolute_time_sleep(nap_this_time);
break;
#endif
case ACCURATE_GTOD:
gettimeofday_sleep(nap_this_time);
break;
case ACCURATE_NANOSLEEP:
nanosleep_sleep(nap_this_time);
break;
default:
errx(-1, "Unknown timer mode %d", accurate);
}
}
从以上实现可以看出，所谓速率控制，在实现上转换成了时间控制，为了提高时间变量操作的精确度，引入了两种级别的变量 timeval 和 timespec, 并增加了微调机制。此外，提供了多种用于睡眠的函数，以供不同操作系统下使用最合适的睡眠方法。
1.1.1 实验结果
1.1.1.1 实验1
环境：10G 发包板
Packet ID：* packet数：12921 字节数：16973900
Top speed模式，实际速率 2000 M/s 左右
设置1024 M/s, 实发速率 760 M/s 左右
设置500 M/s, 实发速率 450 M/s 左右
设置100 M/s, 实发速率 99 M/s 左右
设置50 M/s, 实发速率 49 M/s 左右
设置10 M/s, 实发速率 9.6 M/s 左右
设置5 M/s, 实发速率 4.9 M/s 左右
1.1.1.2 实验2
环境：10G 发包板
ID： * 包数：4 字节： 1930
设置1024 M/s, 实发速率 14 M/s 左右
设置500 M/s, 实发速率 14 M/s 左右
设置100 M/s, 实发速率 16.9 M/s 左右
设置50 M/s, 实发速率 13 M/s 左右
设置10 M/s, 实发速率7.5 M/s 左右
设置5 M/s, 实发速率 1.8 M/s 左右
设置1 M/s, 实发速率 1.34 M/s 左右
1.1.1.3 实验3
环境：10G 发包板
ID： * 包数：1 字节： 34
设置1024 M/s, 实发速率 0.3 M/s 左右
设置100 M/s, 实发速率 0.27 M/s 左右
设置1 M/s, 实发速率 0.32 M/s 左右
1.1.1.4 实验结果分析
从实验结果可以看出，速率控制是否准确与pcap包本身的大小有密切关系，当pcap的大小过小时，速率控制算法失效，反之，pcap包很大时，速率控制算法非常准确。
造成以上现象的原因，与时间控制变量的精度有关。由于精度过大，当pcap非常小（实验2和3相对于实验1而言）的时候，换算成的时间结果的一些关键点会被忽略，导致结果非常不一致。改进的方法可以尝试将所有时间变量改成 timespec 的情况，但这样一来又有问题，大多数睡眠的实现都只支持timeval，对于timespec精度级别的无法支持。
1.1.2 tcpreplay速率控制改进历史
1.1.2.1 1.4.* 版本的改进
1.4.beta5 版本的时候，用了nanosleep函数替代了原先的sleep函数，提高精度
1.4.2 版本的时候，用了 timerdiv 函数，在 Multi 这种模式下，算UST的时候更精确了。
上面这两次修改着力点是一样的，就是原先处理一个timeval，是 sec 和 usec 两个精度分别处理，现在先将sec换成usec的精度来算，就是变量整个精度提高了1百万。这样的结果是，包的大小比较小时，速度控制会更精确。
1.1.2.2 3.0.* 版本的改进
3.0.beta10作者在这一版本想出了一个睡眠的实现方法，据说比nanosleep更精确，叫做sleep_loop
Sleep_loop原理是，先gettimeofday获取系统时间t1,将你要睡眠的时间t2与t1相加得t，然后在一个循环里，每次循环取gettimeofday与t比较，小于t就接着循环，直到不小于t。其代价是CPU使用率更高（事实上，在睡眠的时候，CPU会达到100）
1.1.2.3 3.3.* 版本的改进
3.3.0 比较大的改动：一是使得时间变量的精度升高，从usec提高1000倍到了nsec，
二是睡眠函数的实现更丰富，针对不同的操作系统使用不同的睡眠函数。
时间变量精度提高使得在处理小包的时候当然更精确，附带问题是给睡眠造成难题，因为不是所有睡眠实现都支持这么高精度的时间。为了解决这个问题，作者设计了几个调整函数adjust，作用大体说来是将nsec调整为usec,比如，nsec>500，就直接在usec+1，小于500，则usec-1;另外，对于Pkts的情况，提出了另外一种类似的调整。
此外，针对不同OS提供不同的睡眠实现，可以让更多用户获得好的体验，无论用户使用什么系统。
1.1.3 发现该算法的一个问题
在实现速率控制Mbps时，tcpreplay 实际上是用第 N+1 个包来调整第 N 个包。假设前面N-1个包已经发送完，在发送第N个包前，根据算法，会根据 len(N) 算出一个时间t1，这个t1会加在N-2个包实际使用时间T上，假设第N-1个包的实际发送时间为t2,这样，发第N个包前，就有两个时间，一个是 T+t1,一个是T+t2,后者是前面N-1个包发送的时间，前者是根据Mbps设置前面N-1个包应该发送的时间，如果 t1>t2,就要通过睡眠 （t1-t2）来使得前面 N-1 个包的发送时间等于T+t1，也就是达到用户设定时间，然后，发送第N个包，在发送第N+1个包前又要调整前面N个包的发送时间，这时候运行调整时间的包是第N+1个包，也就是说，tcpreplay总是用下一个包的长度来调整前一个包的时间（仅限于Mbps模式）。
这有什么影响呢？目前的分析结果是：tcpreplay的速率控制算法，也即时间调整算法，其实是一个逐包调整的过程，相当于每一个包都会在整体调整中贡献力量（除了第一个包）。所以，上述问题的关键是第一个包与其余包的对比情况，如果第一个包远远大于其他的包，很可能导致实际速率大于设定的速率。反之，影响不大
