pykka - ¿Los actores son lentos?

Question

Actualmente estoy experimentando con Actor-concurreny (en Python), porque quiero aprender más sobre esto. Por lo tanto, elegí pykka, pero cuando lo pruebo, es más de la mitad de lo lento como una función normal.

El código es solo para ver si funciona; no está destinado a ser elegante. :)

Tal vez hice algo mal?

from pykka.actor import ThreadingActor 
import numpy as np 

class Adder(ThreadingActor): 
    def add_one(self, i): 
     l = [] 
     for j in i: 
      l.append(j+1) 
     return l 

if __name__ == '__main__': 
    data = np.random.random(1000000) 
    adder = Adder.start().proxy() 
    adder.add_one(data) 
    adder.stop() 

Esto no funciona tan rápido:

time python actor.py 

real 0m8.319s 
user 0m8.185s 
sys  0m0.140s 

Y ahora el muñeco función 'normal':

def foo(i): 
    l = [] 
    for j in i: 
     l.append(j+1) 
    return l 

if __name__ == '__main__': 
    data = np.random.random(1000000) 
    foo(data) 

da este resultado:

real 0m3.665s 
user 0m3.348s 
sys  0m0.308s 

Answer 1

Entonces, ¿qué es sucediendo aquí es que su versión funcional está creando dos listas muy grandes que es la mayor parte del tiempo. Cuando introduce actores, datos variables como listas deben copiarse antes de enviarse al actor para mantener la concurrencia correcta. Además, la lista creada dentro del actor debe copiarse también cuando se envía de vuelta al remitente. Esto significa que en lugar de crear dos listas muy grandes, tenemos cuatro listas muy grandes creadas en su lugar.

Considere diseñar cosas para que los datos sean construidos y mantenidos por el actor y luego consultados mediante llamadas al actor minimizando el tamaño de los mensajes que se pasan de un lado a otro. Intente aplicar el principal del movimiento de datos mínimo. Pasar la lista en el caso funcional solo es eficiente porque los datos no se están moviendo para aprovechar un espacio de memoria compartido. Si el actor estuviera en una máquina diferente, no tendríamos el beneficio de un espacio de memoria compartido, incluso si los datos del mensaje eran inmutables y no necesitaban ser copiados.