sistemas operativos: comunicaciÓn y sincronizaciÓn …€¦ · sistemas operativos - servidores...

SISTEMAS OPERATIVOS:COMUNICACIÓN Y SINCRONIZACIÓN ENTRE PROCESOS

Desarrollo de servidores concurrentes

Contenido2

¨ Servidores de peticiones.

¨ Solución basada en procesos.

¨ Solución basada en hilos bajo demanda.

¨ Solución basada en pool de hilos.

Sistemas Operativos - Servidores concurrentes

Contenido3






Servidor de peticiones

¨ En muchos contextos se desarrollan servidores de peticiones:¤ Servidor Web.¤ Servidor de Base de datos.¤ Servidor de aplicaciones.¤ Programa de intercambio de ficheros.¤ Aplicaciones de mensajería.¤ …

4


Servidor5

SERVIDOR

CLIENTE

CLIENTE

CLIENTE

CLIENTE

CLIENTE

CLIENTE


Problema: Servidor de peticiones

¨ Un servidor recibe peticiones que debe procesar.

¨ Estructura de un servidor genérico: ¤ Recepción de petición:

n Cada petición requiere un cierto tiempo en operaciones de entrada/salida para ser recibida.

¤ Procesamiento de la petición:n Un cierto tiempo de procesamiento en CPU.

¤ Envío de respuesta:n Un cierto tiempo de entrada/salida para contestar.

6


Una biblioteca para pruebas

¨ Para poder evaluar las soluciones hoy vamos a usar una biblioteca sencilla como base.

¨ Ideas:¤ Simular la recepción de peticiones.¤ Simular el procesamiento de peticiones.¤ Simular el envío de respuestas.

7


Biblioteca base

#ifndef PETICION_H

#define PETICION_H

struct peticion {

long id;

/* Resto de campos necesarios */

int tipo;

char url[80];

/* ... */

};

typedef struct peticion peticion_t;

void recibir_peticion (peticion_t * p);

void responder_peticion (peticion_t * p);

#endif

8


Recepción de peticiones

static long petid = 0;

void recibir_peticion (peticion_t * p)

{

int delay;

fprintf(stderr, "Recibiendo petición\n");

p->id = petid++;

/* Simulación de tiempo de E/S */

delay = rand() % 5;

sleep(delay);

fprintf(stderr,"Petición %d recibida después de %d segundos\n", p->id, delay);

}

9


Recepción de peticiones

static long petid = 0;

void recibir_peticion (peticion_t * p)

{

int delay;

fprintf(stderr, "Recibiendo petición\n");

p->id = petid++;


delay = rand() % 5;

sleep(delay);

fprintf(stderr,"Petición %d recibida después de %d segundos\n", p->id, delay);

}

10

Aquí iría alguna llamada bloqueante para recibir la petición (por ejemplo de

la red)


Envío de peticiones

void responder_peticion (peticion_t * p)

{

int delay, i;

double x;

fprintf(stderr, "Enviando petición %d\n", p->id);

/* Simulación de tiempo de procesamiento */

for (i=0;i<1000000;i++) { x = 2.0 * i; }


delay = rand() % 20;

sleep(delay);

fprintf(stderr, "Petición %d enviada después de %d segundos\n", p->id, delay);

}

11


Envío de peticiones

void responder_peticion (peticion_t * p)

{

int delay, i;

double x;

fprintf(stderr, "Enviando petición %d\n", p->id);

/* Simulación de tiempo de procesamiento */

for (i=0;i<1000000;i++) { x = 2.0 * i; }


delay = rand() % 20;

sleep(delay);

fprintf(stderr, "Petición %d enviada después de %d segundos\n", p->id, delay);

}

12

Aquí iría alguna llamada bloqueante para responder

a la petición

Aquí iría el procesamiento de la petición


Una primera solución

¨ Ejecutar de modo indefinido la secuencia:¤ Recibir una petición.¤ Procesar la petición.

13

#include "peticion.h“

int main() {

peticion_t p;

for (;;) {

recibir_peticion(&p);

responder_peticion(&p);

}

return 0;

}


Problemas

¨ Llegada de peticiones.¤ Si dos peticiones llegan al mismo tiempo …¤ Si una petición llega mientras otra se está procesando

…

¨ Utilización de los recursos.¤ ¿Cómo será la utilización de la CPU?

14


Solución inicial con medición

#include "peticion.h"

#include <stdio.h>

#include <time.h>

int main()

{

int i;

const int MAX_PETICIONES = 5;

time_t t1,t2;

double dif;

peticion_t p;

t1 = time(NULL);

for (i=0;i<MAX_PETICIONES;i++) {


responder_peticion(&p);

}

t2 = time(NULL);

dif = difftime(t2,t1);

printf("Tiempo: %lf\n",dif);

return 0;

}

15


Ejecución

$ time ./ej1

Recibiendo petición

Petición 0 recibida después de 0 segundos

