1 diseño de sistemas operativos planificador de procesos (scheduler) abián izquierdo montesdeoca...

1

Diseño de Sistemas OperativosDiseño de Sistemas Operativos

Planificador de Planificador de

ProcesosProcesos

(Scheduler)(Scheduler)Abián Izquierdo MontesdeocaAbián Izquierdo Montesdeoca

Eduardo J. Delgado MateoEduardo J. Delgado Mateo

2

Introducción a los procesosIntroducción a los procesos

Un programa es un conjunto de instrucciones Un programa es un conjunto de instrucciones de código máquina y datos guardados en de código máquina y datos guardados en disco en una imagen ejecutable y como tal, es disco en una imagen ejecutable y como tal, es una entidad pasiva.una entidad pasiva.

Un proceso es un programa en ejecución, Un proceso es un programa en ejecución, incluyendo su contador de programa y los incluyendo su contador de programa y los registros de la CPU así como la pila para registros de la CPU así como la pila para datos temporales y parámetros de las rutinas, datos temporales y parámetros de las rutinas, direcciones de retorno y variables salvadas.direcciones de retorno y variables salvadas.

3


Un proceso consume muchos recursos Un proceso consume muchos recursos del sistema, los más importantes son:del sistema, los más importantes son:

• CPU, para ejecutar sus instrucciones.CPU, para ejecutar sus instrucciones.• Memoria física, para almacenar al propio Memoria física, para almacenar al propio

proceso y sus datos.proceso y sus datos.• Ficheros y otros dispositivos del sistema.Ficheros y otros dispositivos del sistema.

El recurso más preciado en el sistema es El recurso más preciado en el sistema es la CPU y normalmente sólo hay una.la CPU y normalmente sólo hay una.

4


Un sistema multiproceso mantiene muchos Un sistema multiproceso mantiene muchos procesos en memoria simultáneamente y uno procesos en memoria simultáneamente y uno se ejecuta hasta que tenga que esperar, se ejecuta hasta que tenga que esperar, normalmente por algún recurso del sistema.normalmente por algún recurso del sistema.

Estos Estos procesos son tareas independientes. Si procesos son tareas independientes. Si un proceso se desploma, no hará que otros un proceso se desploma, no hará que otros procesos en el sistema fallen también.procesos en el sistema fallen también.

Cada proceso se ejecuta en su propio espacio Cada proceso se ejecuta en su propio espacio de memoria virtual sin interaccionar con otros de memoria virtual sin interaccionar con otros procesos, excepto a través de mecanismos del procesos, excepto a través de mecanismos del núcleo.núcleo.

5


El objetivo es tener un proceso El objetivo es tener un proceso ejecutándose en cada CPU del sistema ejecutándose en cada CPU del sistema en todo momento.en todo momento.

Cuando un proceso tiene que esperar, el Cuando un proceso tiene que esperar, el sistema operativo le quita la CPU a ese sistema operativo le quita la CPU a ese proceso y se la da a otro proceso que se proceso y se la da a otro proceso que se la merezca más.la merezca más.

De esto se encarga el De esto se encarga el planificadorplanificador..

6

Los procesos de LinuxLos procesos de Linux

LINUXLINUX es un es un sistema multiproceso.sistema multiproceso. Debe llevar cuentas de los procesos en sí y de Debe llevar cuentas de los procesos en sí y de

los recursos del sistema que está usando, de los recursos del sistema que está usando, de manera que pueda gestionarlos justamente.manera que pueda gestionarlos justamente.

Usa varias estrategias de organización del Usa varias estrategias de organización del tiempo de la CPU para asegurar un reparto tiempo de la CPU para asegurar un reparto justo.justo.

LINUXLINUX soporta procesos soporta procesos normalesnormales y de y de tiempo tiempo realreal, los cuales deben reaccionar muy , los cuales deben reaccionar muy rápidamente a sucesos y reciben un trato rápidamente a sucesos y reciben un trato diferente del planificador.diferente del planificador.

7


Linux representa cada proceso por una Linux representa cada proceso por una estructura de datos estructura de datos task_structtask_struct..

El vector El vector tasktask es una lista de punteros a es una lista de punteros a estructuras estructuras task_structtask_struct en el sistema. en el sistema.

Para encontrar fácilmente el proceso en Para encontrar fácilmente el proceso en ejecución, hay un puntero (ejecución, hay un puntero (currentcurrent) que ) que apunta a este proceso.apunta a este proceso.

8


Los campos de la estructura Los campos de la estructura task_structtask_struct se pueden dividir en áreas funcionales: se pueden dividir en áreas funcionales:

• Información de EstadoInformación de Estado: a medida que un : a medida que un proceso se ejecuta, su proceso se ejecuta, su estadoestado cambia según cambia según las circunstancias. Estos pueden ser las circunstancias. Estos pueden ser running, waiting, stopped y zombie.running, waiting, stopped y zombie.

