如何在beaglebone black上测量TCP/IP吞吐量？

我用的是beaglebone黑色。操作系统是Debian GNU/Linux 7.7。 我正在使用C语言运行一个使用TCP/IP的服务器和客户端

这是我用于服务器的代码：

/* A simple server in the internet domain using TCP
   The port number is passed as an argument */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h> 
#include <sys/socket.h>
#include <netinet/in.h>

void error(const char *msg)
{
    perror(msg);
    exit(1);
}

int main(int argc, char *argv[])
{
     int sockfd, newsockfd, portno;
     socklen_t clilen;
     char buffer[256];
     struct sockaddr_in serv_addr, cli_addr;
     int n;
     if (argc < 2) {
         fprintf(stderr,"ERROR, no port provided\n");
         exit(1);
     }
     sockfd = socket(AF_INET, SOCK_STREAM, 0);
     if (sockfd < 0) 
        error("ERROR opening socket");
     bzero((char *) &serv_addr, sizeof(serv_addr));
     portno = atoi(argv[1]);
     serv_addr.sin_family = AF_INET;
     serv_addr.sin_addr.s_addr = INADDR_ANY;
     serv_addr.sin_port = htons(portno);
     if (bind(sockfd, (struct sockaddr *) &serv_addr,
              sizeof(serv_addr)) < 0) 
              error("ERROR on binding");
     listen(sockfd,5);
     clilen = sizeof(cli_addr);
     newsockfd = accept(sockfd, 
                 (struct sockaddr *) &cli_addr, 
                 &clilen);
     if (newsockfd < 0) 
          error("ERROR on accept");
 while(1)
 {
 bzero(buffer,256);
 n = read(newsockfd,buffer,255);
 if (n < 0) error("ERROR reading from socket");
 printf("Here is the message: %s\n",buffer);
 n = write(newsockfd,"I got your message",18);
 if (n < 0) error("ERROR writing to socket");
 }
 close(newsockfd);
 close(sockfd);
 return 0; 
}

/*internet域中使用TCP的简单服务器
端口号作为参数传递*/
#包括
#包括
#包括
#包括
#包括
#包括
#包括
无效错误（常量字符*消息）
{
佩罗尔（味精）；
出口（1）；
}
int main（int argc，char*argv[]）
{
int sockfd、newsockfd、端口号；
socklen_t clilen；
字符缓冲区[256]；
服务地址中的结构sockaddr\u，cli\u addr；
int n；
如果（argc<2）{
fprintf（stderr，“错误，未提供端口\n”）；
出口（1）；
}
sockfd=套接字（AF_INET，SOCK_STREAM，0）；
if（sockfd<0）
错误（“打开套接字时出错”）；
bzero（（char*）&serv_addr，sizeof（serv_addr））；
portno=atoi（argv[1]）；
serv_addr.sin_family=AF_INET；
serv_addr.sin_addr.s_addr=INADDR_ANY；
serv_addr.sin_port=htons（端口号）；
如果（绑定（sockfd，（结构sockaddr*）和服务地址，
sizeof（服务地址））<0）
错误（“绑定错误”）；
听（sockfd，5）；
clilen=sizeof（cli_addr）；
newsockfd=接受（sockfd，
（结构sockaddr*）和cli_addr，
&克莱伦）；
if（newsockfd<0）
错误（“接受错误”）；
而(1)
{
b0（缓冲器，256）；
n=读取（newsockfd，缓冲区，255）；
如果（n<0）错误（“从套接字读取错误”）；
printf（“这是消息：%s\n”，缓冲区）；
n=写（newsockfd，“我收到你的消息”，18）；
if（n<0）错误（“写入套接字错误”）；
}
关闭（newsockfd）；
关闭（sockfd）；
返回0；
}

这是我为客户使用的代码：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h> 

void error(const char *msg)
{
    perror(msg);
    exit(0);
}

