ProvaTeoria 2012.01.12

2014-07-03T21:35:38Z

GiuliaN: /* Esercizio 1 */

ProvaTeoria 2012.01.12

2014-07-03T21:35:23Z

GiuliaN: /* Esercizio 1 */

ProvaTeoria 2011.01.17

2014-06-06T15:53:30Z

GiuliaN: /* Esercizio 1 */

=[http://www.cs.unibo.it/~renzo/so/compiti/2011-01-17.tot.pdf TESTO COMPITO]=

==Esercizio 1==

<syntaxhighlight lang="C">
/*Scrivere un monitor reqq che gestisca una coda di richieste.
I richiedenti chiamano la funzione che ha la seguente signature:
answer_t reqq.query(request_t request);
Query deve fermare il processo richiedente fino a completamento della richiesta da parte di un gestore. Il valore di ritorno
e' la risposta del gestore.
Ci sono N gestori che si comportano come segue:
multiq_handler: process[i, i=0,..,N-1] {
request_t req;
int type;
while (1) {
req=reqq.getquery(i);
reqq.reply(i,handle(req));
}
}
Le richieste vengono assegnate ai gestori disponibili o accodate se sono tutti impegnati. Quando un gestore termina la
gestione (funzione handle, che non implementare!) invia il risultato tramite la reply. Il valore passato alla reply deve
essere restituito al richiedente come valore di ritorno della funzione query. Se non vi sono richieste disponibili i gestori si
fermano attendendo nuove richieste.*/

monitor reqq{
condition oktogetquery;
condition oktoask;
condition oktogo;
queue waiting;
int gestori=0;

procedure entry answer_t query(request_t request){
waiting.enqueue(request);
if(gestori>=N)
oktoask.wait();
oktogetquery.signal();
send(request);
oktogo.wait();
if(!waiting.isEmpty())
oktoask.signal();
}

procedure entry request_t getquery(int i){
if(waiting.isEmpty())
oktogetquery.wait();
gestori++;
waiting.dequeue();
}

procedure entry answer_t reply(int i, rips){
gestori--;
oktogo.signal();
}
}

</syntaxhighlight>
Giulia e Lisa

----

<syntaxhighlight lang="C">
/*
Esercizio 1: Scrivere un monitor reqq che gestisca una coda di richieste.
I richiedenti chiamano la funzione che ha la seguente signature:
answer_t reqq.query(request_t request);
Query deve fermare il processo richiedente fino a completamento della richiesta da parte di un gestore. Il valore di ritorno
e' la risposta del gestore.
Ci sono N gestori che si comportano come segue:
multiq_handler: process[i, i=0,..,N-1] {
request_t req;
int type;
while (1) {
req=reqq.getquery(i);
reqq.reply(i,handle(req));
}
}
Le richieste vengono assegnate ai gestori disponibili o accodate se sono tutti impegnati. Quando un gestore termina la
gestione (funzione handle, che non implementare!) invia il risultato tramite la reply. Il valore passato alla reply deve
essere restituito al richiedente come valore di ritorno della funzione query. Se non vi sono richieste disponibili i gestori si
fermano attendendo nuove richieste.
*/

/*La mia soluzione si basa su una struttura reqEntry contenente un campo per la domanda, uno per la risposta, una condizione oktoexit e un intero per il gestore.
Quando arriva un richiedente inserisce una struttura con una domanda e con i campi risposta e gestore vuoti.
Quando un gestore si occupa di una domanda setta l'opportuno campo gestore al suo indice e, al termine della routine handle(), inserisce la sua risposta nell'opportuno
campo della struct risvegliando il richiedente*/

struct reqEntry
{
request_t req;
condition oktoexit;
answer_t reply=NULL;
int handler=VOID; //VOID è un valore speciale avente valore diverso dagli indici dei gestori
}
monitor reqq
{
reqEntry* rq=Queue(); /*coda di reqEntry*/
condition oktohandle; /*per i gestori*/
answer_t procedure entry query(request_t request)
{
rq.insert(request);
rp=rq.searchByReq(request);
oktohandle.signal(); /*cerco se esiste un gestore in attesa per la mia richiesta*/
rp->oktoexit.wait();
risp=rp->reply;
remove(rp); /*recupero la risposta e rimuovo la struct dalla coda*/
return risp;
}
request_t procedure entry getquery(int index)
{
if isEmptyFree(rq) /*isEmptyFree ritorna 1 se non ci sono struct libere (cioè con handler VOID) nella coda di reqEntry*/
{
oktohandle.wait();
}
rp=rq.searchFree(); /*restituisce un elemento della coda di reqEntry avente handler VOID*/
rp->handler=index;
return rp;
}
procedure entry reply(int index, answer_t rep)
{
rp=rq.searchByHandler(index); /*cerca nella lista la struct avente handler uguale al mio indice*/
rp->reply=rep;
rp->oktoexit.signal();
}
}
</syntaxhighlight>

==Esercizio 3==

<syntaxhighlight lang="C">

struct sendINFO
{
pid_t receiver;
int nmsg;
}

sendINFO* listINFO=List(); //ogni processo ha un database di strutture sendINFO per sapere quanti messaggi di ogni destinatario
//risultano ancora non recapitati

T* database=List(); //ogni processo ha un database di messaggi

int iasend(pid_t destination, T message)
{
T tmpMSG;
sendINFO tmpINFO;
asend(destination,message);
if ((tmpINFO=listINFO.search(destination))==NULL) //se questo destinatario non ha ancora un'entry nella lista, lo inserisco
{
list.insert(destination,0);
tmpINFO=listINFO.search(destination);
}
tmpINFO.nmsg++;

/*SCORRIMENTO BUFFER DI MESSAGGI E AGGIORNAMENTO LISTA*/
asend(getpid(),"BOT");
while((tmpMSG=arecv(*))!="BOT")
{
if (tmpMSG=="OK")
{
tmpINFO=listINFO.search(tmpMSG.sender);
tmpINFO.nmsg--;
if (nmsg==0)
listINFO.remove(tmpINFO);
}
else
db.add(tmpMSG);
}
tmpINFO=search(destination);
if(tmpINFO!=NULL)
return tmpINFO.nmsg;
else
return 0;
}

T iareceive(pid_t sender)
{
T ris;
ris=db.search(sender);
if (ris==NULL)
ris=arecv(sender);
asend(sender,"OK");
return ris;
}
</syntaxhighlight>
-stefano92

ProvaTeorica 2013.02.15

2014-05-10T18:06:11Z

GiuliaN:

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

Esercizio 1

<syntaxhighlight lang="C">
/*
Esercizio c.1: (a) Scrivere un monitor dualwriter che realizzi un doppio buffer limitato (ogni buffer ha ampiezza
BUFSIZE) che consenta a uno scrittore di scrivere contemporaneamente due elementi che andranno rispettivamente
nel primo e nel secondo buffer. Le letture :
procedure entry void write(type1 e1, type2 e2);
procedure entry type1 read1();
procedure entry type2 read2();
La funzione write deve attendere che ci sia spazio in entrambi i buffer.
La funzione read attende che vi sia almeno un elemento nel buffer indicato
*/
monitor dualwriter
{
type1* buffer1;
type2* buffer2;
condition oktowrite,oktoread1, oktoread2
procedure entry void write (type1 e1, type2 e2)
{
if (sizeof(type1)>=BUFSIZE || sizeof(type2)>=BUFSIZE)
oktowrite.wait();
buffer1.push(e1);
buffer2.push(e2);
oktoread1.signal();
oktoread2.signal();
}

procedure entry type1 read1()
{
if (sizeof(buffer1)==0)
oktoread1.wait();
buffer1.pop();
if (sizeof(buffer2)<BUFSIZE)
oktowrite.signal();
}

procedure entry type2 read2()
{
if (sizeof(buffer2)==0)
oktoread2.wait();
buffer2.pop();
if (sizeof(buffer1)<BUFSIZE)
oktowrite.signal();
}
}
</syntaxhighlight>
-stefano92

----

<syntaxhighlight lang="C">
monitor dualwriter{
queue buffer1;
queue buffer2;
condition oktowrite;
condition oktoread1;
condition oktoread2;

procedure entry void write(type1 e1, type2 e2){
if((buffer1.len() == BUFSIZE) || (buffer2.len() == BUFSIZE)) /*se uno dei due buffer è pieno non puoi inserire*/
oktowrite.wait();

buffer1.enqueue(e1);
buffer2.enqueue(e2);

oktoread1.signal();
oktoread2.signal();
}

procedure entry type1 read1(){
if(buffer1.len() == 0) /*buffer vuoto*/
oktoread1.wait();

buffer1.dequeue;
oktowrite.signal();
}

procedure entry type2 read2(){
if(buffer2.len() == 0) /*buffer vuoto*/
oktoread2.wait();

buffer2.dequeue;
oktowrite.signal();
}
}
</syntaxhighlight>
Giulia

<h2> Esercizio g.1 </h2>
[[File:RoundRobin2cpu.png]]

ProvaTeorica 2013.01.24

2014-04-30T14:02:14Z

GiuliaN:

testo: http://www.cs.unibo.it/~renzo/so/compiti/2013-01-24.tot.pdf

Esercizio C1:
(a) Scrivere un monitor nmbb che realizzi un buffer limitato (di ampiezza BUFSIZE) che consenta alle
chiamate write (inserimento nel buffer) e read (lettura da buffer) di operare su vettori di piu' elementi. In particolare
l'interfaccia delle procedure entry da implementare e' la seguente:
procedure entry write(int n, struct elem *v);
procedure entry read(int m, struct elem *w);
se n o m sono maggiori di BUFSIZE le funzioni non devono fare nulla (caso di errore).
La funzione write deve attendere che ci sia spazio nel buffer per inserire n elementi (il vettore v conterra' n elementi).
Solo quando e' possibile completare l'operazione vengono inseriti tutti gli elementi di v nel buffer.
La funzione read attende che vi siano almeno m elementi nel buffer quindi estrae dal buffer (in ordine FIFO) m elementi e li copia nel vettore w .
(b) sono possibili casi di deadlock? (motivare dettagliatamente la risposta)

La mia Soluzione:
<syntaxhighlight lang="C">
read(): legge dalla coda un elemento senza rimuoverlo
queue(elem v,int n): inserisce nella coda n elementi v;
dequeue(int n): legge n elementi dalla coda e li rimuove;

monitor mnbb{
conditon oktowrite, oktoread;
queue qwrite,qread;

procedure entry write(int n, struct elem *v){
if(n > BUFSIZE){
return(ERROR);
}
if( n > (BUFSIZE - buff.lengh)){
qwrite.queue( n, 1 );
oktowrite.wait();
}
buff.queue( v, n );
if(qread.read() <= buff.lengh){
qread.dequeue(1);
oktoread.signal();
}
}

procedure entry read(int m, struct elem *w){
if(m > BUFSIZE){
return(ERROR);
}
if(m > buff.lengh){
qread.queue( m, 1 );
oktoread.wait();
}
w = buff.dequeue(m);
if(qwrite.read() <= (BUFSIZE - buff.lengh)){
qwrite.dequeue(1);
oktowirte.signal();
}
}
}
</syntaxhighlight>
- Midolo

----

<syntaxhighlight lang="C">
monitor nmbb{
queue buffer;
condition oktowrite;
condition oktoread;

/* assumiamo che essendo un buffer limitato ci sia un solo processo che vuole scrivere e un solo processo che vuole leggere */
int N, M;

procedure entry write(int n, struct elem *v){
if(n>BUFSIZE) return;
N=n;
if((BUFSIZE - buffer.len) < N)
oktowrite.wait();

for(i=0; i<N; i++)
buffer.enqueue(v[i]);

if(buffer.len >= M)
oktoread.signal();
}

procedure entry read(int m, struct elem *w){
if(m>BUFSIZE) return;
M=m;
if((BUFSIZE - buffer.len) < M)
oktoread.wait();

for(i=0; i<M; i++)
w[i] = buffer.dequeue;

if((BUFSIZE - buffer.len) >= N)
oktowrite.signal();
}
}
</syntaxhighlight>
Si può verificare deadlock. Esempio: un lettore vuole leggere un tot di elementi, ma quelli presenti non sono sufficienti. Uno scrittore a sua volta non può più scrivere un certo numero di elementi in quanto il buffer è parzialmente occupato. Lo scrittore aspetterà che il lettore legga; il lettore aspetterà invece lo scrittore: deadlock.

L'eventualità che si verifichi deadlock tuttavia è contemplata dalla traccia, come fa capire il punto b)

Gabriele e Giulia

== Esercizio g1 ==

{| border="1"
|-
|TEMPO
|1
|2
|3
|4
|5
|6
|7
|8
|9
|10
|11
|12
|13
|14
|15
|16
|17
|18
|19
|20
|21
|22
|23
|24
|-
|CPU 1
|P1
|P1
|P1
|P4
|P4
|P4
|P3
|P2
|P2
|<br>
|<br>
|P1
|P1
|<br>
|P3
|P3
|P3
|P4
|<br>
|P1
|P1
|P1
|P1
|P1
|-
|CPU 2
|P2
|P2
|P3
|P3
|P3
|P1
|P1
|P4
|P4
|P4
|P4
|P4
|P4
|P4
|P4
|P4
|P2
|P2
|P2
|P2
|P2
|P3
|P3
|P3
|-
|I/O
|<br>
|<br>
|P2
|P2
|P2
|P2
|<br>
|P1
|P1
|P1
|P1
|P3
|P3
|P3
|P2
|P1
|P1
|P1
|P1
|P3
|P3
|P4
|<br>
|<br>
|}

GiuliaN.

ProvaTeorica 2013.01.24

2014-04-29T15:10:16Z

GiuliaN: /* Esercizio g1 */

Esercizio C1:
(a) Scrivere un monitor nmbb che realizzi un buffer limitato (di ampiezza BUFSIZE) che consenta alle
chiamate write (inserimento nel buffer) e read (lettura da buffer) di operare su vettori di piu' elementi. In particolare
l'interfaccia delle procedure entry da implementare e' la seguente:
procedure entry write(int n, struct elem *v);
procedure entry read(int m, struct elem *w);
se n o m sono maggiori di BUFSIZE le funzioni non devono fare nulla (caso di errore).
La funzione write deve attendere che ci sia spazio nel buffer per inserire n elementi (il vettore v conterra' n elementi).
Solo quando e' possibile completare l'operazione vengono inseriti tutti gli elementi di v nel buffer.
La funzione read attende che vi siano almeno m elementi nel buffer quindi estrae dal buffer (in ordine FIFO) m elementi e li copia nel vettore w .
(b) sono possibili casi di deadlock? (motivare dettagliatamente la risposta)

La mia Soluzione:
<syntaxhighlight lang="C">
read(): legge dalla coda un elemento senza rimuoverlo
queue(elem v,int n): inserisce nella coda n elementi v;
dequeue(int n): legge n elementi dalla coda e li rimuove;

monitor mnbb{
conditon oktowrite, oktoread;
queue qwrite,qread;

procedure entry write(int n, struct elem *v){
if(n > BUFSIZE){
return(ERROR);
}
if( n > (BUFSIZE - buff.lengh)){
qwrite.queue( n, 1 );
oktowrite.wait();
}
buff.queue( v, n );
if(qread.read() <= buff.lengh){
qread.dequeue(1);
oktoread.signal();
}
}

procedure entry read(int m, struct elem *w){
if(m > BUFSIZE){
return(ERROR);
}
if(m > buff.lengh){
qread.queue( m, 1 );
oktoread.wait();
}
w = buff.dequeue(m);
if(qwrite.read() <= (BUFSIZE - buff.lengh)){
qwrite.dequeue(1);
oktowirte.signal();
}
}
}
</syntaxhighlight>
- Midolo

----

<syntaxhighlight lang="C">
monitor nmbb{
queue buffer;
condition oktowrite;
condition oktoread;

/* assumiamo che essendo un buffer limitato ci sia un solo processo che vuole scrivere e un solo processo che vuole leggere */
int N, M;

procedure entry write(int n, struct elem *v){
if(n>BUFSIZE) return;
N=n;
if((BUFSIZE - buffer.len) < N)
oktowrite.wait();

for(i=0; i<N; i++)
buffer.enqueue(v[i]);

if(buffer.len >= M)
oktoread.signal();
}

procedure entry read(int m, struct elem *w){
if(m>BUFSIZE) return;
M=m;
if((BUFSIZE - buffer.len) < M)
oktoread.wait();

for(i=0; i<M; i++)
w[i] = buffer.dequeue;

if((BUFSIZE - buffer.len) >= N)
oktowrite.signal();
}
}
</syntaxhighlight>
Si può verificare deadlock. Esempio: un lettore vuole leggere un tot di elementi, ma quelli presenti non sono sufficienti. Uno scrittore a sua volta non può più scrivere un certo numero di elementi in quanto il buffer è parzialmente occupato. Lo scrittore aspetterà che il lettore legga; il lettore aspetterà invece lo scrittore: deadlock.

L'eventualità che si verifichi deadlock tuttavia è contemplata dalla traccia, come fa capire il punto b)

Gabriele e Giulia

== Esercizio g1 ==

{| border="1"
|-
|TEMPO
|1
|2
|3
|4
|5
|6
|7
|8
|9
|10
|11
|12
|13
|14
|15
|16
|17
|18
|19
|20
|21
|22
|23
|24
|-
|CPU 1
|P1
|P1
|P1
|P4
|P4
|P4
|P3
|P2
|P2
|<br>
|<br>
|P1
|P1
|<br>
|P3
|P3
|P3
|P4
|<br>
|P1
|P1
|P1
|P1
|P1
|-
|CPU 2
|P2
|P2
|P3
|P3
|P3
|P1
|P1
|P4
|P4
|P4
|P4
|P4
|P4
|P4
|P4
|P4
|P2
|P2
|P2
|P2
|P2
|P3
|P3
|P3
|-
|I/O
|<br>
|<br>
|P2
|P2
|P2
|P2
|<br>
|P1
|P1
|P1
|P1
|P3
|P3
|P3
|P2
|P1
|P1
|P1
|P1
|P3
|P3
|P4
|<br>
|<br>
|}

GiuliaN.

ProvaTeorica 2013.01.24

2014-04-29T15:09:45Z

GiuliaN:

ProvaPratica 2011.09.12

2014-04-29T13:59:24Z

GiuliaN: /* Esercizio 1 */

<h1>http://www.cs.unibo.it/~renzo/so/compiti/2011-09-12.pdf</h1>

== Esercizio 1 ==

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

int N_DIR1=0,N_DIR2=0;

int source(char*s)
{
int x=strlen(s);
if (x>=3)
{
if ((s[x-1]=='c') || (s[x-1]=='h'))
{
if (s[x-2]=='.') return 1;
}
}
return 0;
}
void print_diff(char**dir1,char**dir2)
{
int i,j,found=0;
for (i=0;i<N_DIR1;i++){
for(j=0;j<N_DIR2;j++){
if (!strcmp(dir1[i],dir2[j]))
found=1;
}
if (found!=1)
printf("%s presente solo nella directory 1\n",dir1[i]);
found=0;
}

found=0;

for (i=0;i<N_DIR2;i++)
{
for(j=0;j<N_DIR1;j++){
if (!strcmp(dir2[i],dir1[j]))
found=1;
}
if (found!=1)
printf("%s presente solo nella directory 2\n",dir2[i]);
found=0;
}
return;
}
int main (int argc,char*argv[])
{
int ris,i=0;
char c;
char*tmp;
struct stat prova;
char**filedir1=NULL,**filedir2=NULL;
DIR *dp,*dp2;
struct dirent *ep;
if (argc!=3)
{
printf("Usage: ./cmpsource.out DIR1 DIR2\n");
return(1);
}
/*APERTURA DIRECTORY 1*/
dp = opendir (argv[1]);
if (dp != NULL)
{
while ((ep = readdir (dp))) /*Leggo i file nella directory*/
{
ris=lstat(ep->d_name,&prova); /*Recupero le informazioni sul file*/
if (S_ISREG(prova.st_mode)) /*file regolare*/
{
/*IL FILE E' UN ESEGUIBILE REGOLARE*/
if (source(ep->d_name)){ /*IL FILE E' UN SORGENTE (.c/.h)*/
N_DIR1++;
filedir1=(char**)realloc(filedir1,N_DIR1*sizeof(char*));
filedir1[N_DIR1-1]=ep->d_name;
}
}
}
closedir (dp); /*ORA IN filedir1[] CI SONO TUTTI I FILE SORGENTE DELLA DIRECTORY 1*/
}
/*FINE LETTURA DIRECTORY 1*/
/*APERTURA DIRECTORY 2*/
dp2 = opendir (argv[2]);
if (dp2 != NULL)
{
while ((ep = readdir (dp2))) /*Leggo i file nella directory*/
{
ris=lstat(ep->d_name,&prova); /*Recupero le informazioni sul file*/
if (S_ISREG(prova.st_mode)) /*file regolare*/
{
/*IL FILE E' UN ESEGUIBILE REGOLARE*/
if (source(ep->d_name)){ /*IL FILE E' UN SORGENTE (.c/.h)*/
N_DIR2++;
filedir2=(char**)realloc(filedir2,N_DIR2*sizeof(char*));
filedir2[N_DIR2-1]=ep->d_name;
}
}
}
closedir (dp); /*ORA IN filedir1[] CI SONO TUTTI I FILE SORGENTE DELLA DIRECTORY 1*/
}
/*FINE LETTURA DIRECTORY 2*/
print_diff(filedir1,filedir2);
return 0;
}
</syntaxhighlight>

stefano92

----

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

int lastchar(char *name){
int i=0;
while(name[i]!='\0')
i++;
return(i-1);
}//restituisce l'indice dell'ultimo carattere della stringa

int main(int argc, char *argv[]){
char dir1[1024];
char dir2[1024];
int n1, n2;
struct dirent **namelist1;
struct dirent **namelist2;
struct stat buf1;
struct stat buf2;
int lc;

if(argc==3){ /*se vengono passate in input due directory va bene*/
strcpy(dir1,argv[1]);
strcpy(dir2,argv[2]);
n1 = scandir(dir1, &namelist1, NULL, 0);
n2 = scandir(dir2, &namelist2, NULL, 0);
if(n1<0 || n2<0)
perror("scandir");
else {
int index[n1];
int i=0;
int j=0; //delimitatore
while(n1--){
stat(namelist1[n1]->d_name,&buf1);
lc = lastchar(namelist1[n1]->d_name);
if((namelist1[n1]->d_name[lc]=='c' &&
namelist1[n1]->d_name[lc-1]=='.') ||
(namelist1[n1]->d_name[lc]=='h' &&
namelist1[n1]->d_name[lc-1]=='.')){
index[i]=n1;
i++;
}
}
j=i;
int bool=0;
while(n2--){
stat(namelist2[n2]->d_name,&buf2);
lc = lastchar(namelist2[n2]->d_name);
if((namelist2[n2]->d_name[lc]=='c' &&
namelist2[n2]->d_name[lc-1]=='.') ||
(namelist2[n2]->d_name[lc]=='h' &&
namelist2[n2]->d_name[lc-1]=='.')){
for(i=0; i<j; i++){
if(strcmp(namelist2[n2]->d_name, namelist1[index[i]]->d_name)==0){ //sono uguali
bool=1;
index[i]=-1;
}
}
if(bool==0)
printf("%s not in %s\n",namelist2[n2]->d_name,dir1);
}
bool=0;
}
printf("\n");
for(i=0; i<j; i++){
if(index[i]>=0)
printf("%s not in %s\n",namelist1[index[i]]->d_name,dir2);
}
}
}
else /*altrimenti errore, vogliamo in input 2 directory*/
printf("errore\n");
}

</syntaxhighlight>
GiuliaN.

2014-04-07T09:30:34Z

GiuliaN: /* Esercizio 1 */

File:So1.png

2014-04-07T09:30:17Z

GiuliaN:

Help:Editing

2014-04-07T09:29:54Z

GiuliaN: Blanked the page

Help:Editing

2014-04-07T09:29:41Z

GiuliaN: Created page with "heeeeeeeeeeeeeeeeeeeelp"

heeeeeeeeeeeeeeeeeeeelp

2013-12-18T15:25:11Z

GiuliaN: Created page with "Esercizio 1 <syntaxhighlight lang="C"> /* http://www.cs.unibo.it/~renzo/so/pratiche/2013.01.25.pdf Scrivere un programma listexe che fornisca in output l'elenco dei process..."

Main Page

2013-12-18T15:21:52Z

GiuliaN:

Questo è il Wiki del Corso di Sistemi Operativi

[[Esercizi a caso del Prof.]]

[[Python Programma tieni punteggio.]]

[[Comandi visti alle lezioni.]]

[[SYS CALL viste a lezione.]]

[[Parametri con getopt().]]

[[Funzione con numero variabile di parametri.]]

[[stampf - implementazione ridotta della printf.]]

[[ProvaPratica 2013.07.18]]

[[ProvaPratica 2013.06.21]]

[[ProvaPratica 2013.05.29]]

[[ProvaPratica 2013.02.15]]

[[ProvaPratica 2013.01.25]]

----
Ricordate che per creare un account o quando viene richiesto di risolvere un semplice calcolo occorre ricordare quanto scritto [[qui]]

ProvaPratica 2013.06.21

2013-12-15T14:30:41Z

GiuliaN:

== Esercizio 1 ==
<syntaxhighlight lang="C">
/*
Prova Pratica di Laboratorio di Sistemi Operativi
20 giugno 2013
Esercizio 1

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

@author: Tommaso Ognibene
*/

#include <stdio.h>
#include <stdlib.h>
#include <dirent.h>
#include <errno.h>
#include <unistd.h>

/* Comparison function for iNode
* Input: 2 dirent pointers
* Output:
* 1, if iNode[a] > iNode[b]
* 0, if iNode[a] == iNode[b]
* -1, else */
int iNodeComparison(const struct dirent **a, const struct dirent **b)
{
long iNodeA = (long)(*a)->d_ino;
long iNodeB = (long)(*b)->d_ino;
return (iNodeA > iNodeB) - (iNodeA < iNodeB);
}

/* Scan a directory ->
* Order the entries by iNode number ->
* Print name and iNode of each file. */
void scanDirectory(char *dir)
{
int result, iterator;
struct dirent **files;

result = scandir(dir, &files, NULL, iNodeComparison);

// Check if any errors occurred
if (result < 0)
{
perror("scandir()");
exit(EXIT_FAILURE);
}

// Loop through directory entries
for(iterator = 0; iterator < result; iterator++)
{
printf("%s/%s %li\n", dir, files[iterator]->d_name, (long)files[iterator]->d_ino);

// Garbage collection
free(files[iterator]);
}
free(files);
}

// Entry point
int main(int argc, char *argv[])
{
char cwd[1024];

// if (number of parameters
switch(argc)
{
// == 0) => Use the current directory
case 1:
if (!getcwd(cwd, sizeof(cwd)))
{
perror("getcwd()");
exit(EXIT_FAILURE);
}
scanDirectory(cwd);
exit(EXIT_SUCCESS);

// == 1) => Use the given directory
case 2:
scanDirectory(argv[1]);
exit(EXIT_SUCCESS);

// > 1) => Wrong input
default:
printf("The function requires 0 or 1 parameters.\n");
exit(EXIT_FAILURE);
}
}
</syntaxhighlight>

----

La mia versione:
<syntaxhighlight lang="C">
/*Scrivere un programma che stampi il numero di inode di ogni file presente in una direcotory passata come argomento (o della
direcotry corrente se il programma viene chiamato senza parametri) e stampi l'elenco in ordine crescente di numero di i-node.
Es:
$ lsino demo
demo/. 1972484
demo/.. 1971834
demo/1.c 1972528
demo/a.out 1972485
demo/l1 1972486
demo/l2 1972486
demo/l3 1972486
demo/link.c 1972528*/

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

int main(int argc, char *argv[]){
struct stat sb;
char cwd[1024];
struct dirent **namelist;
int n; /*valore di ritorno di scandir*/
int i=0;

if(argc>1){ /*se la directory e' stata data in input*/
strcpy(cwd,argv[1]);
}
else{ /*se la directory non viene data in input*/
getcwd(cwd, sizeof(cwd));
}
/*ora dentro cwd c'è la cartella interessata*/

n = scandir(cwd, &namelist, NULL, alphasort);

if(n<0)
perror("scandir");
else {
while (i<n) {
printf("%s/%s %ld\n", cwd,namelist[i]->d_name,(long)namelist[i]->d_ino);
free(namelist[i]);
i++;
}
free(namelist);
}
}

</syntaxhighlight>
Non mi è chiara una cosa: nel testo specifica "stampi l'elenco in ordine crescente di numero di i-node", tuttavia nell'esempio sono ordinati grazie a quella che penso sia l'alphasort e quindi è la soluzione che ho sviluppato io.
Giulia N.

== Esercizio 3 ==

[Python 3]

<syntaxhighlight lang="Python">
'''
Prova Pratica di Laboratorio di Sistemi Operativi
20 giugno 2013
Esercizio 3

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

@author: Tommaso Ognibene
'''

import os, sys, hashlib

def Main(argv):
# Check number of arguments
if len(argv) != 1:
print("The function does not require arguments to be passed in.")
return

# Build a dictionary with key-value pair {file size - [file name]}
sameSize = { }
PopulateSameSize(sameSize)

# Build a dictionary with key-value pair {MD5 hash - [file name]}
sameContent = { }
for filePaths in sorted(sameSize.values(), key = len, reverse = True):
# No files with same size => No files with same content
if len(filePaths) < 2: break
PopulateSameContent(filePaths, sameContent)

# Print results
PrintResults(sameContent)

print("Done!")

# Populate a dictionary with key-value pair {file size - [file name]}
def PopulateSameSize(sameSize):
for dirPath, _, fileNames in os.walk(os.getcwd()):
for fileName in fileNames:
filePath = os.path.join(dirPath, fileName)
fileSize = os.path.getsize(filePath)
sameSize[fileSize] = sameSize.get(fileSize, []) + [filePath]

# Populate a dictionary with key-value pair {MD5 hash - [file name]}
def PopulateSameContent(filePaths, sameContent):
for filePath in filePaths:
md5 = GetMd5Hash(filePath)
fileRelPath = os.path.relpath(filePath, os.getcwd())
sameContent[md5] = sameContent.get(md5, []) + [fileRelPath]

# Get the MD5 hash without loading the whole file to memory
# Break the file in chunks whose size is a multiple of 128
# This takes advantage of the fact that MD5 has 128-byte digest blocks
def GetMd5Hash(filePath, blockSize = 2 ** 20):
digest = hashlib.md5()
with open(filePath, "rb") as file:
for chunk in iter(lambda: file.read(blockSize), b''):
digest.update(chunk)
return digest.hexdigest()

# Printout the lists of files having same content
def PrintResults(sameContent):
print("Lists of files having same content:")
for files in sorted(sameContent.values(), key = len, reverse = True):
if len(files) < 2: break
print("[{0}]".format(", ".join(file for file in files)))

if __name__ == "__main__":
sys.exit(Main(sys.argv))
</syntaxhighlight>

----

----

ecco la mia versione:
<syntaxhighlight lang="Python">
import os, hashlib

def fileCurrDir():#restituisce una lista res di file presenti nella directory
fcd = os.listdir('.')
res = []
for ott in fcd:
if os.path.isfile('{0}'.format(ott)):res.append(ott)
else:continue
return res

def dictsize(fl=fileCurrDir()):#restituisce un dizionario con key filesize e value lista di filenames aventi size di filesize
res = {}
for f in fl:
if os.path.getsize('{0}'.format(f)) in list(res.keys()):res[os.path.getsize('{0}'.format(f))].append(f);continue
else:pass
res[os.path.getsize('{0}'.format(f))] = list()
res[os.path.getsize('{0}'.format(f))].append(f)
return res

def dictremsa(a=dictsize()):#data un dizionario key::list rimuove tutti gli item la cui len di lista sia unitaria
tmp = list(a.keys())
for tmpkey in tmp:
if len(a[tmpkey]) < 2: a.pop(tmpkey)
else:continue
return a

def hashcontrolinsl(l1): #data una lista di nomi di file compara l hash di tutte le possibili coppie dentro l1
while l1 != []:
toTest = l1.pop()
del res[:]
res.append(toTest)
for tmp in l1:
#res.append(list[toTest,tmp])
#return res
hasher = hashlib.md5()
hasher2 = hashlib.md5()
f = open('{0}'.format(toTest), 'rb')
toHash = f.read()
hasher.update(toHash)
toTesthash = hasher.hexdigest()
f.close()
f = open('{0}'.format(tmp), 'rb')
toHash2 = f.read()
hasher2.update(toHash2)
tmphash = hasher2.hexdigest()
if tmphash==toTesthash: #print('{0} e {1} sono uguali\n'.format(toTest,tmp))
res.append(tmp)
else:continue
if len(res)>1:
print(res);res.pop(0)
for j in res:
l1.pop(l1.index(j))

def hashcontroltoMajorTom(a=dictremsa()):#fa in modo che vengano "hashate" solo delle liste di file che abbiano passato il "stessadimenzione" test
hasher = hashlib.md5()
try:
obviouslyequal = a.pop(0)
print("i seguenti file hanno lo stesso contenuto... NULLA!!!!!:\n")
for oe in obviouslyequal:
print("{0}".format(oe))
except KeyError:pass
values = list(a.values())
print("\ni seguenti file contengono qualcosa ma sono uguali:\n")
for namelist in values:
hashcontrolinsl(namelist)

hashcontroltoMajorTom()
</syntaxhighlight>
-fede

==Bash==
Qualche idea per Bash...<br/>
Si potrebbero usare:<br/>
Per la dimensione in byte dei <file>:
fileSize=$(stat --format=%s <file>)
Per avere l'output del solo hash md5 (senza l'ausilio di altri comandi):
fileHashMd5=$(md5sum <file> | while read fileHash fileName; do echo $fileHash; done)

<syntaxhighlight lang="Bash">
#Fede&Alessio#
for file in *; do
if [[ -f "$file" ]] ; then
filesize=$(stat -c%s "$file")
for file2 in *; do
if [[ -f "$file2" ]] ; then
if [[ "$file" = "$file2" ]]; then
continue
fi
filesize2=$(stat -c%s "$file2")
if [[ $filesize -eq $filesize2 ]]; then
diff "$file" "$file2" && echo ""$file" == "$file2"" ###
fi
fi
done
fi
done
#Purtroppo non siamo riusciti a finire e abbiamo optato per una soluzione poco efficiente con un diff, poi continueremo per rendarlà un po migliore
</syntaxhighlight>

2013-11-25T21:05:39Z

GiuliaN:

[Python 3]

<syntaxhighlight lang="Python">
'''
Prova Pratica di Laboratorio di Sistemi Operativi
29 maggio 2013
Esercizio 3

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

@author: Tommaso Ognibene
'''

import os, sys

def Main(argv):
# Check number of arguments
if len(argv) != 2:
print("The function requires one argument to be passed in.")
return

# Check parameters
topDir = str(sys.argv[1])
if not os.path.isdir(topDir):
print("The parameter should be an existing directory.")
return

# Build a dictionary with key-value pair {file extension - total size}
extensionSize = { }
GetSize(topDir, extensionSize)

# Print results
PrintResults(extensionSize)

def GetSize(topDir, extensionSize):
for dirPath, dirNames, files in os.walk(topDir):
for file in files:
# 'example.mp3' -> ['example', 'mp3']
# 'example.tar.gz' -> ['example', 'tar', 'gz']
parts = file.split('.')
# ['example', 'mp3'] -> ['mp3']
# ['example', 'tar', 'gz'] -> ['tar', 'gz']
parts = parts[1:]
# ['mp3'] -> '.mp3'
# ['tar', 'gz'] -> '.tar.gz'
fileExtension = ".{0}".format(".".join(str(part) for part in parts))

# Compute the size in Bytes and update the dictionary
filePath = os.path.join(dirPath, file)
fileSize = os.path.getsize(filePath)
extensionSize[fileExtension] = extensionSize.get(fileExtension, 0) + fileSize

# Print results
def PrintResults(extensionSize):
for key, value in sorted(extensionSize.items()):
print('{0}: {1} Bytes.'.format(key, value))

if __name__ == "__main__":
sys.exit(Main(sys.argv))
</syntaxhighlight>

----

mia versione
<syntaxhighlight lang="Python">
import os, sys, copy

def dotsubstr(a):#restituisce la sottostringa .suffisso
#fcd = os.listdir('{0}'.format(arg1))
i=0
try:
while a[i]!='.':
i=i+1
return a[i:]
except IndexError:
return -1

def compliarg(li,arg):#restituisce una lista di tutti gli elementi contenenti la sottostringa arg come suffisso
res=[]
while li != []:
a=li.pop()
if a.endswith(arg): res.append(a)
return res

def listremintsect(l2,l1):#restituisce una lista res = l1 - intersezione di l1 ed l2
res=[]
while l1 != []:
a=l1.pop()
if not a in l2: res.append(a)
return res

def createpathlist(c,path):#restituisce una lista di path 'path' relativi ai file contenuti in c.
res = []
while c != []:
res.append('{0}/{1}'.format(path,c.pop()))
return res

def totsizes(d): #data una lista d di path restituisce la somma di tutti i size di d
res = 0
while d != []:
a = d.pop()
if os.path.isfile('{0}'.format(a)):
res = res + os.path.getsize('{0}'.format(a))
return res

def listsubstr(arg): #ritorna un dizionario del tipo diz[str(suffisso)] = int(size relativo al suffisso)
res = {}
fcd = os.listdir('{0}'.format(arg))
while fcd != []:
fcdtmp=copy.deepcopy(fcd) #BUGGONE SENZA COPY!!!!!!
a = fcd.pop()
b = dotsubstr(a)
if b == -1: continue
else: pass
c = compliarg(fcdtmp,b)
s=copy.deepcopy(c) #!!!!!!!!!!!!!!!!!!!!!!!!!
d = createpathlist(c,arg)
res[b] = totsizes(d)

fcd = listremintsect(s,fcd)

return res

try:
res = listsubstr(sys.argv[1])
a=list(res.keys())
while a != []:
b = a.pop()
print('{0}:\t{1}'.format(b,res[b]))
except OSError:
print("Could not solve path")

</syntaxhighlight>
-fede

----

Esercizio 1: Linguaggio C

<syntaxhighlight lang="C">
#include <sys/eventfd.h>
#include <stdio.h>
#include <unistd.h>

#define BUFFSIZE 10

int main(int argc, char *argv[]){
int efd,n,i,ris;
char buf1[BUFFSIZE];
char buf2[BUFFSIZE];

do{
efd = eventfd(0,0);
}while(efd<0);

while(1){
if(fork()){ /*padre*/
scanf("%s",buf1);
ris = write(efd, buf1, sizeof(buf1));
}

else{ /*figlio*/
ris = read(efd, buf2, sizeof(buf2));
n=atoi(buf2);
for(i=0; i<n; i++) printf("x\n");
}
}
}
</syntaxhighlight>
GiuliaN. con grande aiuto da parte dei colleghi