programa - Procesamiento paralelo en python

programa de hilos en python

Question

¿Qué es un código simple que hace un procesamiento paralelo en python 2.7? Todos los ejemplos que he encontrado en línea son intrincados e incluyen códigos innecesarios.

¿Cómo podría hacer un simple programa de factorización de fuerza bruta donde puedo factorizar 1 entero en cada núcleo (4)? mi programa real probablemente solo necesite 2 núcleos y necesite compartir información.

Sé que existen paralelo-python y otras bibliotecas, pero quiero mantener el número de bibliotecas al mínimo, por lo que quiero utilizar las bibliotecas de thread y / o multiprocessing , ya que vienen con python

Answer 1

Estoy de acuerdo en que usar Pool de multiprocessing es probablemente la mejor ruta si desea permanecer dentro de la biblioteca estándar. Si está interesado en hacer otros tipos de procesamiento paralelo, pero no aprende nada nuevo (es decir, sigue usando la misma interfaz que multiprocessing ), puede probar pathos , que proporciona varias formas de mapas paralelos y tiene prácticamente la misma interfaz que el multiprocessing hace.

Python 2.7.6 (default, Nov 12 2013, 13:26:39) 
[GCC 4.2.1 Compatible Apple Clang 4.1 ((tags/Apple/clang-421.11.66))] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> import numpy
>>> numToFactor = 976
>>> def isFactor(x):
...   result = None
...   div = (numToFactor / x)
...   if div*x == numToFactor:
...     result = (x,div)
...   return result
... 
>>> from pathos.multiprocessing import ProcessingPool as MPool
>>> p = MPool(4)
>>> possible = range(1,int(numpy.floor(numpy.sqrt(numToFactor)))+1)
>>> # standard blocking map
>>> result = [x for x in p.map(isFactor, possible) if x is not None]
>>> print result
[(1, 976), (2, 488), (4, 244), (8, 122), (16, 61)]
>>>
>>> # asynchronous map (there''s also iterative maps too)
>>> obj = p.amap(isFactor, possible)                  
>>> obj
<processing.pool.MapResult object at 0x108efc450>
>>> print [x for x in obj.get() if x is not None]
[(1, 976), (2, 488), (4, 244), (8, 122), (16, 61)]
>>>
>>> # there''s also parallel-python maps (blocking, iterative, and async) 
>>> from pathos.pp import ParallelPythonPool as PPool
>>> q = PPool(4)
>>> result = [x for x in q.map(isFactor, possible) if x is not None]
>>> print result
[(1, 976), (2, 488), (4, 244), (8, 122), (16, 61)]

Además, pathos tiene un paquete hermano con la misma interfaz, llamada pyina , que ejecuta mpi4py , pero le proporciona mapas paralelos que se ejecutan en MPI y se pueden ejecutar utilizando varios programadores.

Otra ventaja es que pathos viene con un serializador mucho mejor del que se puede obtener en python estándar, por lo que es mucho más capaz que el multiprocessing al serializar una gama de funciones y otras cosas. Y puedes hacer todo desde el intérprete.

>>> class Foo(object):
...   b = 1
...   def factory(self, a):
...     def _square(x):
...       return a*x**2 + self.b
...     return _square
... 
>>> f = Foo()
>>> f.b = 100
>>> g = f.factory(-1)
>>> p.map(g, range(10))
[100, 99, 96, 91, 84, 75, 64, 51, 36, 19]
>>> 

Obtenga el código aquí: https://github.com/uqfoundation

Answer 2

Una forma simple y sencilla de comenzar con el procesamiento paralelo en python es simplemente el mapeo de grupos en mutiprocesamiento; es como los mapas de python usuales, pero las llamadas a funciones individuales se distribuyen en una cantidad de procesos diferente.

El factoring es un buen ejemplo de esto: puedes comprobar con la fuerza bruta todas las divisiones repartidas entre todas las tareas disponibles:

from multiprocessing import Pool
import numpy

numToFactor = 976

def isFactor(x):
    result = None
    div = (numToFactor / x)
    if div*x == numToFactor:
        result = (x,div)
    return result

if __name__ == ''__main__'':
    pool = Pool(processes=4)
    possibleFactors = range(1,int(numpy.floor(numpy.sqrt(numToFactor)))+1)
    print ''Checking '', possibleFactors
    result = pool.map(isFactor, possibleFactors)
    cleaned = [x for x in result if not x is None]
    print ''Factors are'', cleaned

Esto me da

Checking  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]
Factors are [(1, 976), (2, 488), (4, 244), (8, 122), (16, 61)]

Answer 3

mincemeat es la implementación de mapa / reducción más simple que he encontrado. Además, es muy ligero en las dependencias: es un único archivo y hace todo con la biblioteca estándar.