Conversion ffmpeg

Bonjour,
J’ai une grande quantitée de fichiers vidéos à convertir, avec ffmpeg
et mon processeur est un multicoeur
Je pense que si je convertissait un fichiers par coeur ,
ce serait plus rapide que de convertir chaque fichiers un à un et en utilisant tout mes coeurs pour la conversion du même fichier.
J’aimerais savoir ce que vous en pensez
Merci

Cela me semble un propos inaccessible au niveau utilisateur, la gestion des processus est l’une des fonctions la plus profonde d’un système d’exploitation. Voir la discussion :
http://www.developpez.net/forums/d155758/systemes/linux/administration-systeme/affecter-processus-processeur/

Qu’es ce qu’il te permet de dire cela ?
Je serais toi je ferais quelques tests, 1 à N conversion en // et voir ce qui prend le plus de temps. Sachant que les accès disque ralentiront sûrement les conversions en avoir plusieurs en // n’est pas une mauvaise idée en soi.

Effectivement ffmpeg permet de fixer le nombre de threads. En le fixant à 1 et en lançant plusieurs process cela permet peut-être de faire le test. Voir
https://doc.ubuntu-fr.org/ffmpeg#instruction_generale

salut

tu fais un script du genre, remplace avconv par ffmpeg et adapte les formats, tu le mets dans le dossier où sont les vidéos

#!/bin/bash

for i in *.avi
    do avconv -i "$i" -s 720x480 -pass 1 -threads auto -vcodec libx264 -b 2040k -r 25 -an -f mp4 -y /dev/null
    avconv -i "$i" -s 720x480 -pass 2 -threads auto -vcodec libx264 -b 2040k -r 25 -acodec ac3 -ac 2 -ab 192k -ar 48000 "${i%.avi}.mp4"
done

et tu vas prendre un café tranquillement

ton script est itératif, jweber voulais justement faire plusieurs traitement en // pour profiter pleinement de tous les cœur de son proc.

t’a pas compris -threads auto
on peut mettre
-threads 4 mais il n’est pas certain que ce soit meilleur

Si j’avais bien vu ce réglage, mais il veut savoir si c’est préférable de laisser FFmpeg de gerer ses threads et lui filer les fichiers 1 par 1 (comme tu fait) ou de lancer X conversion à la fois.

De toute façon ca dépends du codecs utilisé

https://ffmpeg.org/ffmpeg-all.html

hreads integer (decoding/encoding,video)
Set the number of threads to be used, in case the selected codec implementation supports multi-threading.

Possible values:

‘auto, 0’
automatically select the number of threads to set

Default value is ‘auto’.

En fait il me semble (c’est à vérifier) qu’ un processeur à X GHz et n coeur, est moins rapide qu’un processeur mono-coeur et X * n GHz , car le problème est que distribuer un même processus sur plusieurs cœurs est problématique ; explications : les variables ou les instructions d’un calcul , sont souvent définis par le calcul précédent , par conséquent quand un calcul effectué par un coeur dépend du résultat d’un autre effectué sur un autre coeur, il y a un temps d’attente.

Je suppose donc qu’il serait plus efficace d’effectuer une conversion par coeurs.

Certes, mais si on cherche n=4 X=4 on trouve… si on cherche n=1 X=16 c’est plus rare…:slight_smile:

C’est bien la raison pour laquelle les processeurs multi-cœurs ont été crées, mais ce qui m’intéresse, c’est de savoir si l’on peut allouer une conversion à un cœur, et une autre à un autre cœur (choisir quel cœur je souhaite utiliser quand je fait une conversion ).

Et savoir si c’est vraiment plus efficace.

Quelques pistes ci-dessous.
principes généraux :
http://tvaira.free.fr/os/cours-sys-ordonnancement.pdf
Une commande système :
# man taskset
Un cours :
http://www.glennklockwood.com/hpc-howtos/process-affinity.html

… google : "linux affinity"
Je viens d’apprendre un mot et des choses !

Bonjour,

A mon humble avis, si la chose qui prend du temps est le calcul (conversion longue à faire), et que tu en as beaucoup à faire, Il est plus rapide de faire 1 fichier par coeur, que 1 fichier sur N Coeurs.

Car tu évites tout problème de parallélisation, de synchronisation.

Les programmeurs sont rarement bons à savoir décorréler des traitements. Et puis, souvent , c’est juste impossible.
Une petite synchronisation par ci, une autre par là, par “sécurité”, et tu perds 50% de gain par thread utilisé. Alors sur 4 coeurs cela devient visible, sur 8, c’est très ennuyeux, sur 16 c’est catastrophique.

1 traitement indépendant par coeur, c’est vraiment très simple et très efficace.