tema2_so-2014 ugr

SO - Jos Antonio Gmez, 2014 1

2. Procesos e hilosSistemas OperativosGrado en Ingeniera InformticaGrupo A

Jos Antonio Gmez Hernndez, 2014


Contenidos Repaso:

Conceptos de proceso e hilo Diagrama de estados de procesos/hilos: estados y transiciones

Implementacin de procesos/hilos en Linux: Diagrama de estados y transiciones Operaciones sobre procesos

Planificacin de procesos: Tipos de planificacin y planificadores Algoritmos: FCFS, Prioridades, Roun-robin, CFS (Linux) Planificacin en multiprocesadores Planificacin en SOS de tiempo-real


Repaso conceptos Algunos conceptos que necesitamos tener claros:

Qu es un proceso y un hilo Imagen de un proceso Bloque de control de proceso y bloque control de hilo Estados de procesos Transiciones entre estados y ejemplo de eventos que las

provocan Cambio de contexto (o proceso)


Procesos en Linux Un proceso representado por el descriptor de proceso o

estructura task_struct (definida en linux/sched.h).


Estructura thread_info Deriva el descriptor de un pro-

ceso a partir del puntero a pila. Campos relevantes:

Indicadores TIF_SIGPENDING y TIF_NEED_RESCHED

cpu: nmero CPU en la que se ejecuta.

preempt_count: contador de apropiacin

Macros: current_thead_info :

direccin de thread_info del proceso actual.

current: direccin del descriptor del proceso del proceso actual.


Identificacin de procesos/hilos El sistema identifica a un proceso por su PID. Su tipo opaco es pid_t, y suele ser un int. Por compatibilidad hacia atrs el valor por defecto mximo

es 32768 (short int). Podemos aumentarlo a travs de /proc/sys/kernel/pid_max,

necesario en grandes servidores. Un hilo se identifica con un TID. El estndar POSIX espera que todas las hebras del grupo

tengan el mismo PID. Linux asigna a un grupo de hilos el PID del lider del grupo

(primer hilo), este se almacena en el tgid. La funcin getpid() devuelve el valor de tgid. En breve,

veremos como obtener el tid de un hilo.


Estados de procesos El campo state almacena el estado de un proceso Linux:

TASK_RUNNING: El proceso es ejecutable o esta en ejecucin. TASK_INTERRUPTIBLE: el proceso esta bloqueado (dormido) de

forma que puede ser interrumpido por una seal. TASK_UNINTERRUPTIBLE: proceso bloqueado no despertable por

una seal. TASK_TRACED: proceso que esta siendo traceado por otro. TASK_STOPPED: la ejecucin del proceso se ha detenido por

algunas de las seales de control de trabajos. El campo exit_state almacena los estados de los procesos

que ha finalizado: EXIT_DEAD: el proceso va a ser eliminado pues su padre a

realizado un wait(): EXIT_ZOMBIE: El padre an no ha realizado wait().


Diagrama de estados


Transiciones y colas sleep_on() - duerme a un proceso de forma ininterrumpible y

lo coloca en la cola de espera (wait queues) del evento indicado como argumento.

interruptible_sleep_on() - duerme de forma interrumpible. wake_up() - despierta a un proceso dormido ininterrup. wake_up_interruptible() - idem interrumpible. Existe una lista de procesos doblemente enlazada con todos

los procesos del sistema y a la cabeza esta el swapper (PID=0, task_struct_init_task).

Los estados TASK_STOPPED, EXIT_ZOMBIE, EXIT_DEAD no estn agrupados en colas.

Los procesos TASK_RUNNING estn en diferentes colas de procesos ejecutables (ver planificacin).


Cambio de estado actual Podemos cambiar el estado de un proceso con las funciones

internas del kernel: set_task_state(task, state); /*pone la tarea al estado

indicado*/ task->state = state; set_current_state(state)=set_task_state(current, state)


Jerarqua de procesos Todos los sistemas Unix/Linux mantienen a los procesos en una

jerarqua: El proceso init (PID=1) es el padre de todos los procesos. Todo proceso tiene exactamente un padre Todo proceso tiene 0 o ms hijos.

Denominamos hermanastros (siblings) a los procesos hijos del mismo padre.

La relacin entre procesos se almacena en el descriptor de proceso: parent: puntero al padre children: lista de hijos.

Podemos localizar el padre: my_parent=current->parent Recorrer la lista de hijos: list_for_children(list, &current-

>children)


Creacin de procesos fork() crea un proceso idntico al llamador exec() ejecuta un programa dentro de un proceso En Linux, fork() se construye basndose en la llamada al sistema

