====== Convertir des images : xargs vs parallel vs boucle bash ======


Reflexion sur le temps et charge processus d'une commande.
Cas concret : convertir un ensemble de fichiers PNG en GIF

===== Echantillon =====

<code bash>du -sh
240 fichiers générés aléatoirement pour un total disque de 7,5 Mo
7,5M	</code>

<code bash>
ls -l | wc -l
240</code>

===== Avec xargs =====

<code bash>$ time  ls -1 *.png  |  xargs -n 1 bash -c 'convert "$0" "${0%.*}.gif"' 

real	0m30,057s
user	0m30,858s
sys	0m4,422s</code>

===== En shell =====

<code bash>$ time ls -1 *.png | parallel -j 3 convert '{}' '{.}.gif'

real	0m28,761s
user	0m54,001s
sys	0m20,123s</code>

===== Avec parallel =====

<code bash>$ time ls -1 *.png | parallel  convert '{}' '{.}.gif'

real	0m25,827s
user	0m56,121s
sys	0m21,074s</code>

===== Quesako =====

**real** fait référence au temps réel écoulé;
user et **sys** font référence au temps CPU utilisé uniquement par le processus.

Le temps **real** est l'horloge du PC - le temps du début à la fin de l'appel. Il s'agit de tout le temps écoulé, y compris les tranches de temps utilisées par d'autres processus et le temps que le processus passe bloqué (par exemple s'il attend la fin des E / S).

Le temps **user** est la quantité de temps CPU passé en code en mode utilisateur (en dehors du noyau) dans le processus. Il s'agit uniquement du temps CPU real utilisé lors de l'exécution du processus. Les autres processus et le temps que le processus passe bloqué ne comptent pas dans ce chiffre.

Le temps **sys** est la quantité de temps CPU passé dans le noyau au sein du processus. Cela signifie exécuter le temps CPU passé dans les appels système au sein du noyau, par opposition au code de bibliothèque, qui s'exécute toujours dans l'espace utilisateur. Comme «user», il s'agit uniquement du temps CPU utilisé par le processus.

**
User + Sys** vous indiqueront combien de temps CPU réel votre processus a utilisé. Notez que cela concerne tous les processeurs, donc si le processus a plusieurs threads (et que ce processus s'exécute sur un ordinateur avec plus d'un processeur), il peut potentiellement dépasser le temps d'horloge murale signalé par **Real** (ce qui se produit généralement). Notez que dans la sortie, ces chiffres incluent le temps utilisateur et **Sys** de tous les processus enfants (et leurs descendants) ainsi que le moment où ils auraient pu être collectés, par exemple par wait (2) ou waitpid (2), bien que les appels système sous-jacents renvoient séparément les statistiques du processus et de ses enfants.


//Gardez à l'esprit que réel représente le temps réel écoulé, tandis que les valeurs **user et sys** représentent le temps d'exécution du processeur. Par conséquent, sur un système multicœur, le temps de l'utilisateur et / ou du système (ainsi que leur somme) peut réellement dépasser le temps réel.//


Bon voilà c'était juste au passage...