ponnhi ponnhi una nueva arquitectura microkernel pthreads en espacio de usuario josé manuel...

PONNHIPONNHIUna Nueva Arquitectura Microkernel

Pthreads en Espacio de Usuario

PONNHIPONNHIUna Nueva Arquitectura Microkernel

Pthreads en Espacio de Usuario

José Manuel Rodríguez GarcíaJuan A. Rico Gallego

Jesús M. Álvarez LlorenteJuan Carlos Díaz Martín

Departamento de Informática

Universidad de Extremadura

PONNHI. Una Nueva Arquitectura Microkernel Pthreads en Espacio de Usuario - XIII Jornadas de Paralelismo - Lleida, septiembre de 2002

PONNHI

1. Motivación y objetivos.2. Principios de diseño.3. La interfaz de PONNHI.4. El microkernel.5. Los servidores.6. Gestión de señales POSIX.7. La cancelación.8. Pruebas de rendimiento.9. Conclusiones y trabajo futuro.


1. Motivación y objetivos

• FSU Pthreads es una extendida implemen-tación de threads POSIX 1003.1c (núcleo de ejecución de ADA 95).

• Tiene una estructura monolítica.• Es robuto y bastante completo.• Nuestra expericiencia con su código fuente

(Champollion, VíTReOS) nos demuestra que es demasiado complejo.




• Otras librerías semejantes, todas POSIX, todas monolíticas:– PTL. Portable Threads Library.– GNU Pth. The GNU Portable Threads.– Provenzano threads.– LinuxThreads.

• Pretendemos construir una nueva librería POSIX, pero microkernel: PONNHI.


2. Principios de diseño

• Diseño inspirado en Minix.

• Dos elementos principales:– Servidores de threads proporcionan a los hilos

cliente las funcionalidades Pthreads.– El microkernel soporta el paso de mensajes y la

planificación

• Las primitivas Pthreads se transforman en paso de mensajes a los servidores a través del núcleo.




S erv id o re s P O N N H I

B u s s o f tw a re



• Los hilos de aplicación componen mensajes para el hilo del núcleo.

• El hilo del núcleo lo traspasa al servidor adecuado.

• Los hilos servidores realizan los trabajos solicitados. S erv id o re s P O N N H I

B u s s o f tw a re



• El hilo del núcleo es un hilo más (con su propio contexto).

• Es un diseño modular: es fácil separar las funcionalidades de Pthreads.

• Es un diseño flexible: es más fácil añadir servicios que en un modelo monolítico.


3. La interfaz de PONNHI• Todas las primitivas Pthreads de los hilos de aplicación

se traducen a primitivas send_rec:

• Los servidores aceptan mensajes mediante la primitiva receive:

• Bloqueo de threads hasta la cita.

void send_rec(int dst, mess_t *mess)void send_rec(int dst, mess_t *mess)

void receive (int src, mess_t *mes)void receive (int src, mess_t *mes)

3. La interfaz de PONNHI



• Ejemplo: pthread_create.

int pthread_create(pthread_t *thread, pthread_attr_t *attr, pthread_func_t func,any_t arg ) { mess_t mess; mess.operation = CREATE_THREAD; mess.arg.mes_1.t = thread; mess.arg.mes_1.attr = attr; mess.arg.mes_1.func = func; mess.arg.mes_1.arg = arg; send_rec(1, &mess); /* Server 1 */ ...}

int pthread_create(pthread_t *thread, pthread_attr_t *attr, pthread_func_t func,any_t arg ) { mess_t mess; mess.operation = CREATE_THREAD; mess.arg.mes_1.t = thread; mess.arg.mes_1.attr = attr; mess.arg.mes_1.func = func; mess.arg.mes_1.arg = arg; send_rec(1, &mess); /* Server 1 */ ...}



• Los servidores solicitan planificación al núcleo mediante send_rec.

• No existe la primitiva send: nunca se hace sin receive.


4. El microkernel

• Tres funciones:– Entregar mensajes– Planificar los hilos– Manejar las señales POSIX

• Es el único autorizado para planificar.• Nunca se planifica: sólo se ejecuta cuando

recibe mensajes de otros hilos (invocación directa por salto largo).

4. El microkernel


4. El microkernel

• La planificación de un hilo se hace invocando restore_context(descriptor_thread).

• Previamente se guarda el contexto mediante save_context(descriptor_thread).

void send_rec(mess_t *mess) { is_in_kernel = TRUE; save_context(kernel.pthread_self); *(servers[KERNEL]->mens) = mess; restore_context(servers[KERNEL]); }

void send_rec(mess_t *mess) { is_in_kernel = TRUE; save_context(kernel.pthread_self); *(servers[KERNEL]->mens) = mess; restore_context(servers[KERNEL]); }

Como PC la dirección de retorno

de send_rec

Como PC la dirección de retorno

de send_rec


• La función principal del núcleo es kernel_f:

4. El microkernel

void kernel_f() { mess_t *mess; while (1) { sched_wait(ANY, &mess) switch(mess.operation) { case 1: ... break; ... case n: ... break; } }}

void kernel_f() { mess_t *mess; while (1) { sched_wait(ANY, &mess) switch(mess.operation) { case 1: ... break; ... case n: ... break; } }}

void sched_wait(int from, mess_t *mess) { save_context(servers[KERNEL]); servers[KERNEL]->mess= mess; sched();}

void sched_wait(int from, mess_t *mess) { save_context(servers[KERNEL]); servers[KERNEL]->mess= mess; sched();}

