第十八节 使用JPerf 工具测试网速

iPerf 与JPerf

在解说网络测速之前，我们先来了解一下测速的工具：iPerf 是一个跨平台的网络性能测试工具，它支持Win/Linux/Mac/Android/iOS 等平台，iPerf 可以测试TCP 和UDP（我们一般不对UDP 进行测速）带宽质量，iPerf 可以丈量最大TCP 带宽，可以具有多种参数进行测试，同时iPerf 还可以报告带宽，耽误抖动和数据包丢失的环境，我们可以使用iPerf 的这些特性来测试一些网络装备如路由器，防火墙，交换机等的性能。
虽然iPerf 很好用，但是它却是下令行格式的软件，对使用测试的人员并不友爱，使用者需要记下他繁琐的下令，不过它还有一个图形界面程序叫做JPerf，使用JPerf 程序能简化了复杂下令行参数的构造，而且它还保存测试效果，而且将测试效果实时图形化出来，更加一目了然，当然，JPerf 也肯定拥有iPerf 的所有功能。
测试网络速率

获取JPerf 网络测速工具

在测速之前，我们需要得到网络测速工具，在我们的论坛上有这个工具，然后，我们直接下载即可：http://www.firebbs.cn/forum.php?mod=viewthread&tid=26274&fromuid=37393。
下载后解压，双击jperf.bat 运行，稍等一会就出现JPerf 的界面，详细见图。

图JPerf 界面
我们来解说一下这个界面的一些内容：

• 图(1)：客户端设置，电脑作为客户端，毗连到服务器中（即我们的开发板作为服务器），服
  务器地址需要填写正确，端口号默认是5001，并发流默认是1 个。
  
• 图(2)：服务器设置，电脑作为服务器，我们的开发板作为客户端，client limit 选项表现仅允许指定客户端毗连，Num Connections 指定最大允许毗连的数量，为0 不限定。
  
• 图(3)：开始和停止JPerf 的运行。
  
• 图(4)：兼容旧版本（当server 端和client 端版本不一样时使用），默认不勾选，Transmit 设置测试模式，我们一般指定发送的时间，以秒为单位，当然也可以指定发送的数据大小，以字节为单位。
  
• 图(5)：如果勾选Dual 表现同时进行双向传输测试，如果勾选Trade 表现单独进行双向传输测试，默认不勾选。
  
• 图(6)：指定需要传输的文件以及表现最大TCP 报文段。
  
• 图(7)：传输层设置，我们一般用来测试TCP 毗连的速率，Buffer Length 选项用于设置缓冲区大小，TCP Window Size 用于指定TCP 窗口大小，Max Segment Size 用于设定最大MTU 值，TCP No Delay 用于设定TCP 不延时。
  
• 图(8)：网速表现窗口，以折线图的情势表现出来。
  
• 图(9)：网速相干数据输出窗口，以文本的情势。
  

测试开发板吸收速率（NETCONN API）

首先，我们肯定需在开发板上开发程序的，那么我们就单独创建一个iPerf 测速线程，在开发板上运行，开发板作为客户端，不断监听客户端（JPerf 上位机）的毗连。
代码实现部分：我们首先拷贝一个移植好的工程，而且在工程中添加两个文件，分别为ipref.c 和ipref.h，然后在ipref.c 文件下添加代码清单 中的代码，其实这个代码跟TCP 服务器实验的代码都是差不多的，只不过吸收到数据不进行处理惩罚而已，在ipref.h 文件下添加代码清单 中的代码。
代码清单 ipref.c 文件内容

