Instituto Tecnolgico De Piedras Negras

Materia: Sistemas Operativos Enrique Mendoza Hernndez Unidad 6 Fecha: 06/10/2011.

6.1 Satisface las tres condiciones de la seccin critica. 1.- La seccin crtica est garantizada a travs del uso de la bandera y a su vez variables. Si ambos procesos usan su bandera a la verdad, slo una tendr xito. 2.- El proceso es siempre, una vez ms a travs de la bandera y vuelta variables. Este algoritmo no proporciona alternancia estricta. 3.- Limita la espera se mantiene a travs del uso de la variable TTturn.

6.2 La exclusin mutua est garantizada: Tenga en cuenta que un proceso entra en la crtica seccin slo si los siguientes requisitos se cumple: no hay otra proceso tiene su variable de indicador que se establece en el cs. Dado que el proceso se establece su variable bandera propia en el conjunto cs antes de comprobar el estado de otros procesos, nos garantiza que no hay dos procesos entrar en el seccin crtica al mismo tiempo.

Avances requisito se cumple: Considere la situacin en varios procesos al mismo tiempo establecen sus variables de la bandera en el cs y luego comprobar si hay cualquier otro proceso tiene la bandera.

Limitado en espera: El acotado en espera se cumple por el hecho de que cuando un proceso k desea entrar en la seccin crtica, su bandera ya no se decide a ralent.

6.3 Espera activa se puede evitar, pero incurre en la sobrecarga asociada con un proceso de poner a dormir y tener que levantarse cuando el programa estatal apropiado se alcanza. Ocupado significa esperar a que un proceso est esperando por una condicin de ser satisfecha en un ciclo cerrado, sin renunciar al procesador.

Un proceso poda esperar por renunciar al procesador, y el bloque en un condiciones y esperar a ser despertado en algn momento oportuno en el en el futuro.

6.4 No son apropiados para sistemas de procesador nico porque la condicin de que rompiera un proceso de bloqueo slo poda obtenerse mediante la ejecucin de un proceso diferente.

6.5 Si un programa a nivel de usuario se le da la capacidad de deshabilitar las interrupciones, entonces se puede deshabilitar la interrupcin del reloj y evitar el cambio de contexto, con lo que podr utilizar el procesador sin que otros procesos de ejecucin.

6.6 Slo se impide que otros procesos se ejecutan en el procesador en el que se interrumpe con discapacidad, no hay limitaciones en lo que podra ser la ejecucin de los procesos en otros procesadores.

6.7 do { waiting[i] = TRUE; key = TRUE; while (waiting[i] && key) key = Swap(&lock, &key); waiting[i] = FALSE; /* critical section */ j = (i+1) % n;

while ((j != i) && !waiting[j]) j = (j+1) % n; if (j == i) lock = FALSE; else waiting[j] = FALSE; /* remainder section */ } while (TRUE);

6.8 Un semforo se inicializa con el nmero permitido de abrir toma de conexionado. Cuando una conexin es aceptada, la adquisicin de () de se llama, cuando una conexin se libera, el mtodo release () se llama.

6.9 Si dos operaciones de espera se ejecutan en un semforo cuando su valor es 1, si las dos operaciones no se realizan automticamente, entonces es posible que ambas operaciones puedan proceder a disminuir el valor del semforo violando as la exclusin mutua.

6.10 int guard = 0; int semaphore value = 0; wait()

{
while (TestAndSet(&guard) == 1); if (semaphore value == 0) { atomically add process to a queue of processes waiting for the semaphore and set guard to 0; } else { semaphore value--; guard = 0;

} }
signal()

