Sistemi Operativi - User contributions [en]

ProvaPratica 2011.05.30

2014-05-19T21:09:27Z

Gab:

[http://www.cs.unibo.it/~renzo/so/pratiche/2011.05.30.pdf Link to exam]

Esercizio 1

sender.c

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

#define COMMUNICATION_SIGNAL 25
#define MAXIMUM_LENGTH 4096

#define PID_LENGTH 10

int main(int argc,char *argv[])
{
int sharedFD = shm_open("/sharedPID", O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
if(!sharedFD)
return;
ftruncate(sharedFD,sizeof(char)*PID_LENGTH);
char *sharedVariable = mmap(NULL,sizeof(char)*PID_LENGTH,PROT_READ | PROT_WRITE,MAP_SHARED,sharedFD,0);
int effectivePID = atoi(sharedVariable);
int sharedParametersFD = shm_open("/sharedParameters", O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
if(!sharedParametersFD)
return;
ftruncate(sharedParametersFD,sizeof(char)*MAXIMUM_LENGTH);
char *parameters = mmap(NULL,sizeof(char)*MAXIMUM_LENGTH,PROT_READ | PROT_WRITE,MAP_SHARED,sharedParametersFD,0);
char parametersToPass[MAXIMUM_LENGTH];
int i;
for(i=0;i<MAXIMUM_LENGTH;i++)
parametersToPass[i]='\0';
for(i=0;i<argc;i++)
{
strcat(parametersToPass,argv[i]);
strcat(parametersToPass,"\n");
}
strcpy(parameters,parametersToPass);
kill(effectivePID,COMMUNICATION_SIGNAL);
return 0;
}
</syntaxhighlight>

receiver.c

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

#define COMMUNICATION_SIGNAL 25

#define MAXIMUM_LENGTH 4096

#define PID_LENGTH 10

static void signalHandler (int sig, siginfo_t *siginfo, void *context)
{
int sharedFD = shm_open("/sharedParameters", O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
if(!sharedFD)
return;
ftruncate(sharedFD,sizeof(char)*MAXIMUM_LENGTH);
char *parameters = mmap(NULL,sizeof(char)*MAXIMUM_LENGTH,PROT_READ | PROT_WRITE,MAP_SHARED,sharedFD,0);
printf("Parameters: %s",parameters);
exit(0);
}

int main(int argc,char *argv[])
{
int sharedFD = shm_open("/sharedPID", O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
if(!sharedFD)
return;
char *currentPIDToPass;
asprintf(&currentPIDToPass,"%d",getpid());
ftruncate(sharedFD,sizeof(char)*PID_LENGTH);
char *sharedVariable = mmap(NULL,sizeof(char)*PID_LENGTH,PROT_READ | PROT_WRITE,MAP_SHARED,sharedFD,0);
strcpy(sharedVariable,currentPIDToPass);
struct sigaction signalStruct;
signalStruct.sa_sigaction = &signalHandler;
sigaction(COMMUNICATION_SIGNAL,&signalStruct,NULL);
while(1){}
return 0;
}
</syntaxhighlight>

Gab

ProvaPratica 2011.05.30

2014-05-19T21:09:12Z

Gab: Created page with "[http://www.cs.unibo.it/~renzo/so/pratiche/2011.05.30.pdf Link to exam] Esercizio 1 sender.c <syntaxhighlight lang="C"> #include <stdlib.h> #include <stdio.h> #include <un..."

Main Page

2014-05-19T21:05:00Z

Gab:

Questo è il Wiki del Corso di Sistemi Operativi

[[Esercizi a caso del Prof.]]

[[Decalogo di Programmazione Concorrente]]

[[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.]]

[[Producer&Consumer MP.]]

[[ProvaPratica 2014.01.23]]

[[ProvaPratica 2013.09.13]]

[[ProvaPratica 2013.07.18]]

[[ProvaPratica 2013.06.21]]

[[ProvaPratica 2013.05.29]]

[[ProvaPratica 2013.02.15]]

[[ProvaPratica 2013.01.25]]

[[ProvaPratica 2012.09.19]]

[[ProvaPratica 2012.07.17]]

[[ProvaPratica 2005.02.10]]

[[ProvaTeoria_2011.07.25]]

[[ProvaTeorica_2012.02.09]]

[[ProvaTeorica_2012.05.24]]

[[ProvaTeorica_2012.06.15]]

[[ProvaTeorica_2012.09.18]]

[[ProvaTeorica_2013.02.15]]

[[ProvaTeorica_2011.02.11]]

[[ProvaTeorica 2013.07.19]]

[[ProvaTeorica 2013.01.24]]

[[ProvaTeorica 2014.01.22]]

[[ProvaTeorica 2012.07.16]]

[[ProvaPratica_2010.07.12]]

[[Prova Teorica 2008.01.16]]

[[Prova Teorica 2013.09.12]]

[[Prova Teorica 2009.09.18]]

[[Prova Teorica 2008.09.17]]

[[Prova Teorica 2007.09.07]]

[[Prova Teorica 2013.06.21]]

[[ProvaPratica 2010.02.03]]

[[ProvaPratica 2011.09.12]]

[[ProvaPratica 2009.02.12]]

[[ProvaPratica 2009.01.15]]

[[Prova Teorica 2007.07.12]]

[[ProvaTeoria 2011.01.17]]

[[ProvaTeoria 2010.05.12]]

[[ProvaTeoria 2012.01.12]]

[[ProvaPratica 2009.09.23]]

[[ProvaPratica 2012.06.20]]

[[ProvaPratica 2010.07.19]]

[[ProvaTeorica 2013.05.30]]

[[ProvaTeoria_2009.01.30]]

[[ProvaTeoria_2012.01.12]]

[[ProvaPratica 2009.06.23]]

[[ProvaTeorica 2013.02.14]]

[[ProvaTeorica 2005.11.04]]

[[ProvaPratica 2011.01.19]]

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

ProvaPratica 2010.07.19

2014-05-01T21:46:55Z

Gab: Created page with "[http://www.cs.unibo.it/~renzo/so/pratiche/2010-07-19.pdf Link to exam] Esercizio1 <syntaxhighlight lang="C"> #include "stdlib.h" #include "stdio.h" #include "unistd.h" #inc..."

[http://www.cs.unibo.it/~renzo/so/pratiche/2010-07-19.pdf Link to exam]

Esercizio1

<syntaxhighlight lang="C">
#include "stdlib.h"
#include "stdio.h"
#include "unistd.h"
#include "string.h"
#include <sys/time.h>
#include <signal.h>

#define MESSAGE_LENGTH 40
#define NUMBER_OF_MESSAGE 100000

int main(int argc,char *arv[])
{
int childToParentPipe[2];
int parentToChildPipe[2];
pipe(childToParentPipe);
pipe(parentToChildPipe);
int childPID = fork();
if(childPID)
{
/* parent */
int toReadDescriptor = childToParentPipe[0];
int toWriteDescriptor = parentToChildPipe[1];
close(childToParentPipe[1]);
close(parentToChildPipe[0]);
char messageToSend[MESSAGE_LENGTH];
int index = 0;
for(index = 0 ; index<MESSAGE_LENGTH;index++)
messageToSend[index] = 'M';
messageToSend[MESSAGE_LENGTH-1]='\0';
char messageToRead[MESSAGE_LENGTH];
struct timeval startTime;
struct timeval endTime;
gettimeofday(&startTime,NULL);
for(index = 0;index <NUMBER_OF_MESSAGE;index++ )
{
write(toWriteDescriptor,messageToSend,MESSAGE_LENGTH);
read(toReadDescriptor,&messageToRead,MESSAGE_LENGTH);
}
gettimeofday(&endTime,NULL);
struct timeval timeUsed;
timersub(&endTime,&startTime,&timeUsed);
printf("Time taken %ld seconds and %d useconds \n", timeUsed.tv_sec, timeUsed.tv_usec);
kill(childPID,SIGTERM);
}
else
{
/* child */
int toReadDescriptor = parentToChildPipe[0];
int toWriteDescriptor = childToParentPipe[1];
close(childToParentPipe[0]);
close(parentToChildPipe[1]);
char arrivedMessage[MESSAGE_LENGTH];
while(1)
{
read(toReadDescriptor,arrivedMessage,MESSAGE_LENGTH);
write(toWriteDescriptor,arrivedMessage,strlen(arrivedMessage));
}
}
return 0;
}
</syntaxhighlight>

Esercizio2

<syntaxhighlight lang="C">
#include "stdlib.h"
#include "stdio.h"
#include "unistd.h"
#include "string.h"
#include <sys/time.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <signal.h>

#define MESSAGE_LENGTH 40
#define NUMBER_OF_MESSAGE 100000

#define PARENT_TO_CHILD_TAG 1

#define CHILD_TO_PARENT_TAG 2

typedef struct MessageBody
{
long type;
char message[MESSAGE_LENGTH];
} MessageBody;

int main(int argc,char *arv[])
{
int messageQueueID = msgget(IPC_PRIVATE, 0666);
int childPID = fork();
if(childPID)
{
/* parent */
MessageBody messageToSend;
messageToSend.type = 1;
int index;
for(index = 0;index<MESSAGE_LENGTH;index++)
messageToSend.message[index] = 'M';
messageToSend.message[MESSAGE_LENGTH-1] = '\0';
MessageBody messageReceived;
struct timeval startTime;
struct timeval endTime;
gettimeofday(&startTime,NULL);
for(index = 0;index < NUMBER_OF_MESSAGE;index++)
{
msgsnd(messageQueueID,&messageToSend,MESSAGE_LENGTH,0);
msgrcv(messageQueueID,&messageReceived,MESSAGE_LENGTH,2,MSG_NOERROR);
}
gettimeofday(&endTime,NULL);
struct timeval timeUsed;
timersub(&endTime,&startTime,&timeUsed);
printf("Time taken %ld seconds and %d useconds \n", timeUsed.tv_sec, timeUsed.tv_usec);
kill(childPID,SIGTERM);
}
else
{
/* child */
while(1)
{
MessageBody messageReceived;
msgrcv(messageQueueID,&messageReceived,MESSAGE_LENGTH,1,MSG_NOERROR);
messageReceived.type = 2;
msgsnd(messageQueueID,&messageReceived,MESSAGE_LENGTH,0);
}
}
return 0;
}
</syntaxhighlight>

Gab

Main Page

2014-05-01T21:42:39Z

Gab:

Questo è il Wiki del Corso di Sistemi Operativi

[[Esercizi a caso del Prof.]]

[[Decalogo di Programmazione Concorrente]]

[[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.]]

[[Producer&Consumer MP.]]

[[ProvaPratica 2014.01.23]]

[[ProvaPratica 2013.09.13]]

[[ProvaPratica 2013.07.18]]

[[ProvaPratica 2013.06.21]]

[[ProvaPratica 2013.05.29]]

[[ProvaPratica 2013.02.15]]

[[ProvaPratica 2013.01.25]]

[[ProvaPratica 2012.09.19]]

[[ProvaPratica 2005.02.10]]

[[ProvaTeoria_2011.07.25]]

[[ProvaTeorica_2012.02.09]]

[[ProvaTeorica_2012.05.24]]

[[ProvaTeorica_2012.06.15]]

[[ProvaTeorica_2012.09.18]]

[[ProvaTeorica_2013.02.15]]

[[ProvaTeorica_2011.02.11]]

[[ProvaTeorica 2013.07.19]]

[[ProvaTeorica 2013.01.24]]

[[ProvaTeorica 2014.01.22]]

[[ProvaTeorica 2012.07.16]]

[[ProvaPratica_2010.07.12]]

[[Prova Teorica 2008.01.16]]

[[Prova Teorica 2013.09.12]]

[[Prova Teorica 2009.09.18]]

[[Prova Teorica 2008.09.17]]

[[Prova Teorica 2007.09.07]]

[[Prova Teorica 2013.06.21]]

[[ProvaPratica 2010.02.03]]

[[ProvaPratica 2011.09.12]]

[[ProvaPratica 2009.02.12]]

[[ProvaPratica 2009.01.15]]

[[Prova Teorica 2007.07.12]]

[[ProvaTeoria 2011.01.17]]

[[ProvaTeoria 2010.05.12]]

[[ProvaTeoria 2012.01.12]]

[[ProvaPratica 2009.09.23]]

[[ProvaPratica 2012.06.20]]

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

ProvaPratica 2012.06.20

2014-05-01T21:39:29Z

Gab:

[http://www.cs.unibo.it/~renzo/so/pratiche/2012.06.20.pdf Link to Exam]

<syntaxhighlight lang="C">

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

int main (int arc, char *argv[])
{
if(arc<2)
return 0;
char *directoryToWatch;
directoryToWatch = argv[1]+1;
int notifierDescriptor = inotify_init();
if(!notifierDescriptor)
{
perror("inotify_init");
return 0;
}
int watcherDescriptor = inotify_add_watch( notifierDescriptor,directoryToWatch, IN_CREATE);
char eventBuffer[sizeof(struct inotify_event)+256];
while(read(notifierDescriptor,eventBuffer,sizeof(struct inotify_event)+256)>0)
{
struct inotify_event *event = ( struct inotify_event * ) eventBuffer;
if ( event->mask & IN_CREATE )
{
if ( event->mask & IN_ISDIR )
printf( "directory %s created.\n", event->name );
else
{
struct stat fileStructure;
char fileName[strlen(directoryToWatch)+strlen(event->name)+1];
strcpy(fileName,directoryToWatch);
strcat(fileName,"/");
strcat(fileName,event->name);
int result = stat(fileName,&fileStructure);
if(result<0)
{
return 0;
}
if(S_IEXEC && fileStructure.st_mode)
{
int resultFromFork = fork();
if(!resultFromFork)
{
//child
int result = execl(fileName,event->name,(char *)0);
if(result<0)
printf("an error: %s\n", strerror(errno));
}
else
{

if(waitpid(-1,NULL,0))
unlink(fileName);

}
}
}
}
}

inotify_rm_watch( notifierDescriptor, watcherDescriptor );
close(notifierDescriptor);
return 0;
}

</syntaxhighlight>

Gab

ProvaPratica 2012.06.20

2014-04-30T15:06:04Z

Gab: Created page with "[http://www.cs.unibo.it/~renzo/so/pratiche/2012.06.20.pdf Link to Exam] <syntaxhighlight lang="C"> #include <stdlib.h> #include <stdio.h> #include <string.h> #include <unis..."

[http://www.cs.unibo.it/~renzo/so/pratiche/2012.06.20.pdf Link to Exam]

<syntaxhighlight lang="C">

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

int main (int arc, char **argv)
{
if(arc<2)
return 0;
char *directoryToWatch;
directoryToWatch = argv[1]+1;
int notifierDescriptor = inotify_init();
if(!notifierDescriptor)
{
perror("inotify_init");
return 0;
}
int watcherDescriptor = inotify_add_watch( notifierDescriptor,directoryToWatch, IN_CREATE);
char eventBuffer[sizeof(struct inotify_event)+256];
while(read(notifierDescriptor,eventBuffer,sizeof(struct inotify_event)+256)>0)
{
struct inotify_event *event = ( struct inotify_event * ) eventBuffer;
if ( event->mask & IN_CREATE )
{
if ( event->mask & IN_ISDIR )
printf( "directory %s created.\n", event->name );
else
{
struct stat fileStructure;
char fileName[strlen(directoryToWatch)+strlen(event->name)+1];
strcpy(fileName,directoryToWatch);
strcat(fileName,"/");
strcat(fileName,event->name);
int result = stat(fileName,&fileStructure);
if(result<0)
{
return 0;
}
if(S_IEXEC && fileStructure.st_mode)
{
int resultFromFork = fork();
if(!resultFromFork)
{
//child
int result = execl(fileName,event->name,(char *)0);
if(result<0)
printf("an error: %s\n", strerror(errno));
}
else
{

if(waitpid(-1,NULL,0))
unlink(fileName);

}
}
}
}
}

inotify_rm_watch( notifierDescriptor, watcherDescriptor );
close(notifierDescriptor);
return 0;
}

</syntaxhighlight>

Gab

Main Page

2014-04-30T15:01:14Z

Gab:

Questo è il Wiki del Corso di Sistemi Operativi

[[Esercizi a caso del Prof.]]

[[Decalogo di Programmazione Concorrente]]

[[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.]]

[[Producer&Consumer MP.]]

[[ProvaPratica 2014.01.23]]

[[ProvaPratica 2013.09.13]]

[[ProvaPratica 2013.07.18]]

[[ProvaPratica 2013.06.21]]

[[ProvaPratica 2013.05.29]]

[[ProvaPratica 2013.02.15]]

[[ProvaPratica 2013.01.25]]

[[ProvaPratica 2012.09.19]]

[[ProvaPratica 2005.02.10]]

[[ProvaTeoria_2011.07.25]]

[[ProvaTeorica_2012.02.09]]

[[ProvaTeorica_2012.05.24]]

[[ProvaTeorica_2012.06.15]]

[[ProvaTeorica_2012.09.18]]

[[ProvaTeorica_2013.02.15]]

[[ProvaTeorica_2011.02.11]]

[[ProvaTeorica 2013.07.19]]

[[ProvaTeorica 2013.01.24]]

[[ProvaTeorica 2014.01.22]]

[[ProvaTeorica 2012.07.16]]

[[ProvaPratica_2010.07.12]]

[[Prova Teorica 2008.01.16]]

[[Prova Teorica 2013.09.12]]

[[Prova Teorica 2009.09.18]]

[[Prova Teorica 2008.09.17]]

[[Prova Teorica 2007.09.07]]

[[Prova Teorica 2013.06.21]]

[[ProvaPratica 2010.02.03]]

[[ProvaPratica 2011.09.12]]

[[ProvaPratica 2009.02.12]]

[[ProvaPratica 2009.01.15]]

[[Prova Teorica 2007.07.12]]

[[ProvaTeoria 2011.01.17]]

[[ProvaTeoria 2010.05.12]]

[[ProvaTeoria 2012.01.12]]

[[ProvaPratica 2009.09.23]]

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

ProvaTeorica 2013.01.24

2014-03-19T08:22:59Z

Gab:

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.

Gabriele e Giulia

ProvaTeorica 2013.01.24

2014-03-19T08:21:52Z

Gab:

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(M >= buffer.len)
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.

Gabriele e Giulia