Qualcuno potrebbe aiutarmi a svolgere questo problemino?
E' troppo tosto per me, aiutatemi almeno a partire (c'è anche un'immagine come allegato):
Descrizione dell’esercitazione
• L’esercitazione consiste nello svilppare un insieme di programmi concorrenti che simulano un sistema formato da due code su cui gli utenti possono inviare delle richieste che verranno poi processate da un demone servitore.
• Nei casi reali, la presenza di due code puo’ essere motivata da esigenze “amministrative”: ad esempio, le due code possono rappresentare due code di stampa, ricerca e didattica, i cui costi devono essere imputati separatamente. Oppure possono essere associate a due classi di utenti diversi che però usano la stessa risorsa (rappresentata dal demone servitore)
Funzionamento del Sistema
• Il cuore del sistema è rappresentato da un un array di 10 interi contenuto in memoria condivisa.
• L’accesso all’array e’regolato da un semaforo binario: un solo processo alla volta può leggere/scrivere nell’array.
• Il demone servitore ha il compito di consultare periodicamente l’array e di servire le richieste che contiene.
• I demoni demoneA e demoneB hanno il compito di inserire nell’array le richieste provenienti dagli utenti e di rimuovere dall’array eventuali richieste (se non sono ancora state processate dal demone servitore)
• demoneA e demoneB ricevono le richieste degli utenti attraverso due code di messaggi A e B.
• Un file di log e’ usato per tenere traccia di tutte le operazioni.
Comandi a disposizione degli utenti per gestire le richieste:
• inserisci coda-x job
– Invia su coda-x la richiesta di inserimento di job.
– Se l’array e’ pieno inserisci deve restituire un messaggio di errore . Questo funzionamento implica che il processo inserisci rimanga in attesa su coda-x di una risposta da parte di demoneX: job inserito oppure ritenta più tardi, oppure job già presente nell’array.
• rimuovi coda-x job
– Invia su coda-x la richiesta di rimozione di job dall’array
• Visualizza
– Stampa in output l’elenco dei jobs da processare (attualmente presenti nell’area di memoria condivisa)
Funzionamento di demoneA/B:
• DemoneA/B rimane in attesa sulla coda delle richieste inviate dagli utenti su quella coda. Il demone puo’ ricevere un messaggio di tipo inserisci o di tipo rimuovi:
– Richiesta inserisci job: il demone accede all’array in memoria condivisa e:
• Se non esiste una entry vuota in cui inserire job restituisce al processo inserisci un messaggio di array pieno, ritenta piu’ tardi.
• Se c’è una entry vuota e nessun’altra entry contiene job, inserisce il job nella entry e resituisce al processo inserisci il messaggio job inserito
• Se job e’ già presente in coda resituisce al processo inserisci il messaggio job già presente nell’array.
• Nel file di log scrive la richiesta ricevuta e l’esito del suo processamento
– Richiesta rimuovi job: rimuove dall’array l’entry contentente il job specificato. Se non esiste un tale job, non succede nulla.
– Nel file di log scrive la richiesta ricevuta e il suo processamento.
• I demoni A e B tengono una traccia delle azioni che compiono registrandole in un file di log che puo’ essere consultato per controllare l’evoluzione del sistema al sopraggiungere dei comandi degli utenti.
• N.B.: il programma visualizza puo’ accedere direttamente all’area di memoria condivisa e stampare sul terminale l’elenco dei job attualmente in attesa di essere processati dal servitore.
Funzionamento di servitore:
Servitore: all’infinito esegue le seguenti operazioni:
1. attende n secondi (n definito allo start-up del demone)
2. Scorre l’array in memoria condivisa, e per ogni entry non vuota (contentente un valore ¹ da 0) il servitore si forka e ogni figlio:
– Scrive nel file di log che sta per processare l’entry
– Rimuove l’entry dall’array (scrive 0 nell’entry)
– Processa l’entry (aspetta 1 £ x £ 10 secondi random)
– Scrive nel file di log che ha processato l’entry e termina
3. Appena ha scandito l’intero array, il processo padre esce dall’area di mutua esclusione della memoria condivisa e si mette in attesa della terminazione dei figli.
4. Quando tutti i figli sono terminati ripete tutte le operazioni dal punto 1
Esempio di output del file di log:
– DemoneA: inserisci 43
– DemoneB: inserisci 994
– DemoneA: inserito 43
– DemoneA: inserisci 123
– DemoneB: inserisci 112
– DemoneA: inserito 123
– demoneB: inserito 994
– …..
– …..
– Servitore: inizio processamento job n. 43: 6 secondi
– Servitore: inizio processamento job n. 123: 8 secondi
– Servitore: inizio processamento job n. 994: 1 secondi
– …
– DemoneA: rimuovi 43
– Servitore: terminato processamento job n. 994
– Servitore: terminato processamento job n. 43
– …..
Che cosa dovete fare:
• Dovete sviluppare dei programmi C che implementino i due demoni A e B, il servitore, ed i tre programmi inserisci, rimuovi e visualizza.
• Potete far uso di qualsiasi system call, programma d’esempio, comandi shell visti a lezione, e di qualsiasi strumento software messo a disposizione dall’ambiente Unix.
Alcuni dettagli implementativi
• Il primo passo della simulazione consiste nel far partire in background i 3 demoni, i quali sono responsabili di allocare le risorse (code, semaforo, memoria condivisa) necessarie al funzionamento della simulazione. Servitore deve essere lanciato con un argomento intero che indica quanti secondi aspettare tra una visita all’array e la successiva.
• I programmi utente (rimuovi, inserisci, visualizza) e i demoni devono tutti essere contenuti in una qualche cartella della vostra home, ma i programmi utente devono funzionare anche se lanciati da un’altra cartella.
• Opzionale: prevedere un meccanismo (ad esempio un segnale speciale da inviare al demone servitore) per terminare automaticamente la simulazione, rimuovendo tutte le risorse e uccidendo i demoni delle code e il servitore stesso).
Alcuni suggerimenti implementativi (non sono obbligatori)
• Un comando inserisci/rimuovi puo’ avere la forma:
inserisci A xy oppure inserisci B xy
Dove A o B indica la coda su cui inviare la richiesta, e xy, che rappresenta il job, e’ un qualsiasi numero intero. E’ anche accettabile che xy sia un numero compreso tra 1 e 255.
• Una entry vuota dell’array puo’ essere rappresentata dal valore 0
• Anziche’ un valore random, per simulare il processamento di un job dell’array da parte di uno dei figli di servitore si puo’ usare un valore che e’ calcolato sulla base del numero xy. (ma deve essere sempre un numero di secondi compreso tra 1 e 10 secondi)
Rispondi quotando
