Programacion Concurrente Y Paralela

Cuestionario

1.- ¿Cuál es la ventaja de la concurrencia en los sistemas monoprocesador?

R= La principal ventaja es la posibilidad de ejecutar 2 o más procesos en un mismo tiempo y se da la multiprogramación

2.- ¿Cuáles son las diferencias entre programación concurrente, paralela y distribuida?

R= La programación concurrente es un conjunto de acciones que pueden ser ejecutadas simultáneamente.

La programación paralela es un tipo de programación concurrente diseñado para ejecutarse en un sistema multiprocesador

La programación distribuida es un tipo de programación paralela que esta diseñada para ejecutarse en un sistema distribuido, es decir, en una red de procesadores autónomos que no comparten una memoria en común.

3.- ¿Cuáles son las diferencias entre multiprogramación, multiproceso y procesamiento distribuido?

R= La multiprogramación es la forma de gestionar los procesos en un sistema monoprocesador.

El multiproceso es la gestión de varios procesos dentro de un monoprocesador.

El multiproceso es la gestión de varios procesos dentro de un sistema multiprocesador donde cada procesador puede acceder a una memoria. El procesamiento distribuido es la gestión de varios procesos en procesadores separados cada uno con su memoria local

4.- ¿Cuáles son los dos problemas principales inherentes a la programación concurrente?

R=E l problema de la exclusión mutua y el de la condición de sincronización

5.- ¿Qué es una sección critica?

R= Es una porción de código que queremos que se ejecute de forma indivisible y atómica. Una parte de código que es compartida por uno o más procesos.

6.- ¿Cuáles son las características de un programa concurrente?

Se caracterizan por un orden parcial en la ejecución de sus instrucciones frente al orden total presente en los programas secuenciales

7.- ¿Qué se entiende por un programa concurrente correcto?

R= Programa que aparte de cumplir las especificaciones funcionales que se le dieron, debe satisfacer, propiedades de seguridad y propiedades de viveza.

Marco Antonio Cardona Benítez

200719212

Programación Concurrente y Paralela

Problemas

Usando las condiciones de Bernstein, construir el grafo de precedencia del siguiente trozo de código y el programa concurrente

S1: cuad := x*x;

S2: m1 := a*cuad;

S3: m2 := b*x;

S4: z := m1 + m2;

S5: y := z + c;

Condiciones:

1. L(Si) ∩ E(Sj) = ∅

2. E(Si) ∩ L(Sj) = ∅

3. E(Si) ∩ E(Sj) = ∅

En primer lugar calculamos los conjuntos de lectura y escritura utilizando las condiciones de Bernstein.

L(S1)={ x }

E(S1)={ cuad }

L(S2)={ cuad, a }

E(S2)={ m1 }

L(S3)={ b, x }

E(S3)={ m2 }

L(S4)={ m1, m2 }

E(S4)={ z }

L(S5)={ z, c }

E(S5)={ y }

Entre S1 y S2: 1. L(S1) ∩ E(S2) = ∅ 2. E(S1) ∩ L(S2) = cuad ≠ ∅ 3. E(S1)∩ E(S2) = ∅ Entre S1 y S3: 1. L(S1) ∩ E(S3) = ∅ 2. E(S1) ∩ L(S3) = ∅ 3. E(S1)∩ E(S3) = ∅ Entre S1 y S4: 1. L(S1) ∩ E(S2) = ∅ 2. E(S1) ∩ L(S2) = ∅ 3. E(S1) ∩ E(S2) = ∅ Entre S1 y S5: 1. L(S1) ∩ E(S5) = ∅ 2. E(S1) ∩ L(S5) = ∅ 3. E(S1) ∩ E(S5) = ∅ Entre S2 y S3: 1. L(S2) ∩ E(S3) = ∅ 2. E(S2) ∩ L(S3) = ∅ 3. E(S2) ∩ E(S3) = ∅ Entre S2 y S4: 1. L(S2) ∩ E(S4) = ∅ 2. E(S2) ∩ L(S4) = m1 ≠ ∅ 3. E(S2) ∩ E(S4) = ∅ Entre S2 y S5: 1. L(S2) ∩ E(S5) = ∅ 2. E(S2) ∩ L(S5) = ∅ 3. E(S2) ∩ E(S5) = ∅ Entre S3 y S4: 1. L(S3) ∩ E(S4) = ∅ 2. E(S3) ∩ L(S4) = m2 ≠ ∅ 3. E(S3) ∩ E(S4) = ∅ Entre S3 y S5: 1. L(S3) ∩ E(S5) = ∅ 2. E(S3) ∩ L(S5) = ∅ 3. E(S3) ∩ E(S5) = ∅ Entre S4 y S5: 1. L(S4) ∩ E(S5) = ∅ 2. E(S4) ∩ L(S5) = z ≠ ∅ 3. E(S4) ∩ E(S5) = ∅

Marco Antonio Cardona Benítez

200719212

Programación Concurrente y Paralela

De todo esto se deduce la siguiente tabla en la que puede verse qué pares de sentencias pueden ejecutarse de forma concurrente: S1 S2 S3 S4 S5 S1 - No Si Si Si S2 - - Si No Si S3 - - - No Si S4 - - - - No S5 - - - - -

A partir de la tabla anterior construimos el grafo de precedencia quedando de la siguiente manera

Marco Antonio Cardona Benítez

200719212

Programación Concurrente y Paralela

Construir dos programas concurrentes que se correspondan con los de la siguiente figura utilizando extends Thread y Runnable

Grafo 1

Grafo 2

Código del grafo 1 implementando herencia

public class progHerencia1 extends Thread{

String palabra;

int duerme;

public progHerencia1(String _palabra, int mili) {

palabra=_palabra;

duerme=mili;

}

public void run(){

try{

Thread.sleep(duerme);

System.out.println(palabra);

}

catch(InterruptedException e){

return;

}

...