2011-04-28 8 views
8

Tengo un grupo de actores de 100 actores en ejecución que comparten un despachador de robo de trabajo con su CorePoolSize establecido en 100. Pero ahora al enviar 19 mensajes a uno de los Actores los 19 mensajes no se paralelizan a 19 Actores, solo hay 5 mensajes que se ejecutan en paralelo. Cuando estos 5 mensajes finalizan, los 5 siguientes mensajes son procesados ​​por estos mismos 5 actores nuevamente, y así sucesivamente. ¿Por qué mis 19 mensajes no se ejecutan en paralelo? ¿Qué me falta aquí?¿Por qué mi distribución de actores se redujo en Akka?

Mi código es básicamente lo siguiente:

object TestActor { 
    val dispatcher = Dispatchers.newExecutorBasedEventDrivenWorkStealingDispatcher("pool") 
        .setCorePoolSize(100) 
        .setMaxPoolSize(100) 
        .build 
} 

class TestActor(val name: Integer) extends Actor { 
    self.lifeCycle = Permanent 
    self.dispatcher = TestActor.dispatcher 
    def receive = { 
     case num: Integer => { println("Actor: " + name + " Received: " + num) 
           Thread.sleep(10000) 
          } 
    } 
} 

trait CyclicLoadBalancing extends LoadBalancer { this: Actor => 
    val testActors: List[ActorRef] 
    val seq = new CyclicIterator[ActorRef](testActors) 
} 

trait TestActorManager extends Actor { 
    self.lifeCycle = Permanent 
    self.faultHandler = OneForOneStrategy(List(classOf[Exception]), 5, 5000) 
    val testActors: List[ActorRef] 
    override def preStart = testActors foreach { self.startLink(_) } 
    override def postStop = self.shutdownLinkedActors() 
} 

val supervisor = actorOf(new TestActorManager with CyclicLoadBalancing { 
val testActors = (1 until 100 toList) map (i => actorOf(new TestActor(i))) 
}).start 

println("Number of Actors: " + Actor.registry.actorsFor(classOf[TestActor]).length) 

val testActor = Actor.registry.actorsFor(classOf[TestActor]).head 

(1 until 20 toList) foreach { testActor ! _ } 

La salida:

Actor: 4 Received: 16 
Actor: 3 Received: 17 
Actor: 1 Received: 19 
Actor: 59 Received: 1 
Actor: 2 Received: 18 

// 10 secs. are passing.. 

Actor: 4 Received: 15 
Actor: 3 Received: 14 
Actor: 1 Received: 13 
Actor: 59 Received: 2 
Actor: 2 Received: 12 

// 10 secs. are passing.. 

Actor: 4 Received: 11 
Actor: 3 Received: 10 
Actor: 59 Received: 3 
Actor: 2 Received: 8 
Actor: 1 Received: 9 

// 10 secs. are passing.. 

Actor: 4 Received: 7 
Actor: 3 Received: 6 
Actor: 59 Received: 4 
Actor: 2 Received: 5 

edición: estoy usando Akka 1.0

+1

¿Con cuántos hilos lo respalda? –

+0

¿Dónde puedo encontrar eso? Básicamente estoy usando este config.file: http://scalablesolutions.se/akka/docs/akka-0.10/configuration.html Intenté modificar la configuración core-pool-size-factor, pero eso no cambió nada . Pero creo que eso es para el despachador predeterminado .. – rocksteady

Respuesta

2

Creo que el despachador le permite personalizar la propiedad rendimiento . Esto define la cantidad de mensajes para un Actor específico que el despachador debe procesar en un solo barrido. Habría que agregar la siguiente configuración en el archivo de akka.conf

actor { 
    throughput = 20 
} 

Por defecto es 5

+0

Hm, gracias, lo intenté, pero todavía tengo el mismo comportamiento :( – rocksteady

12

gracias por su investigación, yo localizada el cuello de botella y lo arreglaron en este comprometerse a Akka principal:

https://github.com/akka/akka/commit/e4e99ef56399e892206ce4a46b9a9107da6c7770

se dará a conocer en Akka 1.1-RC1

Cheers, √

+2

Hola, gracias, comprobaré eso :) Y gracias también por el excelente trabajo en Akka, Estoy muy contento con el marco hasta el momento :) – rocksteady

+0

¡De nada, feliz hAkking! –

+3

Mi respuesta no es aceptable? –

Cuestiones relacionadas