clone(), que sirve para crear tanto procesos como hilos. El trabajo de clone lo realiza do_fork() - definida en kernel/fork.c:

1.dup_task_struct() copia el descriptor del proceso actual.2. Ajustamos varios campos del nuevo task_struct para diferenciarlo de su

padre.3. Lo ponemos a TASK_UNINTERRUPTIBLE para que no se ejecute an.4.copy_process() copia las sub-estructuras segn los indicadores 5. Con alloc_pid() le asignamos un nuevo PID.6. Duplica las sub-estructuras indicadas por los argumentos de clone().7. Retorna al llamador un puntero al nuevo hijo.

fork() se implementa como clone(SIGCHLD,0). vfork() como clone(CLONE_VFORK|CLONE_VM|SIGCHLS, 0)


Esquema


clone()

Indicador SignificadoCLONE_FILESCLONE_FSCLONE_VMCLONE_SIGHANDCLONE_THREADCLONE_VFORK

Padre e hijo comparten los archivos abiertosPadre e hijo comparten informacin del sistema de archivosPadre e hijo comparten el espacio de direccionesComparten manejadores de seales y seales bloqueadasPadre e hijo en el mismo grupo de hilosSe invoc vfork; el padre duerme hasta el hijo lo despierta


Creacion de hilos Creamos un hilo (hebra) con la llamada: clone(CLONE_VM|CLONE_FS|CLONE_FILES|CLONE_SIGHAND,0) Es decir, creamos un proceso que comparte con su llamador

el espacio de direcciones (VM) y los recursos (FS, FILES y SIGHAND).

Hilos kernel hebras que no tienen un espacio de direcciones de usuario (task_struct->mm=NULL) y realizan labores de sistema. Sustituyen a los antiguos demonios.

Estas se crean a travs de otras hebras kernel con *kthread_create() en el estado bloqueado, y, por tanto, hay que despertarlas con wake_up_process().


Ejemplo de clone() (i)#include #include #include #include #include #include #include int var=5;int thread(void *p) { int tid; var++; tid = syscall(SYS_gettid); printf("Hijo: %d %d, varh: %d\n", getpid(), tid, var);}


Ejemplo (y ii)main() { unsigned char stack[4096]; int i, tid; setbuf(stdout, NULL); i = clone(thread, (void **) stack+2048, CLONE_VM| CLONE_FILES |CLONE_FS|CLONE_THREAD|CLONE_SIGHAND, NULL); if (i == -1) perror("clone"); else printf("clone retorna: %d\n", i); tid = syscall(SYS_gettid); printf("padre: %d %d, varp: %d\n", getpid(), tid, var);}


Ejecucin Si compilamos y ejecutamos el ejemplo tal como esta: ./clon Hijo: 6633 6634, varh: 6 padre: 6633 6633, varp: 6

Si solo dejamos: i = clone(thread, (void **) stack+2048, CLONE_FILES, NULL);

./clon padre: 6463 6463, varp: 5 Hijo: 6464 6464, varh: 6 Qu esta pasando?


Actividad en grupo En el ejemplo anterior, hemos utilizado la funcin clone()

con los argumentos siguientes:CLONE_VM|CLONE_FILES|CLONE_FS|CLONE_THREAD|CLONE_SIGHAND Hacer un dibujo que represente las task_struct de ambos

procesos


Terminacin de procesos Se produce cuando un proceso invoca a voluntariamente a _exit() o

involuntariamente cuando recibe una seal. La funcin que finaliza un proceso es do_exit() -kernel/exit.c:

Activa PF_EXITING Decrementa los contadores de uso de mm_struct, fs_struct, files_struct. Si

estos contadores alcanzan el valor 0, destruye los recursos. Ajusta el exit_code del descriptor, que ser devuelto al padre, con el valor pasado

a exit(). Envia al padre la seal de finalizacin; si tiene algn hijo le busca un padre en el

grupo o el init, y pone el estado a TASK_ZOMBIE. Invoca a schedule() para ejecutar otro proceso.

Solo queda del proceso la pila kernel, la estructura thread_info y la task_struct, de cara a que el padre pueda recuperar el cdigo de finalizacin. Cuando se libera el resto?


La llamada wait() Wait(): llamada que bloquea a un proceso padre hasta que

uno de sus hijo finaliza; cuando esto ocurre, le devuelve el PID del hijo finalizado. Adems, devuelve un puntero a la funcin a tras retornar tiene el cdigo de finalizacin del hijo.

