1) El documento analiza el uso de lenguajes de programación concurrentes como Go, Scala, Clojure y Java para implementar algoritmos evolutivos paralelos.
2) Se implementaron algoritmos evolutivos para resolver un problema MaxSAT usando los cuatro lenguajes.
3) Los resultados mostraron que Go y Scala tuvieron un mejor rendimiento que Clojure y Java, logrando soluciones de alta calidad más rápido.
Usando lenguajes de programación concurrentes para desarrollar algoritmos evolutivos paralelos
1. Nuevas tendencias en AGps Communicating Sequential Processes Implementaci´on Resultados Conclusiones
Usando lenguajes de programaci´on
concurrentes para desarrollar algoritmos
evolutivos paralelos
Autor: MSc. Jos´e Albert Cruz Almaguer
Tutores: Dr. Juan Juli´an Merelo Guerv´os (UGR)
Dr.C. Liesner Acevedo Mart´ınez (UCI)
Universidad de Granada, Grupo GENEURA
12 de septiembre de 2014
2. Nuevas tendencias en AGps Communicating Sequential Processes Implementaci´on Resultados Conclusiones
Summary
1 Nuevas tendencias en AGps
Novedad
2 Communicating Sequential Processes
CSP
3 Implementaci´on
Caso Go
Caso Scala
Caso Clojure
Caso Java
4 Resultados
5 Conclusiones
3. Nuevas tendencias en AGps Communicating Sequential Processes Implementaci´on Resultados Conclusiones
Novedad
Algoritmos evolutivos
Nuevas tendencias en AGps: plataformas
paralelas
Solamente es considerado el hardware
4. Nuevas tendencias en AGps Communicating Sequential Processes Implementaci´on Resultados Conclusiones
Novedad
Paradigmas de programaci´on
Funcional: las funciones como conceptos de
primera clase
Concurrente: presencia de construcciones para
manejar procesos como concepto de primera
clase
5. Nuevas tendencias en AGps Communicating Sequential Processes Implementaci´on Resultados Conclusiones
Novedad
Clojure
Variante de Lisp
STM/agent/futures
JVM
6. Nuevas tendencias en AGps Communicating Sequential Processes Implementaci´on Resultados Conclusiones
Novedad
Scala
OO/Funcional
Akka: Concurrencia basada en actores
JVM
7. Nuevas tendencias en AGps Communicating Sequential Processes Implementaci´on Resultados Conclusiones
Novedad
Go
Estructurado/concurrente
CSP: Concurrencia basada en canales
No VM
8. Nuevas tendencias en AGps Communicating Sequential Processes Implementaci´on Resultados Conclusiones
CSP
Communicating Sequential Processes
C´alculo para estudiar procesos
Lenguaje formal para escribir programas
cercanos a la implementaci´on
9. Nuevas tendencias en AGps Communicating Sequential Processes Implementaci´on Resultados Conclusiones
CSP
Communicating Sequential Processes
Base te´orica para los modelos de concurrencia
de varios lenguajes
Go, Erlang (por extensi´on a Scala)
12. Algorithm 0.1: Behavior of evaluators
Input: Inds: Individuals to evaluate
Input: chReps: Channel to feed the reproducers
begin
IndsEval := {(I, V ) | ∀I ∈ Inds, V = fitness(I)}
chReps ← sort(IndsEval)
Algorithm 0.2: Behavior of reproducers
Input: Inds: Individuals to reproduce
Input: chEvals: Channel to feed the evaluators
begin
chEvals ← Muttation ⊙ Crossover ⊙ Parents-Selection (Inds)
Algorithm 0.3: Behavior of the pool
Input: sortedPool: Individuals already evaluated sorted by fitness
Input: indsPool: Individuals not yet evaluated
Input: chReps: Channel for communication with reproducers
Input: chEvals: Channel for communication with evaluators
begin
while not Termination-Condition do
chReps ← FirstN(sortedPool)
chEvals ← FirstN(indsPool)
NInds ← Reps
indsPool + = NInds
NIndsEval ← Evals
sortedPool := merge(sortedPool, NIndsEval)
1
13. Nuevas tendencias en AGps Communicating Sequential Processes Implementaci´on Resultados Conclusiones
Caso Go
Go
type MaxSATProblem struct{
Problem
clauseLength,
varsCount,
clausesCount int
clauses [][]TVarValue
}
func (self *MaxSATProblem)
FitnessFunction(ind TIndividual) int
func (self *MaxSATProblem)
QualityFitnessFunction(v int) bool
14. Nuevas tendencias en AGps Communicating Sequential Processes Implementaci´on Resultados Conclusiones
Caso Go
Go
func (s *ParFitnessQuality)
Run(rSol func(res TPoolFitnessQualityResult)){
eJobs := make(chan IDo, 1)
rJobs := make(chan IDo, 1)
eResults := make(chan TIndsEvaluated, 1)
rResults := make(chan TPopulation, 1)
doJobs := func(jobs chan IDo) {
for job := range jobs {
job.Do()
}
}
15. Nuevas tendencias en AGps Communicating Sequential Processes Implementaci´on Resultados Conclusiones
Caso Go
Go
addeJobs := func() {
active := true
for active {
select {
case <-control1:
active = false
case eJobs <-
EJob{p2Eval.ExtractElements(s.MSEvls),
s.FitnessF, s.QualityF, Do, eResults}:
}
}
close(eJobs)
}
16. Nuevas tendencias en AGps Communicating Sequential Processes Implementaci´on Resultados Conclusiones
Caso Go
Go
waitAndProcessResults := func() {
for !alcanzadaSolucion {
select {
case indEvals := <-eResults:
p2Rep.Append(indEvals)
ce += len(indEvals)
case nInds := <-rResults:
p2Eval.Append(nInds)
}
}
17. Nuevas tendencias en AGps Communicating Sequential Processes Implementaci´on Resultados Conclusiones
Caso Go
Go
for i:=0;i < s.CEvaluators; i++{
go doJobs(eJobs)
}
for i:=0;i < s.CReproducers; i++{
go doJobs(rJobs)
}
18. Nuevas tendencias en AGps Communicating Sequential Processes Implementaci´on Resultados Conclusiones
Caso Go
Go
go addeJobs()
go addrJobs()
waitAndProcessResults()
19. Nuevas tendencias en AGps Communicating Sequential Processes Implementaci´on Resultados Conclusiones
Caso Go
Go
func (job EJob) Do() {
IndEvals := Evaluate(job.Population, ...)
sort.Sort(IndEvals)
job.results <- IndEvals
}
20. Nuevas tendencias en AGps Communicating Sequential Processes Implementaci´on Resultados Conclusiones
Caso Go
Go
func (job RJob) Do() {
rResults := Reproduce(job.IndEvals, job.PMutation)
job.results <- rResults
}
21. Nuevas tendencias en AGps Communicating Sequential Processes Implementaci´on Resultados Conclusiones
Caso Scala
Scala
abstract class Problem {
def fitnessFunction(ind: TIndividual): Long
def qualityFitnessFunction(v: Long): Boolean
private[this] def genIndividual(): TIndividual
def getPop(): TPopulation
}
22. Nuevas tendencias en AGps Communicating Sequential Processes Implementaci´on Resultados Conclusiones
Caso Scala
Scala
class MaxSATProblem extends Problem {
override def fitnessFunction(ind: TIndividual): Long
override def qualityFitnessFunction(v: Long): Boolean
}
23. Nuevas tendencias en AGps Communicating Sequential Processes Implementaci´on Resultados Conclusiones
Caso Scala
Scala
def r u nPa r F i tQu a l i t y ( r e s : ( TIndEval , Long)=>Uni t ){
. . .
va l p2Rep = new Rep r od u c e r sPo o l [ TIndEval ] ( )
va l p2Eval = new Ev a l u a t o r sPo o l [ TI n d i v i d u a l ] ( )
va l pRe s u l tOb t a i n ed = Promi s e [ Uni t ] ( )
pRe s u l tOb t a i n ed . f u t u r e . onSuc c e s s ({
case =>
r e s u l tOb t a i n e d ( b e s t S o l u t i o n , E v a l u a t i o n s )
})
24. Nuevas tendencias en AGps Communicating Sequential Processes Implementaci´on Resultados Conclusiones
Caso Scala
Scala
def mkWorker [T] ( i n d s 2Ev a l : L i s t [T] ,
f e e d e r : => L i s t [T] ,
b e g i nAc t i o n : L i s t [T] => Any ,
endAc t i on : (Any ) => Uni t ,
cond : => Bool ean
) : Futur e [ Any ] = {
va l r e s = Futur e {
b e g i nAc t i o n ( i n d s 2Ev a l )
}
25. Nuevas tendencias en AGps Communicating Sequential Processes Implementaci´on Resultados Conclusiones
Caso Scala
Scala
r e s . onSuc c e s s {
case eRe s u l t : Any =>
endAc t i on ( eRe s u l t )
i f ( cond ) {
va l n i n d s 2Ev a l = f e e d e r
mkWorker ( n i n d s 2Ev a l , f e e d e r , b e g i nAc t i on
}
e l s e {
pRe s u l tOb t a i n ed . t r y S u c c e s s ( )
}
}
r e s
}
26. Nuevas tendencias en AGps Communicating Sequential Processes Implementaci´on Resultados Conclusiones
Caso Scala
Scala
for ( i <− 1 to c o n f i g . Ev a l u a t o r sCou n t ) {
va l i n d s 2Ev a l 1 = p2Eval . e x t r a c tEl eme n t s (ECap )
mkWorker ( i n d s 2Ev a l 1 , p2Eval . e x t r a c tEl eme n t s (ECap )
( i n d s 2Ev a l : L i s t )=>{
va l e v a l s = Ev a l u a t o r . e v a l u a t e ( i n d s 2Ev a l )
e v a l s . s o r tWi t h ( . compareTo ( ) > 0)
} , ( r e s u l t : Any ) => {
p2Rep . append ( r e s u l t )
E v a l u a t i o n s += eRe s u l t . l e n g t h
} , ! a l c a n z a d a S o l u c i o n )
}
27. Nuevas tendencias en AGps Communicating Sequential Processes Implementaci´on Resultados Conclusiones
Caso Scala
Scala
for ( i <− 1 to c o n f i g . Reproduc e r sCount ) {
va l i E v a l s 1 = p2Rep . e x t r a c tEl eme n t s (RCap )
mkWorker ( iEv a l s 1 , p2Rep . e x t r a c tEl eme n t s ( RepCap ) ,
( i E v a l s : L i s t ) => {
Reproduc e r . r ep r od u c e ( i E v a l s . t o L i s t )
} , ( r e s u l t : Any ) => {
p2Eval . append ( r e s u l t )
} , ! a l c a n z a d a S o l u c i o n )
}
30. Nuevas tendencias en AGps Communicating Sequential Processes Implementaci´on Resultados Conclusiones
Caso Java
Java
abstract class Problem {
abstract long fitnessFunction(TIndividual ind);
abstract boolean qualityFitnessFunction(long v);
void runParFitnessQuality(FSolutionObtained resultObtained) {
31. Nuevas tendencias en AGps Communicating Sequential Processes Implementaci´on Resultados Conclusiones
Caso Java
Java
ReproducersPool p2Rep = new ReproducersPool();
EvaluatorsPool<TIndividual> p2Eval =
new EvaluatorsPool<>();
CompletionService<List<TIndEval>> eChannel =
new ExecutorCompletionService<>(executor);
CompletionService<TPopulation> rChannel =
new ExecutorCompletionService<>(executor);
32. Nuevas tendencias en AGps Communicating Sequential Processes Implementaci´on Resultados Conclusiones
Caso Java
Java
for (int i = 0; i < config.ReproducersCount; i++) {
rChannel.submit(new ReproducerJob(
p2Rep.extractElements(ReproducersCapacity), reproducer));
}
for (int i = 0; i < config.EvaluatorsCount; i++) {
eChannel.submit(new EvaluatorJob(
new TPopulation(p2Eval.extractElements(EvaluatorsCapacity)),
evaluator));
}
33. Nuevas tendencias en AGps Communicating Sequential Processes Implementaci´on Resultados Conclusiones
Caso Java
Java
while (!res.alcanzadaSolucion) {
Future<List<TIndEval>> fEResult = eChannel.poll();
if (fEResult != null) {
List<TIndEval> eResult = fEResult.get();
evaluations += eResult.size();
p2Rep.append(eResult);
eChannel.submit(new EvaluatorJob(
new TPopulation(p2Eval.extractElements(
config.EvaluatorsCapacity)), evaluator));
}
34. Nuevas tendencias en AGps Communicating Sequential Processes Implementaci´on Resultados Conclusiones
Caso Java
Java
class EvaluatorJob implements Callable<List<TIndEval>> {
public List<TIndEval> call() {
ArrayList<TIndEval> evals =
evaluator.evaluate(inds2Eval);
evals.sort((ie1, ie2) -> ie2.compareTo(ie1));
return evals;
}
35. Nuevas tendencias en AGps Communicating Sequential Processes Implementaci´on Resultados Conclusiones
Results
Resultados, MaxSAT (fitness > 420)
Lang Parallel time
± SD (ms)
Ws
comb
Seq time
(ms)
RSpeedup Speedup
Java 303 ± 7.87 6 E, 1
R
669.5 2.2 2.2
Scala 661 ± 29.45 27 E,
1 R
1215.2 1.83 1.01
Go 676 ± 28.9 29 E,
9 R
1182.1 1.74 0.98
Clojure 2959 ± 79.75 10 E,
2 R
5689.02 1.92 0.22
36. Nuevas tendencias en AGps Communicating Sequential Processes Implementaci´on Resultados Conclusiones
Conclusiones
Conclusiones
Ventajas de poseer abstracciones concurrentes: calidad del
c´odigo
Java: poca calidad pero mejores resultados
Analizar caso Go con mejor rendimento por cantidad de
evaluaciones ¿generaci´on de n´umeros aleatorios?