2. (20 puntos) a.

Complete el cdigo de los tres procesos siguientes de manera que resuelvan las condiciones de competencia de sus regiones crticas mediante un mecanismo de alternancia estricta es decir, acceso alternado a regin crtica (k y a son variables compartidas por los tres procesos). Seale explcitamente cual es la regin crtica de cada proceso. ( 10 ) b. Explique que significa espera activa. ( 5 ) c. Que requisito debe cumplir el S.O. para permitir la ejecucin de los tres procesos sealados. ( 5 ) Proceso 1 while(TRUE){ while(k!=? ); a= a*8; k=? ; b= b*8; } Proceso 2 while(TRUE){ while(k!=? ); a= a/8; k= ? ; c= c/8; } Proceso 3 while(TRUE){ while(k!=? ); a= a+1; k= ? ; d= d+1; }

Proceso 1: k=1, luego k=2 Proceso 2. K=2, luego k=3 Proceso 3: K=3, Luego k=1

Espera activa significa que el proceso espera haciendo uso del procesador. Para que funcione la espera activa, el sistema operativo debe tener la posibilidad de sacar de ejecucin al proceso cuando completa su ranura de tiempo. Problema 2 (20 puntos). a. Un computador tiene 10 unidades de cinta, compartidas por n procesos. Cada proceso puede solicitar hasta 2 unidades. Cul es el nmero mximo de procesos concurrentes para el que se puede garantizar que no habr interbloqueo?. Justifique.

Basta que un proceso reciba dos recursos para que los libere, por la tanto la condicin de interbloqueo es que 10 procesos reciban un recurso. Si existen hasta 9 procesos, siempre ser posible asignarle dos recursos a uno de ellos, los que sern transferidos a los dems procesos.

