usando lenguajes de programación concurrentes para desarrollar algoritmos evolutivos paralelos

Nuevas tendencias en AGps Communicating Sequential Processes Implementacion Resultados Conclusiones

Usando lenguajes de programacionconcurrentes para desarrollar algoritmos

evolutivos paralelos

Autor: MSc. Jose Albert Cruz AlmaguerTutores: Dr. Juan Julian Merelo Guervos (UGR)

Dr.C. Liesner Acevedo Martınez (UCI)

Universidad de Granada, Grupo GENEURA

12 de septiembre de 2014

Nuevas tendencias en AGps Communicating Sequential Processes Implementacion Resultados Conclusiones

Summary

1 Nuevas tendencias en AGpsNovedad

2 Communicating Sequential ProcessesCSP

3 ImplementacionCaso GoCaso ScalaCaso ClojureCaso Java

4 Resultados

5 Conclusiones

Nuevas tendencias en AGps Communicating Sequential Processes Implementacion Resultados Conclusiones

Novedad

Algoritmos evolutivos

Nuevas tendencias en AGps: plataformas

paralelas

Solamente es considerado el hardware

Nuevas tendencias en AGps Communicating Sequential Processes Implementacion Resultados Conclusiones

Novedad

Paradigmas de programacion

Funcional: las funciones como conceptos deprimera clase

Concurrente: presencia de construcciones para

manejar procesos como concepto de primeraclase

Nuevas tendencias en AGps Communicating Sequential Processes Implementacion Resultados Conclusiones

Novedad

Clojure

Variante de Lisp

STM/agent/futures

JVM

Nuevas tendencias en AGps Communicating Sequential Processes Implementacion Resultados Conclusiones

Novedad

Scala

OO/Funcional

Akka: Concurrencia basada en actores

JVM

Nuevas tendencias en AGps Communicating Sequential Processes Implementacion Resultados Conclusiones

Novedad

Go

Estructurado/concurrente

CSP: Concurrencia basada en canales

No VM

Nuevas tendencias en AGps Communicating Sequential Processes Implementacion Resultados Conclusiones

CSP

Communicating Sequential Processes

Calculo para estudiar procesos

Lenguaje formal para escribir programas

cercanos a la implementacion

Nuevas tendencias en AGps Communicating Sequential Processes Implementacion Resultados Conclusiones

CSP

Communicating Sequential Processes

Base teorica para los modelos de concurrencia

de varios lenguajes

Go, Erlang (por extension a Scala)

Nuevas tendencias en AGps Communicating Sequential Processes Implementacion Resultados Conclusiones

CSP

Communicating Sequential Processes

Conceptos fundamentales: Proceso, Canal (channel,

pipe)

Nuevas tendencias en AGps Communicating Sequential Processes Implementacion Resultados Conclusiones

CSP

Algoritmos evolutivos

Procesos productor/consumidor

Evaluacion ⇔ Reproduccion

Algorithm 0.1: Behavior of evaluators

Input: Inds: Individuals to evaluate

Input: chReps: Channel to feed the reproducers

beginIndsEval := {(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

beginchEvals ← 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

beginwhile not Termination-Condition do

chReps ← FirstN (sortedPool)chEvals ← FirstN (indsPool)NInds ← Reps

indsPool + = NInds

NIndsEval ← Evals

sortedPool := merge(sortedPool, NIndsEval)

1

Nuevas tendencias en AGps Communicating Sequential Processes Implementacion Resultados Conclusiones

Caso Go

Go

type MaxSATProblem struct{ProblemclauseLength,varsCount,clausesCount intclauses [][]TVarValue}func (self *MaxSATProblem)

FitnessFunction(ind TIndividual) intfunc (self *MaxSATProblem)

QualityFitnessFunction(v int) bool

Nuevas tendencias en AGps Communicating Sequential Processes Implementacion 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()}}

Nuevas tendencias en AGps Communicating Sequential Processes Implementacion Resultados Conclusiones

Caso Go

Go

addeJobs := func() {active := truefor active {select {case <-control1:active = false

case eJobs <-EJob{p2Eval.ExtractElements(s.MSEvls),s.FitnessF, s.QualityF, Do, eResults}:

}}close(eJobs)}

Nuevas tendencias en AGps Communicating Sequential Processes Implementacion 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)

}}

Nuevas tendencias en AGps Communicating Sequential Processes Implementacion 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)

}

Nuevas tendencias en AGps Communicating Sequential Processes Implementacion Resultados Conclusiones

Caso Go

Go

go addeJobs()go addrJobs()waitAndProcessResults()

Nuevas tendencias en AGps Communicating Sequential Processes Implementacion Resultados Conclusiones

Caso Go

Go

func (job EJob) Do() {IndEvals := Evaluate(job.Population, ...)sort.Sort(IndEvals)job.results <- IndEvals

}

Nuevas tendencias en AGps Communicating Sequential Processes Implementacion Resultados Conclusiones

Caso Go

Go

func (job RJob) Do() {rResults := Reproduce(job.IndEvals, job.PMutation)job.results <- rResults

}

Nuevas tendencias en AGps Communicating Sequential Processes Implementacion Resultados Conclusiones

Caso Scala

Scala

abstract class Problem {def fitnessFunction(ind: TIndividual): Longdef qualityFitnessFunction(v: Long): Booleanprivate[this] def genIndividual(): TIndividualdef getPop(): TPopulation

}

