Bucles de concha paralela

Quiero procesar muchos archivos y desde que tengo aquí un montón de núcleos, quiero hacerlo en paralelo:

for i in *.myfiles; do do_something $i `derived_params $i` other_params; done

Sé de una solución Makefile pero mis comandos necesitan los argumentos de la lista global de shell. Lo que encontré es:

> function pwait() {
>     while [ $(jobs -p | wc -l) -ge $1 ]; do
>         sleep 1
>     done
> }
>

Para usarlo, todo lo que hay que hacer es poner y después de los trabajos y una llamada en espera, el parámetro proporciona la cantidad de procesos paralelos:

> for i in *; do
>     do_something $i &
>     pwait 10
> done

Pero esto no funciona muy bien, por ejemplo, lo probé con, por ejemplo, un bucle for que convierte muchos archivos, pero me dio un error y dejó los trabajos sin hacer.

No puedo creer que esto aún no se haya hecho ya que la discusión sobre la lista de correo de zsh es muy antigua por ahora. Entonces, ¿sabes algo mejor?

Un archivo MAKE es una buena solución a su problema. Podrías programar esta ejecución paralela en un shell, pero es difícil, como has notado. Una implementación paralela de make no solo se encargará de iniciar trabajos y detectar su finalización, sino que también se encargará del equilibrio de carga, lo cual es complicado.

El requisito de globbing no es un obstáculo: hay implementaciones de make que lo soportan. GNU make, que tiene expansión de comodines como $(wildcard *.c)y acceso de shell como $(shell mycommand)(funciones de búsqueda en el manual de GNU make para obtener más información). Es el valor predeterminado makeen Linux y está disponible en la mayoría de los otros sistemas. Aquí hay un esqueleto de Makefile que puede adaptar a sus necesidades:

fuentes = $ (comodín * .src)

todos: $ (fuentes: .src = .tgt)

% .tgt: $ .src
    hacer_algo $ <$$ (derivados_parámetros $ <)> $ @

Ejecute algo como make -j4ejecutar cuatro trabajos en paralelo o make -j -l3mantener el promedio de carga alrededor de 3.

No estoy seguro de cómo son sus argumentos derivados. Pero con GNU Parallel http: // www.gnu.org/software/parallel/ puede hacer esto para ejecutar un trabajo por núcleo de CPU:

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

Si lo que desea obtener es simplemente cambiar la extensión. {.} Puede ser útil:

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

Mire el video de introducción a GNU Parallel en http://www.youtube.com/watch?v=OpaiGYxkSuQ

¿No usaría el waitcomando del shell para usted?

for i in *
do
    do_something $i &
done
wait

Su ciclo ejecuta un trabajo, luego lo espera y luego realiza el siguiente trabajo. Si lo anterior no funciona para usted, entonces el suyo podría funcionar mejor si se muda pwaitdespués done.

¿Por qué nadie ha mencionado xargs todavía?

Asumiendo que tienes exactamente tres argumentos,

for i in *.myfiles; do echo -n $i `derived_params $i` other_params; done | xargs -n 3 -P $PROCS do_something

De lo contrario, use un delimitador (nulo es útil para eso):

for i in *.myfiles; do echo -n $i `derived_params $i` other_params; echo -ne "\0"; done | xargs -0 -n 1 -P $PROCS do_something

EDITAR: para lo anterior, cada parámetro debe estar separado por un carácter nulo, y luego el número de parámetros debe especificarse con xargs -n.

Intenté algunas de las respuestas. Hacen que el script sea un poco más complejo de lo que se necesita. Lo ideal sería utilizar parallelo xargssería preferible, sin embargo, si las operaciones dentro del ciclo for son complicadas, podría ser problemático crear archivos de líneas grandes y largas para suministrar en paralelo. en su lugar podríamos usar la fuente de la siguiente manera

# Create a test file 
$ cat test.txt
task_test 1
task_test 2

# Create a shell source file 
$ cat task.sh
task_test()
{
    echo $1
}

# use the source under bash -c 
$ cat test.txt | xargs -n1 -I{} bash -c 'source task.sh; {}'
1
2

Por lo tanto, para su problema, la solución se vería así

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

definir hacer algo como do_something.sh

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

}

ejecutar con xargognu parallel

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

Supongo que la independencia funcional de las iteraciones de for está implícita.