Sistemas Operativos

Apellidos:
Nombre:
Sistemas Operativos
Ingenierı́a Informática de Sistemas
Examen Diciembre 2010
1. Juego de Pelota con procesos [2.5 puntos]
Implementar una función void ball game(int num players). que use procesos para simular jugadores. La función a implementar por cada proceso es: Esperar hasta recibir la pelota.
No deben existir races entre los procesos. Una vez recibida la pelota escribirá "Player
<pid>gets ball" y a continuación "Player <pid>send ball to player <pid>". Pueden
usarse las funciones, que son atómicas.
pid t fork();
int printf(const char ∗format, . . . ) ;
pid t getpid(void);
pid t ball who(void);
pid t ball next(void);
void ball send(pid t next);
2. namei() en mfs[2.5 puntos]
Implemente la función int namei(struct file system *fs, struct disk inode *d, const
char *pathname) con subdirectorios. Pueden usarse las siguientes funciones y suponerse un
solo extent:
#define ENTRYSIZE . . .
struct entry {
char name[ENTRYSIZE] ;
short inode;
};
struct file system {
struct disk inode root;
...
};
struct extent {
int start ;
int size ;
}
struct inode {
int size ;
struct extent e;
};
int inode read(struct device ∗dev, struct inode ∗ino, int num);
int inode write(struct device ∗dev, struct inode ∗ino, int num);
int data read(struct device ∗dev, void ∗block, int num);
int data write(struct device ∗dev, void ∗block, int num);
3. Dispositivo de bloques con buffer [2.5 puntos]
Implementar las funciones buffer block read() y buffer block write(). Las funciones se
diferencian de block read/write() en que guardan un buffer indexado por la función int
hash(int block number) de tamaño NUMCHAINS con las últimos bloques usados. Cada entrada es un array de CHAINSIZE bloques. Existe un campo dirty, para indicar si el contenido
es distinto del buffer en disco. La estructura buffer dev esta protegida por el mutex lock,
cada una de los cadenas individuales esta protegida por lock chain[i]. Hay que minimizar
el tiempo usado con cada uno de los locks adquiridos. La lecturas/escrituras (tanto de disco
como a memoria) hay que realizarlas con el lock chain correspondiente adquirido.
#define BLOCKSIZE . . .
#define NUMCHAINS . . .
#define CHAINSIZE . . .
struct chain {
char block[BLOCKSIZE] [CHAINSIZE] ;
int dirty [CHAINSIZE] ;
int block num[CHAINSIZE] ;
};
struct buffer dev {
mutex lock ;
struct device ∗dev;
mutex lock chain[NUMCHAINS] ;
struct chain chain[NUMCHAINS] ;
};
int block read(struct device ∗dev, void ∗buffer , int block number)}
int block write(struct device ∗dev, void ∗buffer , int block number)}
4. Algoritmo de segunda oportunidad [2.5 puntos]
Implemente en C el algoritmo de segunda oportunidad: int second chance(struct frames
*frames, int page, int write) teniendo en cuenta:
Si el mutex está ocupado, pasar a la siguiente página.
El mutex se bloquea antes de comenzar una escritura de una página. La función
page write devuelve el control despues de iniciar la escritura. Cuando la escritura
termina, el controlador desbloquea el lock.
La tabla de modificaciones de los dos campos es:
C viejo M viejo C nuevo M nuevo aclaración
0
0
1
w
se usa esta entrada para la nueva página.
0
1
0
0
Se inicia la escritura de la página.
n
0
n-1
0
Se decrementa el contador.
n
1
n-1
1
Se decrementa el contador.
#define NUMFRAMES
struct frame {
int num page;
int count;
bool modify;
mutex busy;
};
/∗ Num of page stored here ∗/
/∗ Count bit ∗/
/∗ Modify bit ∗/
/∗ La pagina se esta ocupada ∗/
struct frames {
int next;
struct frame[NUMFRAMES] ;
};
int page read(int page, int frame);
int page write(int page, int frame);
void mutex lock(mutex ∗m);
void mutex unlock(mutex ∗m);
int mutex trylock(mutex ∗m);