{
while (TestAndSet(&guard) == 1); if (semaphore value == 0 && there is a process on the wait queue) wake up the first process in the queue of waiting processes else semaphore value++; guard = 0;

6.12 monitor semaphore { int value = 0; condition c; semaphore increment() { value++; c.signal();

}
semaphore decrement() { while (value == 0) c.wait(); value--;

} }
Cada variable de condicin est representada por una cola de hilos la espera de la condicin. Cada hilo tiene un semforo asociado con la cola de entrada. Cuando un hilo realiza una operacin de espera, se crea un semforo nuevo (inicializado a cero), se anexa el semforo a la cola asociada a la variable de condicin, y realiza un bloqueo semforo de la operacin de decremento en la recin creada.

6.13 monitor bounded_buffer { int items[MAX_ITEMS]; int numItems = 0; condition full, empty; void produce(int v) { while (numItems == MAX_ITEMS) full.wait(); items[numItems++] = v; empty.signal(); } int consume() { int retVal; while (numItems == 0) empty.wait(); retVal = items[--numItems]; full.signal(); return retVal; } }

6.14 La solucin al problema del bfer limitado dado arriba copia el valor producido en el buffer local del monitor y las copias de nuevo de bfer local del monitor para el consumidor. Estos copia operaciones podra ser costoso si se utiliza grandes extensiones de memoria para cada regin de amortiguamiento. En consecuencia, se podra modificar el cdigo indicado anteriormente para simplemente copia el puntero a la regin de buffer de entrada y salida del monitor de del Estado.

6.15 Puede ser evitado por mantener las marcas de tiempo asociadas con cola de procesos. Cuando un escritor ha terminado con su tarea, sera tras el proceso que ha estado esperando durante mucho tiempo. Cuando un lector llega y que

otro lector es el acceso a la base de datos, entonces se entra en la seccin crtica slo si no hay esperando escritores. Estas restricciones garantizar la equidad.

6.16 Las operaciones de la seal () asociado con los monitores no se persistentes en el siguiente sentido: si una seal se lleva a cabo y si hay sin hilos en espera, la seal se pasa por alto el sistema. En semforos, por otro lado, todas las seales de los resultados en el correspondiente incremento del valor del semforo, incluso si no hay subprocesos en espera.

6.17 El bloqueo podra ser transferido desde el proceso de sealizacin para el proceso que es el receptor de la seal. El receptor de la seal tendra que competir con todos los otros procesos para obtener el bloqueo de avanzara

6.18 monitor printers { int num avail = 3; int waiting processes[MAX PROCS]; int num waiting; condition c; void request printer(int proc number) { if (num avail > 0) { num avail--; return;

}
waiting processes[num waiting] = proc number; num waiting++; sort(waiting processes); while (num avail == 0 && waiting processes[0] != proc number) c.wait(); waiting processes[0] = waiting processes[num waiting-1];

num waiting--; sort(waiting processes); num avail--;

}
void release printer() { num avail++; c.broadcast();

} }
6.19 monitor file access { int curr sum = 0; int n; condition c; void access file(int my num) { while (curr sum + my num >= n) c.wait(); curr sum += my num;

}
void finish access(int my num) { curr sum -= my num; c.broadcast();

} }

6.20 Podria sufrir el problema de que un proceso puede ser despertado slo para encontrar que todava no es posible para hacer hacia el progreso, ya sea porque no era lo suficientemente flojos como para empezar a con un proceso cuando se despert, o si un proceso de intervencin se control, obtiene el monitor y comienza a acceder al archivo.

6.21 El problema de los lectores-escritores podra ser modificado con las siguientes generar ms esperan las declaraciones: Un lector puede realizar

"Esperar (escritores activos == 0 & & espera escritores == 0)" para comprobar que no hay escritores activos y no hay escritores de espera antes de que entra en la seccin crtica. El escritor puede realizar una "Esperar (escritores activos == 0 & & activos lectores == 0)" de verificacin para asegurarse el acceso mutuamente exclusivo. El sistema tendra que comprobar que uno de los subprocesos en espera tiene que ser despertado por comprobar que uno de su espera condiciones se cumplen despus de una seal.

6.22 monitor alarm { condition c; void delay(int ticks) { int begin time = read clock(); while (read clock() < begin time + ticks) c.wait();

}
void tick() { c.broadcast();

} }
6.23 Son no es apropiado para sistemas de un solo procesador, porque la condicin de que se rompera un proceso fuera de bloqueo slo podan obtenerse por la ejecucin de un proceso diferente. Si el proceso no es renunciar al procesador, otros procesos no tienen la oportunidad de establecer el programa de condicin necesaria para que el primer proceso para avanzar. En un multiprocesador sistema, otros procesos se ejecutan en procesadores de otros y por lo tanto modificar el estado del programa a fin de liberar el primer proceso de bloqueo.

6.24 Si la operacin tiene que ser abortado, los valores de los valores de datos actualizada tiene la necesidad de revertir a los valores antiguos. Este

requiere de los viejos valores de las entradas de datos para ser registrados antes de que las actualizaciones se llevan a cabo.

6.25 El protocolo de bloqueo de dos fases asegura conflicto de serie, porque bloqueos exclusivos (que se utilizan para operaciones de escritura) deben ser adquiridos en serie, sin liberar todos los bloqueos durante la fase de adquisicin (de crecimiento). Otras operaciones que deseen adquirir el mismo bloqueo que debe esperar a que la primera operacin para comenzar a liberar bloqueos. Al exigir que todos los bloqueos primero debe ser adquirido antes de liberar todos los bloqueos, nos estamos asegurando de que los posibles conflictos se evitan.

6.26 Si las transacciones que se emitieron despus de la transaccin deshecho haban tenido acceso a las variables que se han actualizado por la transaccin enrollado de nuevo, entonces estas operaciones tienen que rodar-espalda. Si no ha realizado este tipo de operaciones luego estos las operaciones son libres de cometer cuando sea apropiado. 6.27 Identificar los datos utilizados en la condicin de carrera: la variable los recursos disponibles. Identificar la ubicacin (o ubicaciones) en el cdigo en la carrera condicin se produce: El cdigo que disminuye los recursos disponibles y el cdigo que los recursos disponibles incrementos son las declaraciones que podran participar en condiciones de carrera. Uso de un semforo, fijar la condicin de carrera: Use un semforo para representa la variable de los recursos disponibles y reemplazar el incremento y las operaciones de disminucin por el incremento del semforo y semforo las operaciones de decremento.

6.28 monitor resources { int available_resources; condition resources_avail; int decrease_count(int count) { while (available_resources < count) resources_avail.wait(); available_resources -= count; } int increase_count(int count) { available_resources += count; resources_avail.signal(); }