J'essaie de faire un nombre record sur un fichier gzip de 7,6 Go. J'ai trouvé peu d'approches en utilisant la zcatcommande.

$ zcat T.csv.gz | wc -l
423668947

Cela fonctionne mais cela prend trop de temps (plus de 10 minutes pour obtenir le décompte). J'ai essayé quelques autres approches comme

$ sed -n '$=' T.csv.gz
28173811
$ perl -lne 'END { print $. }' < T.csv.gz
28173811
$ awk 'END {print NR}' T.csv.gz
28173811

Ces trois commandes s'exécutent assez rapidement mais donnent un nombre incorrect de 28173811.

Comment effectuer un décompte d'enregistrements en un minimum de temps?

Les sed, perlet les awkcommandes que vous mentionnez peuvent être correctes, mais ils lu tous les comprimés de données et compte des sauts de ligne dans ce. Ces caractères de nouvelle ligne n'ont rien à voir avec les caractères de nouvelle ligne des données non compressées.

Pour compter le nombre de lignes dans les données non compressées, il est impossible de les décompresser. Votre approche avec zcatest la bonne approche et comme les données sont si volumineuses, il faudra du temps pour les décompresser.

La plupart des utilitaires traitant de la gzipcompression et de la décompression utiliseront très probablement les mêmes routines de bibliothèque partagée pour ce faire. La seule façon de l'accélérer serait de trouver une implémentation des zlibroutines plus rapides que celles par défaut, et de reconstruire par exemple zcatpour les utiliser.

Utilisez unpigz.

La réponse de Kusalananda est correcte, vous aurez besoin de décompresser le fichier entier pour analyser son contenu. /bin/gunziple fait aussi vite que possible, sur un seul cœur. Pigz est une implémentation parallèle gzipqui peut utiliser plusieurs cœurs.

Malheureusement, la décompression de fichiers lui - même gzip normal ne peut pas être parallélisés, mais pigzne offre une version améliorée gunzip, unpigzqui fait des travaux connexes tels que la lecture, l' écriture et la somme de contrôle dans un thread séparé. Dans certains tests rapides, unpigzest presque deux fois plus rapide que gunzipsur ma machine Core i5.

Installez pigzavec votre gestionnaire de paquets préféré et utilisez unpigzau lieu de gunzipou unpigz -cau lieu de zcat. Votre commande devient donc:

$ unpigz -c T.csv.gz | wc -l

Tout cela suppose que le goulot d'étranglement est le CPU, pas le disque, bien sûr.

Le problème avec tous les pipelines, c'est que vous doublez essentiellement le travail. Quelle que soit la rapidité de la décompression, les données doivent toujours être transférées vers un autre processus.

Perl a PerlIO :: gzip qui vous permet de lire directement les flux gzippés. Par conséquent, il pourrait offrir un avantage même si sa vitesse de décompression peut ne pas correspondre à celle de unpigz:

#!/usr/bin/env perl

use strict;
use warnings;

use autouse Carp => 'croak';
use PerlIO::gzip;

@ARGV or croak "Need filename\n";

open my $in, '<:gzip', $ARGV[0]
    or croak "Failed to open '$ARGV[0]': $!";

1 while <$in>;

print "$.\n";

close $in or croak "Failed to close '$ARGV[0]': $!";

Je l'ai essayé avec un fichier compressé gzip de 13 Mo (décompresse à 1,4 Go) sur un ancien MacBook Pro 2010 avec 16 Go de RAM et un vieux ThinkPad T400 avec 8 Go de RAM avec le fichier déjà dans le cache. Sur Mac, le script Perl était significativement plus rapide que l'utilisation de pipelines (5 secondes contre 22 secondes), mais sur ArchLinux, il a perdu à unpigz:

$ time -p ./gzlc.pl spy.gz 
1154737
réel 4,49
utilisateur 4.47
sys 0,01

contre

$ time -p unpigz -c spy.gz | wc -l
1154737
réel 3,68
utilisateur 4.10
sys 1.46

et

$ time -p zcat spy.gz | wc -l
1154737
réel 6,41
utilisateur 6.08
sys 0.86

De toute évidence, l'utilisation unpigz -c file.gz | wc -lest la gagnante ici en termes de vitesse. Et, cette simple ligne de commande bat sûrement l'écriture d'un programme, aussi court soit-il.

La réponse de Kusalananda est généralement correcte. Pour compter les lignes, vous devez rechercher des sauts de ligne. Cependant, il est théoriquement possible de rechercher des sauts de ligne sans décompresser complètement le fichier.

gzip utilise la compression DEFLATE. DEFLATE est une combinaison de l'encodage LZ77 et Huffman. Il peut y avoir un moyen de comprendre uniquement le nœud de symbole Huffman pour la nouvelle ligne et d'ignorer le reste. Il existe presque certainement un moyen de rechercher des sauts de ligne codés à l'aide de L277, de conserver un nombre d'octets et d'ignorer tout le reste.

Donc, à mon humble avis, il est théoriquement possible de trouver une solution plus efficace que unpigz ou zgrep. Cela étant dit, ce n'est certainement pas pratique (à moins que quelqu'un ne l'ait déjà fait).

Peut être fait en utilisant zgrepun -cindicateur et un $paramètre.

Dans ce cas, -c indique à la commande de sortir le nombre de lignes correspondantes et l'expression régulière $ correspond à la fin de la ligne pour correspondre à chaque ligne ou au fichier.

zgrep -c $ T.csv.gz 

Comme l'a commenté @ StéphaneChazelas - zgrep est seulement autour d' un script zcatet grepil devrait fournir des performances similaires à la suggestion originale dezcat | wc -l

Comme vous pouvez le voir, la plupart des réponses essaient d'optimiser ce qu'il peut: le nombre de commutateurs de contexte et d'E / S inter-processus. La raison en est que c'est le seul que vous pouvez facilement optimiser ici.

Maintenant, le problème est que son besoin en ressources est presque négligeable par rapport au besoin en ressources de la décompression. C'est pourquoi les optimisations ne feront vraiment rien de plus rapide.

Là où il pourrait être vraiment accéléré, ce serait un algorithme non-gzip modifié (c'est-à-dire la décompression), qui exclut la production réelle du flux de données décompressé; il calcule plutôt le nombre de sauts de ligne dans le flux décompressé à partir du flux compressé . Ce serait difficile, cela nécessiterait une connaissance approfondie de l'algorithme de gzip (une combinaison des algorithmes de compression LZW et Huffman ). Il est fort probable que l'algorithme ne permet pas d'optimiser significativement le temps de décompression avec l'éclair, qu'il suffit de connaître les décomptes de la nouvelle ligne. Même si cela était possible, une nouvelle bibliothèque de décompression gzip aurait dû être développée (elle n'existe pas jusqu'à ce que nous le sachions).

La réponse réaliste à votre question est que non, vous ne pouvez pas le faire beaucoup plus rapidement.

Vous pouvez peut-être utiliser une décompression gzip parallélisée, si elle existe. Il pourrait utiliser plusieurs cœurs de processeur pour la décompression. S'il n'existe pas, il pourrait être développé assez facilement.

Pour le xz , il existe un compresseur parallèle (pxz).