• Información de la Planificación de Información de la Planificación de Tiempo de la CPU:Tiempo de la CPU: necesaria para decidir necesaria para decidir qué proceso se ejecuta a continuación.qué proceso se ejecuta a continuación.

• Identificadores:Identificadores: de proceso, usuario y de proceso, usuario y grupo.grupo.

9


• Enlaces: Enlaces: punteros a los procesos padre, punteros a los procesos padre, hermanos e hijos.hermanos e hijos.

• Tiempos y TemporizadoresTiempos y Temporizadores: hora de : hora de creación del proceso, consumo de CPU y creación del proceso, consumo de CPU y temporizadores.temporizadores.

• Sistema de FicherosSistema de Ficheros: punteros a los : punteros a los descriptores de cada fichero abierto por el descriptores de cada fichero abierto por el proceso.proceso.

• Contexto Específico del ProcesadorContexto Específico del Procesador: : todos los procesos utilizan los registros, la todos los procesos utilizan los registros, la pila, etc, pero cada uno con valores propios, pila, etc, pero cada uno con valores propios, susu “contexto” “contexto”..

10

Planificación de procesosPlanificación de procesos Cada proceso decide dejar la CPU que está Cada proceso decide dejar la CPU que está

usando cuando tiene que esperar algún usando cuando tiene que esperar algún suceso en el sistema: el proceso será suceso en el sistema: el proceso será suspendido y se seleccionará a otro para suspendido y se seleccionará a otro para ejecutarse. ejecutarse.

El El planificadorplanificador tiene que elegir el proceso que tiene que elegir el proceso que más merece ejecutarse entre todos los más merece ejecutarse entre todos los procesos que se pueden ejecutar en el procesos que se pueden ejecutar en el sistema.sistema.

Cuando se ha elegido un nuevo proceso para Cuando se ha elegido un nuevo proceso para ejecutar, el planificador salva el contexto del ejecutar, el planificador salva el contexto del proceso en curso y luego restaura el estado proceso en curso y luego restaura el estado del nuevo proceso y le da control del sistema.del nuevo proceso y le da control del sistema.

11

Planificación de procesosPlanificación de procesos

La información almacenada por el La información almacenada por el sistema para realizar la planificación de sistema para realizar la planificación de procesos es la siguiente:procesos es la siguiente:

• policy:policy: política de planificación que se política de planificación que se aplicará a este proceso. aplicará a este proceso.

• prioritypriority: prioridad estática del proceso. : prioridad estática del proceso. • rt_priority:rt_priority: prioridad de tiempo real. prioridad de tiempo real.• countercounter: : cuanto de tiempo que falta por cuanto de tiempo que falta por

consumir.consumir.

12

Planificación de procesosPlanificación de procesos En Linux hay dos tipos de procesos, En Linux hay dos tipos de procesos,

normales y de tiempo real: si hay un normales y de tiempo real: si hay un proceso de tiempo real preparado, proceso de tiempo real preparado, siempre se ejecutará primero.siempre se ejecutará primero.

Los procesos normales Los procesos normales ((SCHED_OTHERSCHED_OTHER)) se planifican en base al valor actual de se planifican en base al valor actual de su campo su campo countercounter: en cada instante se : en cada instante se ejecuta el que mayor valor de ejecuta el que mayor valor de countercounter tiene.tiene.

Los procesos de Los procesos de tiempo realtiempo real pueden pueden tener dos tipos de políticas: tener dos tipos de políticas: FIFOFIFO y y Round Robin.Round Robin.

13

Planificación de procesosPlanificación de procesos SCHED_RR: SCHED_RR: cada proceso de tiempo real se cada proceso de tiempo real se

ejecuta por turnos. ejecuta por turnos. Cuando a un proceso se le Cuando a un proceso se le acaba su rodaja de tiempo, abandona el acaba su rodaja de tiempo, abandona el procesador.procesador.

SCHED_FIFO:SCHED_FIFO: cada proceso se ejecuta en el cada proceso se ejecuta en el orden que están en la cola de ejecución. Y sin orden que están en la cola de ejecución. Y sin tener en cuenta su rodaja de tiempo tener en cuenta su rodaja de tiempo se se ejecutará hasta que:ejecutará hasta que:

• Se bloquee al necesitar esperar por la finalización Se bloquee al necesitar esperar por la finalización de una operación de E/S.de una operación de E/S.

• El procesador sea solicitado por otro proceso en El procesador sea solicitado por otro proceso en tiempo real con una prioridad mayor.tiempo real con una prioridad mayor.

• El proceso ceda voluntariamente el procesador El proceso ceda voluntariamente el procesador utilizando la primitiva sched_yield.utilizando la primitiva sched_yield.

14

Planificación de procesosPlanificación de procesos

La estructura de datos del núcleo que La estructura de datos del núcleo que representa un proceso es representa un proceso es struct task_structstruct task_struct definida en el fichero definida en el fichero <linux/shed.h><linux/shed.h>..

