Efficace de la lecture d'un très gros fichier texte en C++

J'avais cette refonte de la loi sur le streaming, au lieu de sur un bloc.

Une approche plus simple serait:

std::ifstream ifs("input.txt");
std::vector<uint64_t> parsed(std::istream_iterator<uint64_t>(ifs), {});

Si vous savez à peu près combien de valeurs sont attendus, à l'aide de std::vector::reserve à l'avant pourrait accélérer davantage.

---

Alternativement, vous pouvez utiliser un fichier mappé en mémoire et itérer sur la séquence de caractères.

• Comment analyser séparées par un espace de flotteurs en C++ rapidement? montre ces approches avec des indicateurs pour les flotteurs.

Mise à jour j'ai modifié le programme ci-dessus pour analyser uint32_ts dans un vecteur.

Lors de l'utilisation d'un exemple de fichier d'entrée de 4,5 Go^[1] le programme s'exécute en 9 secondes^[2]:

sehe@desktop:/tmp$ make -B && sudo chrt -f 99 /usr/bin/time -f "%E elapsed, %c context switches" ./test smaller.txt
g++ -std=c++0x -Wall -pedantic -g -O2 -march=native test.cpp -o test -lboost_system -lboost_iostreams -ltcmalloc
parse success
trailing unparsed: '
'
data.size():   402653184
0:08.96 elapsed, 6 context switches

Bien sûr, il alloue au moins 402653184 * 4 * octet = 1.5 gibibytes. Alors, quand
vous lisez un 45 GO de fichiers, vous aurez besoin d'une estimation de 15GiB de RAM pour stocker tout
le vecteur (en supposant l'absence de fragmentation sur la réaffectation): La 45GiB analyser
complète en 10 min 45s:

make && sudo chrt -f 99 /usr/bin/time -f "%E elapsed, %c context switches" ./test 45gib_uint32s.txt 
make: Nothing to be done for `all'.
tcmalloc: large alloc 17570324480 bytes == 0x2cb6000 @  0x7ffe6b81dd9c 0x7ffe6b83dae9 0x401320 0x7ffe6af4cec5 0x40176f (nil)
Parse success
Trailing unparsed: 1 characters
Data.size():   4026531840
Time taken by parsing: 644.64s
10:45.96 elapsed, 42 context switches

Par comparaison, juste en cours d'exécution wc -l 45gib_uint32s.txt a mis environ 12 minutes (sans priorité en temps réel l'ordonnancement). wc est hyper rapide

Plein De Code Utilisé Pour Indice De Référence

#include <boost/spirit/include/qi.hpp>
#include <boost/iostreams/device/mapped_file.hpp>
#include <chrono>
namespace qi = boost::spirit::qi;
typedef std::vector<uint32_t> data_t;
using hrclock = std::chrono::high_resolution_clock;
int main(int argc, char** argv) {
if (argc<2) return 255;
data_t data;
data.reserve(4392580288);   //for the  45 GiB file benchmark
//data.reserve(402653284); //for the 4.5 GiB file benchmark
boost::iostreams::mapped_file mmap(argv[1], boost::iostreams::mapped_file::readonly);
auto f = mmap.const_data();
auto l = f + mmap.size();
using namespace qi;
auto start_parse = hrclock::now();
bool ok = phrase_parse(f,l,int_parser<uint32_t, 10>() % eol, blank, data);
auto stop_time = hrclock::now();
if (ok)   
std::cout << "Parse success\n";
else 
std::cerr << "Parse failed at #" << std::distance(mmap.const_data(), f) << " around '" << std::string(f,f+50) << "'\n";
if (f!=l) 
std::cerr << "Trailing unparsed: " << std::distance(f,l) << " characters\n";
std::cout << "Data.size():   " << data.size() << "\n";
std::cout << "Time taken by parsing: " << std::chrono::duration_cast<std::chrono::milliseconds>(stop_time-start_parse).count() / 1000.0 << "s\n";
}

---

^[1] généré avec od -t u4 /dev/urandom -A none -v -w4 | pv | dd bs=1M count=$((9*1024/2)) iflag=fullblock > smaller.txt

^[2] de toute évidence, c'était avec le fichier mis en cache dans le cache de tampons sur linux - le gros fichier n'a pas cet avantage

OriginalL'auteur sehe

Vous pouvez carte mémoire le fichier dans la mémoire, mais qui seraient dépendants de la plateforme (unix qui serait mmap sur windows CreateFileMapping/MapViewIntoFile); encore si dans système 32 bits, vous pouvez avoir des problèmes si il n'est pas un assez grand bloc de mémoire virtuelle de gauche (64 bits des systèmes n'aurait pas ce problème).

Mappage de la mémoire est censé être plus rapide que de lire les données en bloc par bloc à partir du disque.

OriginalL'auteur MichaelMoser