Nuevas tendencias en AGps Communicating Sequential Processes Implementacion Resultados Conclusiones

Caso Scala

Scala

class MaxSATProblem extends Problem {override def fitnessFunction(ind: TIndividual): Longoverride def qualityFitnessFunction(v: Long): Boolean

}

Nuevas tendencias en AGps Communicating Sequential Processes Implementacion 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 roduce r sPoo l [ TIndEva l ] ( )va l p2Eva l = new Eva l u a t o r sPoo l [ T I n d i v i d u a l ] ( )va l pResu l tObta i n ed = Promise [ Un i t ] ( )pResu l tObta i n ed . f u t u r e . onSucces s ({

case =>r e s u l tOb t a i n e d ( b e s t S o l u t i on , E v a l u a t i o n s )

})

Nuevas tendencias en AGps Communicating Sequential Processes Implementacion Resultados Conclusiones

Caso Scala

Scala

def mkWorker [T ] ( i n d s 2Eva l : L i s t [T ] ,f e e d e r : => L i s t [T ] ,b eg i nAc t i on : L i s t [T ] => Any ,endAct ion : (Any ) => Unit ,cond : => Boolean) : Futu re [ Any ] = {

va l r e s = Future {beg i nAc t i on ( i n d s 2Eva l )

}

Nuevas tendencias en AGps Communicating Sequential Processes Implementacion Resultados Conclusiones

Caso Scala

Scala

r e s . onSucces s {case eRe s u l t : Any =>

endAct ion ( eRe s u l t )i f ( cond ) {

va l n i nd s 2Eva l = f e e d e rmkWorker ( n i nd s2Eva l , f e ed e r , b eg i nAct i on

}e l s e {

pResu l tObta i n ed . t r y S u c c e s s ( )}

}r e s

}

Nuevas tendencias en AGps Communicating Sequential Processes Implementacion Resultados Conclusiones

Caso Scala

Scala

fo r ( i <− 1 to c o n f i g . Eva l ua to r sCoun t ) {va l i n d s 2Eva l 1 = p2Eva l . e x t r a c tE l emen t s (ECap )mkWorker ( i nd s2Eva l 1 , p2Eva l . e x t r a c tE l emen t s (ECap )

( i n d s 2Eva l : L i s t )=>{va l e v a l s = Eva l u a t o r . e v a l u a t e ( i n d s 2Eva l )e v a l s . s o r tWi th ( . 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 su l t . l e n g t h

} , ! a l c a n z adaSo l u c i on )}

Nuevas tendencias en AGps Communicating Sequential Processes Implementacion Resultados Conclusiones

Caso Scala

Scala

fo r ( i <− 1 to c o n f i g . Reproducer sCount ) {va l i E v a l s 1 = p2Rep . e x t r a c tE l emen t s (RCap)mkWorker ( i E v a l s 1 , p2Rep . e x t r a c tE l emen t s ( RepCap ) ,

( i E v a l s : L i s t ) => {Reproducer . r ep roduce ( i E v a l s . t o L i s t )

} , ( r e s u l t : Any ) => {p2Eva l . append ( r e s u l t )

} , ! a l c a n z adaSo l u c i on )}

Nuevas tendencias en AGps Communicating Sequential Processes Implementacion Resultados Conclusiones

Caso Clojure

Clojure

(defprotocol Problem(fitnessFunction [self])(qualityFitnessFunction [self])(genIndividual [self])(getPop [self])(runSeqCEvals [self])(runParCEvals [self r-obtained-notification])(runSeqFitnessQuality [self])(runParFitnessQuality [self r-obtained-notification])

)

Nuevas tendencias en AGps Communicating Sequential Processes Implementacion Resultados Conclusiones

Caso Clojure

Clojure

(defn mk-worker [& {:keys [inds2eval feederbegin-action end-action condition p-result-obtained]}]

(loop [inds-2-eval inds2eval](let [

current (future (begin-action inds-2-eval))result @current]

(end-action result)(when (condition)

(recur (feeder)))

))

(deliver p-result-obtained true))

Nuevas tendencias en AGps Communicating Sequential Processes Implementacion Resultados Conclusiones

Caso Java

Java

abstract class Problem {abstract long fitnessFunction(TIndividual ind);abstract boolean qualityFitnessFunction(long v);void runParFitnessQuality(FSolutionObtained resultObtained) {

Nuevas tendencias en AGps Communicating Sequential Processes Implementacion 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);

Nuevas tendencias en AGps Communicating Sequential Processes Implementacion 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));

}

Nuevas tendencias en AGps Communicating Sequential Processes Implementacion 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));

}

Nuevas tendencias en AGps Communicating Sequential Processes Implementacion 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;

}

Nuevas tendencias en AGps Communicating Sequential Processes Implementacion Resultados Conclusiones

Results

Resultados, MaxSAT (fitness > 420)

Lang Parallel time± SD (ms)

Wscomb

Seq time(ms)

RSpeedup Speedup

Java 303 ± 7.87 6 E, 1R

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

Nuevas tendencias en AGps Communicating Sequential Processes Implementacion Resultados Conclusiones

Conclusiones

Conclusiones

Ventajas de poseer abstracciones concurrentes: calidad delcodigo

Java: poca calidad pero mejores resultados

Analizar caso Go con mejor rendimento por cantidad deevaluaciones ¿generacion de numeros aleatorios?