Enviando petición 0

Petición 0 enviada después de 13 segundos

















Tiempo: 54.000000

real 0m54.164s

user 0m0.061s

sys 0m0.046s

16


Comparación17

Normal Procesos Hilo x petición Pool de hilos

54 seg.


Contenido18






Primera idea

¨ Cada vez que llega una petición se crea un proceso hijo:¤ El proceso hijo realiza el procesamiento de la petición.¤ El proceso padre pasa a esperar la siguiente petición.

19


Servidor basado en procesos20

SERVIDOR P1

HIJO 1

P2

HIJO 2


Implementación (1/3)


#include <stdio.h>

#include <time.h>

#include <sys/wait.h>

int main() {

const int MAX_PETICIONES = 5;

int i;

time_t t1,t2;

peticion_t p;

int pid, hijos=0;

t1 = time(NULL);

21





do {

fprintf(stderr, "Comprobando hijos\n");

pid = waitpid(-‐1, NULL, WNOHANG);

if (pid>0) { hijos-‐-‐; }

} while (pid > 0);

pid = fork();

if (pid<0) { perror(“Error en la creación del hijo"); }

if (pid==0) { responder_peticion(&p); exit(0); } /* HIJO */

if (pid!=0) { hijos++; } /* PADRE */

}

22



fprintf(stderr, "Comprobando %d hijos\n", hijos);

while (hijos>0) {

pid = waitpid(-‐1, NULL, WNOHANG);

if (pid>0) { hijos-‐-‐; }

} ;

t2 = time(NULL);

double dif = difftime(t2,t1);


return 0;

}

23


Ejecución

$ time ./ej2



Comprobando hijos




Comprobando hijos




Comprobando hijos





Comprobando hijos

Comprobando hijos





Comprobando hijos

Comprobando hijos

Comprobando 3Enviando petición hijos4




Tiempo: 17.000000

real 0m17.311s

user 0m0.872s

sys 0m3.092s

24


Comparación25


54 seg. 17 seg.


Problemas

¨ Hace falta arrancar un proceso (fork) por cada petición que llega.

¨ Hace falta terminar un proceso (exit) por cada petición que termina.

¨ Excesivo consumo de recursos del sistema.

¨ No hay control de admisión.¤ Problemas de calidad de servicio.

26


Soluciones con hilos

¨ Hilos bajo demanda.¤ Cada vez que se recibe una petición

se crea un hilo.

¨ Pool de hilos.¤ Se tiene un número fijo de hilos creados.¤ Cada vez que se recibe una petición se busca un hilo

libre ya creado para que atienda la petición.n Comunicación mediante una cola de peticiones.

27


Contenido28






Hilos bajo demanda

¨ Se tiene un hilo receptor encargado de recibir las peticiones.

¨ Cada vez que llega una petición se crea un hilo y se le pasa una copia la petición al hilo recién creado.¤ Tiene que ser una copia de la petición porque la

petición original se podría modificar.

29


Implementación


#include <stdio.h>

#include <time.h>

#include <pthread.h>

#include <semaphore.h>

sem_t snhijos;

int main()

{

time_t t1, t2;

double dif;

pthread_t thr;

t1 = time(NULL);

sem_init(&snhijos, 0, 0);

pthread_create(&thr, NULL, receptor, NULL);

pthread_join(thr, NULL);

sem_destroy(&snhijos);

t2 = time(NULL);

dif = difftime(t2,t1);


return 0;

}

30


Implementación: receptor

void * receptor (void * param) {

const int MAX_PETICIONES = 5; int nservicio = 0; int i;peticion_t p; pthread_t th_hijo;

for (i=0;i<MAX_PETICIONES;i++) {recibir_peticion(&p); nservicio++;pthread_create(&th_hijo, NULL, servicio, &p);

}

for (i=0;i<nservicio;i++) { fprintf(stderr, "Haciendo wait\n");sem_wait(&snhijos);fprintf(stderr, "Saliendo de wait\n");

}pthread_exit(0); return NULL;

}

31


Implementación: servicio

void * servicio (void * p){

peticion_t pet;

copia_peticion(&pet,(peticion_t*)p);fprintf(stderr, "Iniciando servicio\n");responder_peticion(&pet);sem_post(&snhijos);

fprintf(stderr, "Terminando servicio\n");pthread_exit(0); return NULL;

}

32


Reflexión

¨ ¿Puede darse una condición de carrera?

33


Ejecución

$ time ./ej3




Iniciando servicio



Terminando servicio



Iniciando servicio



Terminando servicio



Iniciando servicio



Terminando servicio



Iniciando servicio



Terminando servicio


34


Ejecución

Haciendo wait

Iniciando servicio

Saliendo de wait


Haciendo wait

Saliendo de wait

Haciendo wait

Saliendo de wait

Haciendo wait

Saliendo de wait

Haciendo wait


Terminando servicio

Saliendo de wait

Tiempo: 12.000000

real 0m12.132s

user 0m0.046s

sys 0m0.015s

35


Comparación36


54 seg. 17 seg. 12 seg.


Problema

¨ La creación y terminación de hilos tiene un coste menor que la de procesos, pero sigue siendo un coste.

¨ No hay control de admisión:¤ ¿Que pasa si llegan muchas peticiones o las peticiones

recibidas no terminan?

37


Reflexión


38

Si se sabe

No se sabe


Reflexión


39

peticion_t p;

recibir_peticion(&p); nservicio++;pthread_create(&hijo, NULL, servicio, &p);


...

void * receptor (void * param)


Reflexión


40

peticion_t p;



...



Reflexión


41

peticion_t p;



...


2


Reflexión


42

peticion_t p;



...


2


Reflexión


43

peticion_t p;



...


peticion_t pet;

copia_peticion(&pet, p);responder_peticion(&pet);

void * servicio (void * p)

2


Reflexión


44

peticion_t p;



...


peticion_t pet;



2


Reflexión


45

peticion_t p;



...


peticion_t pet;



2


Reflexión


46

peticion_t p;



...


peticion_t pet;



3


Reflexión


47

peticion_t p;



...


peticion_t pet;



3


Contenido48






Pool de threads

¨ Un pool de hilos es un conjunto de hilos que se tiene creados desde el principio para ejecutar un servicio:

¤ Cada vez que llega una petición se pone en una cola de peticiones pendientes.

¤ Todos los hilos esperan a que haya alguna petición en la cola y la retiran para procesarla.

49


Implementación: main (1/3)

#include "peticion.h"#include <stdio.h>#include <time.h>#include <pthread.h>#include <semaphore.h>

#define MAX_BUFFER 128peticion_t buffer[MAX_BUFFER];int n_elementos;int pos_servicio = 0;pthread_mutex_t mutex;pthread_cond_t no_lleno;pthread_cond_t no_vacio;

pthread_mutex_t mfin;int fin=0;

50



int main() {

time_t t1, t2;double dif;pthread_t thr;pthread_t ths[MAX_SERVICIO];const int MAX_SERVICIO = 5; int i;

t1 = time(NULL);

pthread_mutex_init(&mutex,NULL);pthread_cond_init(&no_lleno,NULL);pthread_cond_init(&no_vacio,NULL);pthread_mutex_init(&mfin,NULL);

pthread_create(&thr, NULL, receptor, NULL);for (i=0;i<MAX_SERVICIO;i++) {pthread_create(&ths[i], NULL, servicio, NULL);

}

51



pthread_join(thr, NULL);for (i=0;i<MAX_SERVICIO;i++) {

pthread_join(ths[i],NULL);}

pthread_mutex_destroy(&mutex);pthread_cond_destroy(&no_lleno);pthread_cond_destroy(&no_vacio);pthread_mutex_destroy(&mfin);

t2 = time(NULL);

dif = difftime(t2,t1);printf("Tiempo: %lf\n",dif);

return 0;}

52


Implementación: receptor (1/2)

void * receptor (void * param){

const int MAX_PETICIONES = 5;peticion_t p;int i, pos=0;


recibir_peticion(&p);pthread_mutex_lock(&mutex);while (n_elementos == MAX_BUFFER)

pthread_cond_wait(&no_lleno, &mutex); buffer[pos] = p;pos = (pos+1) % MAX_BUFFER;n_elementos++;pthread_cond_signal(&no_vacio);pthread_mutex_unlock(&mutex);

}

53


Implementación: receptor (2/2)

fprintf(stderr,"Finalizando receptor\n");pthread_mutex_lock(&mfin);fin=1;

pthread_mutex_unlock(&mfin);pthread_mutex_lock(&mutex);pthread_cond_broadcast(&no_vacio);pthread_mutex_unlock(&mutex);

fprintf(stderr, "Finalizado receptor\n");pthread_exit(0);return NULL;

} /* receptor */

54


Implementación: servicio (1/2)

void * servicio (void * param) {

peticion_t p;

for (;;) {pthread_mutex_lock(&mutex);while (n_elementos == 0) {

if (fin==1) {fprintf(stderr,"Finalizando servicio\n");pthread_mutex_unlock(&mutex);pthread_exit(0);

}pthread_cond_wait(&no_vacio, &mutex);

} // while

55


Implementación: servicio (2/2)

fprintf(stderr, "Sirviendo posicion %d\n", pos_servicio);p = buffer[pos_servicio];pos_servicio = (pos_servicio + 1) % MAX_BUFFER;n_elementos -‐-‐;pthread_cond_signal(&no_lleno);pthread_mutex_unlock(&mutex);responder_peticion(&p);

}

pthread_exit(0);return NULL;

}

56


Comparación57


54 seg. 17 seg. 12 seg. ?


sistemas operativos: comunicaciÓn y sincronizaciÓn …€¦ · sistemas operativos - servidores...

Documents