Linux utiliza un tabla de procesos compuesta Linux utiliza un tabla de procesos compuesta por este tipo de estructuras llamada por este tipo de estructuras llamada tasktask::

16517 extern struct task_struct *task[NR_TASKS];16517 extern struct task_struct *task[NR_TASKS];

Cada proceso tiene asignado un identificador Cada proceso tiene asignado un identificador mediante el cual se obtiene su entrada mediante el cual se obtiene su entrada correspondiente en la tabla.correspondiente en la tabla.

15

Tabla de procesos: ( 1 )

»» struct_task struct * struct_task struct * next_tasknext_task Puntero al siguiente proceso en la lista.Puntero al siguiente proceso en la lista.

»» struct_task struct * struct_task struct * prev_taskprev_task Puntero al anterior proceso en la lista.Puntero al anterior proceso en la lista.

»» struct_task struct * struct_task struct * next_run next_run Puntero al siguiente proceso en la lista de Puntero al siguiente proceso en la lista de

procesos procesos preparados.preparados.

»» struct_task struct * struct_task struct * prev_run prev_run Puntero al anterior proceso en la lista de Puntero al anterior proceso en la lista de

procesos procesos preparados.preparados.

»» struct_task struct * p_pptr, p_opptr, struct_task struct * p_pptr, p_opptr, Punteros a los procesos padre, padre original, Punteros a los procesos padre, padre original,

p_ysptr, p_cptr, p_osptrp_ysptr, p_cptr, p_osptr hermano mas reciente, hijo más reciente y hermano mas reciente, hijo más reciente y

hermano hermano más antiguo.más antiguo.

»» int pid int pid Identificador del proceso.Identificador del proceso.

»» unsigned short unsigned shortuid, euid, gid, egid, …uid, euid, gid, egid, … Identificadores de usuario (real y efectivo), grupo, ...Identificadores de usuario (real y efectivo), grupo, ...

»» volatile long statevolatile long state Estado del proceso.Estado del proceso.

»» long counterlong counter Número de ciclos de reloj durante los que está Número de ciclos de reloj durante los que está

autorizado a ejecutarse.autorizado a ejecutarse.»» unsigned shorttimeoutunsigned shorttimeout Máximo tiempo de espera en estado de EsperaMáximo tiempo de espera en estado de Espera

16

Tabla de procesos: (2)

»» unsigned shortpolicy unsigned shortpolicy Política de planificación asociada al proceso.Política de planificación asociada al proceso.

»» long prioritylong priority Prioridad estática del proceso.Prioridad estática del proceso.

»» unsigned short rt_priorityunsigned short rt_priority Prioridad estática para procesos en tiempo real.Prioridad estática para procesos en tiempo real.

»» unsigned long signalunsigned long signal Señales en espera.Señales en espera.

»» struct signal_struct *struct signal_struct *sigsig Puntero a los descriptores de las acciones asociadas a Puntero a los descriptores de las acciones asociadas a

las señales.las señales.

»» unsigned long unsigned long blockedblocked Señales ocultas.Señales ocultas.

»» int exit signalint exit signal Código de la señal a enviar al padre al finalizar.Código de la señal a enviar al padre al finalizar.

»» int exit codeint exit code Código a devolver al padre: bits(0..7): número de la Código a devolver al padre: bits(0..7): número de la

señal que provocó el final del proceso bits(8..15): señal que provocó el final del proceso bits(8..15):

código devuelto por la primitiva _exit.código devuelto por la primitiva _exit.

»» struct wait_queue * struct wait_queue * wait_chldexitwait_chldexit Variable utilizada para esperar la finalización de un Variable utilizada para esperar la finalización de un

proceso hijo.proceso hijo.

»» int errnoint errno Variable global donde las llamadas al sistema Variable global donde las llamadas al sistema

colocan colocan el código de error que generan.el código de error que generan.

17

Tabla de procesos: (3)»» long utime, stime, cutime, cstime long utime, stime, cutime, cstime Tiempos consumidos por el proceso y por sus hijos en Tiempos consumidos por el proceso y por sus hijos en

modo usuario y modo núcleo.modo usuario y modo núcleo.

»» int:1 int:1 dumpabledumpable Indica si se debe crear un fichero CORE en caso de Indica si se debe crear un fichero CORE en caso de

error fatal.error fatal.

»» int:1 swappableint:1 swappable Indica si el proceso se puede guardar en memoria Indica si el proceso se puede guardar en memoria

secundaria.secundaria.

»» long[8] debugreglong[8] debugreg Copia de los registros hardware para depuraciónCopia de los registros hardware para depuración

»» struct desc_struct * struct desc_struct * ldtldt Puntero a la tabla de segmentos local del proceso Puntero a la tabla de segmentos local del proceso

»» struct thread_struct * struct thread_struct * tsstss Puntero a una estructura donde se guarda el valor de Puntero a una estructura donde se guarda el valor de

los registros del procesador.los registros del procesador.

»» struct mm_struct * struct mm_struct * mmmm Información de control para la gestión de la memoria.Información de control para la gestión de la memoria.

