Anelli a guscio parallelo

Voglio elaborare molti file e poiché ho qui un mucchio di core, voglio farlo in parallelo:

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

Conosco una soluzione Makefile ma i miei comandi hanno bisogno degli argomenti fuori dalla lista dei globbing della shell. Quello che ho trovato è:

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

Per usarlo, tutto ciò che si deve fare è mettere e dopo i lavori e una chiamata pwait, il parametro fornisce il numero di processi paralleli:

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

Ma questo non funziona molto bene, ad esempio l'ho provato con ad esempio un ciclo for che converte molti file ma mi dà errore e lascia i lavori annullati.

Non riesco a credere che non sia stato ancora fatto poiché la discussione sulla mailing list di zsh è ormai obsoleta. Quindi conosci qualcosa di meglio?

Un makefile è una buona soluzione al tuo problema. Potresti programmare questa esecuzione parallela in una shell, ma è difficile, come hai notato. Un'implementazione parallela di make non si occuperà solo dell'avvio dei lavori e del loro rilevamento, ma gestirà anche il bilanciamento del carico, il che è difficile.

Il requisito per il globbing non è un ostacolo: ci sono implementazioni che lo supportano. GNU make, che ha espansione con caratteri jolly come $(wildcard *.c)e accesso alla shell come $(shell mycommand)(cercare le funzioni nella GNU make manual per ulteriori informazioni). È l'impostazione predefinita makesu Linux e disponibile sulla maggior parte degli altri sistemi. Ecco uno scheletro di Makefile che potresti essere in grado di adattare alle tue esigenze:

fonti = $ (carattere jolly * .src)

tutto: $ (fonti: .src = .tgt)

% .tgt: $ .src
    do_something $ <$$ (deriv_params $ <)> $ @

Eseguire qualcosa come make -j4eseguire quattro lavori in parallelo o make -j -l3mantenere la media del carico intorno a 3.

Non sono sicuro di come siano i tuoi argomenti derivati. Ma con GNU Parallel http: // www.gnu.org/software/parallel/ puoi farlo per eseguire un lavoro per core cpu:

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

Se ciò che vuoi derivare è semplicemente cambiare l'estensione. {.} Può essere utile:

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

Guarda il video introduttivo su GNU Parallel su http://www.youtube.com/watch?v=OpaiGYxkSuQ

L'uso del waitcomando della shell non funzionerebbe per te?

for i in *
do
    do_something $i &
done
wait

Il ciclo esegue un lavoro, quindi lo attende, quindi esegue il lavoro successivo. Se quanto sopra non funziona per te, allora il tuo potrebbe funzionare meglio se ti muovi pwaitdopo done.

Perché nessuno ha ancora menzionato xargs?

Supponendo che tu abbia esattamente tre argomenti,

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

Altrimenti usa un delimitatore (null è utile per quello):

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

EDIT: per quanto sopra, ogni parametro dovrebbe essere separato da un carattere null, quindi il numero di parametri dovrebbe essere specificato con xargs -n.

Ho provato alcune delle risposte. Rendono lo script un po 'più complesso di quanto sia necessario. L'utilizzo ideale parallelo xargssarebbe preferibile, tuttavia, se le operazioni all'interno del ciclo for sono complicate, potrebbe essere problematico creare file di grandi e lunghe linee da fornire in parallelo. invece potremmo usare source come segue

# 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

Quindi per il tuo problema la soluzione sarebbe simile

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

definire fare qualcosa come do_something.sh

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

}

eseguire con xargognu parallel

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

Presumo che sia implicita l'indipendenza funzionale delle iterazioni di for.