Question

我在C中的教育套接字服务器上有以下代码。

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

double get_wall_time()
{
    struct timeval time;
    if (gettimeofday(&time, NULL)){
        return 0;
    }
    return (double)time.tv_sec + (double)time.tv_usec * 0.000001;
}

double get_cpu_time()
{
    return (double)clock() / CLOCKS_PER_SEC;
}

int main()
{
    double wall = get_wall_time();
    double cpu = get_cpu_time();

    int sfd = socket(AF_INET, SOCK_STREAM, 0);

    struct sockaddr_in own_addr = {0};
    own_addr.sin_family = AF_INET;
    own_addr.sin_port = htons(5678);

    bind(sfd, (struct sockaddr *)&own_addr, sizeof(own_addr));
    listen(sfd, 5);

    static char message[] = "hello from server\n";

    double wall_accept = 0;
    double cpu_accept = 0;

    int count = 0;
    while (1) {
        if (count++ == 1000) {
            break;
        }

        double wall_start = get_wall_time();
        double cpu_start = get_cpu_time();
        int client_sfd = accept(sfd, NULL, NULL);
        wall_accept += get_wall_time() - wall_start;
        cpu_accept += get_cpu_time() - cpu_start;

        send(client_sfd, message, sizeof(message), 0);
        close(client_sfd);
    }

    wall = get_wall_time() - wall;
    cpu = get_cpu_time() - cpu;

    printf("wall accept: %lf\n", wall_accept);
    printf("cpu accept: %lf\n", cpu_accept);

    printf("wall: %lf\n", wall);
    printf("cpu: %lf\n", cpu);
}

要测试我使用seq 1000 | time parallel -j 1 -n0 'nc 127.0.0.1 5678' | wc -l结果

wall accept: 6.436480
cpu accept: 0.010000
wall: 6.456266
cpu: 0.020000

对于10000个请求，结果是

wall accept: 55.434541
cpu accept: 0.080000
wall: 55.633679
cpu: 0.260000

accept()是慢还是我做错了？或者这可能是单线程实现的正常结果？

UPD。我还用pthreads编写了一个服务器，以便在不同的帖子中发送消息。

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

double get_wall_time()
{
    struct timeval time;
    if (gettimeofday(&time, NULL)){
        return 0;
    }
    return (double)time.tv_sec + (double)time.tv_usec * 0.000001;
}

double get_cpu_time()
{
    return (double)clock() / CLOCKS_PER_SEC;
}

void *send_message(void *pclient_sfd)
{
    int client_sfd = *(int *)pclient_sfd;
    free(pclient_sfd);

    static char message[] = "hello from server\n";
    send(client_sfd, message, sizeof(message), 0);
    close(client_sfd);

    return NULL;
}

int main()
{
    double wall = get_wall_time();
    double cpu = get_cpu_time();

    int sfd = socket(AF_INET, SOCK_STREAM, 0);

    struct sockaddr_in own_addr = {0};
    own_addr.sin_family = AF_INET;
    own_addr.sin_port = htons(5678);

    bind(sfd, (struct sockaddr *)&own_addr, sizeof(own_addr));
    listen(sfd, 5);

    double wall_accept = 0;
    double cpu_accept = 0;

    int count = 0;
    while (1) {
        if (count++ == 10000) {
            break;
        }

        int *pclient_sfd = malloc(sizeof(*pclient_sfd));

        double wall_start = get_wall_time();
        double cpu_start = get_cpu_time();

        *pclient_sfd = accept(sfd, NULL, NULL);

        wall_accept += get_wall_time() - wall_start;
        cpu_accept += get_cpu_time() - cpu_start;

        pthread_t tid;
        pthread_create(&tid, NULL, send_message, (void *)pclient_sfd);
    }

    wall = get_wall_time() - wall;
    cpu = get_cpu_time() - cpu;

    printf("wall accept: %lf\n", wall_accept);
    printf("cpu accept: %lf\n", cpu_accept);

    printf("wall: %lf\n", wall);
    printf("cpu: %lf\n", cpu);

    return 0;
}

然后我使用seq 10000 | time parallel -j 4 -n0 'nc 127.0.0.1 5678' | wc -l，需要58秒。

Answer 1

这是你测试它的方式。当你使用这个

seq 10000 | time parallel -j 4 -n0 'nc 127.0.0.1 5678' | wc -l

这实际上会对测试产生影响，因为你正在产生大量的进程，例如你实际上没有测试你测试C应用程序产生进程的能力。

如果我们将其改为简单的python脚本，即

#!/usr/bin/env python
import socket
TCP_IP = '127.0.0.1'
TCP_PORT = 5678
BUFFER_SIZE = 1024
msg = "1" 

for i in range(0, 1000):
  s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  s.connect((TCP_IP, TCP_PORT))
  s.send(msg.encode('utf-8'))
  data = s.recv(BUFFER_SIZE)
  s.close()
  print("received data: %s" % data)

并进行测试，结果大不相同。

real    0m0.269s
user    0m0.074s
sys     0m0.114s

如果你真的想测试它，看看你需要使用单独的机器等多快，通常你可能需要使用C或你的限制因素可能是客户端。我见过的最好的工具（HTTP Specific），你可能会找到一些好的代码wrk

https://github.com/wg/wrk

Answer 2

看看你的listen（）第二个参数。尝试增加它。这是来自man 2 listen

的文字

backlog参数定义队列的最大长度 sockfd的挂起连接可能会增长。如果是连接请求队列满时到达，客户端可能会收到错误指示ECONNREFUSED，或者，如果底层协议支持重传，请求可以被忽略，以便稍后重新尝试在连接成功。

在C

2 个答案: