Compression de petit chunks de données

Bonjour a tous,

Je cherche actuellement un moyen de compresser des petits chunks de unsigned char dans mon programme. Ces chunks n'excèdent que rarement les 300 KB et peuvent monter au maximum (mais très très peu probablement) jusqu'a 700KB. L'important n'est pas pour moi la quantité de mémoire que je gagne en compressant mes chunks mais la rapidité, je ne veux pas qu'ajouter de la compression ralentisse trop mon programme.

J'ai testé jusqu'a maintenant 2 libs :
- zlib (http://www.zlib.net): efficace mais terriblement lent, meme avec le plus petit niveau de compression
- lzfx (https://code.google.com/p/lzfx): je n'ai pas testé la rapidité mais les chunks une fois compressées était plus lourd que les chunks non compressées. Il semble que cette lib soit faite pour des données redondantes, ce qui n'est pas mon cas. De surcroit, elle semble incompatible avec Jemalloc et le code n'est plus maintenu depuis 2009.

J'ai aussi entendu parler un peu de Wilt (https://code.google.com/p/wilt-compressor/) mais je ne sais pas vraiment s'il est très efficace.

Avez-vous déja experimenté des libs de ce genre ? En connaissz-vous ? Des conseils ?

En vous remerciant d'avances de vos réponses.

Bonne soirée.

Juste par curiosité : tu veux compresser, mais le gain sur l'occupation en RAM n'a pas d'importance. Tu veux uniquement que la compression soit le plus rapide possible. Mais alors.... pourquoi compresser ?

Si tu veux gagner du temps sur le transfert "grâce" à la compression, c'est à toi de faire un benchmark pour vérifier l'utilité du truc...

Comme dinobogan : tu perdras *toujours* du temps à compresser ET décompresser + transférer.... donc ne compresse pas et transmet, c'est tout !

Tu as beaucoup de chunks à émettre/récupérer ?
Le temps de latence doit être quasi-nul entre la création du chunk et sa consommation ?
Quelles sont les conditions exactes ?

Bonjour,

Je suppose qu'il souhaite sauvegarder ses données compressées dans un fichier et les charger le plus rapidement possible dans son programme ?
Ou qu'il veut "précharger/précalculer" des chuncks et que ces données seront très souvent en mémoire "swap" et qu'il n'a besoin que de quelques parties de ces données qu'il peut alors décompresser.
Les accès disques étant très lent, compresser les données fera gagner un temps non-négligeable lors de leur chargement, il suffit que le temps de décompression soit inférieur au temps de chargement des données ainsi "gagnées".

C'est d'ailleurs la raison pour laquelle le noyau Linux est compressé.


Après un secteur de disque dur faisant 512Ko (si je ne me trompe pas) et étant chargé en un seul bloc en mémoire, si tu as des données de l'ordre de 500ko, il est inutile de compresser les données (4096ko sur les disques récents ?).

Après, je ne pense pas que la compression puisse vraiment faire gagner du temps sur les chargements en caches L3/L2 :aie:.

Moi je pensais à des chunks pour du réseau, en fait ! :P
Où du coup la latence est très très faible, et donc compresser/décompresser ne sert vraiment à rien pour des blocs de quelques unsigned char.


Mais comme le gars n'a pas l'air de repasser ici, et n'a pas décrit sa situation exacte... bah tant pis !

Même si l'auteur du thread ne repasse plus, je donne mes réponses, pour les visiteurs intéressés par le sujet qui atterrirait ici par google:

la bibliothèque LZ4 semble la plus adaptée pour la compression rapide

https://code.google.com/p/lz4/

avec une interface "à la zlib"
https://github.com/exalead/fastlzlib


à l'autre extrémité: xzutil
http://tukaani.org/xz/

L'auteur du thread repasse par ici ne vous en faites pas :) Il y'a juste que comme il n'y a pas eu de réponses pendant quelques jours, j'ai cru que le sujet tomberait aux oubliettes et étant dernièrement très occupé, je ne suis pas repassé.

Bref merci a tous pour vos réponses.

Ici est le pourquoi du comment.
Si je veux faire ceci, c'est parce-que mon appli utilise une structure de données dans laquelle les données sont organisées par petit paquet allant de 300KB a 700KB comme je l'ai dit. Cette structure de données est stocké en RAM et l'appli peut tourner dessus des jours entiers pour le type de calcul que je souhaite effectuer. Certains de ces paquets sont accedé très très souvent mais un très grand nombre d'entre eux ont un faible taux d'accès. C'est pourquoi pour ces paquets de données aux faible taux d'accès, je souhaitais voir si je pouvais compresser un petit peu pour gagner de l'espace en RAM.
L'idée après était d'obtenir un compromis entre temps de compression/décompression et ratio de compression, je ne suis pas idiot et je sais bien que je ne pourrais obtenir les deux en meme temps. C'est pourquoi dans le contexte de mon appli, je souhaite favoriser le temps de compression/décompression par rapport au ratio.

Au final, je me suis tourné vers LZ4 comme l'a indiqué gvollant qui semble correspondre a ce que je cherche. Il faut maintenant que je bench un peu la lib :)

Merci a vous !

W00t ! Je me suis trompé ! Il est revenu ! :P

Donc le but c'est uniquement de réduire la conso de RAM ?
Le bench va être décisif dans ce cas, c'est sûr ! :o
Fais un test global avec/sans compression...
Puis vérifie tes différents traitements un à un pour voir quelle partie consomme beaucoup/peu.

Bon courage !