Discussion :

[aloysius]

Bonjour,

Dans le cadre d'un projet universitaire, j'ai développé un server HTTP en C.

Mon problème vient lors des test de montée en charge, à partir d'un certain nombre de connexions simultanées, le serveur ne répond plus au client.

Cela semble du à la fonction listen (Socket), qui prend un paramètre backlog limitant le nombre de connections simultannées.
Comment faire pour gérer un nombre X de connections simultanées si le backlog est strictement infèrieur à X ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
if (listen(socket_file_descriptor, 10000) < 0){
        perror("Unnable to listen"); exit(EXIT_FAILURE);
}
while(1){
        client_socket_informations_lgth = sizeof(client_socket_informations);
        client_file_descriptor_socket = accept(socket_file_descriptor, (struct sockaddr *)&client_socket_informations, &client_socket_informations_lgth);
 
        if (client_file_descriptor_socket < 0){
            perror("Server accept failed."); exit(EXIT_FAILURE);
        }else if(client_file_descriptor_socket > 0){
            pid_t child;
            do {
                child = fork();
                fprintf(stderr, "Fork again");
            } while ((child == -1) && (errno == EAGAIN));
 
            if(child == 0){
                //Handling the client request
            } else if(child > 0){
                waitpid(child, NULL, 0);
                close(client_file_descriptor_socket);
            }
 
        }
    }

Sachant que sur mon client, ca plante lorsque je me connecte après avoir déjà créé le socket:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
if (connect(sockfd, (struct sockaddr *) &destAddr, sizeof(struct sockaddr)) == -1) {
        fprintf(stderr, "Error with client connecting to server\n");
        close(sockfd);
        return 0;
    }

La solution la plus viable serait d'après moi de toujours attendre que le nombre de connections simultanées soit infèrieur à X avant d'en accepter une nouvelle, cependant comment peut-on faire cela ?
Sinon prendre le problème à l'envers, et dire au client de re-tenter la connection tant qu'il a pas eu une réponse ? Cela signifiant que le serveur ne suit pas la montée en charge ! J'imagine que les client web classiques font cela, mais à quel point ?

Merci par avance

[Bousk]

Salut,

tu lances un process pour chaque socket à ce que je vois ?
De cette manière tu vas finir par noyer ta machine.
Tu ne pourras jamais avoir un nombre de clients illimités, tu dois limiter le nombre de clients dans ton code, en fonction des spéc de ta machine.
Aussi le mode non bloquant pour le serveur aide à ce niveau.
Par exemple dans mon précédent studio, on avait estimé que le serveur pouvait gérer 10k connections sans trop dégrader l'expérience des joueurs, et que sur une machine donnée on pouvait lancer 3 serveurs.
Avec un thread qui passe en revu les clients connectés pour recevoir les données, et dispatcher aux threads de traitement, qui étaient au nombre de 200 si ma mémoire est bonne.
En gros, tu as une super boucle qui recv tout, si des données sont reçues tu mets en file une action pour les traiter. La file en question va sélectionner un thread disponible pour le traitement.
Attention aussi à ne pas pouvoir te faire flooder par un client : un client ne devrait pouvoir utiliser qu'un thread/action à la fois.

Le paramètre de listen indique le nombre de connexions en attente simultannées possibles, avant d'être accepté. On utilise juste SOMAXCONN généralement.

Je suis pas sûr d'être clair mais n'hésite pas si t'as des questions.