Stratégie de vidage des sorties du fichier à la fin

J’ai une application qui surveille un lien de communication haut débit et écrit des journaux dans un fichier (via le fichier IO standard du fichier C). Le temps de réponse aux messages qui arrivent sur le lien est important, donc je ne fflush pas le fichier à chaque message car cela ralentit mon temps de réponse.

Cependant, dans certaines circonstances, mon application se termine “violemment” (par exemple en tuant le processus) et dans ces cas, les derniers messages du journal ne sont pas écrits (même si le lien de communication est resté silencieux pendant un certain temps).

Quelles techniques / stratégies puis-je utiliser pour vérifier que la plupart de mes données sont vidées, mais sans perdre de vitesse?

Edit: L’application s’exécute sous Windows

Utiliser un thread est la solution standard à cela. Demandez à votre code de collecte de données d’écrire des données dans une queue adaptée aux threads et utilisez un sémaphore pour signaler le thread d’écriture.

Cependant, avant d’y aller, vérifiez votre assertion que fflush () serait lent. La plupart des systèmes d’exploitation ont un cache de système de fichiers. Il rend les écritures très rapides, sous forme de copie simple de bloc mémoire-mémoire. Les données sont écrites sur le disque paresseusement, votre plantage ne l’affectera pas.

Si vous êtes sous Unix ou Linux, votre processus recevrait un signal de terminaison que vous pouvez intercepter (sauf SIGKILL ) et fflush() dans votre gestionnaire de signaux.

Pour attraper le signal, voir man sigaction .

EDIT: Aucune idée sur Windows.

Je suggère une écriture asynchrone. De cette façon, vous n’avez pas besoin d’attendre que le processeur d’enregistrement d’écriture se produise, et le système d’exploitation ne retardera pas non plus le processeur d’entrée. Voir les drapeaux FILE_FLAG_WRITE_THROUGH | FILE_FLAG_OVERLAPPED () FILE_FLAG_WRITE_THROUGH | FILE_FLAG_OVERLAPPED FILE_FLAG_WRITE_THROUGH | FILE_FLAG_OVERLAPPED .

Vous n’avez pas besoin de FILE_FLAG_NO_BUFFERING . C’est seulement pour ignorer le cache du système d’exploitation. Vous n’en auriez besoin que si vous vous inquiétez de la mort violente de l’OS entier.

Si votre programme se termine en appelant exit () ou en retournant de main (), le standard C garantit que les stream ouverts sont vidés et fermés, ce qui évite toute manipulation particulière. Il semble d’après votre description que c’est ce qui se passe: si votre programme est mort à cause d’un signal, vous ne verriez pas la couleur.

J’ai du mal à comprendre quel est le problème exactement.

Si vous essayez simplement de trouver un juste milieu entre le vidage souvent et la sortie par défaut entièrement tamponnée, alors peut-être que la mise en mémoire tampon des lignes est ce que vous voulez:

 setvbuf(stream, 0, _IOLBF, 0);