int main(int argc, char *argv[])
{
    int sockfd, portno, n;
    struct sockaddr_in serv_addr;
    struct hostent *server;

    char buffer[256];
    if (argc < 3) {
       fprintf(stderr,"usage %s hostname port\n", argv[0]);
       exit(0);
    }
    portno = atoi(argv[2]);
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0) 
        error("ERROR opening socket");
    server = gethostbyname(argv[1]);
    if (server == NULL) {
        fprintf(stderr,"ERROR, no such host\n");
        exit(0);
    }
    bzero((char *) &serv_addr, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    bcopy((char *)server->h_addr, 
         (char *)&serv_addr.sin_addr.s_addr,
         server->h_length);
    serv_addr.sin_port = htons(portno);
    if (connect(sockfd,(struct sockaddr *) &serv_addr,sizeof(serv_addr)) < 0) 
        error("ERROR connecting");

    while(1)
    {
    printf("Please enter the message: ");
    bzero(buffer,256);
    fgets(buffer,255,stdin);
    n = write(sockfd,buffer,strlen(buffer));
    if (n < 0) 
         error("ERROR writing to socket");
    bzero(buffer,256);
    n = read(sockfd,buffer,255);
    if (n < 0) 
         error("ERROR reading from socket");
    printf("%s\n",buffer);
    }
    close(sockfd);
    return 0;
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
无效错误（常量字符*消息）
{
佩罗尔（味精）；
出口（0）；
}
int main（int argc，char*argv[]）
{
int sockfd，端口号，n；
服务地址中的结构sockaddr\u；
结构主机*服务器；
字符缓冲区[256]；
如果（argc<3）{
fprintf（stderr，“使用%s主机名端口，\n”，argv[0]）；
出口（0）；
}
portno=atoi（argv[2]）；
sockfd=套接字（AF_INET，SOCK_STREAM，0）；
if（sockfd<0）
错误（“打开套接字时出错”）；
server=gethostbyname（argv[1]）；
如果（服务器==NULL）{
fprintf（stderr，“错误，没有这样的主机\n”）；
出口（0）；
}
bzero（（char*）&serv_addr，sizeof（serv_addr））；
serv_addr.sin_family=AF_INET；
b复制（（字符*）服务器->h_地址，
（char*）和serv_addr.sin_addr.s_addr，
服务器->h_长度）；
serv_addr.sin_port=htons（端口号）；
if（connect（sockfd，（struct sockaddr*）&serv_addr，sizeof（serv_addr））<0）
错误（“连接错误”）；
而(1)
{
printf（“请输入消息：”）；
b0（缓冲器，256）；
fgets（缓冲区，255，标准输入）；
n=写入（sockfd，buffer，strlen（buffer））；
if（n<0）
错误（“写入套接字时出错”）；
b0（缓冲器，256）；
n=读取（sockfd，缓冲区，255）；
if（n<0）
错误（“从套接字读取错误”）；
printf（“%s\n”，缓冲区）；
}
关闭（sockfd）；
返回0；
}

我使用

gcc

来编译c代码。然后我像这样运行它们：

在服务器端：

/server 32000

在客户端：

/client[服务器的IP地址]32000

消息从客户端传输到服务器。现在，我如何测量吞吐量？我已经安装了

iperf

，但我不知道在服务器和客户端运行时如何使用它。因为当它们运行时，我只能传输消息，不能键入任何其他命令

---

beaglebone black的以太网为10/100M。如何知道当前通信的以太网吞吐量？

您可以直接安装并使用这是一个基准测试工具。

---

您不需要分别编写服务器和客户端

客户机和服务器是否在同一台机器上运行？我在同一台机器和不同的机器（都在linux上）上都试过了。您是否试图测量此特定TCP会话的吞吐量，或者总体上的TCP吞吐量。两者都有。我需要知道吞吐量的估计值，以确定它是否适合我的目的吞吐量是以位/秒为单位测量的。因此，您需要连续发送数据，直到指定的时间（例如10秒）。计算客户端代码中成功发送/接收的字节数（假设为字节数）。以字节数/10计算吞吐量。