Paralelismo vs.

Concurrencia
Roberto Costumero Moreno
Arquitecturas Multiprocesador
Curso 2011 / 2012

Una visin general

Programas cada vez ms complejos.
Sistemas con mltiples CPUs multicore.
Posibilidad de reducir el tiempo de
ejecucin de un programa.

Ventajas
Menor tiempo de cmputo.
Mayor aprovechamiento de los recursos.
Permite en muchas tareas el acceso
simultneo de varios usuarios.

Favorece una mayor cohesin y un menor

acoplamiento entre las tareas a realizar.

Desventajas
Mayor complejidad de los programas.
Condiciones de carrera, ejecuciones no
determinsticas...

Mayor grado de especializacin de los

ingenieros.

Cdigo muy difcil de depurar.

Qu son la
concurrencia y el
paralelismo?

 Concurrencia: Ejecucin de programas

de forma no determinstica.

Paralelismo: Explotacin de la eficiencia

de programas de forma determinstica.

Concurrencia
Dos operaciones pueden estar realizndose
en el mismo tiempo o no. Depende del
paralelismo.

Es necesaria para implementar paralelismo.

Provee sistemas de sincronizacin y
comunicacin para programas ejecutados
en una o ms CPU.

Paralelismo
Implica la ejecucin simultnea de dos o

ms operaciones en el mismo nmero de

CPUs.

Necesita de mecanismos de concurrencia

para juntar las partes de los clculos
realizados.

Por qu es importante
la concurrencia?
Permite la simulacin de una ejecucin
paralela en un entorno monocore.

Gestiona el acceso seguro a elementos

compartidos y secciones crticas.

Garantiza que el resultado de las

operaciones es siempre el mismo,

independientemente del n de threads.

Por qu es importante
el paralelismo?
Creciente nmero de cores en los
ordenadores.

Permite una gran disminucin del tiempo

de cmputo en programas de gran escala.

Contribuye a un mayor aprovechamiento

de los recursos.

Ejemplos
Clculo secuencial, concurrente (1 CPU) y
paralelo (2 CPU) del nmero PI.

Clculo de la suma de los elementos de un

vector de forma secuencial, concurrente y
paralela.

package main

PI secuencial

import (


"fmt"


"math"


"runtime"
)
func main() {


runtime.GOMAXPROCS(1)


fmt.Println(pi(100000))
}
// pi launches n goroutines to compute an
// approximation of pi.
func pi(n int) float64 {


f := 0.0


for k := 0; k <= n; k++ {




f += term(float64(k))


}


return f
}
func term(k float64) float64 {


return 4 * math.Pow(-1, k) / (2*k + 1)
}

package main

PI Concurrente

import (


"fmt"


"math"


"runtime"
)
func main() {


runtime.GOMAXPROCS(1)


fmt.Println(pi(100000))
}
// pi launches n goroutines to compute an
// approximation of pi.
func pi(n int) float64 {


ch := make(chan float64)


for k := 0; k <= n; k++ {




go term(ch, float64(k))


}


f := 0.0


for k := 0; k <= n; k++ {




f += <-ch


}


return f
}
func term(ch chan float64, k float64) {


ch <- 4 * math.Pow(-1, k) / (2*k + 1)
}

package main

PI Paralelo

import (


"fmt"


"math"


"runtime"
)
func main() {


runtime.GOMAXPROCS(2);


fmt.Println(pi(100000))
}
// pi launches n goroutines to compute an
// approximation of pi.
func pi(n int) float64 {


ch := make(chan float64)


for k := 0; k <= n; k++ {




go term(ch, float64(k))


}


f := 0.0


for k := 0; k <= n; k++ {




f += <-ch


}


return f
}
func term(ch chan float64, k float64) {


ch <- 4 * math.Pow(-1, k) / (2*k + 1)
}

Tiempos ejecucin
3.1416026534897203

Secuencial Concurrente Paralelo

Real

0m0.032s

User

0m0.027s

Sys

0m0.002s

Tiempos ejecucin
3.1416026534897203

Secuencial Concurrente Paralelo

Real

0m0.032s

0m0.689s

User

0m0.027s

0m0.333s

Sys

0m0.002s

0m0.347s

Tiempos ejecucin
3.1416026534897203

Secuencial Concurrente Paralelo

Real

0m0.032s

0m0.689s

0m1.497s

User

0m0.027s

0m0.333s

0m0.493s

Sys

0m0.002s

0m0.347s

0m1.210s

package main

Vector secuencial

import (


"fmt"


"container/vector"


"runtime"
)
func sum (v *vector.IntVector, n int) int {


var total int = 0


for i := n; i < v.Len(); i += 4 {




total += v.At(i)


}


return total
}
func main () {


runtime.GOMAXPROCS(1)


var v *vector.IntVector = new (vector.IntVector)


for i := 0; i < 100000000; i++ {




v.Push(i)


}


var t int = 0


for i := 0; i < 4; i++ {




t += sum (v, i)


}


fmt.Println(t)
}

Vector Concurrente

import (


"fmt"


"container/vector"


"runtime"
)

func sum (v *vector.IntVector, n int, ch chan int) {

var total int = 0


for i := n; i < v.Len(); i += 4 {




total += v.At(i)


}


ch <- total
}
func main () {


runtime.GOMAXPROCS(1)


var v *vector.IntVector = new (vector.IntVector)


for i := 0; i < 100000000; i++ {




v.Push(i)


}


var t int = 0


ch := make(chan int)


for i := 0; i < 4; i++ {




go sum (v, i, ch)


}


for i := 0; i < 4; i++ {




t += <-ch


}


fmt.Println(t)
}

Vector Paralelo

import (


"fmt"


"container/vector"


"runtime"
)

func sum (v *vector.IntVector, n int, ch chan int) {

var total int = 0


for i := n; i < v.Len(); i += 4 {




total += v.At(i)


}


ch <- total
}
func main () {


runtime.GOMAXPROCS(2)


var v *vector.IntVector = new (vector.IntVector)


for i := 0; i < 100000000; i++ {




v.Push(i)


}


var t int = 0


ch := make(chan int)


for i := 0; i < 4; i++ {




go sum (v, i, ch)


}


for i := 0; i < 4; i++ {




t += <-ch


}


fmt.Println(t)
}

Tiempos ejecucin
887459712

Secuencial Concurrente Paralelo

Real

0m3.694s

User

0m3.031s

Sys

0m0.626s

Tiempos de insercin de elementos: real 0m2.716s || user 0m1.977s || sys 0m0.668s

Tiempos ejecucin
887459712

Secuencial Concurrente Paralelo

Real

0m3.694s

0m3.725s

User

0m3.031s

0m3.068s

Sys

0m0.626s

0m0.632s

Tiempos de insercin de elementos: real 0m2.716s || user 0m1.977s || sys 0m0.668s

Tiempos ejecucin
887459712

Secuencial Concurrente Paralelo

Real

0m3.694s

0m3.725s

0m3.179s

User

0m3.031s

0m3.068s

0m3.025s

Sys

0m0.626s

0m0.632s

0m0.638s

Tiempos de insercin de elementos: real 0m2.716s || user 0m1.977s || sys 0m0.668s

Bibliografa

http://existentialtype.wordpress.com/2011/03/17/
parallelism-is-not-concurrency/

http://existentialtype.wordpress.com/2011/03/15/
teaching-fp-to-freshmen/

http://ghcmutterings.wordpress.com/2009/10/06/
parallelism-concurrency/

http://my.opera.com/Vorlath/blog/2009/10/08/
parallel-vs-concurrent

http://golang.org