Dise

1

• Diseño de Sistemas Operativos
• Planificador de Procesos
• (Scheduler)

Abián Izquierdo Montesdeoca Eduardo J. Delgado
Mateo
2
Introducción a los procesos

• Un programa es un conjunto de instrucciones de
  código máquina y datos guardados en disco en una
  imagen ejecutable y como tal, es una entidad
  pasiva.
• Un proceso es un programa en ejecución,
  incluyendo su contador de programa y los
  registros de la CPU así como la pila para datos
  temporales y parámetros de las rutinas,
  direcciones de retorno y variables salvadas.

3
Introducción a los procesos

• Un proceso consume muchos recursos del sistema,
  los más importantes son
• CPU, para ejecutar sus instrucciones.
• Memoria física, para almacenar al propio proceso
  y sus datos.
• Ficheros y otros dispositivos del sistema.
• El recurso más preciado en el sistema es la CPU y
  normalmente sólo hay una.

4
Introducción a los procesos

• Un sistema multiproceso mantiene muchos procesos
  en memoria simultáneamente y uno se ejecuta hasta
  que tenga que esperar, normalmente por algún
  recurso del sistema.
• Estos procesos son tareas independientes. Si un
  proceso se desploma, no hará que otros procesos
  en el sistema fallen también.
• Cada proceso se ejecuta en su propio espacio de
  memoria virtual sin interaccionar con otros
  procesos, excepto a través de mecanismos del
  núcleo.

5
Introducción a los procesos

• El objetivo es tener un proceso ejecutándose en
  cada CPU del sistema en todo momento.
• Cuando un proceso tiene que esperar, el sistema
  operativo le quita la CPU a ese proceso y se la
  da a otro proceso que se la merezca más.
• De esto se encarga el planificador.

6
Los procesos de Linux

• LINUX es un sistema multiproceso.
• Debe llevar cuentas de los procesos en sí y de
  los recursos del sistema que está usando, de
  manera que pueda gestionarlos justamente.
• Usa varias estrategias de organización del tiempo
  de la CPU para asegurar un reparto justo.
• LINUX soporta procesos normales y de tiempo real,
  los cuales deben reaccionar muy rápidamente a
  sucesos y reciben un trato diferente del
  planificador.

7
Los procesos de Linux

• Linux representa cada proceso por una estructura
  de datos task_struct.
• El vector task es una lista de punteros a
  estructuras task_struct en el sistema.
• Para encontrar fácilmente el proceso en
  ejecución, hay un puntero (current) que apunta a
  este proceso.

8
Los procesos de Linux

• Los campos de la estructura task_struct se pueden
  dividir en áreas funcionales
• Información de Estado a medida que un proceso se
  ejecuta, su estado cambia según las
  circunstancias. Estos pueden ser running,
  waiting, stopped y zombie.
• Información de la Planificación de Tiempo de la
  CPU necesaria para decidir qué proceso se
  ejecuta a continuación.
• Identificadores de proceso, usuario y grupo.

9
Los procesos de Linux

• Enlaces punteros a los procesos padre, hermanos
  e hijos.
• Tiempos y Temporizadores hora de creación del
  proceso, consumo de CPU y temporizadores.
• Sistema de Ficheros punteros a los descriptores
  de cada fichero abierto por el proceso.
• Contexto Específico del Procesador todos los
  procesos utilizan los registros, la pila, etc,
  pero cada uno con valores propios, su contexto.

10
Planificación de procesos

• Cada proceso decide dejar la CPU que está usando
  cuando tiene que esperar algún suceso en el
  sistema el proceso será suspendido y se
  seleccionará a otro para ejecutarse.
• El planificador tiene que elegir el proceso que
  más merece ejecutarse entre todos los procesos
  que se pueden ejecutar en el sistema.
• Cuando se ha elegido un nuevo proceso para
  ejecutar, el planificador salva el contexto del
  proceso en curso y luego restaura el estado del
  nuevo proceso y le da control del sistema.

11
Planificación de procesos

• La información almacenada por el sistema para
  realizar la planificación de procesos es la
  siguiente
• policy política de planificación que se aplicará
  a este proceso.
• priority prioridad estática del proceso.
• rt_priority prioridad de tiempo real.
• counter cuanto de tiempo que falta por consumir.

12
Planificación de procesos

• En Linux hay dos tipos de procesos, normales y de
  tiempo real si hay un proceso de tiempo real
  preparado, siempre se ejecutará primero.
