Asynchrone thread-safe journalisation en C++

Je suis à la recherche d'un moyen de le faire asynchrone et thread-safe journalisation dans mon projet de C++, si possible dans un seul fichier. Je suis actuellement à l'aide cerr et clog de la tâche, mais depuis qu'ils sont synchrones, l'exécution, peu de pauses à chaque fois que quelque chose est connecté. C'est un relativement graphiques lourds application, donc ce genre de chose est assez ennuyeux.

Le nouvel enregistreur devriez utiliser les e/S asynchrones pour se débarrasser de ces pauses. Fil-sécurité serait également souhaitable que j'ai l'intention d'ajouter un peu de base de multithreading bientôt.

- Je considéré comme un un-fichier-par-fil approche, mais qui ne semblaient rendre la gestion de journaux d'un cauchemar. Des suggestions?

OriginalL'auteur Electro | 2010-05-28

  1. 19

    J'ai remarqué c'est 1 an+ ancien fil. Peut-être asynchrone logger, j'ai écrit pourrait être d'intérêt.

    http://www.codeproject.com/KB/library/g2log.aspx

    G2log utilise un message protégé de la file d'attente pour transférer les entrées du journal d'un arrière-plan travailleur que la lenteur des accès disque.

    J'ai essayé avec un lock-free file d'attente qui a augmenté la durée moyenne d'un JOURNAL d'appel, mais a diminué le pire des cas le temps, cependant, je suis en utilisant le protégé de la file d'attente, qui est maintenant de la croix-plate-forme. Il est testé sur Windows/Visual Studio 2010 et Ubuntu 11.10/gcc4.6.

    Il est libéré dans le domaine public de sorte que vous pouvez en faire ce que vous voulez avec no strings attached.

    La chose que d'habitude-je faire si l'enregistrement ne doit pas conduire à tout blocage (par exemple, le débogage des conditions de course avec des tirages.. hey ça marche et c'est simple!) est d'utiliser un thread local file d'attente de messages qui stocke les jetons avec les dates (de bien dans ce cas probablement mieux de sortie directement avec async IO). Si vous avez besoin des données, il vous suffit de trier les résultats par la suite et c'est plutôt lourd pour les journalisation général, mais il a le plus faible possible la synchronisation montant: néant.
    Ce qui est important est bien sûr pas le seul à être thread-safe., et le minimum de blocage, mais aussi pour s'assurer que les entrées de journal sont sur fichier si le logiciel plante (erreur de segmentation, à virgule flottante d'erreur, etc). G2log prévoit qu'à l'aide d'un gestionnaire de signal, dans le cas d'un "signal fatal" il vide la file d'attente d'entrées à déposer avant le signal continue (et abandonne le programme)
    suivez les étapes de ce lien stackoverflow.com/help/user-merge pour obtenir vos comptes fusionnés.
    Merci À Chris. J'ai supprimé mon autre "1 point" compte de ce qui était obsolète.

    OriginalL'auteur Kjell Hedström

  2. 4

    C'est TRÈS possible et pratique. Comment puis-je savoir? J'ai écrit exactement ce qu'à mon dernier emploi. Malheureusement (pour nous), ils possèdent maintenant le code. 🙂 Malheureusement, ils n'ont même pas l'utiliser.

    J'ai l'intention d'écrire une version open source dans un avenir proche. En attendant, je peux vous donner quelques conseils.

    1. I/O manipulateurs sont vraiment juste des noms de fonction. Vous pouvez les appliquer pour votre propre classe de log, de sorte que votre enregistreur de cout/cin compatible.
    2. Votre manipulateur fonctions peuvent marquer les opérations et de les stocker dans une file d'attente.
    3. Un thread peut être bloqué sur cette file d'attente pour des morceaux de journal pour venir voler à travers. Il traite ensuite les opérations de la chaîne et génère le journal réel.

    C'est intrinsèquement fil compatible puisque vous êtes en utilisant une file d'attente. Cependant, vous n'auriez toujours voulez mettre un peu de mutex-comme la protection autour de l'écriture à la file d'attente pour qu'un journal << "trucs" << "plus de choses"; type de fonctionnement reste de la ligne-atomique.

    Amusez-vous!

    Ne serait pas un mutex dire que si un thread est déjà en train de l'écrire, il faudrait tourner jusqu'à ce qu'il était débloqué? Comment cela vous aide?
    Je ne serait certainement pas retarder la conversion de l'objet dans le flux. Le mettre dans un autre thread ayant des moyens pour synchroniser... et qui est susceptible de mal comme l'enfer.
    pas de spin, mais bloquer. Mais si vous ne faites pas de chaîne de traitement, il est un intervalle TRÈS court pour charger la file d'attente. La chaîne de traitement est effectuée par le thread de journalisation. @Matthieu, en faisant la chaîne de traitement en temps réel fait mal beaucoup plus que n'importe quel mutex blocage lors du chargement d'une file d'attente.
    J'ai besoin du message de journal pour être transmis immédiatement pour un async écrire, et tout type d'attente de mon fils serait probablement la cause de la fâcheuse pauses, encore une fois.
    faire la chaîne de traitement asynchrone des causes des problèmes de sécurité des threads sur tous les objets connectés, l'exactitude vient avant la performance, et le problème ici n'est pas de blocage sur la file d'attente, mais IO slowliness.

    OriginalL'auteur Amardeep AC9MF

  3. 1

    Je pense que la bonne approche n'en est pas un-fichier-par-fil, mais un fils de fichier par fichier. Si tout un fichier (ou de ressources en général) dans votre système n'est jamais accessible par un seul thread, threads, la programmation devient alors beaucoup plus facile.

    Alors pourquoi ne pas faire de Logger un thread dédié (ou de plusieurs threads, un par fichier, si vous êtes à la journalisation des choses différentes dans les différents fichiers), et dans tous les autres threads, l'écriture de journal serait de placer le message dans la file d'attente d'entrée dans la Enregistreur de fil, qui serait à la fois qu'il est en fait écrit le message précédent. Tout ce qu'il faut est un mutex pour protéger la file d'attente de l'ajout d'un événement alors que l'Enregistreur est à la lecture d'un événement, et un condvar pour Enregistreur à attendre lors de sa file d'attente est vide.

    Vous pouvez vous en sortir sans l'aide d'un mutex avec un lock-free file d'attente. La variable de condition est beaucoup plus différent. En fonction de la charge, vous préférerez peut-être filer plutôt que d'aller à dormir et à être réveiller plus tard. Elle dépend aussi de si oui ou non vous avez l'inactivité de noyaux 🙂
    Si quelque chose occupé attend dans notre système, la surveillance va tuer l'ensemble de l'application 🙂

    OriginalL'auteur Cubbi

  4. 1

    Avez-vous songé à utiliser un journal de la bibliothèque.

    Il y a plusieurs disponibles, j'ai découvert Pantheios récemment et il semble vraiment être tout à fait incroyable.

    C'est plus une avant la fin de l'enregistreur, vous pouvez personnaliser le système qui est utilisé. Il peut interagir avec ACE ou log4cxx par exemple, et il semble vraiment facile à utiliser et à configurer. Le principal avantage est qu'il utilise typesafe opérateurs, ce qui est toujours grande.

    Si vous voulez juste un barebone bibliothèque de journalisation:

    • ACE
    • log4c*
    • Coup de pouce.Journal

    Choisir 🙂

    Je note qu'il est possible de mettre en œuvre sans verrouillage des files d'attente en C++ et qu'ils sont parfaits pour l'exploitation forestière.

    Hm, je ne pense pas que je tiens à apporter tout de ceux-ci. Les deux anciens sembler excessif, et ce dernier a eu beaucoup de problèmes de performances lors de son examen, qui a été l'une des raisons pour lesquelles ils n'ont pas l'ajouter à la poussée de la collecte proprement dite.

    OriginalL'auteur Matthieu M.

  5. 0

    J'ai eu le même problème et je crois avoir trouvé la solution idéale. Je vous présente, un seul en-tête de la bibliothèque appelée loguru: https://github.com/emilk/loguru

    Il est simple à utiliser, portable, configurable, la macro-fonction et par défaut n'est pas #include quoi que ce soit (pour au doux temps de compilation).

    OriginalL'auteur Jezor