Cambio de contexto (i) Cuando hacemos un cambio de contexto, debemos: Salvar el contexto previo. Restaurar el contexto nuevo. P. ej. switch_context(P1,P2) podría ser una rutina en lo más profundo del SO que salva el contexto de P1 en su PCB, y restaura el nuevo contexto del PCB de P2. ¿En qué se diferencia ésta función de una llamada a procedimiento normal? ... Dado que cuando un proceso se esta ejecutando en la CPU esta cargado su contexto, se dice que los procesos se ejecutan en su contexto. Una cuestión que surge ¿Qué contexto utiliza el SO para ejecutarse? Bien, si el SO realiza una función en beneficio de un proceso (para darle un servicio), el SO utiliza el contexto del proceso actual, entre otras cosas por que tiene que obtener/suministrar información de/a el. Si el SO esta atendiendo una interrupción o realiza labores internas (gestión alarmas, recalculo de prioridades, etc) no debería utilizar el contexto del proceso, debe utilizar el contexto de sistemas o contexto de interrupción. La función encargada de realizar el cambio de contexto puede tener la forma de switch_context(P1,P2), donde P1 es el proceso que queremos detener (salvar su contexto) y P2 es el proceso que debemos reanudar su ejecución (cargar en la CPU su contexto). Esta función se invoca por el SO en el contexto del proceso actual, pero es una función un poco particular ... Sistemas Operativos I

Cambio de contexto (ii) call return P1 P2 M. Usuario M. Kernel 3º 1º switch_context(P2,P1) switch_context(P1,P2) La función switch_context(P1,P2) se comporta para el proceso como una función “normal”, es decir, cuando se invoca se transfiere el control a la función y cuando esta finaliza el control continua por la siguiente instrucción a la de invocación. En nuestro caso tiene la particularidad de que al invocarla, esta función lo que hace es salvar el contexto del proceso invocador en su PCB y accedo al PCB del otro proceso y recupero su contexto. Cuando el proceso P2 (u otros procesos) se ha ejecutado un rato vuelvo a invocar a la función, de forma que salvo el contexto de proceso actual (P2) y repongo el de P1. Desde el punto de vista de P1 no ha ocurrido nada diferente a una llamada a función, es como si hubiese estado congelado durante un rato. Para que la función cambio de contexto sea más rápida, debemos esterar que la estructura de los contextos de los procesos sea la misma. Esto que implicación tiene, pues que cuando se crea un proceso debemos ajustar su PCB y su contexto como para que parezca que ha existido anteriormente, es decir, que cuando se ejecute la primera vez debe parecer que retorna de invocar la función switch_context(P1,P2). (a) 2º 4º switch_context() … en detalle, a continuación … Sistemas Operativos I

Ilustración del cambio de contexto: supuestos Suponemos dos procesos: P1 esta ejecutando la instrucción n que es una llamada al sistema. P2 se ejecutó anteriormente y ahora esta en el estado preparado esperando su turno. Convenio: Código del SO Estructura de datos Flujo de control Salvar estructuras de datos Instrucción i-ésima a ejecutar Sistemas Operativos I

Máquina en modo usuario 1º - P1 ejecuta n Memoria Máquina en modo usuario n int c Proceso 1 CPU Proceso 2 n+1 PC SP i Llamada 1 Llamada 2 c j switch_context(P1,P2) . . . registros Otros t,v,x,y k j l,n,o,p Contexto kernel Contexto usuario Resto información PCB1 PCB2 Sistemas Operativos I

2º - Salva contexto usuario y ejecuta fon kernel Memoria Máquina en modo kernel n Proceso 1 CPU Proceso 2 n+1 PC SP i Llamada 1 Llamada 2 c j switch_context(P1,P2) . . . registros Otros Salva contexto Usuario y ejecuta código kernel t,v,x,y j k l,n,o,p Contexto kernel Contexto usuario Resto información PCB1 PCB2 Sistemas Operativos I

3º - Parar proceso, invoca a cambio_contexto Memoria Máquina en modo kernel n Proceso 1 CPU Proceso 2 c+i+1 PC SP m Llamada 1 Llamada 2 c r c+i switch_context(P1,P2) . . . registros Otros Invoca a switch_ context t,v,x,y s j n+1,i,j,k l,n,o,p Contexto kernel Contexto usuario Resto información PCB1 PCB2 Sistemas Operativos I