• Los procesos normales (SCHED_OTHER) se planifican
  en base al valor actual de su campo counter en
  cada instante se ejecuta el que mayor valor de
  counter tiene.
• Los procesos de tiempo real pueden tener dos
  tipos de políticas FIFO y Round Robin.

13
Planificación de procesos

• SCHED_RR cada proceso de tiempo real se ejecuta
  por turnos. Cuando a un proceso se le acaba su
  rodaja de tiempo, abandona el procesador.
• SCHED_FIFO cada proceso se ejecuta en el orden
  que están en la cola de ejecución. Y sin tener en
  cuenta su rodaja de tiempo se ejecutará hasta
  que
• Se bloquee al necesitar esperar por la
  finalización de una operación de E/S.
• El procesador sea solicitado por otro proceso en
  tiempo real con una prioridad mayor.
• El proceso ceda voluntariamente el procesador
  utilizando la primitiva sched_yield.

14
Planificación de procesos

• La estructura de datos del núcleo que representa
  un proceso es struct task_struct definida en el
  fichero ltlinux/shed.hgt.
• Linux utiliza un tabla de procesos compuesta por
  este tipo de estructuras llamada task
• 16517 extern struct task_struct taskNR_TASKS
• Cada proceso tiene asignado un identificador
  mediante el cual se obtiene su entrada
  correspondiente en la tabla.

15
Tabla de procesos ( 1 )

• struct_task struct next_task Puntero al
  siguiente proceso en la lista.
• struct_task struct prev_task Puntero al
  anterior proceso en la lista.
• struct_task struct next_run Puntero al
  siguiente proceso en la lista de procesos
  preparados.
• struct_task struct prev_run Puntero al
  anterior proceso en la lista de procesos
  preparados.
• struct_task struct p_pptr, p_opptr, Punteros
  a los procesos padre, padre original,
• p_ysptr, p_cptr, p_osptr hermano mas
  reciente, hijo más reciente y hermano más
  antiguo.
• int pid Identificador del proceso.
• unsigned shortuid, euid, gid, egid,
  Identificadores de usuario (real y efectivo),
  grupo, ...
• volatile long state Estado del proceso.
• long counter Número de ciclos de reloj
  durante los que está autorizado a ejecutarse.
• unsigned shorttimeout Máximo tiempo de espera
  en estado de Espera

16
Tabla de procesos (2)

• unsigned shortpolicy Política de planificación
  asociada al proceso.
• long priority Prioridad estática del proceso.
• unsigned short rt_priority Prioridad estática
  para procesos en tiempo real.
• unsigned long signal Señales en espera.
• struct signal_struct sig Puntero a los
  descriptores de las acciones asociadas a las
  señales.
• unsigned long blocked Señales ocultas.
• int exit signal Código de la señal a enviar
  al padre al finalizar.
• int exit code Código a devolver al padre
  bits(0..7) número de la señal que provocó el
  final del proceso bits(8..15) código
  devuelto por la primitiva _exit.
• struct wait_queue wait_chldexit Variable
  utilizada para esperar la finalización de un
  proceso hijo.
• int errno Variable global donde las llamadas
  al sistema colocan el código de error que
  generan.

17
Tabla de procesos (3)

• long utime, stime, cutime, cstime Tiempos
  consumidos por el proceso y por sus hijos en
  modo usuario y modo núcleo.
• int1 dumpable Indica si se debe crear un
  fichero CORE en caso de error fatal.
• int1 swappable Indica si el proceso se puede
  guardar en memoria secundaria.
• long8 debugreg Copia de los registros
  hardware para depuración
• struct desc_struct ldt Puntero a la tabla de
  segmentos local del proceso
• struct thread_struct tss Puntero a una
  estructura donde se guarda el valor de los
  registros del procesador.
• struct mm_struct mm Información de control
  para la gestión de la memoria.
• struct files_struct files Puntero a los
  descriptores de ficheros abiertos por el
  proceso.
• struct fs_struct fs Información de control
  para el acceso a ficheros.
• struct tty_struct tty Puntero al terminal
  asociado al proceso.

18
Los procesos de Linux

• La lista tarray_freelist, mantiene una lista de
  las posiciones libres en el vector task
• 16519 extern struct task_struct
  tarray_freelist
• El array pidhash ayuda a mapear PIDs a punteros a
  estructuras del tipo struct task_struct