1. /* FreeRTOS 头文件*/
2. #include "FreeRTOS.h"
3. #include "task.h"
4. #include "queue.h"
5. #include "semphr.h"
7. #include <stdint.h>
8. #include <stdio.h>
10. #include <lwip/sockets.h>
12. #include "iperf.h"
14. #include "lwip/opt.h"
16. #include "lwip/sys.h"
17. #include "lwip/api.h"
19. #define IPERF_PORT 5001
20. #define IPERF_BUFSZ (4 * 1024)
22. void iperf_server(void *thread_param)
23. {
24.         struct netconn *conn, *newconn;
25.         err_t err;
26.         void* recv_data;
27.        
28.         recv_data = (void *)pvPortMalloc(IPERF_BUFSZ);
29.         if (recv_data == NULL) {
30.                 printf("No memory\n");
31.         }
32.        
33.         conn = netconn_new(NETCONN_TCP);
34.         netconn_bind(conn, IP_ADDR_ANY, 5001);
35.        
36.         LWIP_ERROR("tcpecho: invalid conn", (conn != NULL), return;);
37.        
38.         /* Tell connection to go into listening mode. */
39.         netconn_listen(conn);
40.         while (1)
41.         {
42.                 /* Grab new connection. */
43.                 err = netconn_accept(conn, &newconn);
44.                 /*printf("accepted new connection %p\n", newconn);*/
45.                 /* Process the new connection. */
46.                 if (err == ERR_OK)
47.                 {
48.                         struct netbuf *buf;
49. // void *data;
50.                         u16_t len;
51.                        
52.                         while ((err = netconn_recv(newconn, &buf)) == ERR_OK)
53.                         {
54.                                 /*printf("Recved\n");*/
55.                                 do
56.                                 {
57.                                         netbuf_data(buf, &recv_data, &len);
58. // err = netconn_write(newconn, data, len, NETCONN_COPY);
59.                                 }
60.                                 while (netbuf_next(buf) >= 0);
61.                                 netbuf_delete(buf);
62.                         }
63.                         /*printf("Got EOF, looping\n");*/
64.                         /* Close connection and discard connection identifier. */
65.                         netconn_close(newconn);
66.                         netconn_delete(newconn);
67.                 }
68.         }
69. }
70. void
71. iperf_server_init(void)
72. {
73.         sys_thread_new("iperf_server", iperf_server, NULL, 2048, 4);
74. }

复制代码

代码清单 ipref.h 文件内容

1. #ifndef LWIP_IPERF_H
2. #define LWIP_IPERF_H
4. #define TCP_SERVER_THREAD_NAME "iperf_server"
5. #define TCP_SERVER_THREAD_STACKSIZE 1024
6. #define TCP_SERVER_THREAD_PRIO 4
8. void iperf_server(void *thread_param);
9. void iperf_server_init(void);

复制代码

在main.c 文件中将iperf_server_init() 调用一下即可。而且配置好开发板的IP 地址与端口号，我们打开JPerf 测速软件，配置好要毗连的服务器IP 地址与端口，测试时间设置得长一点，我们使用10000 秒，然后点击开始，就得到我们需要的网速数据，速率高达94Mbps，即11.5M 字节/秒，已经黑白常高的速率了，而且通过折线图，我们也能看到这速率是很稳定的，详细见图。

图 NETCONN API 吸收速率
测试开发板吸收速率（Socket API）

这个实验我们只需要把上一个实验中的ipref.c 文件内容替换掉就行了，详细见代码清单。
代码清单 ipref.c 文件内容