»» struct files_struct * struct files_struct * filesfiles Puntero a los descriptores de ficheros abiertos por el Puntero a los descriptores de ficheros abiertos por el

proceso.proceso.

»» struct fs_struct * fs struct fs_struct * fs Información de control para el acceso a ficheros.Información de control para el acceso a ficheros.

»» struct tty_struct * struct tty_struct * ttytty Puntero al terminal asociado al proceso.Puntero al terminal asociado al proceso.

18


La lista La lista tarray_freelisttarray_freelist, mantiene una lista , mantiene una lista de las posiciones libres en el vector de las posiciones libres en el vector tasktask::

16519 extern struct task_struct ** tarray_freelist;16519 extern struct task_struct ** tarray_freelist;

El array El array pidhashpidhash ayuda a mapear PIDs a ayuda a mapear PIDs a punteros a estructuras del tipo punteros a estructuras del tipo struct struct task_structtask_struct::

16546 extern struct task_struct * pidhash[PIDHASH_SZ];16546 extern struct task_struct * pidhash[PIDHASH_SZ];

19

Los procesos de LinuxLos procesos de Linux Las tareas forman una lista circular, Las tareas forman una lista circular,

doblemente encadenada llamada doblemente encadenada llamada lista de lista de tareastareas, utilizando los campos , utilizando los campos next_tasknext_task y y prev_taskprev_task de la estructura. de la estructura.

Esta lista se utiliza para recorrer Esta lista se utiliza para recorrer rápidamente todas las tareas actuales en rápidamente todas las tareas actuales en el sistema evitándonos los slots vacíos el sistema evitándonos los slots vacíos del vector del vector tasktask..

Linux proporciona la siguiente macro Linux proporciona la siguiente macro para realizar el recorrido de la lista:para realizar el recorrido de la lista:

16898 16898 #define for_each_task(p)\#define for_each_task(p)\16899 16899 for(p=&init_task; (p = p->next_task) != &init_task;)for(p=&init_task; (p = p->next_task) != &init_task;)

20

Los procesos de LinuxLos procesos de Linux Linux guarda otra lista circular doblemente Linux guarda otra lista circular doblemente

encadenada de tareas llamada encadenada de tareas llamada run_queue, run_queue, utilizando los campos utilizando los campos prev_runprev_run y y next_runnext_run..

Las tareas se añaden y eliminan de la cola Las tareas se añaden y eliminan de la cola usando las funciones usando las funciones add_to_runqueue add_to_runqueue y y del_from_runqueuedel_from_runqueue definidas en definidas en <linux/shed.c><linux/shed.c>..

Si es necesario mover procesos entre el inicio Si es necesario mover procesos entre el inicio y el final de la cola, se usan las funciones y el final de la cola, se usan las funciones move_first_runqueuemove_first_runqueue y y move_last_runqueue.move_last_runqueue.

Se utiliza Se utiliza init_taskinit_task para indicar el comienzo y para indicar el comienzo y final de las listas.final de las listas.

21

Los procesos de LinuxLos procesos de Linux• Algunas líneas interesantes del fichero Algunas líneas interesantes del fichero

<linux/shed.h><linux/shed.h> son las siguientes: son las siguientes: 16177 extern int nr_running, nr_tasks;16177 extern int nr_running, nr_tasks;16178 extern int last_pid;16178 extern int last_pid;16188 #define TASK_RUNNING 16188 #define TASK_RUNNING 0016189 #define TASK_INTERRUPTIBLE 16189 #define TASK_INTERRUPTIBLE 1116190 #define TASK_UNINTERRUPTIBLE 16190 #define TASK_UNINTERRUPTIBLE 2216191 #define TASK_ZOMBIE 16191 #define TASK_ZOMBIE 4416192 #define TASK_STOPPED 16192 #define TASK_STOPPED 8816193 #define TASK_SWAPPING 16193 #define TASK_SWAPPING 161616195 16195 /* Scheduling policies *//* Scheduling policies */16196 #define SCHED_OTHER 16196 #define SCHED_OTHER 0016197 #define SCHED_FIFO 16197 #define SCHED_FIFO 1116198 #define SCHED_RR 16198 #define SCHED_RR 2216200 16200 /* This is an additional bit set when we want to yield/* This is an additional bit set when we want to yield1620116201 * the CPU for one re-schedule.. */ * the CPU for one re-schedule.. */16202 #define SCHED_YIELD 16202 #define SCHED_YIELD 0x100x10

22

Planificación en Linux: Planificación en Linux: PrioridadesPrioridades

Cada proceso tiene una prioridad dada por un Cada proceso tiene una prioridad dada por un entero del 1 al 40, almacenado en el campo entero del 1 al 40, almacenado en el campo priority.priority.

Los procesos en tiempo real además usan el Los procesos en tiempo real además usan el campo “rt_priority”, quecampo “rt_priority”, que tiene un rango entre 0 tiene un rango entre 0 y 99 (un 0 significa que el proceso no es un y 99 (un 0 significa que el proceso no es un proceso de tiempo real).proceso de tiempo real).

