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?
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Nicolas George
R12y wrote in message <gdvpg1$2ad0$:
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.
R12y wrote in message <gdvpg1$2ad0$1@cabale.usenet-fr.net>:
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.
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
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)
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)
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
"
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
"
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.
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
"
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
"
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.
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
"
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
"
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.
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
"
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
"
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.
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
> 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
> 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.
> 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.
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 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 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".
