Fácil paralelización

Question

a menudo me encuentro escribiendo simple para bucles para llevar a cabo una operación para muchos archivos, por ejemplo:

for i in `find . | grep ".xml$"`; do bzip2 $i; done 

Me parece un poco deprimente que en mi máquina de 4 núcleos solo núcleo se está acostumbrando. ¿Existe alguna manera fácil de agregar paralelismo a mis scripts de shell?

EDITAR: Para introducir un poco más de contexto a mis problemas, lo siento, no estaba más claro para empezar!

A menudo quiero ejecutar scripts simples (ish), como trazar un gráfico, comprimir o descomprimir, o ejecutar algún programa, en conjuntos de datos de tamaño razonable (generalmente entre 100 y 10.000). Los scripts que uso para resolver estos problemas se parecen al anterior, pero pueden tener un comando diferente, o incluso una secuencia de comandos para ejecutar.

Por ejemplo, ahora mismo estoy corriendo:

for i in `find . | grep ".xml.bz2$"`; do find_graph -build_graph $i.graph $i; done 

Así que mis problemas son de ninguna manera específica bzip! (Aunque el bzip paralelo se ve bien, tengo la intención de usarlo en el futuro).

Answer 1

Si tuviera que resolver el problema hoy en día es probable que utilice una herramienta como GNU paralelo (a menos que haya una herramienta especializada para parallelized su tarea como pbzip2):

find . | grep ".xml$" | parallel bzip2 

Para obtener más información:

• ver el vídeo de introducción para una introducción rápida: https://www.youtube.com/playlist?list=PL284C9FF2488BC6D1
• Paseo por el tutorial (parallel_tutorial hombre). Usted comando línea con amor por ello.

Answer 2

Creo que se podría a la siguiente

for i in `find . | grep ".xml$"`; do bzip2 $i&; done 

Pero eso sería escindir sin embargo muchos de los procesos que tiene archivos instantáneamente y no una óptima tan sólo corriendo cuatro procesos a la vez.

Answer 3

This perl program se adapte a sus necesidades bastante bien, usted acaba de hacer esto:

runN -n 4 bzip2 `find . | grep ".xml$"` 

Answer 4

La respuesta a la pregunta general es difícil, ya que depende de los detalles de las cosas que está paralelización. Por otro lado, para este propósito específico, debe usar pbzip2 en lugar de bzip2 simple (es probable que pbzip2 ya esté instalado o al menos en los repositorios o su distribución). Vea aquí para detalles: http://compression.ca/pbzip2/

Answer 5

Me parece que este tipo de operación es contraproducente. La razón es que cuantos más procesos acceden al disco al mismo tiempo, mayor es el tiempo de lectura/escritura, por lo que el resultado final termina en un tiempo más prolongado. El cuello de botella aquí no será un problema de CPU, no importa cuántos núcleos tenga.

¿Alguna vez ha realizado una simple copia de dos archivos grandes al mismo tiempo en la misma unidad de HD? Por lo general, soy más rápido para copiar uno y luego otro.

Sé que esta tarea implica algo de potencia de la CPU (bzip2 es un método de compresión exigente), pero intente medir la carga de la primera CPU antes de seguir el camino "desafiante" que todos los técnicos tienden a elegir mucho más a menudo de lo necesario.

Answer 6

gnu make tiene una buena característica de paralelismo (por ejemplo, -j 5) que funcionaría en su caso. Crear un Makefile

%.xml.bz2 : %.xml 


all: $(patsubt %.xml,%xml.bz2,$(shell find . -name '*.xml')) 

luego hacer un

nice make -j 5 

reemplazar '5' con algún número, probablemente, 1 más que el número de CPUs. Es posible que desee hacer 'bueno' esto en caso de que alguien más quiera usar la máquina mientras está en ella.

Answer 7

Hice algo como esto para bash. El truco maquillaje paralelo es probablemente mucho más rápido para las medidas excepcionales, pero aquí es la sección de código principal para implementar algo como esto en bash, tendrá que modificarlo para sus propósitos sin embargo:

#!/bin/bash 

# Replace NNN with the number of loops you want to run through 
# and CMD with the command you want to parallel-ize. 

set -m 

nodes=`grep processor /proc/cpuinfo | wc -l` 
job=($(yes 0 | head -n $nodes | tr '\n' ' ')) 

isin() 
{ 
    local v=$1 

    shift 1 
    while (($# > 0)) 
    do 
    if [ $v = $1 ]; then return 0; fi 
    shift 1 
    done 
    return 1 
} 

dowait() 
{ 
    while true 
    do 
    nj=($(jobs -p)) 
    if ((${#nj[@]} < nodes)) 
    then 
     for ((o=0; o<nodes; o++)) 
     do 
     if ! isin ${job[$o]} ${nj[*]}; then let job[o]=0; fi 
     done 
     return; 
    fi 
    sleep 1 
    done 
} 

let x=0 
while ((x < NNN)) 
do 
    for ((o=0; o<nodes; o++)) 
    do 
    if ((job[o] == 0)); then break; fi 
    done 

    if ((o == nodes)); then 
    dowait; 
    continue; 
    fi 

    CMD & 
    let job[o]=$! 

    let x++ 
done 

wait 

Answer 8

Solución : uso xargs para funcionar en paralelo (no se olvide de la opción -n!)

find -name \*.xml -print0 | xargs -0 -n 1 -P 3 bzip2