python - gevent: desventaja de engendrar gran cantidad de greenlets?

limit spawning

Question

Después de mi pregunta en el comentario a esta respuesta a la pregunta "Grupo de Gevent con solicitudes web anidadas" :

Suponiendo que uno tiene una gran cantidad de tareas, ¿hay algún inconveniente en usar gevent.spawn (...) para generarlas todas simultáneamente en lugar de usar gevent pool y pool.spawn (...) para limitar el número de concurrentes? ¿Greenlets?

Formulado de manera diferente: ¿existe alguna ventaja de "limitar la concurrencia" con un gevent.Pool incluso si el problema no lo requiere?

¿Alguna idea de lo que constituiría un "gran número" para este problema?

Answer 1

Es más limpio y una buena práctica cuando se trata de muchas cosas. Me encontré con esto hace unas semanas, estaba usando gevent spawn para verificar un montón de correos electrónicos contra DNS en el orden de 30k :).

from gevent.pool import Pool
import logging
rows = [ ... a large list of stuff ...]
CONCURRENCY = 200 # run 200 greenlets at once or whatever you want
pool = Pool(CONCURRENCY)
count = 0

def do_work_function(param1,param2):
   print param1 + param2

for row in rows:
  count += 1 # for logging purposes to track progress
  logging.info(count)
  pool.spawn(do_work_function,param1,param2) # blocks here when pool size == CONCURRENCY

pool.join() #blocks here until the last 200 are complete

Descubrí en mi prueba que cuando la CONCURRENCIA era de alrededor de 200 es cuando la carga de mi máquina se mantenía en torno a 1 en un EC2 m1.small. Sin embargo, lo hice un poco ingenuamente, si volviera a hacerlo, ejecutaría varios grupos de servidores y dormiría un rato entre ellos para tratar de distribuir la carga en la NIC y la CPU de manera más equitativa.

Una última cosa a tener en cuenta es mantener un ojo en sus archivos abiertos y aumentar eso si es necesario: http://www.cyberciti.biz/faq/linux-increase-the-maximum-number-of-open-files . Los greenlets que estaba ejecutando ocupaban alrededor de 5 descriptores de archivo por greenlet, por lo que puedes correr muy rápido si no tienes cuidado. Esto puede no ser útil si la carga de su sistema está por encima de uno, ya que comenzará a ver rendimientos decrecientes a pesar de todo.

Answer 2

Llegó aquí desde Google y decidió realizar algunas pruebas rápidas para generar N greenlets crecientes. Compartiendo los resultados, ya que pueden ser útiles para otros buscadores:

# 1 greenlet
real    0m1.032s
user    0m0.017s
sys     0m0.009s

# 100 greenlets
real    0m1.037s
user    0m0.021s
sys     0m0.010s

# 1,000 greenlets
real    0m1.045s
user    0m0.035s
sys     0m0.013s

# 10,000 greenlets
real    0m1.232s
user    0m0.265s
sys     0m0.059s

# 100,000 greenlets
real    0m3.992s
user    0m3.201s
sys     0m0.444s

Entonces, hasta 1.000 greenlets y la pérdida de rendimiento es mínima, pero una vez que empiezas a alcanzar más de 10,000 greenlets, todo se ralentiza.

Código de prueba:

import gevent

N = 0

def test():
    gevent.sleep(1)

while N < 1000:
  N += 1
  gevent.spawn(test)

gevent.wait()