Actualmente las funciones que controlan la Actualmente las funciones que controlan la prioridad son prioridad son sys_set_priority sys_set_priority y y sys_nicesys_nice, , aunque esta última está obsoleta.aunque esta última está obsoleta.

23

Planificación en Linux: Planificación en Linux: PrioridadesPrioridades

Tanto las tareas normales como las tareas en Tanto las tareas normales como las tareas en tiempo real usan el campo tiempo real usan el campo counter counter para para estimar las prioridades.estimar las prioridades.

Ambos tipos de procesos usan el campo Ambos tipos de procesos usan el campo counter counter para rellenar su cuanto de tiempo para rellenar su cuanto de tiempo restante.restante.

rt_priority rt_priority se usa sólo para ordenar los se usa sólo para ordenar los procesos en tiempo real por prioridad.procesos en tiempo real por prioridad.

Las funciones Las funciones sched_setscheduler sched_setscheduler yy sched_setparam sched_setparam permiten cambiar la politica permiten cambiar la politica de planificación de un proceso.de planificación de un proceso.

24

Función ScheduleFunción Schedule26686 asmlinkage void schedule(void)26686 asmlinkage void schedule(void)26687 {26687 {26688 struct schedule_data * sched_data;26688 struct schedule_data * sched_data;26689 struct task_struct * prev, * next;26689 struct task_struct * prev, * next;26691266912669226692 /* prev = proceso actual *//* prev = proceso actual */26694 prev = current;26694 prev = current;26712 26712 /* move an exhausted RR process to be last.. *//* move an exhausted RR process to be last.. */26713 prev->need_resched = 0;26713 prev->need_resched = 0;

26714 26714 /* Si counter==0 y es política Round Robin se /* Si counter==0 y es política Round Robin se inicia su counter y se pasa al final de la cola */inicia su counter y se pasa al final de la cola */

26715 26715 if (!prev->counter && prev->policy == SCHED_RR){if (!prev->counter && prev->policy == SCHED_RR){26716 prev->counter = prev->priority;26716 prev->counter = prev->priority;26717 move_last_runqueue(prev);26717 move_last_runqueue(prev);26718 }26718 }

25

Función ScheduleFunción Schedule/* Se eliminan de la cola los procesos que no estén en estado de /* Se eliminan de la cola los procesos que no estén en estado de preparado. Si el proceso es interrumpible y está esperando una señal preparado. Si el proceso es interrumpible y está esperando una señal se pone a preparado*/se pone a preparado*/

26720 switch (prev->state) {26720 switch (prev->state) {26721 case TASK_INTERRUPTIBLE:26721 case TASK_INTERRUPTIBLE:26722 if (signal_pending(prev)) {26722 if (signal_pending(prev)) {26723 prev->state = TASK_RUNNING;26723 prev->state = TASK_RUNNING;26724 break;26724 break;26725 }26725 }26726 default:26726 default:26727 del_from_runqueue(prev);26727 del_from_runqueue(prev);26728 case TASK_RUNNING:26728 case TASK_RUNNING:26729 }26729 }

26

Función ScheduleFunción Schedule/* Nos recorremos la lista de procesos preparados buscando el mejor /* Nos recorremos la lista de procesos preparados buscando el mejor de todos para seleecionarlo */de todos para seleecionarlo */

26733 26733 /* this is the scheduler proper: *//* this is the scheduler proper: */26734 {26734 {2673526735 struct task_struct * p = init_task.next_run; struct task_struct * p = init_task.next_run;26736 int c = -1000;26736 int c = -1000;26757 while (p != &init_task) {26757 while (p != &init_task) {26758 if (can_schedule(p)) {26758 if (can_schedule(p)) {26759 int weight = goodness(p, prev, this_cpu);26759 int weight = goodness(p, prev, this_cpu);26760 if (weight > c)26760 if (weight > c)26761 c = weight, next = p;26761 c = weight, next = p;26762 }26762 }26763 p = p->next_run;26763 p = p->next_run;26764 }26764 }

27

Función ScheduleFunción Schedule26766 26766 /* Si todos los contadores == 0 se recalculan los /* Si todos los contadores == 0 se recalculan los

contadores de todos los procesos*/contadores de todos los procesos*/2676726767 if (!c) { if (!c) {26768 struct task_struct *p;26768 struct task_struct *p;26770 for_each_task(p)26770 for_each_task(p)26771 p->counter = p->priority;26771 p->counter = p->priority;26773 }26773 }26774 }26774 }26775 26775 /* Si el proceso elegido es otro del actual-> CC *//* Si el proceso elegido es otro del actual-> CC */2680126801 if (prev != next) { if (prev != next) { 26804 26804 /* Se incrementa el número de cambios de cont. *//* Se incrementa el número de cambios de cont. */26805 kstat.context_swtch++; 26805 kstat.context_swtch++; 26808 26808 /* Se hace el cambio de contexto *//* Se hace el cambio de contexto */26807 switch_to(prev,next);26807 switch_to(prev,next);26810 }26810 }2681326813 return;return;26818 }26818 }

