Programación concurrente con GPars

Programación concurrente con Groovy

Wednesday, May 30, 12

Hola!
Mario García (@marioggar)
Freelance Software alchemist
Groovy passionate!

Madrid Groovy User Group member (@MadridGUG)


¿Qué es GPars?
Es un framework que proporciona a los desarrolladores
Java una forma segura e intuitiva de manejar tareas
concurrentes
Escrito en su mayoría en Java
Sospechosos habituales:
Vaclav Pech (Jetbrains)


¿Por qué usar GPars?
Usas Groovy o Java
Quieres escribir código empleando concurrencia ó
paralelismo
Vas a usar hardware de varios nucleos
La programación concurrente siempre te ha parecido
muy compleja.
PORQUE ESTA INCLUIDO EN GROOVY


¿Qué vamos a ver?
Ayudas a nivel de código
Conceptos a nivel de arquitectura
Protección de objetos compartidos


Estas ayudas nos permitirán escribir código
concurrente variando poco o nada nuestro código
actual.
Parallel Arrays (fork/join)
Syntaxis mas funcional (map/reduce/ﬁlter)
Ejecución asincrona de funciones (closures)


Parallel Arrays


Parallel Arrays
Todos los métodos que utilizabamos sobre colecciones
tienen ahora a su “hermano paralelo”.
findAll --> findAllParallel, collect--> collectParallel
Estos métodos nos permiten realizar las mismas
tareas de manera parallela cordinandolas a la
finalizacion de la misma.
Basado en Fork/Join jsr166


def ﬁndAllPeopleNameOver30AndSingle(people){
people.
ﬁndAll{it.age >30}.
collect{it.name}
}


GParsPool.withPool {
people.
ﬁndAllParallel{it.age >30}.
collectParallel{it.name}
}
}


GParsPool.withPool
La clase GParsPool es la que permite el DSL de
concurrencia para collecciones y objetos
groovyx.gpars.GParsPool
El método withPool puede tomar como
parametros el numero de hilos creados en el pool
y un manejador de excepciones


Parallel Arrays
Meta-class enchancer
Si no queremos “encerrar” nuestro código con
withPool{ ... } podemos utilizar la clase
ParallelEnhancer
groovyx.gpars.ParallelEnhancer
Agregara al metaClass de nuestra coleccion las
nuevas funciones concurrentes.


ParallelEnhancer.enhanceInstance(people)
people.
ﬁndAllParallel{it.age > 30}.
collectParallel{it.name}
}


Parallel Arrays
Umm no podría hacerlo con menos?
Claro!! :)
Podemos seguir utilizando la misma sintaxis de
colecciones bien utilizando el método
makeConcurrent() sobre una colección...


people.makeConcurrent().
ﬁndAll{it.age > 30}.
collect{it.name}
}


Parallel Arrays
...Bien manteniendo nuestro método original e
invocandole pasandole como parametro una colección
concurrente.


people.
ﬁndAll{it.age > 30}.
collect{it.name}
}

ﬁndAllPeopleNameOver30AndSingle(
people.makeConcurrent()
)


Parallel Arrays
Un gatito muere en algun lugar cuando:
Se accede a una colección not-thread-safe desde un
método “parallel”
Se crea una closure con estado. Todas las closures
que se pasan como parametro a un método paralelo
deben de ser thread-safe o dicho de otro modo
deben ser “sin estado”


Parallel Arrays
def result = []
people.
ﬁndAllParallel{it.age > 30}.
eachParallel{ result << it.name}

result
}
Miaoooouuuu


Map/Reduce


Map/Reduce
La DSL Map/Reduce para el manejo de colecciones da
a GPars un sabor más “funcional”.
Map/Reduce “rinde más rápido” que los métodos
xxxParallel para operaciones encadenadas sobre una
coleccion paralela
Algunos métodos map/reduce se pueden usar de la
misma manera que los metodos xxxParallel ya que
tienen semanticas parecidas


Map/Reduce
people.parallel.
ﬁlter{it.age > 30}.
map{it.name}.collection
}


Map/Reduce
Cada ejecución xxxParallel hace la conversión
paralela-->normal para cumplir con el contrato de los
métodos no paralelos.
Los métodos Map/Reduce se ejecutan sobre una la
colección paralela. Usamos la propiedad parallel para
acceder a ella.
Los métodos Map/Reduce devuelven una colección
paralela. Cuando queramos que devuelvan una
colección normal utilizamos la propiedad collection


Map/Reduce

soccerDays.parallel.
filter{it.fieldViewers > 1000000}.
map{[it,(it.soccerPlayers / it.fieldViewers) * 100]}.
filter{it[1] > 0.018}.
map{it[0].day}.collection


Ejecución asincrona
Combinar la ejecución asincrona de varias tareas y
pasarlas como argumentos a otras funciones
Hay tareas que se pueden descomponer en varias subtareas
más sencillas

