DidaWiki

Questa pagina è in sola lettura. Puoi visualizzare il sorgente, ma non puoi modificarlo. Contatta l'amministratore se pensi che ci sia un errore.
====== Esercitazione 8 ======


===== Esercizio 1 =====

Scrivere un programma C in cui si attivano M thread produttori ed N thread consumatori che condividono una coda (di capacità “infinita”). Il programma accetta come argomento anche un intero K che corrisponde al numero totale di messaggi che i produttori producono concorrentemente nella coda (ogni produttore produce K/M messaggi -- se M divide K). I consumatori leggono i messaggi dalla coda in un ciclo infinito fino a quando non ricevono un messaggio speciale che li fa terminare. Implementare la coda concorrente, ed il protocollo di terminazione senza usare la cancellazione esplicita dei threads. Testare il programma al variare di M ed N. Controllare con ''valgrind'' che non ci siano problemi nell'accesso alle variabili del programma e che tutta la memoria allocata sia completamente rilasciata all'uscita del programma.

===== Esercizio 2 =====

Realizzare una semplice calcolatrice scientifica testuale. Il programma legge da tastiera una operazione alla volta, una per riga (es. sqrt(3) + 2/5), quindi per ogni richiesta forka ed esegue la calcolatrice testuale fornita dal sistema ''bc'' (tipicamente installato in /usr/bin -- utilizzare i parametri -lq, cioè ''bc -lq'') a cui, tramite pipe senza nome, passa l'operazione da svolgere e prende il risultato calcolato (ridirigere nella pipe sia lo standard output che lo standard error di 'bc'). Il risultato ottenuto verrà stampato sullo standard output secondo il seguente formato:\\
Operazione:   op\\
Risultato :  res 


(nota su utilizzo di ''bc -lq'': riceve una formula dallo standard input, e stampa su standard output il risultato. Per "testarlo" da shell potete usare il comando ''echo'' in questo modo: ''echo "sqrt(3)+2/5" | bc -lq''. Vedremo meglio piu' avanti il significato di questo comando. Ricordiamo inoltre che il comando ''bc'' rimane in attesa di nuove operazioni finche' non viene chiuso il suo standard input, o non viene passata la stringa 'quit'.)
===== Esercizio 3 =====

Considerare il seguento programma ''dec.c'':
<code>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>

#define SYSCALL(r,c,e) if((r=c)==-1) { perror(e);exit(errno); }
int main(int argc, char *argv[]) {
    int  x,r;
    if (argc>1) {
	x = atoi(argv[1]);
	if (x<0) goto fine;
	SYSCALL(r, write(1, &x,sizeof(x)),"write1");
    }
    do {
	SYSCALL(r,read(0, &x,sizeof(x)),"read");
	if (r==0) { 
	    fprintf(stderr, "Processo %d, esco perche' lo standard input e' chiuso!\n", getpid());
	    return 0;
	}
	fprintf(stderr, "Processo %d, ricevuto %d\n", getpid(),x);
	--x;
	if (x<0)  break;
	SYSCALL(r, write(1, &x,sizeof(x)), "write2");
    } while(1);
 fine:
    fprintf(stderr, "Processo %d, esco perche' raggiunto valore negativo\n", getpid());
    return 0;
}
</code>
Scrivere un programma (chiamato //pipedec//) che prende in ingresso un intero positivo. //pipedec// lancia 2 processi figli ognuno dei quali esegue con una chiamata ''exec*'' il programma //dec//. Solo ad uno dei due processi figli viene passato come argomento l'intero positivo passato al programma //pipedec//. I due processi figli devono essere connessi tra di loro in modo tale che lo standard input di un processo sia connesso con lo standard output dell'altro processo (la connessione e' quindi bidirezionale).