UTNianos

Hola gente! Estoy preparando el final de SO (que aun me falta mucho por leer) y empeze a hacer algunos ejercicios de final (De Filesystem, Planificacion y Sincronizacion por ahora.. que es lo que lei). El tema es que los ejercicios de final son muy diferentes a los de las guias teoricas (mezclan mucho y piden cosas que antes no habia visto.

Bueno, el hecho es que me gustaria que me digan que les parece la siguiente resolucion de los ejercicios que aparecen en el final del 10/12/2013 que esta subido a campus virtual (tambien lo adjunto por aca asi no lo tienen que buscar).



1)
Variables comunes:
int cintaA = 200
int cintaB = 100
int mutex_cintaA = 1
int mutex_cintaB = 1
int mutex_cintaS = 1

Maquina()
while(1){
....mercaderia = Fabrica();
....wait(mutex_cintaX);
....depositar_cintaX(mercaderia):
....signal(mutex_cintaX);
}

Robot()
while(1){
....wait(mutex_cintaX):
....mercaderia = retirar_cintaX();
....signal(mutex_cintaX);
....if(turno_cintaA()){
........wait(mutex_cintaA);
........wait(cintaA);
........depositar_cintaA(mercaderia);
........signal(mutex_cintaA);
....}else{
........wait(mutex_cintaB):
........wait(cintaB);
........depositar_cintaB(mercaderia);
........signal(mutex_cintaB);
}

EmpleadoA()
while(1){
....wait(mutex_cintaA):
....mercaderia = retirar_cintaA();
....signal(cintaA);
....signal(mutex_cintaA);
....armar_paquere();
}

EmpleadoB()
while(1){
....wait(mutex_cintaB):
....mercaderia = retirar_cintaB();
....signal(cintaB);
....signal(mutex_cintaB);
....armar_paquere();
}

2) En este segundo ejercicio tengo una duda que es el tema de los accesos que requiero a disco para poder encontrar el inodo de resumen.pdf. Tengo entendido que los inodos en EXT2 se levantan en memoria ni bien se carga el SO, pero no me cierra porque me dice que resumen.pdf se encuentra en el inodo numero 10

Puntero: 4 bytes
Bloques: 4 KiB --> 4096 Bytes
Cantidad de Entradas por bloque: 4096 bytes / 4 bytes = 1024 entradas
Relacion de Accesos logicos y fisicos: 1 acceso logico son 4 accesos fisicos (no estoy seguro.. pero asumo que la lectura de un sector es de un acceso fisico)
Resumen.pdf: 10Mib = 10240KiB

a)
Cantidad de bloques de archivos a leer: 10240KiB / 4KiB = 2560 bloques (2560 accesos logicos)

De la cantidad anterior: 10 bloques son directos, 1024 son indirectos de nivel 1 y 1526 son indirectos nivel 2, por lo tanto a la cantidad de accesos logicos que se obtuvieron anteriormente hay que sumarle 1 acceso de la indireccion de nivel 1 y 3 accesos de la indireccion de nivel 2 (porque utiliza dos indirecciones de segundo nivel). Por otro lado en el punto b me pide que grafique el contenido del archivo /root/secret diciendo cuantos bloques ocupa cada archvio. Mi pregunta aca es que cosas deberia poner exactamente.

Cantidad Total de Accesos Logicos: 2564
Cantidad Total de Accesos Fisicos: 10256

b)
Contenido de /root/secret
resumen.pdf - inodo 10 - 2560 bloques
resumenHL.pdf - inodo 10 - 2560 bloques (son los mismos bloques que el de arriba)
resumen.tar.gz - inodo 11 - 1280 bloques
resumenSL.tar.gz - inodo 12 - 0 bloques (es un inodo nuevo que posee una referencia al archivo original!)

Eso es todo. Espero que me puedan decir las cosas que hice mal (creo que todo jajaja) asi aprendo a hacer este tipo de ejercicios porque se me complican de verdad (y eso que lei toda la teoria de filesystem de silbercharzt).

Saludos,
Sinnick

