fichier sous: "Département d'efficacité imprévu."
Les 90 premiers millions de numéros prennent environ 761 mb, comme sortie par: p> selon tuyau qui à un ancien a pris 80 secondes, sur le même processeur. Maintenant la surprise: p> sortie: p> 300k plus grand? Cela n'a pas l'air bien. D'abord, j'ai vérifié avec homme Parallèlement code>, il peut accélérer l'archivage des gros fichiers d'archivage gzip code> en coupant l'entrée vers le haut et en utilisant différents processeurs pour comprimer les morceaux. Donc, même si
gzip code> est threaded em> cette technique le fait multi-filetés em>: p>
gzip code>: p>
zDiff code> si les fichiers avaient le même contenu - oui, identique. J'aurais supposé tout compresseur em> ferait mieux avec un flux de données continu que d'un. Pourquoi
bigfile2.gz code> plus petit que
bigfile.gz code>? P> p>
3 Réponses :
Je pense que c'est la fréquence de la fabrication de dictionnaires, qui est différente.
Il s'agit de l'équilibre entre la vitesse et l'efficacité de la compression, comme gzip em> vs lzma em>. p>
Je suppose que c'est plus fréquent dans le cas divisé.
Donc, les chiffres du dictionnaire sont plus similaires à ceux suivants. P>
Il y avait une conférence de 20 minutes sur YouTube em>, Raul Faille: Comment fonctionne Gzip Compression | JSCONF UE 2014 . P>
Re: "Ce qui suit." Il n'est pas trop clair ce que Noun-Object the suivant i> signifie. Désolé, mais la conférence Raul Faille, livrée avec un accent épais de l'Espagne dans une monotone timide molle par un auto-expert non expert en compression, est trop lent pour mes oreilles américaines habituées à des bavards rapides - il serait préférable de simplement citer le Une partie que vous pensez est pertinente ou de lien vers le segment le plus pertinent de la vidéo.
La raison en est que, pour cette entrée plutôt inhabituelle, des blocs de déflèvement plus petits sont meilleurs que les plus grands. Par défaut Vous pouvez faire beaucoup mieux en définissant une plus petite taille de bloc pour chaque em> bloc en utilisant zlib A> 'S L'optimum L'amélioration provient de la nature extrêmement régulière de l'entrée, entraînant une séquence régulière de match et de commandes littérales. Plus la taille du bloc est petite, moins de ces commandes distinctes qui apparaissent, qui prennent ensuite moins de bits pour coder chacun d'eux. Ceci est toujours vrai pour gzip code> utilise des blocs de déflèvements plus importants, car cela fonctionne mieux pour les données d'entrée normales. La commande
parallèle code> forçant quelques blocs de déflèvements plus petits en rompant l'entrée toutes les 1 Mo, entraînant un petit gain. Bien que la plupart des blocs sont toujours de la même taille. P>
MEMLEVEL code> paramètre dans
déflateinit2 () code>. Ici, je compresse la même sortie dans un seul fil à chaque fois, à l'aide des valeurs
MEMLEVEL CODE> de 9 à 2, où un
plus petit> MEMLEVEL code> est une taille de bloc de déformation inférieure (notez que zlib. Un peu mieux que votre
gzip code> au niveau par défaut): p>
MEMLEVELL code> Pour que ces données s'avère être 4, pour laquelle les données compressées sont de 12 Mo (9%) inférieures à celles pour les
MEMLEVEL code> de 8. Pour
MEMLEVEL code> 8, la taille du bloc de déflate est de 16383 symboles, tandis que pour
MEMLEVEL code> 4, la taille du bloc de déflate est de 1023 symboles. Un symbole est un octet littéral ou une correspondance. P>
MEMLEVEL code> 3, mais à ce moment-là, la surcharge de la description du code au début de chaque bloc de déflate annule l'amélioration de moins de codes distincts. P>
zopfli code>
est un compresseur de déflate qui optimise la taille du bloc et les commandes sélectionnées et ont réussi à la compresser à 100 656 812 octets. Il a fallu trois heures et demie! zopfli code> est invoqué avec
porcz code>
à l'aide du niveau de compression 11 . P>
Juste pour être clair, le zlib b> MEMLEVEL code> 2-9 i> Les options sont pas i> identique à la
gzip code> Vitesse de compression 'S
- # code> ( 1-9 i>) options, correct?
Correct. Le 1-9 est un niveau de compression, qui contrôle la dureté du compresseur des chaînes assorties. En fait, pour cette entrée, le niveau par défaut de 6 comprime mieux que 9! Mais c'est une histoire pour une autre fois.
Quelque chose à propos de ce type de données fait mieux 1023 symboles. Un réglage à grain finirait-il (disons 1013 symboles, etc.) compressez-vous à un optimum plus petit? Le 1023 est également constitué de la taille de la taille i> du jeu de données, c'est-à-dire 1023 symboles restent optimaux s'il y avait 9 millions de chiffres, ou 900 millions? Réponse: Test des valeurs plus petites que 90 mil., 9mil., 900k, 90k: parallèle code> semble généralement faire un peu mieux que
gzip code>. 900 mil. donne également
parallèle code> la victoire mineure.
Vous pouvez faire mieux avec une taille de bloc plus petite, si moins de commandes distinctes ont été utilisées. J'imaginais de construire un flux dégonflé à la main pour ces données, et il aurait de très petits blocs avec un numéro pour introduire chaque nouvelle séquence d'un nombre de 1000 numéros, puis un bloc avec juste des correspondances pour les 999 autres. Voir ma note sur zopfli , qui a optimisé cela. Je vérifierai plus tard quelle est la taille de bloc qu'elle utilisait.
Du parallèle code> a une option
parallèle code> s parallèle et ce que cela fait qu'il faut 40 fois plus longtemps.
En fait, c'est très intéressant. Il est probablement possible de recompresser 9 * 9 fois et de voir quel est le meilleur résultat ...
@Shimondoodkin va pour ça.
L'effet est probablement dû à la taille du bloc de compression. Compression du même flux d'entrée avec une plage de paramètres tels que ceci:
-rw-r--r-- 1 203473375 Jul 4 16:39 1.gz -rw-r--r-- 1 201160853 Jul 4 16:40 2.gz -rw-r--r-- 1 200181562 Jul 4 16:40 3.gz -rw-r--r-- 1 204266147 Jul 4 16:40 4.gz -rw-r--r-- 1 199144028 Jul 4 16:40 5.gz -rw-r--r-- 1 199688429 Jul 4 16:40 6.gz -rw-r--r-- 1 199689546 Jul 4 16:41 7.gz -rw-r--r-- 1 200376213 Jul 4 16:41 8.gz -rw-r--r-- 1 200381681 Jul 4 16:42 9.gz
Non, ce n'est pas l'effet ici. Le niveau de compression n'est pas changé. En outre, le niveau de compression ne change pas la taille du bloc. Vous voyez encore un autre effet, qui est le niveau de compression plus élevé qui trouve des correspondances plus longues, mais cette amélioration étant contré par un plus grand nombre de longueurs et de distances distinctes, nécessitant plus de bits par correspondance au code.
Je pensais que le programme GZIP a changé la taille du bloc lorsqu'il définit le niveau de compression, mais je suis maintenant corrigé. Merci @mark pour me corriger!
Trivia: Direction de 15 minutes de CPU faisant un parallèle comparatif code> vs plaine
gzip code> table,
temps pour F in {1..9}; echo $ f "" $ (SEQ 90000000 | gzip - $ f | wc -c) "" $ (SEQ 90000000 | parallèle --Pipe --Recend '' -k gzip - $ f | wc -c); FAIRE CODE>, révèle que la nature
gzip code> est un peu plus petit pour
-1 code> via
-3 code> et plus grand par la suite.
parallèle code> atteint son minimum avec
gzip -5 code> à 198735045 i> octets.
Plus de trivia: Ajout de porcz code> à cette boucle,
$ (SEQ 90000000 | PIGZ - $ F | WC -C) code>, montre que c'est Sweet Spot est également
-5 < / code> à 197271587 octets.
PIGZ CODE> est le plus petit à chaque fois, sauf pour
-2 code> où il se trouve en 2e place après
gzip code>.
Fait intéressant sur mon iMac,
bigfile2.gz code> sort plus petit et le temps écoulé est presque identique pour une invocation parallèle et standard.
@Marksetchell pour une raison quelconque de la raison pour laquelle le Mac OS X
SEQ code> ne produit pas la même sortie. Vous pouvez essayer
Jot code> à la place.
Il peut être pertinent de noter que
porcz code> est plus petit et plus rapide que
parallèle code> +
gzip code> (198345773 ici, contre 200381681 à partir de
gzip < / CODE> et 52S UTILISATEUR ET 6½S REAL, contre 36½ personnes et réel).
Parallel --Pipe Code> est inefficace. Utilisez
parallel --pipepart code> si possible (ce n'est pas dans ce cas, car vous lisez à partir d'un tuyau, mais vous avez eu un fichier, --PIPEPART serait plus rapide).