Mientras que habrá subtareas que tarden en ejecutarse, puede
que otras solo tarden un momento

Si ejecutaramos secuencialmente las tareas, las pesadas
bloquearian a las ligeras.


Ejemplo: Media Aritmetica
Composición de closures:
Hay que dividir la computación del problema en diferentes
closures

La ejecución de cada closure por separado es inmutable,
no depende de los datos de la otra

Se combinaran en una tercera closure que cordinará los
resultados de ambas


def peopleYears = {people-> people*.age.sum()}.asyncFun()
def howManyPeople = {people-> people.size()}.asyncFun()
def avg = {yearsSum,peopleSize->
yearsSum/peopleSize
}.asyncFun()

avg(
peopleYears(people),
howManyPeople(people)
)


Conceptos a nivel de
arquitectura


Concetos a nivel...
En esta parte veremos partes de GPars más
avanzadas que requieren que planteemos nuestra
aplicación de otra manera
Dataﬂow
Actores


Dataflow
GPars nos permite definir procesos como un flujo de
datos en lugar de como un flujo de ejecución
Se genera un arbol de dependencias entre datos


Dataﬂow

Upps...


Dataﬂow
result

top states

rows Esto esta mejor...


Dataﬂow
Demo: Tornados en Estados Unidos
Recuperamos todos los ocurridos (rows)

Recuperamos el maestro de estados (states)

Recogemos los 3 más peligrosos (result)

Recogemos los nombres (result)

Contabilizamos fecha de ﬁnalización (end)


Dataflow
def flow = new Dataflows()
task {
1) flow.rows = getTornadoRows()
flow.remoteData = getSimulatedDataFromARemoteHost()
}
2) task {flow.states = getStateRows()}
3) task {flow.top = ... }
task {
flow.result = flow.top.collect{data->
4)
flow.states.find{s-> s.stateCode == data.stateCode}.stateName
}
flow.end = System.currentTimeMillis()
}


Dataflow
Flow:

1) Se descargan los datos de los tornados y unos datos
remotos (Estos ultimos hacen esperar un poco el proceso)

2) Esta tarea como no tiene ninguna dependencia se ejecuta a
la vez que la tarea uno evitando la espera del proceso remoto

3) Se ejecuta cuando se han resuelto las variables de la tarea 1

4) Se ejecuta cuando se han resuelto las variables de las tareas
2 y 3 (flow.top y flow.states)


Dataﬂow
Solución bastante elegante estableciendo
dependencias entre datos
Cuidado con las dependencias circulares == deadlock
No lo recomiendo para arboles “muy grandes”. Se
pierde el objetivo y se puede acabar en el punto
anterior.


Actors


Actors

NO ESTOS NO


Actors
Los actores nos permiten la cordinación explicita entre
procesos asincronos.
Recomendado para tareas complejas con
dependencias de paso de mensajes entre ambas.
Simula el paradigma de envio de mensajes (send,reply)


Actors
Inspirado en los Actores de Scala pero mejorado.
Actores con estado: Solo en casos concretos
Actores sin estado: recomendados


Actors
Demo: F1
Tenemos una serie de corredores cuyos coches
tienen que notificar a direccion de carrera su
posición.
Actores implicados
Conductores: Notifican su posición
Comisario de carrera: Notifica el estado de la
carrera


¿Para qué podemos usarlo?


¿Para qué?
Ideal para:
Procesos de calculo matemático
Procesos en arbol con nodos inmutables pero
dependientes como por ejemplo:
Ejemplo: Media aritmetica. La suma de elementos me la da un servicio que
tarda x, pero mientras espero puedo calcular el numero total de elementos.

En general procesos en los que tienes que componer datos dependiendo
de otros que provinenen de diferentes fuentes heterogeneas y con alta
latencia.


¿Para qué?
Ideal para:
Programación funcional (Map/Reduce)
Programación orientada a eventos (Actores)


GPars es mucho más
Agents
Speculations
STM (Software Transactional Memory)
...


GPars es mucho más
Página proyecto
http://gpars.codehaus.org/
Libros
Groovy In Action (2nd Ed)
(Contiene un capítulo dedicado unicamente a GPars)


GPars es mucho más
Blogs, videos...
Paul King (Video) GPars Concurrency

http://www.youtube.com/watch?v=dUDKnIIWw48

Tomas Lin: Grails/Gorm con GPars

http://fbﬂex.wordpress.com/2010/06/11/writing-batch-import-scripts-with-
grails-gsql-and-gpars/

Arturo Herrero (Slide) Functional Groovy

http://www.slideshare.net/arturoherrero/functional-programming-with-groovy


Programación concurrente con GPars

Más contenido relacionado

Similar a Programación concurrente con GPars

Más de Mario García

Último

Programación concurrente con GPars