• 16546 extern struct task_struct
  pidhashPIDHASH_SZ

19
Los procesos de Linux

• Las tareas forman una lista circular, doblemente
  encadenada llamada lista de tareas, utilizando
  los campos next_task y prev_task de la
  estructura.
• Esta lista se utiliza para recorrer rápidamente
  todas las tareas actuales en el sistema
  evitándonos los slots vacíos del vector task.
• Linux proporciona la siguiente macro para
  realizar el recorrido de la lista
• 16898 define for_each_task(p)\
• 16899 for(pinit_task (p p-gtnext_task) !
  init_task)

20
Los procesos de Linux

• Linux guarda otra lista circular doblemente
  encadenada de tareas llamada run_queue,
  utilizando los campos prev_run y next_run.
• Las tareas se añaden y eliminan de la cola usando
  las funciones add_to_runqueue y del_from_runqueue
  definidas en ltlinux/shed.cgt.
• Si es necesario mover procesos entre el inicio y
  el final de la cola, se usan las funciones
  move_first_runqueue y move_last_runqueue.
• Se utiliza init_task para indicar el comienzo y
  final de las listas.

21
Los procesos de Linux

• Algunas líneas interesantes del fichero
  ltlinux/shed.hgt son las siguientes
• 16177 extern int nr_running, nr_tasks
• 16178 extern int last_pid
• 16188 define TASK_RUNNING 0
• 16189 define TASK_INTERRUPTIBLE 1
• 16190 define TASK_UNINTERRUPTIBLE 2
• 16191 define TASK_ZOMBIE 4
• 16192 define TASK_STOPPED 8
• 16193 define TASK_SWAPPING 16
• 16195 / Scheduling policies /
• 16196 define SCHED_OTHER 0
• 16197 define SCHED_FIFO 1
• 16198 define SCHED_RR 2
• 16200 / This is an additional bit set when we
  want to yield
• 16201 the CPU for one re-schedule.. /
• 16202 define SCHED_YIELD 0x10

22
Planificación en Linux Prioridades

• Cada proceso tiene una prioridad dada por un
  entero del 1 al 40, almacenado en el campo
  priority.
• Los procesos en tiempo real además usan el campo
  rt_priority, que tiene un rango entre 0 y 99
  (un 0 significa que el proceso no es un proceso
  de tiempo real).
• Actualmente las funciones que controlan la
  prioridad son sys_set_priority y sys_nice, aunque
  esta última está obsoleta.

23
Planificación en Linux Prioridades

• Tanto las tareas normales como las tareas en
  tiempo real usan el campo counter para estimar
  las prioridades.
• Ambos tipos de procesos usan el campo counter
  para rellenar su cuanto de tiempo restante.
• rt_priority se usa sólo para ordenar los procesos
  en tiempo real por prioridad.
• Las funciones sched_setscheduler y sched_setparam
  permiten cambiar la politica de planificación de
  un proceso.

24
Función Schedule

• 26686 asmlinkage void schedule(void)
• 26687
• 26688 struct schedule_data sched_data
• 26689 struct task_struct prev, next
• 26691
• 26692 / prev proceso actual /
• 26694 prev current
• 26712 / move an exhausted RR process to be
  last.. /
• 26713 prev-gtneed_resched 0
• 26714 / Si counter0 y es política Round
  Robin se
• inicia su counter y se pasa al final de la cola
  /
• 26715 if (!prev-gtcounter prev-gtpolicy
  SCHED_RR)
• 26716 prev-gtcounter prev-gtpriority
• 26717 move_last_runqueue(prev)
• 26718

25
Función Schedule

• / 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
• se pone a preparado/
• 26720 switch (prev-gtstate)
• 26721 case TASK_INTERRUPTIBLE
• 26722 if (signal_pending(prev))
• 26723 prev-gtstate TASK_RUNNING
• 26724 break
• 26725
• 26726 default
• 26727 del_from_runqueue(prev)
• 26728 case TASK_RUNNING
• 26729

26
Función Schedule

• / Nos recorremos la lista de procesos preparados
  buscando el mejor
• de todos para seleecionarlo /
• 26733 / this is the scheduler proper /
• 26734
• 26735 struct task_struct p
  init_task.next_run
• 26736 int c -1000
• 26757 while (p ! init_task)
• 26758 if (can_schedule(p))
• 26759 int weight goodness(p,
  prev, this_cpu)