1. /* FreeRTOS 头文件*/
2. #include "FreeRTOS.h"
3. #include "task.h"
4. #include "queue.h"
6. #include "semphr.h"
8. #include <stdint.h>
9. #include <stdio.h>
11. //#include <lwip/time.h>
12. #include <lwip/sockets.h>
13. //#include <lwip/select.h>
14. //#include "netdb.h"
15. #include "iperf.h"
17. #include "lwip/opt.h"
19. #include "lwip/sys.h"
20. #include "lwip/api.h"
22. #define IPERF_PORT 5001
23. #define IPERF_BUFSZ (4 * 1024)
25. void iperf_server(void *thread_param)
26. {
27.         uint8_t *recv_data;
28.         socklen_t sin_size;
29.         uint32_t tick1, tick2;
30.         int sock = -1, connected, bytes_received;
31.         uint64_t recvlen;
32.         struct sockaddr_in server_addr, client_addr;
33.         char speed[32] = { 0 };
34.         fd_set readset;
35.         struct timeval timeout;
36.        
37.         recv_data = (uint8_t *)pvPortMalloc(IPERF_BUFSZ);
38.         if (recv_data == NULL)
39.         {
40.                 printf("No memory\n");
41.                 goto __exit;
42.         }
43.        
44.         sock = socket(AF_INET, SOCK_STREAM, 0);
45.         if (sock < 0)
46.         {
47.                 printf("Socket error\n");
48.                 goto __exit;
49.         }
50.        
51.         server_addr.sin_family = AF_INET;
52.         server_addr.sin_addr.s_addr = INADDR_ANY;
53.         server_addr.sin_port = htons(IPERF_PORT);
54.         memset(&(server_addr.sin_zero), 0x0, sizeof(server_addr.sin_zero));
55.        
56. if (bind(sock, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1)
57.         {
58.                 printf("Unable to bind\n");
59.                 goto __exit;
60.         }
61.        
62.         if (listen(sock, 5) == -1)
63.         {
64.                 printf("Listen error\n");
65.                 goto __exit;
66.         }
67.        
68.         timeout.tv_sec = 3;
69.         timeout.tv_usec = 0;
70.        
71.         printf("iperf_server\n");
72.         while (1)
73.         {
74.                 FD_ZERO(&readset);
75.                 FD_SET(sock, &readset);
76.                
77.                 if (select(sock + 1, &readset, NULL, NULL, &timeout) == 0)
78.                         continue;
79.                
80.                 printf("iperf_server\n");
81.                 sin_size = sizeof(struct sockaddr_in);
82.        
83.                 connected = accept(sock, (struct sockaddr *)&client_addr, &sin_size);
84.        
85.                 printf("new client connected from (%s, %d)\n",
86.                         inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
87.                
88.                 {
89.                         int flag = 1;
90.                
91.                         setsockopt(connected,
92.                                         IPPROTO_TCP, /* set option at TCP level */
93.                                         TCP_NODELAY, /* name of option */
94.                                         (void *) &flag, /* the cast is historical cruft */
95.                                         sizeof(int)); /* length of option value */
96.                 }
97.        
98.                 recvlen = 0;
100.                 tick1 = xTaskGetTickCount();
101.                 while (1)
102.                 {
103.                         bytes_received = recv(connected, recv_data, IPERF_BUFSZ, 0);
104.                         if (bytes_received <= 0) break;
105.                
106.                         recvlen += bytes_received;
107.                
108.                         tick2 = xTaskGetTickCount();
109.                         if (tick2 - tick1 >= configTICK_RATE_HZ * 5)
110.                         {
111.                                 float f;
112.                                 f=(float)(recvlen * configTICK_RATE_HZ/125/(tick2-tick1));
113.                                 f /= 1000.0f;
114. // snprintf(speed, sizeof(speed), "%.4f Mbps!\n", f);
115. // printf("%s", speed);
116.                                 tick1 = tick2;
117.                                 recvlen = 0;
118.                         }
119.                 }
120.        
121.                 if (connected >= 0) closesocket(connected);
122.                 connected = -1;
123.         }
124.        
125. __exit:
126.         if (sock >= 0) closesocket(sock);
127.         if (recv_data) free(recv_data);
128. }
130. void
131. iperf_server_init(void)
132. {
133.         sys_thread_new("iperf_server", iperf_server, NULL, 2048, 4);
134. }

复制代码

然后得到数据，对比数据，我们发现，NETCONN API 的服从是比Socket API 的服从更高，这是由于Socket API 需要对数据进行拷贝，才能传递到上层应用中，不过71Mbps（8.7M 字节/秒）的速率已经是算很高了，详细见图。

图 Socket API 吸收速率
测试开发板发送速率（NETCONN API）

测完两种API 的吸收速率，那么就来测试一下开发板的发送速率，发送速率其实是更加重要的，好比开发板收罗一些图像，想要发送出去，如果发送速率跟不上的话，传输出去的图像就会卡帧，而发送速率充足快，就会很流通，我们测试发送速率将开发板作为客户端，JPerf 软件则作为服务器，我们开发板向服务器发送数据。首先我们也是把移植好的工程拿过来，而且添加两个文件，分别为iperf_client.c 和iperf_client.h，然后在对应的文件中添加所示的代码
代码清单 iperf_client.c 文件内容

1. #include "iperf_client.h"
3. #include "lwip/opt.h"
5. #include "lwip/sys.h"
6. #include "lwip/api.h"
8. #define IPERF_PORT 5001
9. #define IPERF_BUFSZ (4 * 1024)
11. static void iperf_client(void *thread_param)
12. {
13.         struct netconn *conn;
14.        
15.         int i;
16.        
17.         int ret;
18.        
19.         uint8_t *send_buf;
20.        
21.         uint64_t sentlen;
22.        
23.         u32_t tick1, tick2;
25.         ip4_addr_t ipaddr;
26.        
27.         send_buf = (uint8_t *) pvPortMalloc(IPERF_BUFSZ);
28.         if (!send_buf) return ;
29.        
30.         for (i = 0; i < IPERF_BUFSZ; i ++)
31.                 send_buf[i] = i & 0xff;
32.                
33.         while (1)
34.         {
35.                 conn = netconn_new(NETCONN_TCP);
36.                 if (conn == NULL)
37.                 {
38.                         printf("create conn failed!\n");
39.                         vTaskDelay(10);
40.                         continue;
41.                 }
42.                
43.                 IP4_ADDR(&ipaddr,192,168,0,181);
44.                
45.                 ret = netconn_connect(conn,&ipaddr,5001);
46.                 if (ret == -1)
47.                 {
48.                         printf("Connect failed!\n");
49.                         netconn_close(conn);
50.                         vTaskDelay(10);
51.                         continue;
52.                 }
53.                
54.                 printf("Connect to iperf server successful!\n");
55.                 tick1 = sys_now();
56.                 while (1)
57.                 {
58.                         tick2 = sys_now();
59.                        
60.                         if (tick2 - tick1 >= configTICK_RATE_HZ * 5)
61.                         {
62.                                 float f;
63.                                 f = (float)(sentlen*configTICK_RATE_HZ/125/(tick2 - →tick1));
64.                                 f /= 1000.0f;
65.                                 printf("send speed = %.4f Mbps!\n", f);
66.                        
67.                                 tick1 = tick2;
68.                                 sentlen = 0;
69.                         }       
70.                         ret = netconn_write(conn,send_buf,IPERF_BUFSZ,0);
71.                         if (ret == ERR_OK)
72.                         {
73.                                 sentlen += IPERF_BUFSZ;
74.                         }
75.                 }
76. // netconn_close(conn);
77. // netconn_delete(conn);
78.         }
79. }
81. void
82. iperf_client_init(void)
83. {
84.         sys_thread_new("iperf_client", iperf_client, NULL, 2048, 4);
85.        
86. }

复制代码

代码清单 iperf_client.h 文件内容

1. #ifndef IPERF_CLIENT_H
2. #define IPERF_CLIENT_H
4. void iperf_client_init(void);
6. #endif /* IPERF_CLIENT_H */

复制代码

在main.c 文件中调用iperf_client_init() 函数即可，然后配置JPerf 软件成为客户端，让开发板进行毗连，开发板毗连的客户端IP 地址与端口号根据实际环境去配置即可，详细见图，从实验现象可以看出，发送的速率还是很快的（94Mbps，即11.5M 字节/秒）而且还很稳定。

图 NETCONN API 发送速率
测试开发板发送速率（Socket API）

本实验基于是一个实验，我们将测试开发板发送速率（NETCONN API）的工程拿过来，将iperf_client.c 的内容替换代码清单 所示的代码即可。
代码清单 iperf_client.c 文件内容

1. #include "iperf_client.h"
3. #include "lwip/opt.h"
5. #include "lwip/sys.h"
6. #include "lwip/api.h"
7. #include <lwip/sockets.h>
9. #define PORT 5001
10. #define IP_ADDR "192.168.0.181"
12. #define IPERF_BUFSZ (4 * 1024)
14. static void iperf_client(void *thread_param)
15. {
16.         int sock = -1,i;
17.         struct sockaddr_in client_addr;
18.         uint8_t* send_buf;
19.         u32_t tick1, tick2;
20.         uint64_t sentlen;
21.        
22.         send_buf = (uint8_t *) pvPortMalloc(IPERF_BUFSZ);
23.         if (!send_buf)
24.                 return ;
25.                
26.         for (i = 0; i < IPERF_BUFSZ; i ++)
27.                 send_buf[i] = i & 0xff;
28.         while (1)
29.         {
30.                 sock = socket(AF_INET, SOCK_STREAM, 0);
31.                 if (sock < 0)
32.                 {
33.                         printf("Socket error\n");
34.                         vTaskDelay(10);
35.                         continue;
36.                 }
37.                
38.                 client_addr.sin_family = AF_INET;
39.                 client_addr.sin_port = htons(PORT);
40.                 client_addr.sin_addr.s_addr = inet_addr(IP_ADDR);
41.                 memset(&(client_addr.sin_zero), 0, sizeof(client_addr.sin_zero));
42.                 if (connect(sock,
43.                                         (struct sockaddr *)&client_addr,
44.                                         sizeof(struct sockaddr)) == -1)
45.                 {
46.                         printf("Connect failed!\n");
47.                         closesocket(sock);
48.                         vTaskDelay(10);
49.                         continue;
50.                 }
51.                
52.                 printf("Connect to iperf server successful!\n");
53.                 tick1 = sys_now();
54.                 while (1)
55.                 {
56.                         tick2 = sys_now();
57.                         if (tick2 - tick1 >= configTICK_RATE_HZ * 5)
58.                         {
59.                                 float f;
60.                                 f = (float)(sentlen*configTICK_RATE_HZ/125/(tick2 - tick1));
61.                                 f /= 1000.0f;
62.                                 printf("send speed = %.4f Mbps!\n", f);
63.                                
64.                                 tick1 = tick2;
65.                                 sentlen = 0;
66.                         }
67.                        
68.                         if (write(sock,send_buf,IPERF_BUFSZ) < 0)
69.                                 break;
70.                         else
71.                         {
72.                                 sentlen += IPERF_BUFSZ;
73.                         }
74.                 }
75.                 closesocket(sock);
76.         }
77. }
79. void
80. iperf_client_init(void)
81. {
82.         sys_thread_new("iperf_client", iperf_client, NULL, 2048, 8);
83. }

复制代码

测试效果详细见图，从两个实验的对比可以看出，基于Socket API 的发送速率根本相差无几。

图 Socket API 发送速率
提高LwIP 网络传输的速率

如果按照LwIP 默认的配置，是远不可能达到我们实验所表现的速率的，由于还没优化，那肯定也是不稳定的，下面我们来看看优化的参数，首先，网速一定受限于硬件，只有硬件是很好的，那么软件才能优化的更好，网卡肯定要选择好一点的网卡，然后在工程中的stm32f4xx_hal_config.h文件中配置以太网发送和吸收的缓冲区大小，默认是4，我们可以稍微改大一点，详细见代码清单。
代码清单stm32f4xx_hal_config.h 文件配置参数

1. #define ETH_RXBUFNB ((uint32_t)8U) /* 接收缓冲区*/
2. #define ETH_TXBUFNB ((uint32_t)8U) /* 发送缓冲区*/

复制代码

此外，还需在lwipopts.h 文件中配置LwIP 的参数，详细见代码清单，首先，我们对LwIP管理的内存肯定要分配的大一些，而对于发送数据是存储在ROM 或者静态存储区的时间，还要将MEMP_NUM_PBUF 宏定义改的大一点，当然发送缓冲区大小和发送缓冲区队列长度决定了发送速率的大小，根据差异需求进行配置，而且需要不断调试，而对于吸收数据的配置，应该配置TCP 缓冲队列中的报文段数量与TCP 吸收窗口大小，特别是吸收窗口的大小，这直接可以影响数据的吸收速率。
代码清单 lwipopts.h 文件配置参数

1. //内存堆heap 大小
2. #define MEM_SIZE (25*1024)
4. /* memp 结构的pbuf 数量, 如果应用从ROM 或者静态存储区发送大量数据时
5. 这个值应该设置大一点*/
6. #define MEMP_NUM_PBUF 25
8. /* 最多同时在TCP 缓冲队列中的报文段数量*/
9. #define MEMP_NUM_TCP_SEG 150
11. /* 内存池大小*/
12. #define PBUF_POOL_SIZE 65
14. /* 每个pbuf 内存池大小*/
15. #define PBUF_POOL_BUFSIZE \
17. LWIP_MEM_ALIGN_SIZE(TCP_MSS+40+PBUF_LINK_ENCAPSULATION_HLEN+PBUF_LINK_HLEN)
19. /* 最大TCP 报文段，TCP_MSS = (MTU - IP 报头大小- TCP 报头大小*/
20. #define TCP_MSS (1500 - 40)
22. /* TCP 发送缓冲区大小（字节） */
23. #define TCP_SND_BUF (11*TCP_MSS)
25. /* TCP 发送缓冲区队列的最大长度*/
26. #define TCP_SND_QUEUELEN (8* TCP_SND_BUF/TCP_MSS)
28. /* TCP 接收窗口大小*/
29. #define TCP_WND (11*TCP_MSS)

复制代码

当然，除此之外，想要整个LwIP 能高速平稳运行，只配置这些是不够的，好比我们应该使用停止的方式吸收数据，这就省去了CPU 查询数据，而且，我们应该将内核邮箱的容量增大，这样子在吸收到数据之后，投递给内核就不会由于无法投递而阻塞，同时内核线程的优先级应该设置得更高一点，这样子就能及时去处理惩罚这些数据，当然，我们也可以独立使用一个新的发送线程，这样子内核就无需调用底层网卡函数，它可以用心处理惩罚数据，发送数据的事情就交由发送线程去处理惩罚，同时，在处理惩罚数据的时间，不使用串口打印信息，由于串口是一个很慢的外设，当然啦，关于提高LwIP 网络传输的速率，还有很多东西要优化的，这也跟使用环境有关系，不能一概而论，只是给出一些方向，详细怎么实现，还需要各人亲身实践去调试。

---

参考资料wIP 应用开发实战指南—基于野火STM32

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。