Discussion :

[_dranece_]

Bonjour,
Je suis en train de travailler sur un projet client-server. Les clients envoient des données à intervalle régulier sur le server à travers un socket. Le server reçoit les informations, les garde en mémoire et toutes les 5 minutes enregistre toutes les informations dans un fichiers (en les ajoutant au données déjà enregistrer).

Le client est fini et fonctionne.
Le server reçoit bien les données. Un processus fils est créé lors du lancement du programme pour gérer la sauvegarde sur fichier toutes les 5 min. La partie sauvegarde fonctionne également.

Il me reste plus qu'à stocker les données reçues en mémoire et à les lire dans mon processus fils. C'est cette partie qui me pose problème car je ne sais pas quelle solution choisir sachant que plusieurs clients peuvent envoyer leurs données en même temps. Sémaphore, espace mémoire partagée, file de message (IPC) ou autre?
La file de message semble être bien adaptée mais il me semble que la taille est limitée et si il y a beaucoup de clients, je ne sais pas cette solution tiendra la route.

Merci d'avance pour vos conseils.

[Mac LAK]

Ben de toutes façons, c'est transitoire : dès que le serveur réceptionne des données, il doit les émettre le plus rapidement possible vers le processus de sauvegarde, et ne pas les garder inutilement.

Donc, dans tous les cas, si ton serveur possède "beaucoup" de données en mémoire, c'est que le système d'échange (quel qu'il soit) est saturé et/ou occupé. Tu n'as donc qu'un "simple" buffer à gérer.

Le plus évolutif et le plus fiable serait sûrement d'utiliser une FIFO structurée de part et d'autre, servant de buffer de taille indéfinie (= jusqu'à saturation de la RAM du PC serveur, donc). Ton serveur comme ton processus de sauvegarde possèdent une FIFO, identique en format bien sûr.

Tu n'as alors plus qu'à écrire deux fonctions "Send" et "Receive" qui traiteront un seul et unique élément, transféré de processus à processus, et ceci peu importe le mécanisme utilisé. De toutes façons, tu peux le remplacer à loisir si le besoin s'en fait sentir... Et tu peux ainsi outrepasser d'éventuelles limites système liées au tailles maximales des systèmes de communication.

De plus, tu conserves un usage quasi-optimal de la mémoire : chaque élément à sauvegarder n'existe qu'une seule et unique fois dans la RAM du PC serveur : soit dans le processus serveur (en attente de transfert), soit dans le processus de stockage (en attente d'écriture dans le fichier), soit dans le "tuyau" de communication interprocessus (en cours de transfert, donc déjà "supprimé" côté serveur et pas encore "arrivé" côté stockage).

De plus, côté sauvegarde, tes données étant réceptionnées dans une FIFO, tu as directement un container adapté pour flusher vers le disque de façon pratique. D'ailleurs, plutôt que de sauvegarder toutes les 5 minutes, j'aurais plutôt tendance à mettre le processus en priorité basse et à flusher dès que possible vers le disque, mais ça reste un avis personnel. Tout dépend ce que tu dois privilégier, à savoir la charge CPU / occupation disque (sauvegarde le moins possible) ou la sécurité des données / occupation mémoire (sauvegarde dès que possible).

[_dranece_]

Merci pour ta réponse très complète (mais un poil compliqué pour moi ).

Je transmet comme tu me l'as recommandé les infos que je reçoit directement au processus de sauvegarde. J'ai choisi d'utiliser une file de message pour une question de simplicité. Dans le processus de sauvegarde, je concatène au fur et à mesure des réceptions les infos dans une chaine de caractères que je vide toutes les 5 min après l'avoir ajouté à mon fichier de sauvegarde.
J'ai donc un peu simplifié ta solution pour éviter de trop galérer même si c'est nettement moins optimale mais ça fonctionne comme même parfaitement.

J'ai encore une petite question, faut-il protéger ma file de message par un mutex ou est-elle nativement protégée?

[Mac LAK]

J'ai donc un peu simplifié ta solution pour éviter de trop galérer même si c'est nettement moins optimale mais ça fonctionne comme même parfaitement.

Il faut surtout que tu gères correctement la mémoire côté processus de sauvegarde, afin de ne pas la saturer (= penser à forcer une écriture si ça devient "trop gros") ni encombrer les structures inter-processus (= ne pas laisser les données dans la file de messages système).

J'ai encore une petite question, faut-il protéger ma file de message par un mutex ou est-elle nativement protégée?

Je ne suis pas un grand spécialiste de l'IPC *nix, mais de mémoire, il me semble que ces files sont nativement protégées, comme les tubes, parce qu'elles sont unidirectionnelles.
A confirmer toutefois : les *nix que j'utilise sont en général des versions temps réel dédiées à l'embarqué, et intègrent peut-être des fonctionnalités supplémentaires par rapport à la "norme" Unix et/ou Linux...