Boucles parallèles de coquilles

Je ne suis pas sûr de ce à quoi ressemblent vos arguments dérivés. Mais avec GNU Parallel http:// www.gnu.org/software/parallel/ vous pouvez faire cela pour exécuter un travail par noyau de CPU :

find . | parallel -j+0 'a={}; name=${a##*/}; upper=$(echo "$name" | tr "[:lower:]" "[:upper:]");
   echo "$name - $upper"'

Si ce que vous voulez dériver consiste simplement à changer l'extension, le {.} peut être pratique :

parallel -j+0 lame {} -o {.}.mp3 ::: *.wav

Regardez la vidéo d'introduction à GNU Parallel sur http://www.youtube.com/watch?v=OpaiGYxkSuQ

Ne serait-il pas plus judicieux d'utiliser la commande wait de votre shell pour cela?

for i in *
do
    do_something $i &
done
wait

Votre boucle exécute une tâche puis attend, puis passe à la tâche suivante. Si ce qui précède ne fonctionne pas pour vous, alors la vôtre pourrait mieux fonctionner si vous déplacez pwait après done.

Pourquoi personne n'a encore mentionné xargs?

En supposant que vous avez exactement trois arguments,

pour i in *.mesfichiers; faire echo -n $i `derived_params $i` other_params; done | xargs -n 3 -P $PROCS do_something

Sinon, utilisez un délimiteur (null est pratique pour cela):

pour i in *.mesfichiers; faire echo -n $i `derived_params $i` other_params; echo -ne "\0"; done | xargs -0 -n 1 -P $PROCS do_something

EDIT: pour ce qui précède, chaque paramètre doit être séparé par un caractère null, puis le nombre de paramètres doit être spécifié avec le xargs -n.

J'ai essayé certaines des réponses. Elles rendent le script un peu plus complexe que ce qui est nécessaire. Idéalement, l'utilisation de parallel ou de xargs serait préférable, cependant, si les opérations à l'intérieur de la boucle for sont compliquées, il pourrait être problématique de créer de gros et longs fichiers de lignes à fournir à parallel. Au lieu de cela, nous pourrions utiliser source comme suit

# Créer un fichier de test
$ cat test.txt
task_test 1
task_test 2

# Créer un fichier source shell
$ cat task.sh
task_test()
{
    echo $1
}

# Utiliser la source sous bash -c
$ cat test.txt | xargs -n1 -I{} bash -c 'source task.sh; {}'
1
2

Ainsi, pour la solution de votre problème, cela ressemblerait à

for i in *.mesfichiers; echo " do_something $i `derived_params $i` other_params
" >> commands.txt ; done

Définir quelque chose comme do_something.sh

do_something(){
process $1
echo $2 
whatever $3 

}

exécutez avec xarg ou parallel gnu

   cat commands.txt | xargs -n1 -I{} -P8 bash -c 'source do_something.sh; {}'

Je suppose que l'indépendance fonctionnelle des itérations de for est implicite.