Práctica 1 - SO II (continuación 3ª)

En esta nueva solución incompleta se nos presenta la imperativa de hacer un planificador un poco mejor o pero. En nuestro caso lo que vamos a hacer es que el planificador seleccione al proceso según el campo “p_nr“. Este campo está definido en el archivo “proc.h” de la sigiente forma, pero antes debemos saber como encontramos la definción de “p_nr”, pues como diría Luis Cearra, con esta chuleta:

find . -name ‘*.[ch]’ -exec grep ‘p_nr’ {} \; -print

Lógicamente como sois casi ingenieros no hace falta que la detalle, la verdad es que es un 99,9% igual a la que utiliza Luis en sus clases asi que el que fue a ellas no necesita saberlo pero como no todos pueden ir a clase la detallaré:

FIND = BUSCA
. = AQUI (en mi caso en /usr/src/kernel/)
-name = UN ARCHIVO
‘*.[ch]’ = DE EXTENCION .c O DE EXTENSION .h
-EXEC = SI ENCENTRAS ALGUNO EJECUTA …
GREP = EJECUTA GREP (buscador de texto en fichero)
‘p_nr’ = LAS COMILLAS NO SON NECESARIAS Y LE DIGO QUE BUSQUE EL TEXTO p_nr
{} = CUANDO FIND ENCUENTRA UN FICHERO ES SUSTITUIDO POR LAS LLAVES
\; = CIERRAN EL EXEC (sin interes)
-PRINT = DAME EL NOMBRE DEL FICHERO EN DONDE ENCUENTRAS LA CADENA p_nr

Como resultado hemos obtenido:
Primero los resultados y luego el fichero en donde esta el resultado.



Por lo que vemos que “p_nr” se declara en el fichero “proc.h”, lo editamos con “elvis” o con “mined”

struct proc {
struct stackframe_s p_reg;

proc_nr_t p_nr;
struct priv *p_priv;
short p_rts_flags;
short p_misc_flags;

char p_priority;
char p_max_priority;
char p_ticks_left;
char p_quantum_size;

struct mem_map p_memmap[NR_LOCAL_SEGS];

clock_t p_user_time;
clock_t p_sys_time;

struct proc *p_nextready;
struct proc *p_caller_q;
struct proc *p_q_link;
message *p_messbuf;
int p_getfrom_e;
int p_sendto_e;

sigset_t p_pending;

char p_name[P_NAME_LEN];

int p_endpoint;
};

Como vemos es de tipo:

proc_nr_t p_nr;

Como yo soy muy curiso, quiero saber como es el tipo de p_nr:

find . -name ‘*.[ch]’ -exec grep ‘proc_nr_t’ {} \; -print

Da como resultado:



Ahora ya sabemos que “proc_nr_t” esta declarado en type.h y que es un int.

Ahora que ya hemos realizado la introducción vamos con la práctica.

3
3.1 Leer
3.1.1 Leer
3.1.2 Leer

Aquí nos dice únicamente que hay que modificar el proc.c, es un alivio después de ver todos los ficheros que tiene el directorio /kernel.

3.1.3 Recomendación, que la función enqueque almacene ya los procesos ordenado.

Aquí es donde yo creo que empieza la práctica, es decir hay que manipular el proc.c y claramente la función enqueque.

PRIVATE void enqueue(rp)
register struct proc *rp;
{

int q;
int front;


sched(rp, &q, &front);

/* Now add the process to the queue. */
if (rdy_head[q] == NIL_PROC) { /* add to empty queue */
rdy_head[q] = rdy_tail[q] = rp; /* create a new queue */
rp->p_nextready = NIL_PROC; /* mark new end */
}
else if (front) { /* add to head of queue */
rp->p_nextready = rdy_head[q]; /* chain head of queue */
rdy_head[q] = rp; /* set new queue head */
}
else { /* add to tail of queue */
rdy_tail[q]->p_nextready = rp; /* chain tail of queue */
rdy_tail[q] = rp; /* set new queue tail */
rp->p_nextready = NIL_PROC; /* mark new end */
}

/* Now select the next process to run. */
pick_proc();

}

Que es lo que hay que haces, PUES NO LO VOY A DECIR pero si os guiaré en este pequeño procedimiento para que sepeais lo que yo he hecho y lo que creo que se debe hacer.

