Sistemi Operativi - User contributions [en]

ProvaTeorica 2013.05.30

2014-05-19T15:29:40Z

Mrta:

<h1>[http://www.cs.unibo.it/~renzo/so/compiti/2013.05.30.tot.pdf Testo del compito]</h1>

<h2> Esercizio g.1</h2>

<p> <b>PUNTO A:</b> (7+256+(256^2)+(256^3))*1kb =16.843.015kb quindi approssimativamente 16MB</p>
<p> <b> PUNTO B:</B> blocco indiretto triplo -> primo livello di idirizzamento 256 esimo blocco -> secondo livello di indirizzamento 256 esimo blocco -> terzo livello di indirizzamento al blocco 100000. Qundi in totale 4 blocchi </p>

<h2> Esercizio g.2 </h2>
[[File:Holt.png]]

<syntaxhighlight lang="C">
monitor eventp
{
typedef struct EP
{
unsigned int value;
condition okNotNull;
condition okToAdd;
intqueue q;
}
}

procedure entry EP* create(unsigned value)
{
EP *ep = new EP(value);
eps.enqueu(ep);
return ep;
}

procedure entry write(EP *d,unsigned value)
{
if(d.value+value > d.value.size()|| !d.q.empty()) {
d.q.enqueue(value);
d.okToAdd.wait();
d.q.dequeue();
}
d.value = d.value + value;
if (d.q.top()+value <= d.value.size())
d.okToAdd.signal();
else
d.okNotNull.signal();
}

// MAXINT - currentvalue < value
procedure entry unsigned int read(EP *ep)
{
if(!ep.value)
ep.okNotNull.wait();
unsigned int toReturn = ep.value;
ep.value = 0;
ep.okToAdd.signal();
return toReturn;
}
<syntaxhighlight>

Prova Teorica 2009.01.14

2014-05-19T14:58:06Z

Mrta: Created page with "Esercizio 1: Scrivere un monitor che implementi un buffer limitato (SIZE elementi) dove i messaggi abbiano associata una priorita'. I processi produttori richiamano pbb.enqueu..."

Esercizio 1: Scrivere un monitor che implementi un buffer limitato (SIZE elementi) dove
i messaggi abbiano associata una priorita'. I processi produttori richiamano
pbb.enqueue(m,prio)
mentre i processi consumatori chiamano
m=pbb.dequeue()
I primi SIZE processi produttori pongono i loro elementi nel buffer senza bloccarsi, i successivi si fermano in attesa.
Il consumatore deve sempre prendere l'elemento a priorita' massima fra quelli nel buffer *e* fra quelli in attesa.

<syntaxhighlight lang="C">
struct el {
int prio;
condition c;
};

struct bufel {
T payload;
struct el prioc;
};

struct bufel buf[SIZE+1];
int nbuf, nqueue;
condition oktoread;

procedure entry void enqueue(T m, int prio) {
if(nbuf>=SIZE) {
el=new(struct el); el.prio=prio;
nqueue++; q.enqueue(el); nqueue--;
free(el);
}
buf[nbuf].prio=prio; buf[nbuf].payload=m;
nbuf++;
sort(buf, nbuf); //in ordine crescente
oktoread.signal();
}

procedure entry dequeu(void) {
if(nbuf+nqueue==0)
oktoread.wait()
if(nqueue>0) {
el=q.dequeue(); //quello a prio max
el.c.signal();
}
nbuf--;
return nuf[nbuf].payload;
}

</syntaxhighlight>

ProvaPratica 2012.07.17

2014-05-19T14:09:35Z

Mrta:

<syntaxhighlight lang = "C">
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#define BUF_SIZE 20

int main(int argc, char** argv){
int ncopie, i, ris;
char command[BUF_SIZE];
if (argc<3) {printf("inserisci due o più argomenti (ncopie, command)\n"); exit(1);}
ncopie = atoi(argv[1]);
strcpy(command, argv[2]);
for (i = 0; i<ncopie; i++){
if(fork()){//processo padre
}
else {
char *env_el;
env_el = malloc(BUF_SIZE);
sprintf(env_el, "NCOPIA=%d", i);
//asprintf
//devo aggiungerci in fondo lo zero terminatore
char *newenviron[] = {env_el, (char*) 0};
//argv+2 sono gli argomenti, ovvero tutti gli argomenti passati dopo il secondo
ris = execve(argv[2], argv+2, newenviron);
if (ris == -1) {perror("execve"); exit(1);}
}
}
for (i = 0; i<ncopie; i++) wait(NULL);
return 1;
}</syntaxhighlight>
Alessandro
(In realtà non funziona bene, di fatto un processo fa quello che dovrebbe fare e gli altri danno bad address, se trovate l'errore correggetelo e scrivete qua sotto cosa avete cambiato e perché)

<syntaxhighlight lang="C">
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#define BUF_SIZE 20

int main(int argc, char** argv){
int ncopie, i, ris;
char command[BUF_SIZE];
if (argc<3) {printf("inserisci due argomenti (ncopie, command)\n"); exit(1);}
ncopie = atoi(argv[1]);
int fd[ncopie];
pid_t pid[ncopie];
for (i = 0; i<ncopie; i++){
char *tmpfile;
asprintf(&tmpfile,"/tmp/ncopie.%d.%d",getpid(),i);
fd[i]=open(tmpfile,O_CREAT|O_RDWR,0600);
unlink(tmpfile);
if((pid[i]=fork())==0){//processo padre
char *NCOPIA;
asprintf(&NCOPIA, "NCOPIA=%d", i);
char *newenviron[] = { NCOPIA, (void *)0};
dup2(fd[i],STDOUT_FILENO);
ris = execve(argv[2], argv+2, newenviron);
if (ris == -1) {perror("execve"); exit(1);}
}
}
for (i = 0; i<ncopie; i++) {
waitpid(pid[i],NULL,0);
lseek(fd[i],SEEK_SET,0);
char *buf[1024];
int n;
while ((n=read(fd[i],buf,1024))>0)
write(STDOUT_FILENO,buf,n);
}

return 1;
}
</syntaxhighlight>

ProvaPratica 2014.01.23

2014-04-30T14:53:51Z

Mrta:

[C esercizi 1 e 2]
<syntaxhighlight lang="C">
/*
*Esercizio 1: Linguaggio C (obbligatorio): (20 punti)
*Scrivere un programma in C “linean” che prenda come parametro il pathname di un file e un numero intero (che chiameremo n).
*Il programma deve stampare come output il numero di caratteri presenti nella n-ma riga del file se il file e' un file regolare di testo, non deve stampare nulla negli altri casi.
*Un file viene considerato di testo se tutti i suoi byte hanno valori compresi nel range 1-127.
*Per controllare se il file e' “regolare” usare la system call lstat
*/

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <errno.h>

#define BUFFSIZE 200

int istextfile( FILE *fd ){ //check if the file is a regular file of text,it means that every byte has a value between 1-127
int c;
while ( (c = getc ( fd ) ) != EOF && c <= 127 );
rewind(fd); //sets the file's cursor at the beginning,otherwise the linean program cannot find the line
return ( (c == EOF)? 1 : 0 );
}

void linean( char *path , int line ){
FILE *fd;
struct stat buf;
char bufline[BUFFSIZE];
char *res;
int n = line;
res = NULL;
lstat( path , &buf );
if ( S_ISREG( buf.st_mode ) )
{
fd = fopen( path , "r" );
if ( fd == NULL )
{
perror( "Error to open the file\n" );
exit(1);
}
if ( istextfile( fd ) )
{
while ( ( line > 0 ) ) //iterates until at the nline and when is reached then checks if the buffer contains something
{
res = fgets(bufline, BUFFSIZE , fd ); //every time the nline is buffered,when exits from the cicle, the buffer contains the nline
line--;
}
if ( res != NULL )
{
printf( "The file %s in line %d has : %d char\n" , path , n , ( strlen( bufline ) - 1 ) ); //strlen also consider the carriage return
}
else
printf( "Error: isn't possible to find the line\n" );
}
else
printf( "Error is not a regular file of text\n" );

fclose(fd);

}
else
printf( "The file %s isn't a regular file\n" , path );

}

int main( int argc , char *argv[] ){
int n = atoi( argv[2] );
linean( argv[1] , n );
return(0);
}

</syntaxhighlight>

<syntaxhighlight lang="C">
/*
*Esercizio 2: completamento (10 punti)
*Si scriva un programma C chiamato “lineandir”. Il risultato del programma, stampato su standard output, deve essere un solo
*numero intero: la somma del numero di caratteri presenti nelle n-me righe di tutti i file regolari, di testo, non nascosti (il primo
*carattere deve essere diverso da punto) della directory corrente.
*/

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <errno.h>
#include <stdlib.h>
#include <dirent.h>

#define BUFFSIZE 200

int istextfile( FILE *fd );
int linean( char *path , int line );
void lineandir( char *dir , int line );

void lineandir( char *dir , int line ){
int count , i;
int sumline;
struct dirent **de;
sumline = 0;
count = scandir( dir , &de , NULL , alphasort );
for ( i = 0 ; i < count ; i++ )
{
if ( de[i]->d_name[0] != '.' ) //doesn't consider the hidden files
sumline = sumline + linean( de[i]->d_name , line );
free(de[i]);
}
printf("The sum of char for every regular text file's nline in the current directory is: %d\n" , sumline );
free(de);
}

int istextfile( FILE *fd ){
int c;
while ( (c = getc ( fd ) ) != EOF && c <= 127 );
rewind(fd);
return ( (c == EOF)? 1 : 0 );
}

/*linean is modified so it can return the value of the char in the nline */
int linean( char *path , int line ){
FILE *fd;
struct stat buf;
char bufline[BUFFSIZE];
char *res;
int n = line;
res = NULL;
lstat( path , &buf );
if ( S_ISREG( buf.st_mode ) )
{
fd = fopen( path , "r" );
if ( fd == NULL )
{
perror( "Error to open the file\n" );
exit(1);
}
if ( istextfile( fd ) )
{
while ( ( line > 0 ) )
{
res = fgets(bufline, BUFFSIZE , fd );
line--;
}
if ( res != NULL )
{
return( ( strlen( bufline ) - 1 ) );
}
else
printf( "Error: isn't possible to find the line\n" );
}
else
printf( "Error is not a regular file of text\n" );

fclose(fd);

}
else
printf( "The file %s isn't a regular file\n" , path );

}

int main( int argc , char *argv[] ){
int n = atoi( argv[1] );
lineandir( "./" , n );
return(0);
}
</syntaxhighlight>

[Bash esercizio 3]
<syntaxhighlight lang="Bash">
#Esercizio 3: Script bash o Python: (10 punti):
#Il comando che dovrete implementare come script shell o programma python e' updatedir. Updatedir prende due directorycome parametri.
#updatedir dira dirb deve copiare in dirb tutti i file regolari che sono in dira e non in dirb. Se un file regolare e' presente con lo stesso nome sia in
#dira sia in dirb, il file deve essere copiato dalla dira alla dirb solo se i contenuti differiscono.

#! /bin/bash

for file in "$1"/*; do
if [[ -f $file ]] ; then #checks if the file is regular
thereisnotfile=1 #variable that identify if the file is also in dir2
for file2 in "$2"/*; do
if [[ -f $file2 ]] ; then
if [[ $file2 != $file ]] ; then #checks if the file is only in dir1 and not in dir2
continue
else
thereisnotfile=0 #the file is in both dir
fi
if [[ $thereisnotfile -eq 0 ]]; then
if [[ $(md5sum "$file") != $(md5sum "$file2") ]] ; then #checks if the file in dir1 is different of file in dir2 by md5sum
bn=$(basename "$file")
cp $file "$2"/"$bn"
thereisnotfile=2 #is set in this way for not continue to iterate
fi
fi
fi
done
if [[ $thereisnotfile -eq 1 ]]; then
bn=$(basename "$file")
cp $file "$2"/"$bn"
fi
fi
done
</syntaxhighlight>
Pirata

<syntaxhighlight lang="Bash">
#!/bin/bash

function usage {
command=$(basename "$0")
echo "Usage: $command source destination"
exit 1
}

if [[ ! -d $1 ]]
then
echo "Source is not a dir"
usage
fi

if [[ ! -d $2 ]]
then
echo "Destination is not a dir"
usage
fi

find $1 -type f -print0 | while IFS= read -r -d $'\0' file; do
filename=$(basename "$file")
if [[ -f "$2$filename" ]]
then
cp "$file" "$2$filename"
else
if cmp -s "$file" "$2$filename"
then
/* Do nothing are the same */
else
cp "$file" "$2$filename"
fi
fi
done
</syntaxhighlight>
Mrta

ProvaTeorica 2010.07.12

2014-04-14T15:36:34Z

Mrta: Created page with "== Esercizio 2 == Fatto dal professore <syntaxhighlight lang="Python"> # Esercizio 2: Message passing con priorita'. Sia dato un servizio di message passing asincrono. Si i..."

== Esercizio 2 ==

Fatto dal professore

<syntaxhighlight lang="Python">

# Esercizio 2: Message passing con priorita'. Sia dato un servizio di message passing asincrono. Si implementi un servizio
# di message passing con priorita' senza fare uso di processi server. Il nuovo servizio ha due chiamate psend(dest, prio,
# msg) e precv(sender). La precv consente la ricezione da chiunque (sender==*). Quando un processo P chiama la precv
# questa deve restituire il messaggio di massima priorita' fra quelli spediti dal sender specificato a P o sospendere il
# processo se non ce ne sono in attesa. (suggerimento: se serve si puo' usare la funzione getpid() che restituisce
# l'identificativo del processo chiamante).

psend(dest, pio, msg)
asend(dest,(MSG,getpid(),prio,msg))

precv(sender)
asend(getpid,(NULLTAG,getpid(),NULL,NULL))
do:
(tag,senderx,prio,msg)=arev(*)
if(tag==MSG):
msgdb.add(senderx,prio,msg)
while tag!=NULLTAG.
while (m=msgdb.getmaxprio(sender))=None:
(tag,senderx,prio,msg)=arev(*)
msgdb.add(senderx,prio,msg)
return m
</syntaxhighlight>

ProvaTeorica 2012.06.15

2014-04-14T15:23:32Z

Mrta:

<h1>http://www.cs.unibo.it/~renzo/so/compiti/2012-06-15.tot.pdf</h1>

<syntaxhighlight lang="C">
/*
* URL: http://www.cs.unibo.it/~renzo/so/compiti/2012-06-15.tot.pdf
* author: Tommaso Ognibene
*/

monitor palindrome5
{
// Struttura che rappresenta i numeri bloccati
typedef struct
{
condition C;
int N;
} Stopped;

Stopped stopped[10];
for (int i = 0; i < 10; i++)
stopped[i].N = 0;
int n = 0;
int palindrome[10];
repeated = {} // Python-like dictionary

procedure entry synch(int index)
{
// Se ho raggiunto la lunghezza del palindromo
if (n == 10)
{
// Azzero le variabili
n = 0;
repeated = {};
}
// [Case 1] parte sinistra del palindromo
if (n < 5)
{
// Se il numero e' gia' stato inserito
if (repeated[index])
{
// Mi fermo e attendo di essere sbloccato
stopped[index].N++;
stopped[index].C.wait();
stopped[index].N--;
}
palindrome[n++] = index;
repeated[index] = true;
}
// [Case 2] parte destra del palindromo
else
{
int number = palindrome[n - 5];
/* [Case 1] Esiste (almeno) un numero in attesa che corrisponde al numero che
si deve inserire. Lo riattivo. In questo modo evito la starvation. */
if (stopped[number].N > 0)
{
stopped[number].C.signal();
// Mi fermo e attendo di essere sbloccato
stopped[index].N++;
stopped[index].C.wait();
stopped[index].N--;
}
/* [Case 2] Non esiste un numero in attesa che corrisponde al numero che
si deve inserire. Inoltre l'attuale non corrisponde al numero che
si deve inserire. */
else if (number != index)
{
// Mi fermo e attendo di essere sbloccato
stopped[index].N++;
stopped[index].C.wait();
stopped[index].N--;
}
palindrome[n++] = index;
}
}
}
</syntaxhighlight>

Esercizio del professore da rivedere

<syntaxhighlight lang="C">
condition c[10]; /* current != -1 && ((pali && !i in seq) || (ndrome && seq[n]==i)) */
int current=-1;
boolean waiting[10];
boolean pali=True;
boolean ndrome=False;
int seq[5];
int n=0;

procedure entry synch(i) {
waiting[i]=True;
if(current==i) {
current=-1;
if(pali) {
if(n==4) ndrone=True, pali = False;
if(x=anynotin(seq, n, waiting))
c[x].signal();
} else {
c[seq[n]].signal;
if(n==0) ndrone=False, pali=True;

}
}
if(current!=-1 || pali && cerca(i, seq, n)!=0 || (ndrome && n!=4))
c[i].wait();
if(pali)
seq[n++]==i;
else
n--;
current=i;
waiting[i]=False;
}
</syntaxhighlight>

== Esercizio c.2 ==

<syntaxhighlight lang="Python">
/*
Esercizio c.2: Implementare facendo uso di un processo server e usando le asend() e areceive() le seguenti primitive
di comunicazione:
sx2send(m,dest1,dest2); Invia il messaggio m o a dest1 o a dest2 (ma non ad entrambi)
m = sx2receive(sender); Riceve un messaggio in maniera sincrona.
il mittente e il destinatario devono riattivarsi solo quando il destinatario ha ricevuto il messaggio.
*/

def sx2send(m,dest1,dest2):
asend(SND,getpid(),dest1,dest2,m),server)
arecv(server);

def(sx2receive(sender):
asend((RECV,getpid(),sender,NULL,NULL),server)
return arecv(server)

process server:
waiting=Set({})
pending=[]
while(True):
(tag,proc,pi1,p2,m)=arecv(*)
if(TAG==SND)
if p1 in waiting:
asend(m,p1)
asend(ACK,proc)
waiting-={p1}
else if p2 in waiting:
asend(m,p2)
asend(ACK,proc)
waiting-={p2}
else pending.append((proc,m,p1,p2))
else: #TAG==RECV
if(px,mx,p1x,p2x)=searchpending(pending,sender):
#cerca il primo che ha sender come uno dei destinatari
#ed elimina l'elemento dalla sequenza
asend(mx,sender)
asend(ACK,mx)
else:
waiting+={sender}
</syntaxhighlight>

ProvaTeorica 2012.06.15

2014-04-14T15:02:34Z

Mrta:

ProvaPratica 2005.02.10

2014-04-09T15:47:21Z

Mrta:

== Esercizio 1 ==

In una rete token-ring, i nodi sono organizzati ad anello e si scambiano un “token” che passa da un nodo al successivo.<br>
Quando un processo riceve il token:<br>
● stampa “pid: ho ricevuto il token”<br>
● attende 1 secondo<br>
● stampa “pid: spedisco il token al processo x”<br>
● spedisce il token al processo x<br>
dove pid è l'identificatore del processo che stampa, e x è l'identificatore del processo successivo.<br>
Scrivere un programma che genera N processi che comunicano tramite "token-ring". Viene lasciata allo studente la scelta<br>
del meccanismo di sincronizzazione/comunicazione (ma vedi punto 2).<br>
<br>

<syntaxhighlight lang="C">
/*
Prova Pratica di Laboratorio di Sistemi Operativi
10 febbraio 2005
Esercizio 1

URL: http://www.cs.unibo.it/~renzo/so/pratiche/2005.02.10.pdf

Nota: variazione che prevede un gestore (Master), di un token ring
composto da n processi figli (Slaves).

@author: Tommaso Ognibene
*/

// Dependencies
#include <ctype.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <unistd.h>

// Constants
#define True 1
#define False 0

// Data types
struct tokenRing
{
pid_t Pid;
int Token[2];
int Output[2];
struct tokenRing *Next, *Prev;
};

typedef struct tokenRing TokenRing;

// Function declarations
static inline void errorAndDie(const char *msg);
static inline void printAndDie(const char *msg);
static inline void testTokenRing(int n);
static inline int isNumber(char *text);

// Entry point
extern void run(int argc, char *argv[])
{
// Pre-conditions
if (argc != 2)
printAndDie("The function requires one parameter to be passed in.");
if (!isNumber(argv[1]))
printAndDie("The parameter should be a natural number.");

testTokenRing(atoi(argv[1]));
}

/*
* Check whether a string is a natural number or not
* Input: str, the string
* Output: 1, if the string is a natural number
* 0, else
*/
static inline int isNumber(char *str)
{
int i;

i = 0;
while (i < strlen(str) && isdigit(str[i]))
i++;

return i == strlen(str);
}

/*
* Create a token ring of n processes.
* The parent shall manage the token ring.
* Run a test showing the main logical steps in the parent standard output.
* Input: n, the number of processes
*/
static inline void testTokenRing(int n)
{
const char fifoPath[] = "token.fifo";
char token[5] = "token";
char buffer[512];
int i, fifo;
pid_t pid;
ssize_t count;
TokenRing *it, *first, *temp;

// First element of the token ring
first = it = (TokenRing *) malloc(sizeof (TokenRing));

// Create the named pipe if it does not yet exist
if (access(fifoPath, F_OK) < 0)
if (mkfifo(fifoPath, S_IRWXU) < 0)
errorAndDie("mkfifo");

for (i = 0; i < n; i++)
{
// Create a pipe for token communication
if (pipe(it->Token) < 0)
errorAndDie("pipe");

// Create a pipe for output redirection
if (pipe(it->Output) < 0)
errorAndDie("pipe");

// Fork
pid = fork();
if (pid < 0)
errorAndDie("fork");

// Child process
if (pid == 0)
{
// Open named pipe for writing
fifo = open(fifoPath, O_WRONLY);
if (fifo < 0)
errorAndDie("open");

// Close output side
if (close(it->Token[1]) < 0)
errorAndDie("close");

// Close input side
if (close(it->Output[0]) < 0)
errorAndDie("close");

// Re-direct the standard output
if (dup2(it->Output[1], STDOUT_FILENO) < 0)
errorAndDie("dup2");

while (True)
{
// Clear the buffer
memset(buffer, 0, sizeof (buffer));

// Wait for the token
count = read(it->Token[0], buffer, sizeof (buffer));
if (count < 0)
errorAndDie("read");

fprintf(stdout, "[slave #%d] Received the token from Master.\n", getpid());
fprintf(stdout, "[slave #%d] I'm gonna do some stuff now.\n", getpid());
fflush(stdout);
sleep(2);
fprintf(stdout, "[slave #%d] Giving back the token to Master.\n", getpid());
fflush(stdout);

// Give the token back
count = write(fifo, token, sizeof (token));
if (count < 0)
errorAndDie("write");
}

// Close the pipes
if (close(it->Token[0]) < 0 || close(it->Output[1]) < 0 || close(fifo) < 0)
errorAndDie("close");

exit(EXIT_SUCCESS);
}

// Close unused sides of the pipes
if (close(it->Token[0]) < 0 || close(it->Output[1]) < 0)
errorAndDie("close");

it->Pid = pid;

if (i + 1 == n)
break;

it->Next = (TokenRing *) malloc(sizeof (TokenRing));
temp = it;
it = it->Next;
it->Prev = temp;
}
it->Next = first;
first->Prev = it;

// Open named pipe for reading
fifo = open(fifoPath, O_RDONLY);
if (fifo < 0)
errorAndDie("open");

// Manage the token ring
it = first;
while (True)
{
// Clear the buffer
memset(buffer, 0, sizeof (buffer));

// Assign the token
printf("[Master] Assigning the token to slave #%d\n", it->Pid);
count = write(it->Token[1], token, sizeof (token));
if (count < 0)
errorAndDie("write");

// Redirect the children output
for (i = 0; i < 2; i++)
{
count = read(it->Output[0], buffer, sizeof (buffer));
if (count < 0)
errorAndDie("read");

if (write(STDOUT_FILENO, buffer, count) < 0)
errorAndDie("write");
}

// Wait for the token in return
count = read(fifo, buffer, sizeof (buffer));
if (count < 0)
errorAndDie("read");
printf("[Master] Received the token from slave #%d\n", it->Pid);

it = it->Next;
}

// Close the pipes
if (close(it->Token[1]) < 0 || close(it->Output[0]) < 0 || close(fifo) < 0)
errorAndDie("close");

// Remove the named pipe
if (unlink(fifoPath) < 0)
errorAndDie("unlink");
}

/*
* Print error message and exit
* Input: msg, the error message
*/
static inline void errorAndDie(const char *msg)
{
perror(msg);
exit(EXIT_FAILURE);
}

/*
* Print message and exit
* Input: msg, the message
*/
static inline void printAndDie(const char *msg)
{
printf("%s\n", msg);
exit(EXIT_FAILURE);
}
</syntaxhighlight>

Esercizio del professore da revisionare

<syntaxhighlight lang="C">
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

static int token=42;
int main(int argc, char *argv[])
{
int i;
int n=atoi(argv[1]);
char *s;
pid_t firstproc,nextproc,newproc;
firstproc=newproc=fork();
nextproc=0;
for (i=0; i<n; i++) {
if (newproc==0) {
int fdin, fdout;
//nextproc e' il successivo
if (nextproc != 0) {
asprintf(&s,"/tmp/np%03d",nextproc);
mknod(s,S_IFIFO | 0644, 0);
fdout=open(s,O_WRONLY);
free(s);
asprintf(&s,"/tmp/np%03d",getpid());
mknod(s,S_IFIFO | 0644, 0);
fdin=open(s,O_RDONLY);
free(s);
} else {
asprintf(&s,"/tmp/np%03d",getpid());
mknod(s,S_IFIFO | 0644, 0);
fdin=open(s,O_RDONLY);
free(s);
read(fdin,&nextproc,sizeof(nextproc));
asprintf(&s,"/tmp/np%03d",nextproc);
mknod(s,S_IFIFO | 0644, 0);
fdout=open(s,O_WRONLY);
free(s);
write(fdout, &token, sizeof(token));
}
while (1) {
int buf;
read(fdin, &buf, sizeof(buf));
printf("%d ricevuto il token\n",getpid());
sleep(1);
printf("%d spedisco il token a %d\n",getpid(),nextproc);
write(fdout, &token, sizeof(token));
}
exit(0);
}
nextproc=newproc;
if (i<n-1) newproc=fork();
}
int fdout;
asprintf(&s,"/tmp/np%03d",nextproc);
mknod(s,S_IFIFO | 0644, 0);
fdout=open(s,O_WRONLY);
free(s);
write(fdout, &firstproc, sizeof(firstproc));
close(fdout);
for (i=0; i<n; i++) {
int status;
wait(&status);
}
}
</syntaxhighlight>

ProvaPratica 2015.02.10

2014-04-09T15:44:54Z

Mrta: Mrta moved page ProvaPratica 2015.02.10 to ProvaPratica 2055.02.10

#REDIRECT [[ProvaPratica 2055.02.10]]

ProvaPratica 2055.02.10

2014-04-09T15:44:54Z

Mrta: Mrta moved page ProvaPratica 2015.02.10 to ProvaPratica 2055.02.10

ProvaPratica 2055.02.10

2014-04-09T15:43:06Z

Mrta: Created page with "== Esercizio 1 == In una rete token-ring, i nodi sono organizzati ad anello e si scambiano un “token” che passa da un nodo al successivo.<br> Quando un processo riceve il..."

ProvaPratica 2010.07.12

2014-04-09T14:48:35Z

Mrta:

<h1>http://www.cs.unibo.it/~renzo/so/compiti/2010-07-12.tot.pdf</h1>

== Esercizio 1 ==

<syntaxhighlight lang="C">
int aggiorna_maxprio(int maxprio,int prio,int waiting[]){
int i;
if(waiting[maxprio] == 0)
{
maxprio=0;
for(i=prio;i>=0;i--)
{
if(waiting[i]!=0)
{
maxprio=i;
break;
}
}
return maxprio;
}

monitor priocoop{
condition run[10];
int waiting[10]=0,0,0,0,0,0,0,0,0,0;
int maxprio=0;
int occupato=0;

procedure entry init(prio){
if(occupato==1)
{
if(maxprio < prio)
{
maxprio=prio;
}
waiting[prio]++;
run[prio].wait();
waiting[prio]--;
maxprio=aggiorna_maxprio(maxprio,prio,waiting);
}
occupato=1;
}

procedure entry yield(prio){
run[maxprio].signal();
if(maxprio < prio)
{
maxprio=prio;
}
waiting[prio]++;
run[prio].wait();
waiting[prio]--;
maxprio=aggiorna_maxprio(maxprio,prio,waiting);
}

procedure entry fini(prio){
occupato=0;
waiting[prio]--;
maxprio=aggiorna_maxprio(maxprio,prio,waiting);
run[maxprio].signal();
}
</syntaxhighlight>
Alessandro

<syntaxhighlight lang="C">
//Processo con prioritá 0 = Processo con piú alta prioritá
//Processo con prioritá 9 = Processo con meno prioritá
monitor priocoop {
condition oktogo[10];
int wait[10] = 0,0,0,0,0,0,0,0,0;
int running;
priocoop.init(prio) {
if(running != 0) {
wait[prio]++;
oktogo[prio].wait;
wait[prio]--;
}

running++;
}

priocoop.yield(prio) {
running--;
for(int i = 0;i<10;i++) {
if(wait[i] != 0) {
oktogo[i].signal();
wait[prio]++;
oktogo[prio].wait;
wait[prio]--;
break();
}
}
running++;
}

priocoop.fini() {
running--;
for(int i = 0;i<10;i++) {
if(wait[i] != 0) {
oktogo[i].signal();
break();
}
}

}
}
</syntaxhighlight>
-Midolo

<syntaxhighlight lang="C">
//0: priorita' maggiore
//9: priorita' minore
cond oktoenter[10];
int count[10];
bool running = false;

//restituisce la priorita' maggiore che ha un processo in attesa
getprio() {
for(i=0;i<10;i++) {
if(count[i]>0)
break;
}
return i;
}

priocoop() {
init (prio) {
if (running) {
count[prio]++;
oktoenter[prio].wait();
count[prio]--;
}
running = true;
}
yield(prio) {
i=getprio();
if (i < 10) {
// running = false;
oktoenter[i].signal();
count(prio)++
oktoenter[proc].wait();
// running = true;
count[prio]--;
}
}
fini(prio){
i=getprio();
if(i<10)
oktoenter[i].signal;
else
running=false;
}
}
</syntaxhighlight>
-Stefano B.

----

<syntaxhighlight lang="C">
monitor priocoop{
condition oktoenter[10];
queue waiting[10];

procedure entry init(int prio){
if(!(prio >= 0 && prio<=9))
exit(0);
}

procedure entry yield(int prio){
int priority=-1;
for (i=0; i<10; i++) {
if (! waiting[i].isempty())
priority=i;
}
oktoenter[priority].signal();
if(priority>=0){ /* se non ci fosse questo controllo avremmo un caso di deadlock
* in quanto le code sono vuote */
waiting[prio].enqueue();
oktoenter[prio].wait();
waiting[prio].dequeue();
}
}

procedure entry fini(){
int priority=-1;
for (i=0; i<10; i++) {
if (! waiting[i].isempty())
priority=i;
}
oktoenter[priority].signal();
}
}
</syntaxhighlight>
Francesca e Giulia

== Esercizio 2 ==
<syntaxhighlight lang="C">
db.getpriortymax(); //funzione che restituisce il messaggio con prioritá maggiore e lo rimuove dal db o 0 nel caso il db sia vuoto
Process n: {

psend(dest, prio,msg) {
asend((msg, prio),dest);
}

precv(sender) {
while((msg,prio) = arecv(sender)) {
db[sender].insert((msg,prio));
}
return (db[sender].getpriortymax());
}

}
</syntaxhighlight>
-Midolo

==Esercizio 3 ==
<syntaxhighlight lang="C">
lock=-1;

Process P[i]{
while(true){
do{;}
while(twomult.op(lock)==lock);
//critical section
lock = -lock;
//no critical section
}
}
</syntaxhighlight>

Inizialmente: a=1; b=1;

Primo processo:
lock=-1 a=-1 b=1
Siccome lock!=b esce dal while.

Secondo processo:
lock=-1 a=1 b=-1
Siccome lock==b non esce dal while e continua:
lock=-1 a=1 b=-1
Si ripeterano sempre gli stessi valori,
fino al cambio di valore di lock che passa da
-1 a 1 così :
lock=1 a=-1 b=-1;
Siccome lock!=b esce dal while.
Mentre l'altro processo si bloccherà poichè:
lock=1 a=1 b=1;
fino al ritorno di lock al valore -1;
lock=-1 a=-1 b=1;
C.V.D

----Alessandro

<h1>Parte generale</h1>

== Esercizio 1 ==
<syntaxhighlight lang="C">
P1: 1ms IoR, 7ms CPU, 1ms IoW, 1ms IoR, 7ms CPU, 1ms IoW, 1ms IoR, 7ms CPU, 1ms IoW, 1ms IoR, 7ms CPU, 1ms IoW
P2: 2ms IoR, 2ms CPU, 2ms IoW, 2ms IoR, 2ms CPU, 2ms IoW, 2ms IoR, 2ms CPU, 2ms IoW, 2ms IoR, 2ms CPU, 2ms IoW

time 1234567890123456789012345678901234567890
CPU 111111122111111122111111122111111122
IO 122 112222 112222 112222 1 22

time 1234567890123456789012345678901234567890
CPU 11221111122111122111 2211111111 11111
IO 122 2222 112222 22221122 11 1
</syntaxhighlight>

== Esercizio 2 ==
a) Lo stato è SAFE per x >= 8

Esempio di sequenza:

[[File:So1.png]]

COH valuta 2 = 20 → 15 → 30 → 0 → 30+x → 10+x → 32+x il seguito dipende dal valore di x

La sequenza è: 2 - 1 - 3 - 4

b1) con x = 8 e la sequenza: 2 - 4 si arriva in uno stato UNSAFE

b2) con x = 7 e la sequenza: 2 - 1 si è in uno stato SAFE

Giulia N.

ProvaPratica 2010.07.12

2014-04-09T14:47:02Z

Mrta:

<h1>http://www.cs.unibo.it/~renzo/so/compiti/2010-07-12.tot.pdf</h1>

== Esercizio 1 ==

<syntaxhighlight lang="C">
int aggiorna_maxprio(int maxprio,int prio,int waiting[]){
int i;
if(waiting[maxprio] == 0)
{
maxprio=0;
for(i=prio;i>=0;i--)
{
if(waiting[i]!=0)
{
maxprio=i;
break;
}
}
return maxprio;
}

monitor priocoop{
condition run[10];
int waiting[10]=0,0,0,0,0,0,0,0,0,0;
int maxprio=0;
int occupato=0;

procedure entry init(prio){
if(occupato==1)
{
if(maxprio < prio)
{
maxprio=prio;
}
waiting[prio]++;
run[prio].wait();
waiting[prio]--;
maxprio=aggiorna_maxprio(maxprio,prio,waiting);
}
occupato=1;
}

procedure entry yield(prio){
run[maxprio].signal();
if(maxprio < prio)
{
maxprio=prio;
}
waiting[prio]++;
run[prio].wait();
waiting[prio]--;
maxprio=aggiorna_maxprio(maxprio,prio,waiting);
}

procedure entry fini(prio){
occupato=0;
waiting[prio]--;
maxprio=aggiorna_maxprio(maxprio,prio,waiting);
run[maxprio].signal();
}
</syntaxhighlight>
Alessandro

<syntaxhighlight lang="C">
//Processo con prioritá 0 = Processo con piú alta prioritá
//Processo con prioritá 9 = Processo con meno prioritá
monitor priocoop {
condition oktogo[10];
int wait[10] = 0,0,0,0,0,0,0,0,0;
int running;
priocoop.init(prio) {
if(running != 0) {
wait[prio]++;
oktogo[prio].wait;
wait[prio]--;
}

running++;
}

priocoop.yield(prio) {
running--;
for(int i = 0;i<10;i++) {
if(wait[i] != 0) {
oktogo[i].signal();
wait[prio]++;
oktogo[prio].wait;
wait[prio]--;
break();
}
}
running++;
}

priocoop.fini() {
running--;
for(int i = 0;i<10;i++) {
if(wait[i] != 0) {
oktogo[i].signal();
break();
}
}

}
}
</syntaxhighlight>
-Midolo

<syntaxhighlight lang="C">
//0: priorita' maggiore
//9: priorita' minore
cond oktoenter[10];
int count[10];
bool running = false;

//restituisce la priorita' maggiore che ha un processo in attesa
getprio() {
for(i=0;i<10;i++) {
if(count[i]>0)
break;
}
return i;
}

priocoop() {
init (prio) {
if (running) {
count[prio]++;
oktoenter[prio].wait();
count[prio]--;
}
running = true;
}
yield(prio) {
i=getprio();
if (i < 10) {
// running = false;
oktoenter[i].signal();
count(prio)++
oktoenter[proc].wait();
// running = true;
count[prio]--;
}
}
fini(prio){
i=getprio();
if(i<10)
oktoenter[i].signal;
else
running=false;
}
}
</syntaxhighlight>
-Stefano B.

----

<syntaxhighlight lang="C">
monitor priocoop{
condition oktoenter[10];
queue waiting[10];

procedure entry init(int prio){
if(!(prio >= 0 && prio<=9))
exit(0);
}

procedure entry yield(int prio){
int priority=-1;
for (i=0; i<10; i++) {
if (! waiting[i].isempty())
priority=i;
}
oktoenter[priority].signal();
if(priority>=0){ /* se non ci fosse questo controllo avremmo un caso di deadlock
* in quanto le code sono vuote */
waiting[prio].enqueue();
oktoenter[prio].wait();
waiting[prio].dequeue();
}
}

procedure entry fini(){
int priority=-1;
for (i=0; i<10; i++) {
if (! waiting[i].isempty())
priority=i;
}
oktoenter[priority].signal();
}
}
</syntaxhighlight>
Francesca e Giulia

== Esercizio 2 ==
<syntaxhighlight lang="C">
db.getpriortymax(); //funzione che restituisce il messaggio con prioritá maggiore e lo rimuove dal db o 0 nel caso il db sia vuoto
Process n: {

psend(dest, prio,msg) {
asend((msg, prio),dest);
}

precv(sender) {
while((msg,prio) = arecv(sender)) {
db[sender].insert((msg,prio));
}
return (db[sender].getpriortymax());
}

}
</syntaxhighlight>
-Midolo

==Esercizio 3 ==
<syntaxhighlight lang="C">
lock=-1;

Process P[i]{
while(true){
do{;}
while(twomult.op(lock)==lock);
//critical section
lock = -lock;
//no critical section
}
}
</syntaxhighlight>

Inizialmente: a=1; b=1;

Primo processo:
lock=-1 a=-1 b=1
Siccome lock!=b esce dal while.

Secondo processo:
lock=-1 a=1 b=-1
Siccome lock==b non esce dal while e continua:
lock=-1 a=1 b=-1
Si ripeterano sempre gli stessi valori,
fino al cambio di valore di lock che passa da
-1 a 1 così :
lock=1 a=-1 b=-1;
Siccome lock!=b esce dal while.
Mentre l'altro processo si bloccherà poichè:
lock=1 a=1 b=1;
fino al ritorno di lock al valore -1;
lock=-1 a=-1 b=1;
C.V.D

----Alessandro

<h1>Parte generale</h1>

== Esercizio 1 ==
<syntaxhighlight>
P1: 1ms IoR, 7ms CPU, 1ms IoW, 1ms IoR, 7ms CPU, 1ms IoW, 1ms IoR, 7ms CPU, 1ms IoW, 1ms IoR, 7ms CPU, 1ms IoW
P2: 2ms IoR, 2ms CPU, 2ms IoW, 2ms IoR, 2ms CPU, 2ms IoW, 2ms IoR, 2ms CPU, 2ms IoW, 2ms IoR, 2ms CPU, 2ms IoW

time 1234567890123456789012345678901234567890
CPU 111111122111111122111111122111111122
IO 122 112222 112222 112222 1 22

time 1234567890123456789012345678901234567890
CPU 11221111122111122111 2211111111 11111
IO 122 2222 112222 22221122 11 1
</syntaxhighlight>

== Esercizio 2 ==
a) Lo stato è SAFE per x >= 8

Esempio di sequenza:

[[File:So1.png]]

COH valuta 2 = 20 → 15 → 30 → 0 → 30+x → 10+x → 32+x il seguito dipende dal valore di x

La sequenza è: 2 - 1 - 3 - 4

b1) con x = 8 e la sequenza: 2 - 4 si arriva in uno stato UNSAFE

b2) con x = 7 e la sequenza: 2 - 1 si è in uno stato SAFE

Giulia N.