4º - Cambio_contexto() salva contexto kernel Memoria Máquina en modo kernel n Proceso 1 CPU Proceso 2 c+i+1 PC SP m Llamada 1 Llamada 2 c r c+i switch_context(P1,P2) . . . registros Otros s_c salva contexto kernel t,v,x,y s j n+1,i,j,k l,n,o,p Contexto kernel Contexto usuario Resto información PCB1 PCB2 Sistemas Operativos I

¿Cómo estamos? Llegados a este punto P1 esta detenido, “congelado” y nos disponemos a reanudar, “descongelar”, a P2 (que previamente habíamos parado en algún instante anterior). Es decir, estamos en el punto marcado como (a) en la transparencia 18. Sistemas Operativos I

5º - Repone contexto kernel de P2 Memoria Máquina en modo kernel n Proceso 1 CPU Proceso 2 t PC SP v Llamada 1 Llamada 2 c t x switch_context(P1,P2) . . . registros Otros c+i,m,r,s t,v,x,y y j l,n,o,p n+1,i,j,k Contexto kernel Contexto usuario Resto información PCB1 PCB2 Sistemas Operativos I

6º - El kernel termina la fon que inicio de P2 Memoria Máquina en modo kernel n Proceso 1 CPU Proceso 2 t PC SP v Llamada 1 Llamada 2 c t x switch_context(P1,P2) . . . registros Otros c+i,m,r,s j y l,n,o,p n+1,i,j,k Contexto kernel Contexto usuario Resto información PCB1 PCB2 Sistemas Operativos I

7º - Finalizada fon, retorna a modo usuario Memoria Máquina en modo kernel El kernel repone el contexto de usuario n Proceso 1 CPU Proceso 2 l PC SP n Llamada 1 Llamada 2 c t o switch_context(P1,P2) . . . registros Otros c+i,m,r,s p j l,n,o,p n+1,i,j,k Contexto kernel Contexto usuario Resto información PCB1 PCB2 Sistemas Operativos I

8º - reanudamos ejecución de P2 Máquina en modo usuario Proceso 1 CPU l Proceso 2 l PC SP n Llamada 1 Llamada 2 c t o switch_context(P1,P2) . . . registros Otros c+i,m,r,s j p n+1,i,j,k Contexto kernel Contexto usuario Resto información PCB1 PCB2 Sistemas Operativos I

Observaciones Cuando conmutamos al proceso P2, este tiene la estructura de PCB que aparece el el dibujo adjunto. Es decir, hemos supuesto que se ha ejecutado con anterioridad. ¿Qué pasa si acabo de lanzar P2? Contexto modo kernel Contexto modo usuario Información general del PCB Sistemas Operativos I

Respuesta La llamada al sistema CrearProceso() esta diseñada para crear un proceso cuyo PCB tiene la estructura anterior. ¿Qué valores tiene el contexto de este PCB? El SO ajusta los valores del contexto de usuario para que el proceso recién creado se ejecute desde su primera instrucción. Se crea un contexto kernel para que parezca que el proceso retorna de una llamada al sistema. Nueva pregunta ¿por qué hacer esto así? ... Respuesta en Problema 4 de Temas 1 y 2. Sistemas Operativos I

Mecánica del cambio de contexto El cambio de contexto es muy dependiente de la máquina: salvar registros generales y de punto flotante, estado del coprocesador, ... El coste del cambio de contexto proviene: Coste directo de salvar registros de propósito general y los especiales. Coste indirecto de limpieza de cachés (los datos de las cachés del proceso actual son inválidos para el entrante). El coste de la operación de cambio de contexto proviene de: un coste directo derivado de salvar los registros, y de un coste indirecto, generado por que al restaurar el contexto del proceso que se va a ejecutar, los contenidos, totales o parciales, de la(s) caché(s) no son válidos y por tanto hay que invalidarlos. Pero además, como las caché se basan en el principio de localidad para suministrar una alta tasa de acierto, cuando iniciamos la ejecución de un proceso la tasa de aciertos será baja por lo que el arranque del proceso es costoso en tiempo. Sistemas Operativos I