UNA COSA ESTA CLARA NO ESTOY RESOLVIENDO LA PRÁCTICA SOLO HAGO LO MISMO QUE EN EL FORO DE LA ESCUELA PERO MÁS AMPLIO. NO DOY RESULTADOS SOLO POR EJEMPLO DOY EL SIGNIFICADO DE INSTRUCCIONES EN C O EXPLICO ALGUNOS DETALLES RAROS DE MINIX, UNIX, SIEMPRE QUE MI CAPACIDAD INTELECTUAL Y MI ENTENDIMIENTO LO PERMITA. ADEMÁS DOY DETALLES QUE COMO NO ENTRAN PARA EXAMEN NO OS SIRVE PARA NADA, POR EJEMPLO DETALLAR INSTRUCCIONES EN “C”, PERO QUE SI OS SIRVEN PARA ENTERDER LA PRÁCTICA. OTRA COSA ES QUE COMO A MI GUSTA HACER ESTO (EXPLICAR) ME SIENTO AGRADECIDO CON TODAS LA VISITAS A ESTE HUMILDE BLOG AUNQUE SEA SOLO POR ESTE CUATRIMESTRE, Y QUE SI A ALGUNO LE SIRVE PARA APROBER PUES AHÍ ESTA ESO. DE TODAS FORMAS CONTESTARÉ CUALQUIER DUDA EN MI CORREO O EN EL FORO DE DELEGACIÓN.

HA QUEDADO CLARO QUE MI INTENCIÓN NO ES RESOLVER LA PRÁCTICA SINO AYUDAR A AQUELLOS QUE NO TIENEN TIEMPO Y DARSELO TODO UN POCO MÁS MASTICAÍTO AUNQUE PARA ALGUNOS ESO ES PERJUDICIAL.

Continuarmos …

Vamos a detallar el código:

/* Determine where to insert to process. */
sched(rp, &q, &front);

Algunos se preguntan que hace esto pues es muy claro aunque en lo que voy a decir YO tengo una duda, yo opino a que SCHED se le pasa un descriptor de proceso (creo que se llama así, una variable “q” por referencia y una variable “front” por referencia, eso diríamos en PASCAL pero como es C se le pasas direcciones de memoria de la variable “q” y “front”.

Que hace sched, pues devuelve en q, la cola donde debe ir insertado el proceso que le pasamos como primer parámetro, y esto lo sabemos por la definición que se hace en SCHED de esas variable:

int *queue; /* return: queue to use */
int *front; /* return: front or back */

Mas abajo vemos que:

*queue = rp->p_priority;

Es decir, el CONTENIDO de la variable QUEUE es la prioridad, y esto que demonios quieres decir, QUE LA PRIORIDAD DE UN PROCESO DETERMINA LA COLA EN LA QUE LO VAMOS A INSERTAR.

Lógicamente antes de ese código hemos subido, bajado, mantenido su prioridad, etc etc etc, un proceso puede entrar en SCHED con prioridad X y salir con prioridad Y, o con X. (esto no del todo cierto tiene una errata, a ver si la encuentras).

En “front” se le dice si insertamos delante o detrás, desde mi punto de vista este código es absurdo en esta parte de la práctica ya que ahora no vamos a insertar por delante o por detras sino que vamos a ordenar en la cola de procesos a un proceso según el campo p_nr.

Es decir (antes):

HEADCOLA_7: —> P10(p_nr=13) — P14(p_nr=23) — P9(p_nr=12) P10(p_nr=13) — P14(p_nr=23) — P9(p_nr=12) — P20(p_nr=16) P9(p_nr=12) — P10(p_nr=13) — P14(p_nr=23) P9(p_nr=12) — P10(p_nr=13) — P20(p_nr=16) — P14(p_nr=23) <— TAILCOLA_7

Como vemos se ha insertado en el orden que le corresponde.

Ahora ya es cosa vuestra el curraros como se hace para insertar de forma ordenada en una lista enlazada, es un problema de ESTRUCTURA DE DATOS I, y espero que no os suponga mucho problema.

En realidad es una lista enlazada con cabecera y final pero con la peculiaridad de que:

La cabecera apunta al primer proceso listo para ejecutarse de la Cola X.
El final apunta al ultimo proceso listo para ejecutarse de la Cola X.
El último proceso listo para ejecutarse de la Cola X, no apunta al puntero que deterimina el final de la cola, esto es quizas lo más lioso de entender. Si sacais esto no tendreis problema.

Otra cosa a tener en cuenta es que cabecera y final no son 2 puntero sino son 2 array de punteros que cada uno apunta a una cola determinada.

Acordaros de cotemplar el caso base y posteriormente el caso general.

Me falta por poneros los resultados que me salen a mi cuando ejecuto las 3 pruebas con el nuevo planificador, espero ponerlo lo antes posible, no más tardar de mañana.

Ahora debes hacer aquí tu parde de la práctica.



Salu2.