Lecture rapide fichier binaire & Buffer

Bonjour à tous,

Actuellement j'ai un code qui lit un fichier binaire octet par octet. (et convertie le contenu en int ou string...). Jusqu'à maintenant je lisai directement le fichier binaire.

Mais les fichiers qui sont lus sont très gros (jusqu'au Go). On m'a donc conseillé de passer par les buffers pour gagner en rapidité :

Code:

---

1 2 3 4 5

std::ifstream fichier(filestdf.c_str(),std::ios_base::binary); std::stringstream buffer;   buffer << fichier.rdbuf(); fichier.close();

---

Après beaucoup de modifications, mon programme fonctionne comme auparavant sauf qu'il est encore plus lent! Donc apparament il faudrai allouer la mémoire du buffer, ou/et "lire le fichier dans le buffer" au fur et à mesure (morceau par morceau).

Mon problème est que je ne trouve pas la syntaxe pour tester ce que j'explique plus haut. Mes questions : Est ce que la méthode que je veux appliquer est pertinente (point de vue rapidité)? Si oui, quelles sont les fonctions ou la méthode que je doit appliquer?

Le plus rapide consiste a passer par des fichiers memory mapped.
Regarde du cote de boost::iostreams qui fournit une interface portable pour ce genre de chose.

Est ce que tu pourrais détailler le concept des memory mapped? Et quelles sont les différences avec l'utilisation de boost::iostreams?

le file mapping va créer une vue sur ton fichier comme si celui-ci etait chargé en mémoire, sauf qu'il ne l'est pas. Cela va créer une sorte de buffer virtuel. Lorsque tu lis dans ce buffer, si le fichier n'est pas encore lu a cet endroit la le système d'exploitation va le chercher sur le disque (ce qui prend un peu de temps bien sur) et le mettre la.
Le gain dépend principalement de la facon dont tu accèdes aux données; si il s'agit d'une lecture aléatoire il n'y a pas grand chose a faire mais si c'est sequenciel, ca va vite.
Avant d'en arriver la, si on te conseilles de passer par les buffers es tu sûr du bout de code que tu as posté? L'idée principale derrière le buffer est de lire un certain nombre de données (mettons 1 meg), de traiter ce mégaoctet (sans lire sr le disque puisque tout a déjà été lu), puis passer au meg suivant, lire un meg...
ensuite il y a beaucoup de moyens d'accelerer; par exemple tu peux lire 1 meg, puis en parallèle lire un autre meg, et sur un autre thread, faire le traitement du premier megaoctet. Ainsi tu te retrouve avec un thread qui lit sur le disque et un autre qui utilise les données (ca demande un peu de synchronisation des threads donc seulement si tu as besoin d'un truc très rapide)

Merci pour toutes ces explications très instructives.

Oui je suis sur de mon code, mais bon j'affecte tout le fichier au buffer. Mais du coup, l'accès au données devient très long. J'y accède comme un tableau.

La lecture de mon fichier, doit se faire octet par octet car c'est en lisant au fur et mesure le fichier que je sais comment le lire et faire mais manip en conséquence (je ne sais pas si c'est très clair).

L'idée était de charger une partie de mon fichier dans le buffer de le lire, et ensuite de charger la suite de mon fichier, lire, etc etc. Mais je ne sais pas comment le faire... Et mes recherches sur boost::iostreams et les memory mapped n'ont pas été très concluantes...

Serait-il possible d'avoir un bout d'exemple pour l'une de ces méthodes?

La doc :

http://boost.org/doc/libs/1_46_1/lib...pped_file.html

std::ifstream n'est pas déjà bufferisée ?

Si tel est le cas, je pense que c'est déjà bien adapté à ton problème.