28

Macro switch_toMacro switch_to/* Se guardan en la pila los registros esi, edi y ebp *//* Se guardan en la pila los registros esi, edi y ebp */1293912939 #define #define switch_toswitch_to(prev,next) do { \ (prev,next) do { \ 1294012940 unsigned long eax, edx, ecx; \ unsigned long eax, edx, ecx; \ 1294112941 asm volatile("pushl %%ebx\n\t" \ asm volatile("pushl %%ebx\n\t" \ 1294212942 "pushl %%esi\n\t" "pushl %%esi\n\t" 1294312943 "pushl %%edi\n\t" \ "pushl %%edi\n\t" \ 1294412944 "pushl %%ebp\n\t" \ "pushl %%ebp\n\t" \

/* Se guarda el puntero de pila en la TSS del proceso*//* Se guarda el puntero de pila en la TSS del proceso*/ 1294512945 "movl %%esp,%0\n\t" "movl %%esp,%0\n\t" /* save ESP *//* save ESP */ \ \

/* Se restaura el nuevo puntero de pila *//* Se restaura el nuevo puntero de pila */1294612946 "movl %5,%%esp\n\t" "movl %5,%%esp\n\t" /* restore ESP *//* restore ESP */ \ \

/* Se guarda la dirección de la etiqueta 1 en el contador de programa/* Se guarda la dirección de la etiqueta 1 en el contador de programadel proceso (para luego retornar ahí */del proceso (para luego retornar ahí */1294712947 "movl $1f,%1\n\t" "movl $1f,%1\n\t" /* save EIP *//* save EIP */ \ \

29

Macro switch_toMacro switch_to/* Se pone en la pila el contador de programa del nuevo proceso/* Se pone en la pila el contador de programa del nuevo proceso (nuevo proceso que va a tomar la CPU) para luego hacer un pop y(nuevo proceso que va a tomar la CPU) para luego hacer un pop y comenzar */comenzar */1294812948 "pushl %6\n\t" /* restore EIP */ \ "pushl %6\n\t" /* restore EIP */ \

/* Se guardan y actualizan los registros de segmento y las tablas de/* Se guardan y actualizan los registros de segmento y las tablas de paginas */paginas */1294912949 "jmp __switch_to\n" \ "jmp __switch_to\n" \ /* Dirección del salto para un nuevo proceso *//* Dirección del salto para un nuevo proceso */1295012950 "1:\t" \ "1:\t" \

/*Se restaurán los registros restantes del nuevo proceso*//*Se restaurán los registros restantes del nuevo proceso*/1295112951 "popl %%ebp\n\t" \ "popl %%ebp\n\t" \ 1295212952 "popl %%edi\n\t" \ "popl %%edi\n\t" \ 1295312953 "popl %%esi\n\t" \ "popl %%esi\n\t" \ 1295412954 "popl %%ebx" \ "popl %%ebx" \ 1295912959 } while (0)} while (0)

30

Función goodnessFunción goodness/*evalúa la prioridad de los/*evalúa la prioridad de los candidatos candidatos a ser ejecutados a a ser ejecutados acontinuación*/continuación*/

26388 26388 static inline int goodness(struct task_struct * p,static inline int goodness(struct task_struct * p,26389 26389 struct task_struct * prev, int this_cpu)struct task_struct * prev, int this_cpu)26390 {26390 {26391 int policy = p->policy;26391 int policy = p->policy;26392 int weight;26392 int weight;26393 26393 /* Se reinicia el flag SCHED_YIELD *//* Se reinicia el flag SCHED_YIELD */26394 if (policy & SCHED_YIELD) {26394 if (policy & SCHED_YIELD) {26395 p->policy = policy & ~SCHED_YIELD;26395 p->policy = policy & ~SCHED_YIELD;26396 return 0;26396 return 0;26397 }26397 }

31

Función goodnessFunción goodness/* Si es un proceso de tiempo real se le aumenta su goodness en 1000/* Si es un proceso de tiempo real se le aumenta su goodness en 1000para darle prioridad*/para darle prioridad*/26402 if (policy != SCHED_OTHER)26402 if (policy != SCHED_OTHER)26403 return 1000 + p->rt_priority;26403 return 1000 + p->rt_priority;

26411 weight = p->counter;26411 weight = p->counter;

/* Si el proceso comparte zonas de memoria con el anterior ejecutado/* Si el proceso comparte zonas de memoria con el anterior ejecutadose aumenta su goodness. */se aumenta su goodness. */26412 if (weight) {26412 if (weight) {26423 if (p->mm == prev->mm)26423 if (p->mm == prev->mm)26424 weight += 1;26424 weight += 1;26425 weight += p->priority;26425 weight += p->priority;26426 }26426 }26427 26427 26428 return weight;26428 return weight;26429 }26429 }

