J’ai remarqué que boost.asio a beaucoup d’exemples de sockets, de ports série et de toutes sortes d’exemples non liés à des fichiers. Google n’a pas vraiment trouvé beaucoup de choses pour moi qui mentionnent si asio est une bonne ou valide approche pour faire des E / S de fichiers asynchrones.
J’ai des tonnes de données que je voudrais écrire sur le disque de manière asynchrone. Cela peut être fait avec io natif nested dans Windows (ma plate-forme), mais je préférerais avoir une solution indépendante de la plate-forme.
Je suis curieux si
En commençant par (je pense) Boost 1.36 (qui contient Asio 1.2.0), vous pouvez utiliser [boost :: asio ::] windows :: stream_handle ou windows :: random_access_handle pour envelopper un HANDLE et y exécuter des méthodes de lecture et d’écriture asynchrones utilisez la structure OVERLAPPED en interne.
User Lazin mentionne également boost :: asio :: windows :: random_access_handle qui peut être utilisé pour des opérations asynchrones (par exemple, des canaux nommés, mais aussi des fichiers).
Comme Boost.Asio en soi est largement utilisé à l’heure actuelle et que l’implémentation utilise des IO superposées en interne, je dirais oui.
Comme il n’ya pas de feuille de route sur le site Asio , je dirais qu’il n’y aura pas de nouveaux ajouts à Boost.Asio pour cette fonctionnalité. Bien que les consortingbuteurs aient toujours la possibilité d’append du code et des classes à Boost.Asio. Peut-être que vous pouvez même consortingbuer vous-même aux parties manquantes! 🙂
boost :: fichier asio i / o sur Linux
Sous Linux, asio utilise le mécanisme epoll
pour détecter si un descripteur de socket / fichier est prêt pour la lecture / écriture. Si vous tentez d’utiliser vanilla asio sur un fichier normal sous Linux, vous obtiendrez une exception “opération non autorisée” car epoll ne prend pas en charge les fichiers standard sous Linux .
La solution consiste à configurer asio pour utiliser le mécanisme de select
sous Linux. Vous pouvez le faire en définissant BOOST_ASIO_DISABLE_EPOLL
. Si vous travaillez avec un grand nombre de sockets ouverts, le compromis choisi ici est plus lent que epoll . Ouvrez un fichier régulièrement en utilisant open()
, puis transmettez le descripteur de fichier à un boost::asio::posix::stream_descriptor
.
boost :: fichier asio i / o sous Windows
Sous Windows, vous pouvez utiliser boost::asio::windows::object_handle
pour envelopper un Handle
créé à partir d’une opération de fichier. Voir exemple .
boost :: asio :: windows :: random_access_handle est la manière la plus simple de faire cela, si vous avez besoin de quelque chose de avancé, par exemple un LockFileEx asynchrone ou autre chose, vous pouvez étendre asio, append vos propres événements asynchrones. Exemple
ASIO prend en charge les E / S superposées sur Windows où la prise en charge est bonne. Sur Unixes, cette idée a stagné à cause de:
La seule exception courante est le service de fichiers directement aux sockets. Ceci est un cas si commun que Linux a une fonction kernel qui gère cela pour vous. Encore une fois, la raison pour laquelle vous utilisez des E / S de fichiers asynchrones est annulée.
En résumé: l’ASIO semble refléter la philosophie de conception du système d’exploitation sous-jacent, les E / S superposées étant ignorées par la plupart des développeurs Unix, elles ne sont donc pas sockets en charge sur cette plate-forme.
Linux a une bibliothèque asio qui n’est pas plus difficile à utiliser que les API Windows pour ce travail (je l’ai utilisé). Les deux systèmes d’exploitation implémentent la même architecture conceptuelle. Ils diffèrent dans les détails pertinents pour l’écriture d’une bonne bibliothèque, mais pas au point que vous ne pouvez pas avoir une interface commune pour les deux plates-formes de système d’exploitation (j’en ai utilisé une).
Fondamentalement, toutes les versions d’E / S Async File suivent l’architecture “Fry Cook”. Voici ce que je veux dire dans le contexte d’une opération de lecture: Je (traitement du fil) monte à un comptoir de restauration rapide et demande un cheeseburger (certaines données). Il me donne une copie de mon ticket de commande (certaines structures de données) et envoie un ticket au cuisinier (le kernel et le système de fichiers) pour cuisiner mon burger. Je vais ensuite m’asseoir ou lire mon téléphone (faire un autre travail). Plus tard, quelqu’un annonce que mon burger est prêt (un signal au thread de traitement) et je collectionne mes aliments (le tampon de lecture).