Esta funcin invoca a release_task() que: Elimina el descriptor de la lista de tareas. Si es la ltima tarea de su grupo, y el lder esta zombi, notifica

al padre del lder zombi. Libera la memoria de la pila kernel,thread_info y task_struct.


Procesos hijos sin padre Qu ocurre sin un proceso finaliza antes que sus hijo? Como no deseamos que existan procesos zombis, debemos

asignar un nuevo padre al proceso(s): si es posible al grupo de hilo al que pertenece, sino al proceso init.

De esto se encarga la funcin find_new_reaper() dentro de do_exit().


Planificacin Tipos de planificadores:

Estudio individual: Apartado 9.1 del Stallings Tipos de planificacin del procesador.

Tipos de planificacin Criterios y algoritmos de planificacin Planificacin en Linux:

CFS (Completely Fair Scheduler). Planificacin en tiempo-real Planificacin en multiprocesadores


Tipos de planificadores

Planificador a largo plazo procesos batch

Planificador a medio plazo gestin de memoria

Planificador a corto plazo o simplemente scheduler o planificador


Tipos de planificacin Las polticas de planificacin se puede dividir en dos tipos:

Planificacin apropiativa (preemptive) Al proceso actual se le puede retirar el control de la CPU bien por otro proceso, bien por algn componente del sistema operativo.

Planificacin no apropiativa (non preemptive) Al proceso actual NO se le puede retirar el control por ningn proceso o componente del SO; slo el proceso actual puede ceder el control de la CPU.


Linux y apropiatividad Los kernels actuales de Linux permiten ajustar el grano de

apropiatividad del sistema dependiendo del uso que vayamos a hacer del mismo.

Define puntos de apropiacin: seccin del cdigo en la que es posible apropiar al proceso actual para ceder la CPU a otra funcin del sistema o proceso.

Las RSIs no invocan al planificador directamente, sino que lo hacen de forma retardada activando la bandera TIF_NEED_RESCHED=1, marcando que cuando sea posible se debe planificar.

Cuando la ejecucin kernel alcanza un punto de apropiacin (las EDs del kernel estan seguras), se mira el estado de la bandera, y si esta a 1, se invoca al planificador.


Apropiatividad en Linux Debemos modificar las RSIs para invocar de forma

asncrona, y diferida, el planificador. Por tanto tenemos dos formas de invocacin del

planificador: sincrona y asncrona.

TIF_NEED_RESCHED=1;


Trabajo en Grupo 2.2. Suponemos que estamos diseando el planificador a corto

plazo de un SO, y no enfrentamos a la situacin donde debemos programar que debe hacer el planificador cuando la cola de procesos preparados est vaca, por ejemplo, porque no hay procesos o los que hay estn bloqueados.

Pasos: Modificar el planificador visto en Tema 0, para que controle la

posibilidad de que la cola este vaca. La solucin dada puede ser funcionalmente correcta pero puede

tener algn problema de eficiencia. Podemos hacerla ms eficiente?


