queue

Le
Rakotomandimby (R12y) Mihamina
Bonjour,
Je souhaite lancer parallelement des taches.
Par exemple, en ce moment, pour encoder tout un répertoire de fichiers
mpeg en theora, je fais juste un:

for F in *.mpeg
do
ffmpeg2theora $F
rm $F
done

Là j'ai simplifié l'appel, mais il y a une liste d'options, normalement

Dans ce cas là, il s'occupe des fichiers un par un les uns apres les
autres.
Sachant que je fais ça la nuit, je voudrais qu'il occupe _au_ _moins_
les 4 Cores de mon ordinateur, alors je me dis que je dois faire du
"parallelle".
Je me renseigne.
Je tombe sur: http://itb.biologie.hu-berlin.de/~benda/software/bash.html
Mais avant, dans le contexte de ce lien, quelle est la définition d'une
"queue"?
Une espèce de file d'attente?

Merci pour vos explications.


--
Serveurs infogérés:
http://www.infogerance.us/infogerance/packs-serveurs-infogeres
Vidéos High-Tech et Jeu Vidéo
Téléchargements
Vos réponses
Gagnez chaque mois un abonnement Premium avec GNT : Inscrivez-vous !
Trier par : date / pertinence
Nicolas George
Le #17643591
R12y wrote in message
Sachant que je fais ça la nuit, je voudrais qu'il occupe _au_ _moins_
les 4 Cores de mon ordinateur, alors je me dis que je dois faire du
"parallelle".



Pour ce genre de choses, il y a make -j 4, c'est précisément prévu pour.

Au passage, par rapport aux codecs actuels, Theora est franchement à la
traîne. Tout compte, il n'y a pas beaucoup de raisons d'utiliser Theora de
nos jours : il y a d'excellentes implémentations libres de codecs plus
efficaces, et côté brevets, Theora est autant dans l'incertitude que les
autres.
Mihamina Rakotomandimby
Le #17664991
Nicolas George wrote:
Au passage, par rapport aux codecs actuels, Theora est franchement à la
traîne. Tout compte, il n'y a pas beaucoup de raisons d'utiliser Theora de
nos jours : il y a d'excellentes implémentations libres de codecs plus
efficaces, et côté brevets, Theora est autant dans l'incertitude que les
autres.



Mince, ce que c'était au départ me plaisait bien pourtant.
Quelqu'un saurait pourquoi Theora est devenu "à la ramasse"? Mauvais
background technique? Mauvais développeurs?...

Ca a des chance de rattrapper son retard, ou bien c'est figé et donc
mauvais pour de bon?

Et pourquoi il y a "incertitude" sur ce type de codecs? Sur les formats
de compression (genre bzip2) il n'y a pas ce problème là, par exemple.

Suivi sur fr.comp.applications.libres

--
Huile Essentielle de Camphre http://www.huile-camphre.fr
Infogerance http://www.infogerance.us
(Serveurs, Postes de travail, Développement logiciel)
Lie Algebra
Le #17699741
"
Je souhaite lancer parallelement des taches.
Par exemple, en ce moment, pour encoder tout un répertoire de fichiers
mpeg en theora


>
[...]


>
Là j'ai simplifié l'appel, mais il y a une liste d'options, normalement

Dans ce cas là, il s'occupe des fichiers un par un les uns apres les
autres.
Sachant que je fais ça la nuit, je voudrais qu'il occupe _au_ _moins_
les 4 Cores de mon ordinateur, alors je me dis que je dois faire du
"parallelle".



Mise à part l'utilisation de make et de l'option -j, pour un besoin très
similaire (encodage audio cette fois au format musepack), j'avais
implémenté un mécanisme de queue très rudimentaire en shell bourne:


MAX_PROC=4 # MAX_PROC >= 1
DONE=0
CNT
PLST
for f in $@; do
mppenc ${f} &
LST="${LST} $!"
DONE=$(expr ${DONE} + 1)
if [ ${DONE} -eq ${CNT} ]; then
wait 2>/dev/null
break
fi
if [ ${DONE} -ge ${MAX_PROC} ]; then
for job in ${LST}; do
if wait ${job}; then
continue 2
fi
done 2>/dev/null
fi
done