void sched() { while(ready.head == NULL) if (pending == TRUE) mess_signal(); kernel.pthread_self = ready.head; kernel.pthread_self->state|=S_RUNNING; kernel.pthread_self->state&=~S_RECEIVING; is_in_kernel=FALSE; restore_context(kernel.pthread_self); }

void sched() { while(ready.head == NULL) if (pending == TRUE) mess_signal(); kernel.pthread_self = ready.head; kernel.pthread_self->state|=S_RUNNING; kernel.pthread_self->state&=~S_RECEIVING; is_in_kernel=FALSE; restore_context(kernel.pthread_self); }


5. Los servidores• Proporcionan los servicios Pthread.• ¿Cuántos hacen falta?

– Cuantos menos, menos paso de mensajes.– Cuantos menos, más monolítico.

• Según criterios funcionales, 4 servidores:– Servidor de gestión de hilos– Servidor de mecanismos de sincronización– Servidor de señales POSIX– Servidor de datos específicos

• Se

5. Los servidores


5. Los servidores

• Tienen una estructura semejante al núcleo.

server_POSIX_SIGNALS() { mess_t *mensaje; init_signals(); do { receive(ANY, &mess); switch (mess->operation) { case SIGACTION: .... break; ... case PTHREAD_KILL: ... break; ... } } while (1);}

server_POSIX_SIGNALS() { mess_t *mensaje; init_signals(); do { receive(ANY, &mess); switch (mess->operation) { case SIGACTION: .... break; ... case PTHREAD_KILL: ... break; ... } } while (1);}


6. Gestión de señales POSIX

• El servidor de señales instala el manejador universal de señales para todas las señales POSIX.

• Se redefine sigaction() para que no invoque al S.O., sino que envíe un mensaje al servidor de señales.

• El servidor de señales anota los manejadores que establecen los hilos.

• Cuando llega una señal, el manejador universal envía un mensaje al núcleo para que se lo pase al servidor de señales y éste la distribuya de la forma adecuada.




• El manejador universal de señales:

void sigcatch(int sig, siginfo_t *siginfo, void *sigcontext) { if(!is_in_kernel) { is_in_kernel = TRUE; save_context(kernel.pthread_self); sig_send(sig, siginfo, sigcontext); } else { sigaddset(&pending_signals,sig); pending=TRUE; }}

void sigcatch(int sig, siginfo_t *siginfo, void *sigcontext) { if(!is_in_kernel) { is_in_kernel = TRUE; save_context(kernel.pthread_self); sig_send(sig, siginfo, sigcontext); } else { sigaddset(&pending_signals,sig); pending=TRUE; }}

void sig_send(int sig, siginfo_t *siginfo, void *sigcontext) { mess_t mess; mess.operation = SIGNAL; mess.type = 0; mess.arg.mes_8.sig = sig; mess.arg.mes_8.siginfo = siginfo; mess.arg.mes_8.sigcontext = sigcontext; mess.arg.mes_8.t = kernel.pthread_self; (*(servers[KERNEL]->mess)) = &mess; restore_context(servers[KERNEL]); }

void sig_send(int sig, siginfo_t *siginfo, void *sigcontext) { mess_t mess; mess.operation = SIGNAL; mess.type = 0; mess.arg.mes_8.sig = sig; mess.arg.mes_8.siginfo = siginfo; mess.arg.mes_8.sigcontext = sigcontext; mess.arg.mes_8.t = kernel.pthread_self; (*(servers[KERNEL]->mess)) = &mess; restore_context(servers[KERNEL]); }


7. La cancelación

• Un hilo puede ordenar la cancelación de otro.

• Un hilo puede aceptar o no la cancelación, en función de su estado.

• El servidor modifica el contexto del hilo cancelado para que cuando se reanude pase por handle_cancel.– Si acepta la cancelación, finaliza.– Si la rechaza, quedará pendiente hasta que cambie su

estado.

7. La cancelación


8. Pruebas de rendimiento

• Comparamos PONNHI con 3 librerías monolíticas.• Hacemos 5 tests:

– Test 1: 100.000 cambios de contexto entre 2 hilos.– Test 2: 100.000 bloqueos/liberaciones de mútex.– Test 3: 10.000 sincronizaciones en variable de condición entre 2

hilos.– Test 4: 10.000 sincronizaciones sigwait/pthread_kill entre 2

hilos.– Test 5: Creación de 1000 hilos.




0

50

100

150

200

250

300

350

400

450

500

Tie

mpo

en

ms.

T1 T2 T3 T4 T5

PONNHI QNX RTP FSU Pthreads LinuxThreads

4 cambios de contextofrente a la modificación

de una variable

4 cambios de contextofrente a la modificación

de una variable


9. Conclusiones y trabajo futuro

• Es posible construir Pthreads con arquitectura microkernel.

• Los servicios básicos ya funcionan– Trabajamos en características avanzadas como herencia

de prioridad y techo de prioridad.– Conviene mejorar el rendimiento en lo posible.

• PONNHI es manejable. Lo estamos portando a Minix y microcontrolador HITACHI.

• Objetivo: que sirva de base para Ada95.

9. Conclusiones y trabajo futuro


Agradecimientos

Este trabajo ha sido financiado por los proyectos

FEDER II S742-F96, “Servidor escalable de reconocimiento de voz” y

CICYT nº TIC99-0960, “Diseño e Implementación de Algoritmos de Procesado de Señal de Altas Prestaciones para Reconocimiento de

Voz en Condiciones Adversas”

Agradecimientos

ponnhi ponnhi una nueva arquitectura microkernel pthreads en espacio de usuario josé manuel...

Documents