32

Otras funcionesOtras funciones

Existen un conjunto de funciones que Existen un conjunto de funciones que manipulan procesos dentro de la cola de manipulan procesos dentro de la cola de ejecución. Algunas de estas funciones son las ejecución. Algunas de estas funciones son las siguientes:siguientes:

• move_first_runqueuemove_first_runqueue: mueve el proceso pasado : mueve el proceso pasado por parámetro al principio de la cola de ejecuciónpor parámetro al principio de la cola de ejecución

• move_last_runqueuemove_last_runqueue: igual pero al final de la cola.: igual pero al final de la cola.• add_to_runqueueadd_to_runqueue: añade un proceso al comienzo : añade un proceso al comienzo

de la cola de ejecuciónde la cola de ejecución• del_from_runqueuedel_from_runqueue: :

33

Otras funcionesOtras funciones/* Devuelve verdadero si el proceso tiene una señal pendiente/* Devuelve verdadero si el proceso tiene una señal pendiente

observando el campo sigpending de la estructura task_struct */observando el campo sigpending de la estructura task_struct */

16644 extern inline int signal_pending(struct task_struct * p)16644 extern inline int signal_pending(struct task_struct * p)

16645 {16645 {

16646 return (p->sigpending != 0);16646 return (p->sigpending != 0);

16647 }16647 }

34

Otras funcionesOtras funciones/*Esta función modifica el nivel de prioridad de un proceso*//*Esta función modifica el nivel de prioridad de un proceso*/

/* who: Identificador /* who: Identificador which: Tipo de identificador: un proceso, un grupo de which: Tipo de identificador: un proceso, un grupo de procesos o todos los procesos de un usuarioprocesos o todos los procesos de un usuario niceval: Incremento de la prioridad (-20..19)niceval: Incremento de la prioridad (-20..19)*/*/29213 asmlinkage int sys_setpriority(int which, int who,int niceval) 29213 asmlinkage int sys_setpriority(int which, int who,int niceval) 29214 29214 29215 {29215 {29216 struct task_struct *p;29216 struct task_struct *p;29217 unsigned int priority;29217 unsigned int priority;29218 int error; 29218 int error; 2921929219

35

Otras funcionesOtras funciones/* Comprueba que es un tipo de identificador válido*//* Comprueba que es un tipo de identificador válido*/

29220 if (which > 2 || which < 0) 29220 if (which > 2 || which < 0)

29221 return -EINVAL;29221 return -EINVAL;

29225 error = ESRCH;29225 error = ESRCH;

/* Codigo reescrito por claridad. /* Codigo reescrito por claridad. Se normaliza niceval entre 1 y Se normaliza niceval entre 1 y 40*/40*/

if (niceval < -19)if (niceval < -19)

priority = 40;priority = 40;

elseelse

if (niceval > 19)if (niceval > 19)

priority = 1;priority = 1;

elseelse

priority = 20 – niceval;priority = 20 – niceval;

/* Codigo reescrito por claridad *//* Codigo reescrito por claridad */

36

Otras funcionesOtras funciones/* Se busca en las tareas del sistema cuales satisfacen las condiciones/* Se busca en las tareas del sistema cuales satisfacen las condiciones

“ “who” y “which” y modifica sus prioridades si se tienen los permisos who” y “which” y modifica sus prioridades si se tienen los permisos correspondientes.*/correspondientes.*/

2924029240

29241 for_each_task(p) {29241 for_each_task(p) {

29242 if (!proc_sel(p, which, who))29242 if (!proc_sel(p, which, who))

29243 continue;29243 continue;

/* Se miran los permisos *//* Se miran los permisos */

29254 p->priority = priority;29254 p->priority = priority;

29255 }29255 }

29258 return -error;29258 return -error;

29259 }29259 }

/*Esta función devuelve la mayor de las prioridades de los procesos./*Esta función devuelve la mayor de las prioridades de los procesos.

Es analoga a la anterior.*/Es analoga a la anterior.*/

29265 asmlinkage int sys_getpriority(int which, int who) 29265 asmlinkage int sys_getpriority(int which, int who)

37

Otras funcionesOtras funciones/*Esta función permite cambiar la política de planificación y/o/*Esta función permite cambiar la política de planificación y/o parámetros de la misma.*/parámetros de la misma.*/

27618 static int setscheduler(pid_t pid, int policy,27618 static int setscheduler(pid_t pid, int policy,27619 struct sched_param *param)27619 struct sched_param *param)27620 {27620 {

pid: el proceso objetivo, 0 significa proceso actual policy: la nueva pid: el proceso objetivo, 0 significa proceso actual policy: la nueva política de planificaciónpolítica de planificación

param: un struct que contiene información adicional (el param: un struct que contiene información adicional (el nuevo valor para rt_priority).nuevo valor para rt_priority).*/*/

27621 struct sched_param lp;27621 struct sched_param lp;27622 struct task_struct *p;27622 struct task_struct *p;

38

Otras funcionesOtras funciones/* Se copian los parametros de la zona de usuario *//* Se copian los parametros de la zona de usuario */27630 copy_from_user(&lp, param,27630 copy_from_user(&lp, param,27631 sizeof(struct sched_param)))27631 sizeof(struct sched_param)))