Sous réserve que le transcodage réussisse (aucune gestion d'erreur
n'étant faite), au plus $MAX_PROC process sont traités en parallèle.
Après la n-ième itération (avec n=$MAX_PROC), un nouveau process est
exécuté dès lors qu'un process exécuté précédemment est terminé.
Enfin, la boucle se termine dès que tous les process lancés en
arrière plan et en cours d'exécution soient eux-même terminés.

E.S
Lie Algebra
Le #17699761
"
Je souhaite lancer parallelement des taches.
Par exemple, en ce moment, pour encoder tout un répertoire de fichiers
mpeg en theora
[...]
Là j'ai simplifié l'appel, mais il y a une liste d'options, normalement

Dans ce cas là, il s'occupe des fichiers un par un les uns apres les
autres.
Sachant que je fais ça la nuit, je voudrais qu'il occupe _au_ _moins_
les 4 Cores de mon ordinateur, alors je me dis que je dois faire du
"parallelle".



Mise à part l'utilisation de make et de l'option -j, pour un besoin très
similaire (encodage audio cette fois au format musepack), j'avais
implémenté un mécanisme de queue très rudimentaire en shell bourne:


MAX_PROC=4 # MAX_PROC >= 1
DONE=0
CNT
PLST
for f in $@; do
mppenc ${f} &
LST="${LST} $!"
DONE=$(expr ${DONE} + 1)
if [ ${DONE} -eq ${CNT} ]; then
wait 2>/dev/null
break
fi
if [ ${DONE} -ge ${MAX_PROC} ]; then
for job in ${LST}; do
if wait ${job}; then
continue 2
fi
done 2>/dev/null
fi
done

Sous réserve que le transcodage réussisse (aucune gestion d'erreur
n'étant faite), au plus $MAX_PROC process sont traités en parallèle.
Après la n-ième itération (avec n=$MAX_PROC), un nouveau process est
exécuté dès lors qu'un process exécuté précédemment est terminé.
Enfin, la boucle se termine dès que tous les process lancés en
arrière plan et en cours d'exécution soient eux-même terminés.

E.S
Lie Algebra
Le #17699751
"
Je souhaite lancer parallelement des taches.
Par exemple, en ce moment, pour encoder tout un répertoire de fichiers
mpeg en theora
[...]
Là j'ai simplifié l'appel, mais il y a une liste d'options, normalement

Dans ce cas là, il s'occupe des fichiers un par un les uns apres les
autres.
Sachant que je fais ça la nuit, je voudrais qu'il occupe _au_ _moins_
les 4 Cores de mon ordinateur, alors je me dis que je dois faire du
"parallelle".



Mise à part l'utilisation de make et de l'option -j, pour un besoin très
similaire (encodage audio cette fois au format musepack), j'avais
implémenté un mécanisme de queue très rudimentaire en shell bourne:


MAX_PROC=4 # MAX_PROC >= 1
DONE=0
CNT
PLST
for f in *.wav; do
mppenc ${f} &
LST="${LST} $!"
DONE=$(expr ${DONE} + 1)
if [ ${DONE} -eq ${CNT} ]; then
wait 2>/dev/null
break
fi
if [ ${DONE} -ge ${MAX_PROC} ]; then
for job in ${LST}; do
if wait ${job}; then
continue 2
fi
done 2>/dev/null
fi
done

Sous réserve que le transcodage réussisse (aucune gestion d'erreur
n'étant faite), au plus $MAX_PROC process sont traités en parallèle.
Après la n-ième itération (avec n=$MAX_PROC), un nouveau process est
exécuté dès lors qu'un process exécuté précédemment est terminé.
Enfin, la boucle se termine dès que tous les process lancés en
arrière plan et en cours d'exécution soient eux-même terminés.

E.S
Lie Algebra
Le #17699811
"
Je souhaite lancer parallelement des taches.
Par exemple, en ce moment, pour encoder tout un répertoire de fichiers
mpeg en theora
[...]
Là j'ai simplifié l'appel, mais il y a une liste d'options, normalement

Dans ce cas là, il s'occupe des fichiers un par un les uns apres les
autres.
Sachant que je fais ça la nuit, je voudrais qu'il occupe _au_ _moins_
les 4 Cores de mon ordinateur, alors je me dis que je dois faire du
"parallelle".



Mise à part l'utilisation de make et de l'option -j, pour un besoin très
similaire (encodage audio cette fois au format musepack), j'avais
implémenté un mécanisme de queue très rudimentaire en shell bourne:


MAX_PROC=4 # MAX_PROC >= 1
DONE=0
CNT
PLST
for f in *.wav; do
mppenc ${f} &
LST="${LST} $!"
DONE=$(expr ${DONE} + 1)
if [ ${DONE} -eq ${CNT} ]; then
wait 2>/dev/null
break
fi
if [ ${DONE} -ge ${MAX_PROC} ]; then
for job in ${LST}; do
if wait ${job}; then
continue 2
fi
done 2>/dev/null
fi
done

Sous réserve que le transcodage réussisse (aucune gestion d'erreur
n'étant faite), au plus $MAX_PROC process sont traités en parallèle.
Après la n-ième itération (avec n=$MAX_PROC), un nouveau process est
exécuté dès lors qu'un process exécuté précédemment est terminé.
Enfin, la boucle se termine dès que tous les process lancés en
arrière plan et en cours d'exécution sont eux-même terminés.

E.S
Lie Algebra
Le #17699801
> Je souhaite lancer parallelement des taches.
Par exemple, en ce moment, pour encoder tout un répertoire de fichiers
mpeg en theora
[...]
Là j'ai simplifié l'appel, mais il y a une liste d'options, normalement

Dans ce cas là, il s'occupe des fichiers un par un les uns apres les
autres.
Sachant que je fais ça la nuit, je voudrais qu'il occupe _au_ _moins_
les 4 Cores de mon ordinateur, alors je me dis que je dois faire du
"parallelle".



Mise à part l'utilisation de make et de l'option -j, pour un besoin très
similaire (encodage audio cette fois au format musepack), j'avais
implémenté un mécanisme de queue très rudimentaire en shell bourne:


MAX_PROC=4 # MAX_PROC >= 1
DONE=0
CNT
PLST
for f in *.wav; do
mppenc ${f} &
LST="${LST} $!"
DONE=$(expr ${DONE} + 1)
if [ ${DONE} -eq ${CNT} ]; then
wait 2>/dev/null
break
fi
if [ ${DONE} -ge ${MAX_PROC} ]; then
for job in ${LST}; do
if wait ${job}; then
continue 2
fi
done 2>/dev/null
fi
done

Sous réserve que le transcodage réussisse (aucune gestion d'erreur
n'étant faite), au plus $MAX_PROC process sont traités en parallèle.
Après la n-ième itération (avec n=$MAX_PROC), un nouveau process est
exécuté dès lors qu'un process exécuté précédemment est terminé.
Enfin, la boucle se termine dès que tous les process lancés en
arrière plan et en cours d'exécution sont eux-mêmes terminés.

E.S
Stephane CHAZELAS
Le #17703141
2008-10-25, 21:43(+03), Rakotomandimby (R12y) Mihamina:
Je souhaite lancer parallelement des taches.
Par exemple, en ce moment, pour encoder tout un répertoire de fichiers
mpeg en theora, je fais juste un:

for F in *.mpeg
do
ffmpeg2theora $F
rm $F
done

Là j'ai simplifié l'appel, mais il y a une liste d'options, normalement

Dans ce cas là, il s'occupe des fichiers un par un les uns apres les
autres.
Sachant que je fais ça la nuit, je voudrais qu'il occupe _au_ _moins_
les 4 Cores de mon ordinateur, alors je me dis que je dois faire du
"parallelle".


[...]

Tu peux utiliser un named pipe comme dans:

mkfifo tokens
printf '%sn' . . . . > tokens &
exec 3< tokens 4> tokens

job() {
read token <&3
(eval "$1" 3<&- 4>&-; echo >&4) &
}

for f in ./*.mpeg; do
job 'ffmpeg2theora "$f" && rm "$f"'
done

wait

Sinon, ya GNU xargs:

printf '%s' ./*.mpeg | xargs -r0P4 -n1 sh -c '
ffmpeg2theora "$1" && rm "$1"' inline

--
Stéphane
Publicité
Poster une réponse
Anonyme