b. En que se diferencia un interbloqueo de una posposicin indefinida. En el interbloqueo, ningn proceso progresa, ya que estn todos en espera. En el caso de posposicin indefinida, la actividad de una de las tareas posterga a las dems. c. Analice las consecuencias de posposicin indefinida en un sistema de tiempo compartido y en un sistema de tiempo real. En un proceso de tiempo compartido es molesto esperar demasiado, pero queda la posibilidad que el proceso de mayor prioridad termine y deje progresar a los que esperan. En el caso de tiempo real, no es tolerable la posposicin indefinida, puesto que lo que caracteriza a un sistema de tiempo real es la respuesta dentro de un tiempo mnimo. Problema 1(20 pts.) Los lectores azules y los lectores blancos se odian mutuamente, por lo que exigen leer un rea de datos compartida acompaados slo por a lo sumo 10 lectores de su mismo color. Desarrolle los procesos lee_azul y lee_banco, simtricos que permiten ejecutar el procedimiento lee_datos(), en las condiciones propuestas. No debe haber esperas indefinidas para los lectores de ningn color. Utilice semforos para sincronizar. Puede utilizar funciones como cola_vacia(semforo), que retorna verdadera si la cola de un semforo no tiene elementos en espera. Semforo semazul, semblanco, mutex, de_a_10; Integer total azul, azul, totalblanco, blanco; Boolean pasablanco, pasazul; Program azul_n Wait(mutex) If (!pasablanco and (totalazul<MAX or colavaca(semblanco)) {

signal (semazul) azul=azul+1 if (azul==1){ pasazul=true; totalblanco=0; { totalazul=totalazul+1 } Signal (mutex) Wait (semazul) Wait (de_a_diez) Leedatos() Signal(de_a_diez) Wait(mutex) azul=azul-1 If (azul==0) { pasazul=Falso If(!colavaca(semblanco)) { While(!colavaca(semblanco) { Signal(semblanco) blanco=blanco+1 } pasablanco=true totalazul=0 } Signal(mutex) } Program blanco_i Wait(mutex) If (!pasazul and (totalblanco<MAX or colavaca(azul)) { signal (blanco) blanco=blanco+1 if (azul==1){ pasablanco=true;

totalazul=0; { totalblanco=totalblanco+1 } Signal (mutex) Wait (blanco) Wait (de_a_diez) Leedatos() Signal(de_a_diez) Wait(mutex) blanco=blanco-1 If (blanco==0) { pasblancol=Falso If(!colavaca(azul)) { While(!colavaca(azul) Signal(azul) azul=azul+1 pasazul=true totalblanco=0 } Signal(mutex) } principal{ De_a-diez.entero=10 Pasablanco=false Pasazul=false Azul.entero=0 Blanco.entero=0 Totalblanco=0 Totalazul=0 Cobegin blanco_i i:1,n azul_n: n=1..k coend

Problema 3 (15 pts) En sper computador paralelo, cada unidad de proceso puede ejecutar operaciones unarias o binarias, en un tiempo de 0,1seg. Determine el ptimo de ganancia paralela (mxima ganancia, mnimo de procesadores) que se puede obtener en la operacin: X= Descripcin secuencial: P1= A+B P2= 4*C P3=4*B P4=COS(P1) P5=A-P3 P6 = A+P4 P7=SEN(P5) P8=SQRT(P6) P9=P8-P2 P10=P9/P7 P11=SQRT(P10) P1 P4 P6 P8 P9 P10 P11 P1 P4 P6 P8 P9 P10 P2 P3 P5 P7
A COS ( A B) 4 C SEN ( A 4 B)

P3 P5 P7 P2

P11

Tiempo secuencial: 11 Tiempo paralelo: 7 Ganancia: 11/7= 1,57 Esta ganancia se obtiene con 3 procesadores. Sin embargo, segn la tabla, se observa que el proceso P2 se puede posponer y hacerse despus de P7, con lo que la misma ganancia se obtiene con 2 procesadores, que corresponde a la cantidad ptima.

Sistemas Operativos Prueba #2 Problema 1 (30 pts) El archivo prob1.dat contiene 1.000.000 de registros de la forma: Nombre:_(20 espacios)___Apellido:__(20 espacios)__carnet:___(15 espacios)__ Nombre:......... El archivo est desordenado. Haciendo uso de los system calls de Unix 1. Obtener una copia del archivo, ordenado por apellido. 2. El largo de registro es 79 caracteres. Las partes fijas son nombre:, apellido: carnet: #include<fcntl.h> #include<string.h> main() { int fd1,fd2; long posicion,veces,pos;

char *compara="zzzzzzzzzzzzzzzzzzz",*ultimo; char nombre[21],apellido[21],rut[16]; ultimo=" "; fd1=open("prob.dat",O_RDONLY); fd2=open("ordenado.dat",O_WRONLY); for (veces=0;veces<100000;veces++) { for(posicion=0;posicion<1000000;posicion++) { lseek(fd1,posicion*79+36,0); //el apellido se inicia en la posicin 36 de cada registro. read(fd1,apellido,20); //printf("apellido= %s\n",apellido); if(strcmp(apellido,compara)<0) if(strcmp(ultimo,apellido) < 0) { compara=apellido; pos=posicion; } } //Encuentra el menor alfabticamente en el archivo, //que no ha sido clasificado previamente //printf("%s es el ultimo"); lseek(fd1,pos,0); read(fd1,nombre,20); read(fd1,apellido,20); read(fd1,rut,15); ultimo=apellido; compara="zzzzz"; //se recuperan los datos del menor alfabticamente write(fd2,apellido,20); write(fd2,nombre,20); write(fd2,rut,15); //se escribe en orden alfabtico. } //contina la bsqueda del siguiente menor }

3. Hacer un programa que ingrese nombre, apellido y carnet en la posicin i. Por molestar se quiere hacer esa tarea con tres procesos, uno escribe el nombre, otro el apellido y el tercero el carnet. Debe tenerse cuidado de no alterar las partes fijas del archivo. #include<fcntl.h> main() { long posicion, i; int fd; char nombre[20], apellido[20], carnet[15]; fd=open(prob1.dat,O_RDONLY); scanf(%d %s %s %s,&posicion, nombre, apellido, carnet); if(!fork()) { //proceso nombre lseek(fd,posicion*76 +7,0) write(fd,nombre,20); } else if(!fork()) { //proceso apellido lseek(fd,posicion*76+36,0) write(fd, apellido,20); } else { //proceso carnet lseek(fd, posicion*76+63,0); write(fd, carnet,15); } }

4. El archivo prob1.dat tiene permisos 600. Qu pasa si el programa lo ejecuta - Un miembro del grupo - Un usuario cualquiera Ningun usuario que no sea el propietario puede modificar el archivo, o leerlo, por lo que nadie ms que el dueo lo puede ejecutar. 5. Repita el anlisis si los permisos de prob1.dat son 444 SE puede realizar la parte 1, que saca una copia del archivo, por lo que slo requiere lectura, pero no la parte 2. 6. Que se debe hacer para que junto con mantener el permiso original 600, cualquier usuario pueda ejecutar el programa del punto 2. Basta con asignar SUID al programa (chmod +s al programa que modifica el archivo).

Problema 1 (20 pts) Que significa que un directorio tenga privilegio de ejecutable en UNIX (2) Permite hacer cambio de directorio a ese directorio. Que privilegios y donde hay que establecerlos para que un archivo no pueda ser ledo, escrito y ejecutado y adems no pueda ser visto su nombre nada ms que para su propietario.(5) El archivo debe tener privilegio de lectura slo para el dueo, al igual que el directorio donde se encuentra el archivo. Problema 2 (20 pts) El archivo Unix arbol.dat contiene un rbol binario. Los datos son del tipo short int (2 bytes). Los datos estn escritos en forma secuencial segn las posiciones 1,2,3,4,etc.,Los hijos de el nodo de posicin i se encuentran en 2*i (hijo izquierdo) y 2*i+1 (hijo derecho). El padre del nodo en posicin i est en (int) i/2. Disee un programa en C, que utilice los system calls, que reciba un nmero binario a la entrada, que se analiza bit a bit. Partiendo siempre desde la raz, imprime su valor, luego, si el bit es 0, recorre el hijo izquierdo y si el bit es 1, recorre el hijo derecho. El ltimo bit ingresado se marca con 1. las cadenas

de bits tienen a lo sumo 20 bits de largo. Una vez que se agota la entrada, se debe imprimir el camino inverso. // Solucin ejecutable en UNIX. //Se ha cambiado el tipo de dato a long int, para permitir una poblacin mayor de datos //Se incluye el listado del archivo utilizado para generar los datos Programa para generar el rbol de datos (archivo arbol.dat) El arbol es una simple secuencia de nmeros, desde 1 a 300000, los cuales se acceden siguiendo una estructura de rbol. #include<stdio.h> #include<fcntl.h> main() { int fd; long int dato; fd=open("arbol.dat",O_WRONLY+O_CREAT); for(dato=1; dato< 300000; dato++) write(fd, &dato, sizeof dato); }

Programa que recorre el arbol, siguiendo la entrada 1: derecha, 0: izquierda #include<stdio.h> #include<fcntl.h> main () { long int leido, lugar; int fd, ingreso, fin, altura; fd = open ("arbol.dat", O_RDONLY); read (fd, &leido, sizeof leido); printf ("raiz: %d\n", leido); scanf ("%d", &ingreso); lugar = 1; altura = 0; while (ingreso != -1) // camino de bajada. { altura++; if (ingreso == 0) lugar = 2 * lugar; else lugar = 2 * lugar + 1; lseek (fd, lugar * 4 - 4, 0); read (fd, &leido, sizeof leido); printf ("%d altura: %d\n", leido, altura); scanf ("%d", &ingreso); } // camino de subida fin = 1; while (fin != 0) { lseek (fd, lugar * 4 - 4, 0); read (fd, &leido, 4); printf ("%d altura %d\n", leido, altura); lugar = (int) (lugar / 2); if (lugar == 0) fin = 0; altura--; }

1. Disee un programa que utilizando system calls de UNIX haga lo siguiente: Un proceso padre debe originar un proceso hijo y establecer una va de comunicacin tipo pipe. Mediante el pipe, el proceso padre debe enviar al hijo su nmero de pid (el del padre) y luego queda slo en espera de seales. El proceso hijo entonces enviar una seal 2 al proceso padre. Cuando el proceso padre reciba una seal 2, crear un nuevo proceso que tiene como fin imprimir un mensaje de saludo y su nmero de pid. Luego debe enviar una seal 9 al primer proceso hijo. Disee el cdigo del programa en lenguaje C. (habr bonificacin de 5 puntos si corre) Cuantos procesos se ejecutan? Termina al final el programa o quedan procesos activos? cuntos?. Nota: el pid de un proceso es un entero. #include<signal.h> #include<stdio.h> int pidhijo; void accion() { int mipid; mipid=getpid(); kill(pidhijo,9); printf("el proceso %d ha botado el proceso %d\n",mipid, } main() { int fd[2]; int pid; pipe(fd);

pidhijo);

signal(SIGINT, accion); if(!(pidhijo=fork())) { read(fd[0],&pid,4); kill(pid,SIGINT); printf("el proceso %d hijo, le enva la seal al padre %d\n",getpid(),pid); for(;;); } else { pid=getpid(); write(fd[1],&pid,4); } for(;;); } Cdigo fuente vlido. Se crean dos procesos adems del proceso original. El proceso original no termina. Problema 3. a) Cmo puede el sistema de archivos UNIX proteger de virus? Limitando el permiso de modificacin de los archivos. b) Que significa permiso de ejecucin en un directorio en UNIX y para que sirve? Permite hacer cd (cambio de directorio) a un directorio. c) Describa las acciones que debe realizar el S.O. al crear un proceso mediante fork(). 1. Se crea una entrada en la tabla de procesos. 2. La tabla de direcciones de cdigo es la misma del programa original. La tabla de datos, se inicializa con los contenidos del proceso original. d) Si el proceso padre abre un archivo antes del fork(), que efecto tienen los accesos de los procesos padre e hijo al mismo archivo. Si se abre antes del fork, padre e hijo comparten el descriptor, lo que significa que tendrn permanentemente la misma vista del archivo (igual offset).

2. El archivo Unix personas.dat contiene registros con campos del tipo: Nombre Char 20 Apellido Char 20 Direccin Char 30 Edad short int (2 bytes) Sueldo long (4 bytes) Numident long (4 bytes) El archivo tiene 1.000.000 registros y est desordenado. El archivo ndice.ndx contiene una secuencia de registros con el orden alfabtico del archivo. Disee un programa para ejecutar concurrentemente las siguientes tareas: a) Listado en orden alfabtico del archivo. b) Total de dinero gastado en sueldos. c) Edad promedio de las personas. Observacin: los datos no se modifican, por lo que no se requiere exclusin mutua. Main() { int fd1, fdx; double promedio; short int edad; long reg; ordenado, sueldo, totedad, totsueldo; char datos[80]; fd1=open(personas.dat, O_RDONLY); fd2=open(ndice.ndx, O_RDONLY); fd3=open(personas.dat, O_READONLY); */ es necesario abrir dos veces el archivo personas para tener dos descriptores independientes. if (!fork()) { /* cdigo del proceso hijo, que har la lectura en orden alfabtico for(reg=0; reg <1000000; reg++) { /*Bsqueda indexada. read(fd2, &ordenado;4);

lseek(fd1, ordenado*80, 0); read(fd1, &datos, 80); imprima(datos); } else{ for (reg=0; reg < 1000000; reg++) { lseek(fd3, 70,1) read(fd3, &edad, 2); read(fd3, &sueldo, 4); totedad+=edad; totsueldo += sueldo; lsaeek(fd3, 4, 1); } printf(el pago por sueldo es %d la edad promedio es %6.3f, totsueldo, totedad/1000000); } }

2. Disee un programa en hilos de Linux que realiza la multiplicacin en paralelo de una matriz 20x50 por otra de 50x100, lo que produce un resultado 20x100 #include<pthread.h> #include<stdio.h> #include<stdlib.h> #define largo 20 #define ancho 50 #define alto 100 int A[largo][ancho], B[ancho][alto],C[largo][alto]; void *multipFila(void *param) { int fila=*(int *)param; int j,k; for(j=0;j<alto,j++) { C[fila][j]=0;

for(k=0;k<ancho;k++) C[fila][j]+=A[fila][k]*B[k][j] } }// el hilo no requiere retornar valores, ya que ste qued en la fila de la matriz. //tampoco se requiere sincronizacin con semforos ya que cada hilo dar origeb a una //fila completa del resultado. void main() { int i,j,param[largo]; pthread_t tid[largo]; //inicia matrices A y B for(i=0;i<largo;i++) for(j=0;j<ancho,j++) A[i][j]=10*rand()/RAND_MAX //Los valores de A son enteros aleatorios entre 0 y 10. for(i=0;i<ancho;i++) for(j=0;j<alto,j++) B[i][j]=10*rand()/RAND_MAX //Manda a multiplicar un hilo por fila. for(i=0;i<largo;i++) { param[i]=i; pthread_create(&tid[i], multipFila,&param[i]); } for(i=0;i<largo;i++) pthread_join(&tid[i],NULL); //ahora slo hay que imprimir la matriz C }