/* Se buca el proceso a modificar *//* Se buca el proceso a modificar */27639 p = find_process_by_pid(pid);27639 p = find_process_by_pid(pid);

/* ¿Se deja la misma política o se debe modificar? *//* ¿Se deja la misma política o se debe modificar? */27645 if (policy < 0)27645 if (policy < 0)27646 policy = p->policy;27646 policy = p->policy;

/* Se comprueba que el proceso tiene permisos para cambiar su/* Se comprueba que el proceso tiene permisos para cambiar su politica de planificación */politica de planificación */

/* Se actualizan los campos *//* Se actualizan los campos */27672 p->policy = policy;27672 p->policy = policy;27673 p->rt_priority = lp.sched_priority;27673 p->rt_priority = lp.sched_priority;

39

Otras funcionesOtras funciones/* Si es un proceso preparado se mueve al principio *//* Si es un proceso preparado se mueve al principio */

27674 if (p->next_run)27674 if (p->next_run)

27675 move_first_runqueue(p);27675 move_first_runqueue(p);

/* Se indica que se ha de replanificar *//* Se indica que se ha de replanificar */

2767727677 current->need_resched = 1;current->need_resched = 1;

27685 return retval;27685 return retval;

27686 }27686 }

40

Otras funcionesOtras funciones/* Esta función comprueba si el proceso pasado por parámetro es más/* Esta función comprueba si el proceso pasado por parámetro es másprioritario que el actual. Si es así habrá que replanificar el acceso alprioritario que el actual. Si es así habrá que replanificar el acceso alprocesador.*/procesador.*/

26221 static inline void reschedule_idle(26221 static inline void reschedule_idle(26222 struct task_struct * p)26222 struct task_struct * p)26223 {26223 {26224 26224 /* Si es proceso en tiempo real o tiene más cuanto de tiempo por/* Si es proceso en tiempo real o tiene más cuanto de tiempo por consumir que el actual hay que replanificar */consumir que el actual hay que replanificar */26225 if (p->policy != SCHED_OTHER ||26225 if (p->policy != SCHED_OTHER ||26226 p->counter > current->counter + 3) {26226 p->counter > current->counter + 3) {26227 current->need_resched = 1;26227 current->need_resched = 1;26228 return;26228 return;26229 }26229 }26269 }26269 }

41

Otras funcionesOtras funciones/*Esta función despierta un proceso estableciendo el estado a /*Esta función despierta un proceso estableciendo el estado a RUNNING. Si no está en lista de ejecución lo añade.*/RUNNING. Si no está en lista de ejecución lo añade.*/

26356 void wake_up_process(struct task_struct * p)26356 void wake_up_process(struct task_struct * p)26357 {26357 {26358 unsigned long flags;26358 unsigned long flags;

/* Se pone el estado a TASK_RUNNING *//* Se pone el estado a TASK_RUNNING */26361 p->state = TASK_RUNNING;26361 p->state = TASK_RUNNING;

/* Si no está en la cola lo añade *//* Si no está en la cola lo añade */26362 if (!p->next_run) {26362 if (!p->next_run) {26363 add_to_runqueue(p);26363 add_to_runqueue(p);26364 reschedule_idle(p);26364 reschedule_idle(p);26365 }26365 }26367 }26367 }

42

Otras funcionesOtras funciones/*Esta función actualiza el cuanto de tiempo restante de un proceso y/*Esta función actualiza el cuanto de tiempo restante de un proceso y sus campos de contabilidad.*/sus campos de contabilidad.*/

27382 static void update_process_times(unsigned long ticks, unsigned 27382 static void update_process_times(unsigned long ticks, unsigned long system)long system)

27384 {27384 {27387 struct task_struct * p = current;27387 struct task_struct * p = current;27388 unsigned long user = ticks - system;27388 unsigned long user = ticks - system;

/* Se actualiza el cuanto de tiempo *//* Se actualiza el cuanto de tiempo */2739027390p->counter -= ticks;p->counter -= ticks;

/* Si el contador ha expirado se pone a 0 y se manda a replanificar *//* Si el contador ha expirado se pone a 0 y se manda a replanificar */27391 if (p->counter < 0) {27391 if (p->counter < 0) {27392 p->counter = 0;27392 p->counter = 0;27393 p->need_resched = 1;27393 p->need_resched = 1;27400 }27400 }

/* Se actualizan los campos de contabilidad del proceso *//* Se actualizan los campos de contabilidad del proceso */27401 update_one_process(p, ticks, user, system, 0);27401 update_one_process(p, ticks, user, system, 0);27403 }27403 }

1 diseño de sistemas operativos planificador de procesos (scheduler) abián izquierdo montesdeoca...

Documents