Discussion :

[elmago]

Bonjour,

j'apprend actuellement le C++ afin d'accélérer quelques programmes sur mon serveur, et pour cela, j'ai décidé de réaliser un serveur HTTP multi-clients.

Je ne veux pas utiliser de librairies telles que boost, je préfère tout re-coder moi-même afin de vraiment tout comprendre.

Mais, je débute et rencontre déjà des problèmes Si je suis correct, pour réaliser un serveur HTTP, je dois gérer manuellement les sessions TCP, pour cela mon programme débute par une classe TCP_Server.

Voici le code que j'ai déjà écrit pour cette classe, tout a l'air de fonctionner pour le moment.

Header file:

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
 
#include <iostream>
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <thread>
 
class TCP_Server {
public:
    // Constructor
    TCP_Server();
private:
    // Socket descriptor
    int m_socket_desc;
    // 
    struct sockaddr_in m_server;
};

Source file:

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
#include "TCP_Server.h"
 
TCP_Server::TCP_Server() {
    // Creating a socket
    m_socket_desc = socket(AF_INET, SOCK_STREAM, 0);
    if (m_socket_desc == -1) {
        std::cout << "Could not create socket" << std::endl;
    }
    else
    {
        std::cout << "Server started" << std::endl;
    }
 
    // Prepare the sockaddr_in structure
    m_server.sin_family = AF_INET;
    m_server.sin_addr.s_addr = INADDR_ANY;
    m_server.sin_port = 80;
 
    // Bind it
    // bind() return 0 when there is no problem
    if (bind(m_socket_desc, (struct sockaddr*)&m_server, sizeof(m_server)) != 0) {
        std::cout << "Bind failed" << std::endl;
    }
    else
    {
        std::cout << "Socket binded on port " << m_server.sin_port << std::endl;
    }
 
    // Put the server on (with a pending queue of 15)
    // listen() is a command used for listening to TCP handshake requests
    // listen() return 0 when there is no problem
    if (listen(m_socket_desc, 15) != 0) {
        std::cout << "Listen failed" << std::endl;
    }
    else
    {
        std::cout << "Server started" << std::endl;
    }
 
    // Create a new thread for each new TCP session when a SYN request has been detected
    while (1) {
        std::cout << "Waiting for connections ..." << std::endl;
        // std::thread thread...
    }
}

Si j'ai bien compris, je dois maintenant créer un nouveau thread pour chaque session TCP, lançant la méthode accept() qui va effectuer le TCP handshake ... Mais après avoir lu des dizaines de tutos en C et C++, je n'y arrive pas

Donc je me permet de demander un petit coup de pouce de votre part

Pour info, je code pour les plateformes debian / centOS / OSX.

[Ehonn]

Bonjour

Si tu utilises l'API du noyau Linux, c'est plus "classique" d'utiliser un fd_set pour gérer plusieurs connexions.
http://linux.die.net/man/3/fd_set

Je te laisse chercher des tutos avec les mots clefs fd_set et TCP.

[elmago]

d'accord, merci, je vais m'intéresser à cette fonction

[elmago]

Sur plusieurs sites et forums j'ai pu lire qu'une gestion 1 connexion => 1 thread consommait trop de resources, est-ce qu'il y aurait une meilleure méthode à conseiller ?

[jblecanard]

Salut

Pour ma part, je conseillerais plutôt l'usage de epoll pour gérer tes connexions plutôt que de fd_set. Cette fonction est plus puissante et supporte un très grand nombre de file descriptors, ce qui n'est pas le cas de select et de pselect qui sont limités. epoll est le remplaçant nouvelle génération de poll qui est aussi scalable mais dont les performances deviennent mauvaises si le nombre de FDs est grand.

Pour utiliser un nombre de thread limité avec un grand nombre de connexions, il te "suffit" de surveiller plusieurs connexions dans un seul thread avec epoll.

[elmago]

Après avoir lu pas mal de doc, j'ai choisi de me tourner vers kqueue() au lieu de epoll() (je l'implémenterais peut-être plus tard pour prendre en charge plus de systèmes).

Pour le moment, j'ai donc déclaré dans le .h :

Code :

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

1
2
3
4
 
private:
    // Sockets events queue
    int socketEvents;

Et je l'ai implémenté comme ceci:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
// Create the events queue
// kqueue() return -1 when there is an error
socketEvents = kqueue();
if (socketEvents < 0) {
    std::cout << "Socket events queue creation failed" << std::endl;
    exit(EXIT_FAILURE);
}
else
{
    std::cout << "Socket events queue created" << std::endl;
}

Par la suite, si je comprends bien, il me faudra créer un boucle infinie "while(1){}" et enregistrer chaque nouvelle connexion dans ma queue socketEvents, est-ce correct ?
Je me demande aussi, comment fait-on pour reconnaître quelle connexion appartient à quel client ?

[Emmanuel Deloget]

Sur plusieurs sites et forums j'ai pu lire qu'une gestion 1 connexion => 1 thread consommait trop de resources, est-ce qu'il y aurait une meilleure méthode à conseiller ?

Je confirme que ça pose problème. Si tu as 10000 connexions sur ton serveur, tu va le mettre à genoux rien que pour traiter les switch de contexte - alors que ta bande passante sera peut-être à peine entamée.

Ce que tu essaie de faire, c'est de trouver une solution à un problème connu : le problème des (justement) 10000 connexions - C10K pour les amis de la famille (http://en.wikipedia.org/wiki/C10k_problem). Ce site (http://www.kegel.com/c10k.html) est assez complet dans la liste des solutions proposées. L'échelle suivante - C10M - recelle aussi des idées intéressantes (http://highscalability.com/blog/2013...-kernel-i.html).