Sinnick,
El ejercicio de sincronización tiene algunos errores.
En primer lugar, fijate que los semaforos mutex están mal usados. Los mutex se usan para "proteger" el contenido de una variable compartida por dos o más procesos.
Por ejemplo, si tengo un programa que hace:
x:=generarID();
printf(x);
La idea es que no venga algun otro programa y en el medio de las dos instrucciones me cambie el valor de la variable x, porque en ese caso imprimiría otro valor. Entonces deberías poner un mutex asi:
wait(mutex_x);
x:=generarID();
printf(x);
signal(mutex_x);

Así que te diría que repienses como estas usando los mutex, que es lo que estas protegiendo...

Y después, donde dice:
....if(turno_cintaA()){
........wait(mutex_cintaA);
........wait(cintaA);
........depositar_cintaA(mercaderia);
........signal(mutex_cintaA);

Tenes que tener cuidado porque si "wait(cintaA)" llegara a poner cintaA en -1, el proceso se bloquearía y el mutex_cintaA quedaría en 0, (porque antes le hiciste un wait) por lo que cualquier otro proceso que use este mutex se bloquería también.

Saludos!

Gracias por la respuesta! Ahora me voy a poner a revisarlo bien. Respecto al ejercicio de disco? Estuve pensando y me parece que me faltan los accesos que necesito para llegar a resumen.pdf, pero no estoy seguro como se hace..

Saludos!

Paso mi resolucion
Saludos!

SEM_A=200
SEM_B=100
SEM_ROBOT=0
SEM_E_A=0
SEM_E_B=0
MUTEX=1

MAQUINA()
=========
WHILE(1){
........WAIT(MUTEX)
........MERCADERIA = FABRICA()
........DEPOSITA_CINTAX(MERCADERIA)
........SIGNAL(MUTEX)
........SIGNAL(SEM_ROBOT)
}

ROBOT()
=======
WHILE(1){
........WAIT(SEM_ROBOT)
........WAIT(MUTEX)
........MERCADERIA= RETIRAR_CINTAX()
........IF(TURNO_CINTAA()){
................DEPOSITA_CINTAA(MERCADERIA)
................SIGNAL(MUTEX)
................WAIT(SEM_A)
................SIGNAL(SEM_E_A)
........}ELSE{
................DEPOSITA_CINTAB(MERCADERIA)
................SIGNAL(MUTEX)
................WAIT(SEM_B)
................SIGNAL(SEM_E_B)
........}
}

EMPLEADOA()
===========
WHILE(1){
........WAIT(SEM_E_A)
........WAIT(MUTEX)
........MERCADERIA=RETIRA_CINTAA()
........SIGNAL(MUTEX)
........SIGNAL(SEM_A)
........ARMA_EL_PAQUETE()
}

EMPLEADOB()
===========
WHILE(1){
........WAIT(SEM_E_B)
........WAIT(MUTEX)
........MERCADERIA=RETIRA_CINTAB()
........SIGNAL(MUTEX)
........SIGNAL(SEM_B)
........ARMA_EL_PAQUETE()
}

Revivo este tema, ¿algún ayudante y/o profesor que pueda confirmar si alguna o las dos soluciones que propusieron para el ejercicio de sincronización está bien o mal?

A mi entender, la 1er solución propuesta tiene el error grave de que el Robot podría intentar sacar paquetes de la cinta principal cuando todavía las máquinas no depositaron absolutamente nada.

Pero la 2da solución propuesta también me hace ruido, es decir, me parece que hay un exceso de mutex, incluso hay secciones del código que están muteadas innecesariamente a mi parecer.

---

A mi la cantidad de accesos del ejercicio 2a me dio 2568 (2560 bloques de datos + 3 de indirección simple + 1 de indirección doble + "/" + "root" + "secret" + "resumen.pdf (el inodo en cuestión")

La duda que tengo es la siguiente, ¿Qué nos indica esa nota debajo del ejercicio que dice que el disco tiene sectores de 1 KB (aparte de que tenemos 4 sectores por bloque ya que el bloque es de 4 KB)? ¿Nos está diciendo que a la cantidad de accesos calculada previamente hay que multiplicarla por 4 (ya que el ejercicio pide ACCESOS A DISCO)? En ese caso, ¿Qué es lo que hay que multiplicar por 4, el total de accesos, sólo los accesos a bloques de datos y bloques de punteros, la ruta?

Hola, yo resolveria asi:

1)
Variables comunes:
int cintaA = 200 / Int cintaB = 100 / int depositado_cintaX = 0 / int mutex_cintaA = 1 / int mutex_cintaB = 1 / int mutex_cintaX = 1