Solucin a TG 2.2 1 solucin:Planificador() {while (true) { if (cola_preparados==vacia) halt; else { Selecciona (Pj); Cambio_contexto(Pi,Pj); }}

2 solucin: optimizacinwhile (true){ Selecciona (Pj); Cambio_contexto(Pi,Pj);} Creamos un proceso nulo

u ocioso: siempre preparado menor prioridad del

sistema


TG 2.2: solucin La funcin de planificacin debera comprobar antes de

seleccionar a un proceso que la cola de preparados no esta vaca. Si esta vaca, necesitamos programar la CPU para hacer una actividad no til, por ejemplo, un bucle ocioso o detener la CPU con halt.

Esta solucin sera correcta pero obliga a ejecutar cdigo extra (comprobar n elementos de la cola de preparados) cada vez que invoquemos al planificador. Cmo este cdigo se ejecuta cientos de miles de veces, sera mucho tiempo desperdiciado.

Podemos optimizar la solucin anterior, introduciendo un proceso que siempre este preparado, el proceso nulo, con lo cual podemos quitar esa comprobacin. Adems, como el proceso no debe competir con el resto por el uso de CPU, debe tener la menor prioridad posible.


Trabajo en grupo 2.3 Si utilizamos una planificacin NO apropiativa puede el

procesador manejar una interrupcin mientras esta ejecutando al proceso actual?


TG 2.3: solucin En principio una poltica no apropiativa no permitira que se

atendiesen las interrupciones. Ahora bien, esto provocara bastante irresponsividad del sistema.

Podemos atender las interrupciones sin violar la poltica de planificacin de procesos siempre y cuando esto no provoque un cambio de procesos. Es decir, antes de que se produzca la interrupcin y despus de tratarla, el proceso en ejecucin es el mismo Las RSIs no invocan al Planificador.


Planificacin en tiempo-real El planificador tiene ordenar la ejecucin de las tareas a

preparadas de forma que cada una pueda cumplir el plazo (deadline) asociado.

Esto nos obliga entre otras cosas a: Desarrollar kernel apropiativos: objetivo, reducir la latencia de

despacho para poder planificar en el tiempo correcto la tarea que debe responder a un evento.

Desarrollar algoritmos de planificacin que tengan en cuenta los plazos de la tareas, cosa que no ocurre en los sistemas operativos de propsito general.

Adaptaciones: algoritmo EDF (Early Deadline First).


Latencia de despacho

Protocolos para evitar la inversin de prioridad: herencia de prioridad y protocolo tope.


Algoritmos y Criterios En el Apartado 9.2 Algoritmos de planificacin del

Stallings podemos ver los algoritmos de planificacin ms comunes.

Nosotros slo veremos los algoritmos generales: FIFO Prioridades Round-Robin Realimentacin (Feedback)

La Tabla 9.2 del libro de Stallings algunos de los criterios (mtricas) de planificacin.

Estudiarlos como trabajo individual para poder abordar el trabajo en grupo entregable del tema.


Planificador de Linux Implementado en la funcin schedule() en kernel/sched.c. El planificador genrico tiene dos componentes:

Componente activado por un proceso al bloquearse o ceder la CPU.

Componente peridico que se activa cada cierto tiempo. El planificador interacciona adems con las clases de

planificacin: De tiempo-real: SCHED_FIFO y SCHED_RR De tiempo compartido: SCHED_NORMAL,SCHED_BATCH, SCHED_IDLE

SCHED_FIFO, SCHED_RR y SCHED_OTHERS definidas por POSIX1.b.

El planificador de Linux soporta: mquina NUMA y UMA, multicores e hiperthrearing.


Componentes del planificador

Planificadorperidico

Planificadorprincipal

Clases de planificacin

Tiempo-realroun-robin

Tareas

CFSTiempo-realFIFO

Planificador genrico

CPUCambiocontexto


Elementos en task_struct Algunos elementos del task_struct relacionados con

planificacin: prio: prioridad usada por el planificador rt_priority: prioridad de tiempo-real. sched_class: clase de planificacin del proceso. sched_entity: el mecanismo grupos de control establece que se

planifiquen entidades (procesos o grupos de procesos).


task_struct (cont.) policy: almacena la poltica de planificacin aplicada al

proceso: SCHED_NORMAL: manejados por CFS al igual que:

SCHED_BATCH: procesos batch -no interactivos- acotados por computo, son desfavorecidos por las decisiones de planificacin. Nunca apropian a otro proceso gestionado por CFS y por interfieren con trabajos interactivos. Es aconsejable en situaciones en las que no se desea decrementar la prioridad esttica con nice, pero la tarea no debera influenciar la interactividad del sistema.

SCHED_IDLE: tareas de poca importancia con peso relativo mnimo. No es responsable de planificar la tarea ociosa.

SCHED_RR y SCHED_FIFO: implementan procesos de tiempo-real soft. Gestionados por la clase de tiempo-real.


Clases de planificacin Suministran la conexin entre el planificador genrico y el planificador individual. struct sched_class { const struct sched_class *next; void (*enqueue_task(); /* aade proceso a la cola de ejecucin rq, y nr_running++*/ void (*dequeue_task(); /* lo elimina de rq, y nr_running-- */ void (*yield_task) (); /* cede el control de la CPU*/ struct task_struct * (*pick_next_task) ();/*selecciona siguiente tarea a ejecutar*/ void (*put_prev_task)(); /* retira a la tarea del procesador */ void (*set_curr_task)(); /* se invoca al cambiar tarea de clase*/ void (*task_tick)(); /* invocada por el planificador periodico en cada invocacin */ void (*task_new)(); /* notifica al planificador de la creacin de una tarea */ . . . }; Hay una instancia de la estructura por clase de planificacin. Forman una jerarqua plana: procesos tiempo-real > procesos CFS > procesos idle. La jerarqua se establece en tiempo de compilacin (no hay mecanismo para aadir una nueva clase

dinmicamente).


Cola de ejecucin Cada procesador tiene su cola de ejecucin (rq) y cada proceso

esta en una nica cola. struct rq { unsigned long nr_running; /* n procesos ejecutables */ #define CPU_LOAD_IDX_MAX 5; unsigned long cpu_load[CPU_LOAD_IDX:MAX]; /*historico de la carga*/ struct load_weight load; /*carga de la cola */ struct cfs_rq cfs; /* cola embebida para cfs*/ struct rt_rq rt; /*cola embebida para rt*/ struct task_struct *curr, *idle; /*procesos actual y ocioso*/ u64 clock; /* reloj por cola; actualizado al invocar al planificador periodico*/ . . . }


Entidades de planificacin La estructura que describe una entidad es:struct sched_entity { struct load_weight load; /*para equilibrio de carga*/ struct rb_node run_node; /*nodo de arbol rojo-negro*/ unsigned int on_rq; /* indica si la entidad esta planificada en una cola*/ u64 exec_start; /* tiempo inicio ejecucin */ u64 sum_exec_start; /t consumido de CPU*/ u64 vrtime; /*tiempo virtual */ u64 prev_sum_exec_runtime; /* valor salvado de sum_exec_start al quitarle control CPU*/ . . .};


Prioridades El kernel utiliza un rango de prioridades siguiente

Valores de prioridad mostrados por el sistema Linux mantiene hasta 8 valores de prioridad por compatibilidad: prioirity p->prio intpri 60 + p->prio opri 60 + p->prio pri_foo p->prio - 20 pri_bar p->prio + 1 pri_baz p->prio + 100 pri 39 - p->priority pri_api -1 - p->priority

Tiempo-real

0 + prioridad -20 valor nice +19

0 99 100 139

normal

top: muestra el valor de ps -o priorityps con: -l muestra el valor intprio -l -c muestra -o pri


Poltica de planificacin El planificador siempre selecciona para ejecucin al

proceso con mayor prioridad. Si hay dos procesos con la misma prioridad, ejecutar al

que lleva ms tiempo esperando. Si el proceso pertenece a la clase FIFO, lo ejecutar hasta

el final o hasta que se bloquee.


Calculo de pesos de carga La importancia de una tarea viene dada por su prioridad y

por su peso de carga (load weight). Idea: un proceso que cambia disminuye su prioridad en un

nivel nice obtiene el 10% ms de CPU, mientras que aumentar un nivel resta un 10% de CPU.

Para ello, el kernel convierte prioridades de peso de carga:

static const int prio_to_weight[40] = {/* -20 */ 88761, 71755, 56483, 46273, 36291,/* -15 */ 29154, 23254, 18705, 14949, 11916,/* -10 */ 9548, 7620, 6100, 4904, 3906,/* -5 */ 3121, 2501, 1991, 1586, 1277,/* 0 */ 1024, 820, 655, 526, 423,/* 5 */ 335, 272, 215, 172, 137,/* 10 */ 110, 87, 70, 56, 45,/* 15 */ 36, 29, 23, 18, 15,};


Pesos de carga La matriz contiene un valor para cada nivel nice en el rango

[0,39]. El multiplicador entre entradas es 1.25. Ejemplos uso:

Dos procesos con nice 0: cada uno obtiene el 50% de CPU: 1024/(1024+1024).

Si un proceso sube un nivel nice (incrementa prioridad en 1) decrementa su peso (1024/1.25 820). Ahora 1024/(1024+820)= 0.55 y 820/(1024+820)=0.45. Un proceso obtiene el 55% de CPU y el otro un 45% (una diferencia del 10%).

La funcin que realiza estos clculos es set_load_weight().


El planificador peridico Implementado por scheduler_tick() se invoca con una

frecuencia de HZ, en update_process_times() para cargar el tick actual al proceso actual (En kernel/timer.c)

Tiene dos funciones principales: Manejar las estadsticas kernel relativas a planificacin. Activar el planificador peridico de la clase de planificacin

responsable del proceso actual, delegando la labor en el planificador de clase:

curr->sched_class->task_tick(rq, curr); Si debemos replanificar la tarea actual, el mtodo de la

clase bsicamente activa el bit TIF_NEED_RESCHED.


El planificador principal La funcin schedule() se invoca directamente en diversos

puntos del kernel para cambiar de proceso. Adems, cuando retornamos de una llamada al sistema,

comprobamos si hay que replanificar mediante TIF_NEED_RESCHED, y si es necesario se invoca a schedule().

La funcin la podemos ver en http://lxr.linux.no/#linux+v3.1/kernel/sched.c#L4260.


Planificador principal (ii) Las acciones principales son:

1. Seleccionar la cola y el proceso actual:rq=cpu_rq(cpu);prev=rq->cur;

2. Desactivar la tarea actual de la cola.desactivate_task(rq, prev, 1);

3. Seleccionar el siguiente proceso a ejecutar.next=pick_next_task(rq, next);

4. Invocar al cambio de contexto:if (likely(prev!=next)

context_switch(rq, prev, next);5. Comprobar si hay que replanificar:

if (need_resched()) goto need_resched;


Cambio de contexto El cambio de contexto descansa en las funciones:

switch_mm() que cambia el contexto de memoria de usuario descrito por task_struct->mm

switch_to(prev,next,prev) que cambia los contenidos de los registros del procesador y la pila kernel. Su formato equivale a prev=switch(prev, next).

Si la tarea entrante o saliente es una hebra kernel utiliza un mecanismo denominado TLB perezoso, en el que se indica al procesador que realmente no hay que conmutar de memoria.


Clase CFS: definicin Definida en kernel/sched_fair.c: static const struct sched_class fair_sched_class = { .next=&idle_sched_class, .enqueue_task= enqueue_task_fair, .dequeue_task= dequeue_task_fair, .yield_task= yield_task_fair, .check_preempt_curr= check_preempt_wakeup, .pick_next_task= pick_next_task_fair, .put_prev_task= put_prev_task_fair, . . . .task_tick= task_tick_fair, . . . }


Clase CFS CFS (Complety Fair Scheduler) intenta modelar un procesador

multitarea perfecto. No asigna rodajas de tiempo a los procesos, asigna una

proporcin del procesador que depende de la carga del sistema cada proceso se ejecuta durante un tiempo proporcional a su peso dividido por la suma total de pesos.

TimeslicePi = (PesoPi / PesosPj ) P Donde P = sched_latency si n>nr_latency Min_granularidad x n en otro caso Como el tiempo asignado tiende a cero conforme crece el

nmero de procesos, define una granularidad mnima= suelo de tiempo asignado).

En la implementacin actual: sched_latency=8, nr_latency=8 y min_granularity= 1 us.


Tiempo asignado a proceso Para calculo tiempo asignado se usa un periodo:

5 o menos procesos: 20ms Sistema cargado: 5ms ms por proceso.

Tiempo asignado= (longitud periodo*peso)/peso rq Ejemplo:

Proceso P1

P2

P3

Nice +5 0 -5

Peso 335 1024 3121

Tiempo asignado

1.5 ms 4.5 ms 14 ms


CFS: seleccin proceso Tiempo virtual de ejecucin (vruntime)=tiempo de ejecucin

real normalizado por el nmero de procesos en ejecucin. Este tiempo es gestionado por update_curr() definida en kernel/sched_fair.c.

Vruntime= (PesoNice0/Perso cola)x tiempo_real =tiempo_ejecucion_actual* 1024/peso rq CFS intenta equilibrar los tiempos virtuales de ejecucin de los

procesos con la regla: se elige para ejecucin el proceso con vruntime ms pequeo.

Cola de ejecucin de CFS rbol rojo-negro (rbtree): rbol de bsqueda binario auto-equilibrado donde la clave de bsqueda es vruntime. Insercin/borrado con O(log n).

El proceso con vruntime menor es la hoja ms a la izquierda en el rbol.


Ejemplo extrado de Ktown Coder, Process SchedulingIn Linux en www.countrycoders.com/comp314.php


Parmetros planificacin Lista de las variables relacionadas con planificacin:

% sysctl -A | grep "sched" | grep -v "domain"

Valor actual de las variables ajustables: /proc/sched_debug Estadsticas cola actual: /proc/schedstat Informacin planificacin proceso PID: /proc//sched


Clase de tiempo real Si existe un proceso de

tiempo-real ejecutable en el sistema este se ejecutar antes que el resto, salvo que haya otro de prioridad mayor.

La cola de ejecucin es simple:


Planificacin SMP Aspectos considerados:

Comparticin de la carga de CPU imparcial Afinidad de una tarea por un procesador Migracin de tareas sin sobrecarga


Dominios de planificacin La colas de ejecucin se organizan en

dominios de planificacin Un dominio de planificacin agrupa CPUs

que comparten propiesades y algoritmos, y que pueden equilibrase entre ellas.

Cada dominio contiene un o varios grupos de CPUs que pueden tratarse como una unidad.

Podemos configurar numerosos parmetros en /proc/sys/kernel/cpuX/domainY.


Dominio de planificacin struct sched_domain { /* These fields must be setup */ struct sched_domain *parent; /* top domain must be null terminated */ struct sched_domain *child; /* bottom domain must be null terminated */ struct sched_group *groups; /* the balancing groups of the domain */ unsigned long min_interval; /* Minimum balance interval ms */ unsigned long max_interval; /* Maximum balance interval ms */ unsigned int busy_factor; /* less balancing by factor if busy */ unsigned int imbalance_pct; /* No balance until over watermark */ unsigned int cache_nice_tries; /* Leave cache hot tasks for # tries */ unsigned int busy_idx; unsigned int idle_idx; unsigned int newidle_idx; unsigned int wake_idx; unsigned int forkexec_idx; unsigned int smt_gain; int flags; /* See SD_* */ int level; /* Runtime fields. */ unsigned long last_balance; /* init to jiffies. units in jiffies */ unsigned int balance_interval; /* initialise to 1. units in ms. */ unsigned int nr_balance_failed; /* initialise to 0 */. . . }


Grupo de planificacinstruct sched_group { struct sched_group *next; /* Must be a circular list */ atomic_t ref; unsigned int group_weight; struct sched_group_power *sgp; /* * The CPUs this group covers. * * NOTE: this field is variable length. (Allocated dynamically * by attaching extra space to the end of the structure, * depending on how many CPUs the kernel has booted up with) */ unsigned long cpumask[0]; };


Gestin de potencia Un aspecto importante a considerar en los diseo

actuales es la gestin de potencia, encaminada a mantener la potencia de cmputo reduciendo: Los costes de consumo de energa Los costes de refrigeracin

Esta gestin se puede realizar a varios niveles: Nivel de CPU: P-states, C-states y T-states. Nivel de SO: CPUfreq (paquetes cpufrequtils y

cpupower) y planificacin


Especificacin ACPI Advanced Configuration and Power

Interface: especificacin abierta para la gestin de potencia y gestin trmica controladas por el SO.

Desarrollada por Microsoft, Intel, HP, Phoenix, y Toshiba.

Define cuatro estados Globales (G-estados): G0: estado de funcionamiento:

estados-C y estados-P G1: estado dormido S-estados G2: Estado apagado soft G3: Estado apagado mecanico

Techarp, PC Power Management Guide Rev. 2.0, disponible en http://www.techarp.com/showarticle.aspx?artno=420


Estados de la CPU S-estados: estados dormidos en

G1. Van de S1 a S5. C-estados: estados de potencia

en G0. C0:activo, C1:halt, C2:stop, C3, deep sleep,...

P-estados: relacionados con el control de la frecuencia y el voltaje del procesador. Se usan con G0 y C0. P1-Pn, a mayor n menos freq y volt.

T-estados: estados throttles relativos a la gestin trmica. Introducen ciclos ociosos.

ACPI spec v5.0, Dic. 2011


Estructura CPUfreq El subsistema CPUfreq es el responsable de ajustar

explcitamente la frecuencia del procesador. Estructura modularizada que separa polticas (gobernadores)

de mecanismos (drivers especficos de CPUs).

Mdulo CPUfreq (interfaces /proc y /sys)

UserspacePerformance

Conservative

Powersave

cpuspeedPowersaved

speedstep-centrino Powernow-k8acpi-cpufreq

Driver ACPI del procesador

Gobernadoresa nivel usuario

Gobernadoresen el kernel

Drivers especficosDe CPU

Ondemand


Gobernadores Performace mantiene la CPU a la mxima frecuencia

posible dentro un rango especificado por el usuario. Powersave mantiene la CPU a la menor frecuencia posible

dentro del rango. Userspace exporta la informacin disponible de frecuencia

a nivel de usuario (sysfs) permitiendo su control al mismo. On-demand ajusta la frecuencia dependiendo del uso

actual de la CPU. Conservative Como 'ondemand' pero ajuste ms gradual

(menos agresivo). Podemos ver el gobernador por defecto en

/sys/devices/system/cpu/cpuX/scaling_governor


Herramientas Cpufrequtils podemos ver, modificar los ajustes del kernel

relativos al subsistema CPUfreq. Las rdenes cpufreq* son utiles para modificar los estados-P, especialmente escalado de frecuencia y gobernadores.

Cpupower ver todos los parmetros relativos a potencia de todas las CPUs, incluidos los estados-turbo. Engloba a la anterior.

PowerTOP ayuda a identificar las razones de un consumo alto innecesario, por ejemplo, procesos que despiertan al procesador del estado ocioso.

Se pueden crear perfiles en /etc/pm-profiler.


Planificacin y energa En CMP con recursos compartidos entre ncleos de un

paquete fsico, el rendimiento mximo se obtiene cuando el planificador distribuye la carga equitativamente entre todos lo paquetes.

En CMP sin recursos compartidos entre ncleos de un mismo paquete fsico, se ahorrar energa sin afectar al rendimiento si el planificador distribuye primero la carga entre ncleos de un paquete, antes de buscar paquetes vacos.


Algoritmos de planificacin El administrador puede elegir el algoritmo de planificacin

moficando las entradas sched_mc_power_saving y sched_smt_power_saving de /sys/devices/system/cpu/

Rendimiento ptimo Ahorro de energa


Grupos de control El planificador trata con entidades planificables,

que no tienen por que ser procesos. Esto permite definir grupos de planificacin

Diferentes procesos se asignan a diferentes grupos. El planificador reparte la CPU imparcialmente entre grupos, y luego entre proceso de un grupo. Esto reparte imparcialmente la CPU entre usuarios.


Grupos de control Suministran un mecanismo para:

Asignar/limitar/priorizar recursos: CPU, memoria, y dispositivos. Contabilidad: medir el uso de recursos. Aislamiento: espacios de nombres separados por grupo. Control: congelar grupos o hacer checkpoint/restart.

Los cgroups son jerrquicos: un grupo hereda los lmites del grupo padre.


Subsistemas de gc Existen diferentes subsistemas (controladores de recursos):

cpu: utilizado por el planificador para suministrar el acceso de las tareas de un cgroup a la CPU. cpuacct: genera automticamente informes de la CPU utilizada por las tareas de un cgroup. cpuset: asigna CPUs individuales y memoria en sistemas multicore. devices: permite/deniega el acceso de las tareas a un dispositivo. freezer: detiene la ejecucin de todos los procesos de un grupo. memory: limita el uso de memoria a tareas de un cgroup, y genera informes automticos del uso

de memoria de esas tarea. blkio: establece los lmites de accesos de E/S desde/hacia dispositivos de bloques (discos, USB, ...) net_cls: etiqueta paquetes de red con un identificador de clase (classid) que permite al

controlador de trfico (tc) identificar los paquetes originados en una tarea de un grupo. ns:_subsitemas de espacios de nombres (namespaces), visto en Tema 1,


Relaciones Definiciones:

Tarea: proceso de usuario o kernel Cgroup: una o ms tareas. Subsistema: modulo que modifica el comportamiento de las

tareas de un cgroup. Jerarqua: varios cgroups en un rbol.

Existen varias reglas que gobiernan la relacin entre subsistemas, jerarquas, grupos de control y tareas (procesos).

Hay cuatro reglas:


Regla 1


Regla 2


Regla 3


Regla 4


Uso de los cgroups Pueden utilizarse de diferentes modos:

Seudo-sistema de archivos cgroups (cgroupfs). Herramientas de libcgroup: cgcreate, cgexec, cgclassify, ... El demonio engine rules los gestiona segn la informacin de

los archivos de configuracin. Indirectamente a travs de otros mecanismos como Linux

Containers (LXC), libvirt, systemd.


Mtodo 1: Cgroups FS Los subsistemas se habilitan como una opcin de montaje de

cgroupfs: mount -t cgroup -o$subsistema Habilitamos los archivos del subsistema en cada cgroup (directorio): /dev/cgroup/migrupo/subsysA.optionB Podemos verlos en /proc/cgroups. En Ubuntu, podemos instalarlo con $ sudo aptitude install cgroups-bin libcgroup1 Esto nos monta por defecto los siguientes fs: $ ls -l /sys/fs/cgroup cpu cpuacct devices memory Podemos ver los grupos de control con cat /proc/cgroups


CgroupsFS: ejemplo Crear dos grupos para asignar tiempo de CPU:

Creamos el correspondiente subdirectorio en sys/fs/cgroup/cpu: $ mkdir Navegadores; mkdir multimedia

Asignamos el porcentaje de cpu al grupo escribiendo en el archivo cpu.shares: $ echo 2048 > /sys/fs/cgroup/cpu/multimedia/cpu.shares $ echo 1024 > /sys/fs/cgroup/cpu/multimedia/cpu.shares

Movemos una tarea al cgrupo escribiendo su PID en el archivo tasks. $ firefox& $ echo $! > /sys/fs/cgroup/cpu/navegadores/tasks $ mplayer micancion.mp3& $ echo $! > /sys/fs/cgroup/cpu/multimedia/tasks

tema2_so-2014 ugr

Documents