• 26760 if (weight gt c)
• 26761 c weight, next p
• 26762
• 26763 p p-gtnext_run
• 26764

27
Función Schedule

• 26766 / Si todos los contadores 0 se
  recalculan los
• contadores de todos los procesos/
• 26767 if (!c)
• 26768 struct task_struct p
• 26770 for_each_task(p)
• 26771 p-gtcounter p-gtpriority
• 26773
• 26774
• 26775 / Si el proceso elegido es otro del
  actual-gt CC /
• 26801 if (prev ! next)
• 26804 / Se incrementa el número de cambios
  de cont. /
• 26805 kstat.context_swtch
• 26808 / Se hace el cambio de contexto /
• 26807 switch_to(prev,next)
• 26810
• 26813 return
• 26818

28
Macro switch_to

• / Se guardan en la pila los registros esi, edi y
  ebp /
• 12939 define switch_to(prev,next) do \
• 12940 unsigned long eax, edx, ecx \
• 12941 asm volatile("pushl ebx\n\t" \
• 12942 "pushl esi\n\t"
• 12943 "pushl edi\n\t" \
• "pushl ebp\n\t" \
• / Se guarda el puntero de pila en la TSS del
  proceso/
• "movl esp,0\n\t" / save ESP / \
• / Se restaura el nuevo puntero de pila /
• "movl 5,esp\n\t" / restore ESP / \
• / Se guarda la dirección de la etiqueta 1 en el
  contador de programa
• del proceso (para luego retornar ahí /
• 12947 "movl 1f,1\n\t" / save EIP / \

29
Macro switch_to

• / 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
• comenzar /
• 12948 "pushl 6\n\t" / restore EIP / \
• / Se guardan y actualizan los registros de
  segmento y las tablas de
• paginas /
• 12949 "jmp __switch_to\n" \
• / Dirección del salto para un nuevo proceso /
• 12950 "1\t" \
• /Se restaurán los registros restantes del nuevo
  proceso/
• 12951 "popl ebp\n\t" \
• 12952 "popl edi\n\t" \
• 12953 "popl esi\n\t" \
• 12954 "popl ebx" \
• 12959 while (0)

30
Función goodness

• /evalúa la prioridad de los candidatos a ser
  ejecutados a
• continuación/
• 26388 static inline int goodness(struct
  task_struct p,
• 26389 struct task_struct prev, int this_cpu)
• 26390
• 26391 int policy p-gtpolicy
• 26392 int weight
• 26393 / Se reinicia el flag SCHED_YIELD /
• 26394 if (policy SCHED_YIELD)
• 26395 p-gtpolicy policy SCHED_YIELD
• 26396 return 0
• 26397

31
Función goodness

• / Si es un proceso de tiempo real se le aumenta
  su goodness en 1000
• para darle prioridad/
• 26402 if (policy ! SCHED_OTHER)
• 26403 return 1000 p-gtrt_priority
• 26411 weight p-gtcounter
• / Si el proceso comparte zonas de memoria con el
  anterior ejecutado
• se aumenta su goodness. /
• 26412 if (weight)
• 26423 if (p-gtmm prev-gtmm)
• 26424 weight 1
• 26425 weight p-gtpriority
• 26426
• 26427
• 26428 return weight
• 26429

32
Otras funciones

• Existen un conjunto de funciones que manipulan
  procesos dentro de la cola de ejecución. Algunas
  de estas funciones son las siguientes
• move_first_runqueue mueve el proceso pasado por
  parámetro al principio de la cola de ejecución
• move_last_runqueue igual pero al final de la
  cola.
• add_to_runqueue añade un proceso al comienzo de
  la cola de ejecución
• del_from_runqueue

33
Otras funciones

• / Devuelve verdadero si el proceso tiene una
  señal pendiente
• observando el campo sigpending de la estructura
  task_struct /
• 16644 extern inline int signal_pending(struct
  task_struct p)
• 16645
• 16646 return (p-gtsigpending ! 0)
• 16647

34
Otras funciones

• /Esta función modifica el nivel de prioridad de
  un proceso/
• / who Identificador
• which Tipo de identificador un proceso, un
  grupo de
• procesos o todos los procesos de un usuario
• niceval Incremento de la prioridad (-20..19)
• /
• 29213 asmlinkage int sys_setpriority(int which,
  int who,int niceval)
• 29214
• 29215
• 29216 struct task_struct p
• 29217 unsigned int priority
• 29218 int error
• 29219

35
Otras funciones

• / Comprueba que es un tipo de identificador
  válido/
• 29220 if (which gt 2 which lt 0)
• 29221 return -EINVAL
• 29225 error ESRCH
• / Codigo reescrito por claridad. Se normaliza
  niceval entre 1 y 40/
• if (niceval lt -19)
• priority 40
• else
• if (niceval gt 19)
• priority 1
• else
• priority 20 niceval
• / Codigo reescrito por claridad /

36
Otras funciones

• / Se busca en las tareas del sistema cuales
  satisfacen las condiciones
• who y which y modifica sus prioridades si se
  tienen los permisos correspondientes./
• 29240
• 29241 for_each_task(p)
• 29242 if (!proc_sel(p, which, who))
• 29243 continue
• / Se miran los permisos /
• 29254 p-gtpriority priority
• 29255
• 29258 return -error
• 29259
• /Esta función devuelve la mayor de las
  prioridades de los procesos.
• Es analoga a la anterior./
• 29265 asmlinkage int sys_getpriority(int which,
  int who)

37
Otras funciones

• /Esta función permite cambiar la política de
  planificación y/o
• parámetros de la misma./
• 27618 static int setscheduler(pid_t pid, int
  policy,
• 27619 struct sched_param param)
• 27620
• pid el proceso objetivo, 0 significa proceso
  actual policy la nueva política de planificación
• param un struct que contiene información
  adicional (el
• nuevo valor para rt_priority)./
• 27621 struct sched_param lp
• 27622 struct task_struct p

38
Otras funciones

• / Se copian los parametros de la zona de usuario
  /
• 27630 copy_from_user(lp, param,
• 27631 sizeof(struct sched_param)))
• / Se buca el proceso a modificar /
• 27639 p find_process_by_pid(pid)
• / Se deja la misma política o se debe
  modificar? /
• 27645 if (policy lt 0)
• 27646 policy p-gtpolicy
• / Se comprueba que el proceso tiene permisos
  para cambiar su
• politica de planificación /
• / Se actualizan los campos /
• 27672 p-gtpolicy policy
• 27673 p-gtrt_priority lp.sched_priority

39
Otras funciones

• / Si es un proceso preparado se mueve al
  principio /
• 27674 if (p-gtnext_run)
• 27675 move_first_runqueue(p)
• / Se indica que se ha de replanificar /
• current-gtneed_resched 1
• 27685 return retval
• 27686

40
Otras funciones

• / Esta función comprueba si el proceso pasado
  por parámetro es más
• prioritario que el actual. Si es así habrá que
  replanificar el acceso al
• procesador./
• 26221 static inline void reschedule_idle(
• 26222 struct task_struct p)
• 26223
• 26224
• / Si es proceso en tiempo real o tiene más
  cuanto de tiempo por
• consumir que el actual hay que replanificar /
• 26225 if (p-gtpolicy ! SCHED_OTHER
• 26226 p-gtcounter gt current-gtcounter 3)
• 26227 current-gtneed_resched 1
• 26228 return
• 26229
• 26269

41
Otras funciones

• /Esta función despierta un proceso estableciendo
  el estado a
• RUNNING. Si no está en lista de ejecución lo
  añade./
• 26356 void wake_up_process(struct task_struct
  p)
• 26357
• 26358 unsigned long flags
• / Se pone el estado a TASK_RUNNING /
• 26361 p-gtstate TASK_RUNNING
• / Si no está en la cola lo añade /
• 26362 if (!p-gtnext_run)
• 26363 add_to_runqueue(p)
• 26364 reschedule_idle(p)
• 26365
• 26367

42
Otras funciones

• /Esta función actualiza el cuanto de tiempo
  restante de un proceso y
• sus campos de contabilidad./
• 27382 static void update_process_times(unsigned
  long ticks, unsigned long system)
• 27384
• 27387 struct task_struct p current
• 27388 unsigned long user ticks - system
• / Se actualiza el cuanto de tiempo /
• p-gtcounter - ticks
• / Si el contador ha expirado se pone a 0 y se
  manda a replanificar /
• 27391 if (p-gtcounter lt 0)
• 27392 p-gtcounter 0
• 27393 p-gtneed_resched 1
• 27400
• / Se actualizan los campos de contabilidad del
  proceso /
• 27401 update_one_process(p, ticks, user,
  system, 0)