Pues les presento un pequeño código para realizar tareas en paralelo. El código es muy simple y seguro que contendrá fallos, aunque ejecutándolo felizmente da sus resultados.
Este es el código:
Código:
#!/usr/bin/env python
import sys
import string
import subprocess
import shlex
def process(p,par):
list = shlex.split(p)
fich_salida = None
try:
indice = list.index(">")
fich_salida_nombre = list[indice + 1]
fich_salida = open(fich_salida_nombre,"w+")
del list[indice] #borra >
del list[indice] #borra fichero
except ValueError:
try:
indice = list.index(">>")
fich_salida_nombre = list[indice + 1]
fich_salida = open(fich_salida_nombre,"a+")
del list[indice] #borra >>
del list[indice] #borra fichero
except ValueError:
fich_salida = None
subp = None
if par == False:
if fich_salida != None:
retcode = subprocess.call(list,stdout=fich_salida)
else:
retcode = subprocess.call(list)
else:
if fich_salida != None:
subp = subprocess.Popen(list,stdout=fich_salida)
else:
subp = subprocess.Popen(list)
return subp
args = sys.argv
if len(args) == 2:
print args[1]
else:
print "paralelizer <fich>"
sys.exit()
f = open(args[1],"r")
list_process = []
for line in f:
if line == "[start]\n" or line == "[end]\n":
paralel = False
elif line == "[paralel]\n":
paralel = True
else:
proc = process(line,paralel)
if paralel == True:
list_process.append(proc)
if paralel == False and len(list_process) > 0:
for item in list_process[:]:
item.wait()
list_process = []
La manera de ejecutarlo es tan simple como "./paralelizer <fichero.txt>" donde el fichero tiene una estructura como la que sigue:
Código:
[start]
<comandos>
[paralel]
<comandos>
[end]
<comandos>
Un ejemplo de fichero puede ser el siguiente:
Código:
[start]
[paralel]
find . -name "*.png" > p1.txt
find /usr/share -name "*.png" > p2.txt
[end]
cat p1.txt p2.txt > p.txt
rm p1.txt p2.txt
El fichero empieza con la etiqueta "[start]" indicando lo comandos que se ejecutarán al empezar. Luego viene la etiqueta "[paralel]" indicando los comandos que se ejecutarán en paralelo. Finalmente la etiqueta "[end]" indica los comandos que se ejecutarán cuando hayan acabado todos los comando indicados en la etiqueta [paralel]
Los comandos del fichero intentan ser lo más parecido a los comandos bash, aunque hay algunas excepciones, como por ejemplo las redirecciones (sólo están soportadas las de salida, y bajo restrucciones), y las tuberías. Tampoco están soportados los comandos interactivos (más bien, se desconoce su comportamiento).
Razones para utilizar este programa:
1) permite ejecutar fácilmente comandos asegurando (si no hay problemas) que hayan acabado otros comandos, o una serie de ellos (los de la etiqueta "[paralel]")
2) puede mejorar el rendimiento de tareas en ordenadores con varios procesadores
(*)(*) Con el fichero de ejemplo que he puesto y el comando "time" para medir el tiempo, se ha tardado una media de 0.57 segundos (con contenido cacheado) ejecutando un comando equivalente ("find . /usr/share -name "*.png" > p.txt") se ha tardado una media de 0.84 segundos (también con contenido cacheado). Esto en un ordenador de doble núcleo.
Si alguien quiere subir el archivo a su blog, sitio web, etc, es perfectamente libre de hacerlo, para eso está puesto. También pueden mejorar el código si así lo desean.
Un saludo y usen el programa