Maquina()

while(1){
mercaderia = Fabrica();
wait(mutex_cintaX);
depositar_cintaX(mercaderia):
signal(mutex_cintaX);
signal(depositado_cintaX);
}

Robot()

while(1){
wait(depositado_cintaX);
wait(mutex_cintaX):
mercaderia = retirar_cintaX();
signal(mutex_cintaX);

if(turno_cintaA()){
wait(cintaA);
wait(mutex_cintaA);
depositar_cintaA(mercaderia);
signal(mutex_cintaA);

}else{

wait(cintaB);
wait(mutex_cintaB):
depositar_cintaB(mercaderia);
signal(mutex_cintaB);
}

EmpleadoA()
while(1){
wait(mutex_cintaA):
mercaderia = retirar_cintaA();
signal(mutex_cintaA);
signal(cintaA);
armar_paquere();
}

EmpleadoB()
while(1){
wait(mutex_cintaB):
mercaderia = retirar_cintaB();
signal(mutex_cintaB);
signal(cintaB);
armar_paquere();
}

Hola, mi resolución es casi igual a la de Danlco, pero me parece que el problema con esa resolución es que los empleados pueden querer sacar paquetes de la cinta A y B sin que haya ninguno cargado. Mi resolución agrega 2 semáforos más:

mutex_cintaX, mutex_cintaA, mutex_cintaB = 0
depositado_cintaX, cantCintaA, cantCintaB = 0
libreCintaA = 200, libreCintaB=100

Maquina()

while(1){
mercaderia = Fabrica();
wait(mutex_cintaX);
depositar_cintaX(mercaderia):
signal(mutex_cintaX);
signal(depositado_cintaX);
}

Robot()

while(1){
wait(depositado_cintaX);
wait(mutex_cintaX):
mercaderia = retirar_cintaX();
signal(mutex_cintaX);

if(turno_cintaA()){
wait(libreCintaA);
wait(mutex_cintaA);
depositar_cintaA(mercaderia);
signal(mutex_cintaA);
signal(cantCintaA);

}else{

wait(libreCintaB);
wait(mutex_cintaB):
depositar_cintaB(mercaderia);
signal(mutex_cintaB);
signal(cantCintaB);
}

EmpleadoA()
while(1){
wait(cantCintaA);
wait(mutex_cintaA);
mercaderia = retirar_cintaA();
signal(mutex_cintaA);
signal(libreCintaA);
armar_paquete();
}

EmpleadoB()
while(1){
wait(cantCintaB);
wait(mutex_cintaB);
mercaderia = retirar_cintaB();
signal(mutex_cintaB);
signal(cintaB);
armar_paquete();
}

Gracia a lo que comentaron pude corregir lo que me faltaba
Me quedo con la resolucion de fer89cai

Coincido con los errores que marco legui de la primera solucion. Pero en su solucion al poner:

................DEPOSITA_CINTAA(MERCADERIA)
................SIGNAL(MUTEX)
................WAIT(SEM_A)

Ahi no sirve de mucho, pq lo hubiera depositado igual.. y la idea es que se deposite solo si hay espacio. Utilizar el mismo mutex para todo hace que se deje de depositar en la cinta X por que se esta retirando de ella y tratando de depositar en A o B, por eso me parece mejor usar tres semaforos mutex diferentes como hizo fer89cai.

con el A estoy de acuerdo con fer, lo hice tal cual solo que los llamé "lleno"y "vacio"

el B, alguien podría dar otra opinión?
Dieron 2 resultados distintos pero de i-nodos y no tengo idea del tema.