Networking 如何测量文件从服务器传输到客户端的时间？

Networking 如何测量文件从服务器传输到客户端的时间？,networking,Networking,我想测量通过PGM/UDP协议将文件从send传输到recv的时间。实际上，我尝试使用clock（）函数来测量send和recv程序的执行时间，但它似乎不正确。我应该如何测量文件传输的时间 代码如下： clock_t t = clock(); do { struct timeval tv; size_t len; int timeout; pgm_error_t *pg

send

recv

clock（）

send

recv

clock_t t = clock();
    do 
    {
                    struct timeval tv;
                    size_t len;
        int timeout;


     pgm_error_t *pgm_err = NULL;
        const int status = pgm_recv (rx_sock,
                                     buf,
                                     sizeof(buf),
                                     0,
                                     &len,
                                     &pgm_err);
        switch (status) 
        {
                case PGM_IO_STATUS_NORMAL:
/* receive file */

                    if (len < 30)
                    {
                        strncpy(newFile, buf, len);
                         if (0 == strncmp(newFile, testNewFile, len))
                        {
                                 flag = 1;
                                 continue;
                         }

                        strncpy(endFile, buf, len);
                        if (0 == strncmp(endFile, testEndFile, len))
                        {

                                //g_quit = 1;
                                t = clock() -t;
                                printf("%s takes time: %f\n", fileName, ((float)t) / CLOCKS_PER_SEC);
                                                                continue;
                        }

                    }


                       if (flag == 1)
                       {
                               strncpy(fileName, buf, len);
                            //   puts(fileName);
                               fp = fopen(fileName, "wb");
                               g_assert(fp);
                               flag = 0;

                       }
                      else

                        num_read = fwrite (buf, sizeof(char), len, fp);


                        break;
                case PGM_IO_STATUS_TIMER_PENDING:
                        {
                            socklen_t optlen = sizeof (tv);
                            pgm_getsockopt (rx_sock, IPPROTO_PGM, PGM_TIME_REMAIN, &tv, &optlen);
                        }
                        goto block;
                case PGM_IO_STATUS_RATE_LIMITED:
                        {
                            socklen_t optlen = sizeof (tv);
                            pgm_getsockopt (rx_sock, IPPROTO_PGM, PGM_RATE_REMAIN, &tv, &optlen);
                        }
                case PGM_IO_STATUS_WOULD_BLOCK:
block:
                        timeout = PGM_IO_STATUS_WOULD_BLOCK == status ? -1 : ((tv.tv_sec * 1000) + (tv.tv_usec / 1000));
                        memset (fds, 0, sizeof(fds));
                        fds[0].fd = g_quit_pipe[0];
                        fds[0].events = POLLIN;
                        pgm_poll_info (rx_sock, &fds[1], &n_fds, POLLIN);
                        poll (fds, 1 + n_fds, timeout);

                        break;
                default:
                        if (pgm_err) 
                        {
                                g_warning ("%s", pgm_err->message);
                                pgm_error_free (pgm_err);
                                pgm_err = NULL;
                        }
                        if (PGM_IO_STATUS_ERROR == status)
                              break;


        }
    }while (!g_quit);


    fclose (fp);
    return NULL; 

clock_t=clock（）；
做
{
结构时间值电视；
尺寸透镜；
int超时；
pgm_error_t*pgm_err=NULL；
const int status=pgm\U recv（接收插座，
缓冲器，
sizeof（buf），
0,
&伦，
&pgm_err）；
开关（状态）
{
案例PGM_IO_状态_正常：
/*接收文件*/
if（len<30）
{
strncpy（新文件、buf、len）；
if（0==strncmp（newFile，testNewFile，len））
{
flag=1；
继续；
}
strncpy（endFile，buf，len）；
如果（0==strncmp（endFile，testEndFile，len））
{
//g_quit=1；
t=时钟（）-t；
printf（“%s花费时间：%f\n”，文件名，（（浮点）t）/每秒时钟数）；
继续；
}
}
如果（标志==1）
{
strncpy（文件名，buf，len）；
//放置（文件名）；
fp=fopen（文件名，“wb”）；
g_断言（fp）；
flag=0；
}
其他的
num_read=fwrite（buf，sizeof（char），len，fp）；
打破
案例PGM_IO_状态_定时器_未决：
{
socklen_t optlen=尺寸（电视）；
pgm_getsockopt（接收、发送、发送、保留时间、电视和optlen）；
}
后藤区；
案例PGM_IO_状态_费率_有限公司：
{
socklen_t optlen=尺寸（电视）；
pgm_getsockopt（接收sock、IPPROTO_pgm、pgm_费率、电视和optlen）；
}
案例PGM\U IO\U状态将\U阻塞：
区块：
超时=PGM_IO_STATUS_will_BLOCK==状态？-1:（（tv.tv_sec*1000）+（tv.tv_usec/1000））；
memset（fds，0，sizeof（fds））；
fds[0].fd=g_退出_管道[0]；
fds[0]。事件=POLLIN；
pgm_轮询信息（rx_sock和fds[1]，&n_fds，轮询）；
轮询（fds，1+n_fds，超时）；
打破
违约：
如果（pgm_错误）
{
g_警告（“%s”，pgm_错误->消息）；
无pgm_错误（pgm_错误）；
pgm_err=NULL；
}
如果（PGM_IO_状态_错误==状态）
打破
}
}而（！g_退出）；
fclose（fp）；
返回NULL；

clock（）