Informatica 1, Sez. di Cremona

Transcript

1 Informatica 1, Sez. di Cremona Prova in itinere del 27 Gennaio 2010 Si risolvano i seguenti esercizi. La prova prevede un punteggio massimo di 17/14-esimi, cui andranno sommati i punti ottenuti nel primo compitino e quelli del laboratorio. Il tempo a disposizione è 2 h. e 30 minuti Esercizio 1 (punti 4) Si consideri il seguente programma (i puntini indicano parti del codice irrilevanti) # typedef int *Point; typedef Point *Dpoint; int x = 3; int F1 ( ) /* prototipo della funzione F1*/ void F2 (Point P) /* prototipo della funzione F2*/ void main () { int y; y = x + F1( ); printf ( il risultato finale è %d \n, y) int F1 ( ) { Dpoint DP; DP = malloc( sizeof (Point)); *DP = malloc (sizeof (int)); F2 (*DP); return (**DP) void F2 (Point P) { *P = 5 Si descriva, preferibilmente mediante apposite figure lo stato completo della memoria: a. subito dopo la chiamata di F2 da parte di F1 b. appena prima della terminazione del main Al momento del ritorno al main sono state create delle dangling references o è stata creata della garbage? NB Per stato completo della memoria si intende soprattutto lo stato della stack e quello della heap. Tuttavia può essere utile disegnare o fare riferimento anche all area dati che contiene il codice oggetto del main e delle funzioni. Alternativamente è anche possibile indicare mediante generici xxx, yyy gli indirizzi di alcune istruzioni del codice oggetto sia del main che delle funzioni.

2 Esercizio 2 (punti 4) Si consideri un file di testo Testo costituito da una sequenza di stringhe lunghe al più 30 caratteri; ogni stringa è terminata dall apposito carattere newline. Si scriva un sottoprogramma (non un intero programma!) che: 1. Apra il file Testo; 2. Costruisca una lista di stringhe che contenga esattamente le stringhe del file disposte in ordine alfabetico (NB: il file non è originariamente già ordinato); 3. Chiuda il file;. 4. Produca come risultato un puntatore alla testa della lista costruita.. NB1: Il codice del sottoprogramma deve essere preceduto dalle eventuali dichiarazioni necessarie per la corretta compilazione ed esecuzione del sottoprogramma stesso. NB2: E fortemente consigliato fare uso di sottoprogrammi già definiti, preferibilmente sottoprogrammi della libreria standard del C, o anche sottoprogrammi definiti nel testo. Qualora si faccia uso di questi ultimi non è necessario ridefinirli, basta dichiararli; se tuttavia essi abbisognassero di qualche modifica rispetto al codice originario è necessario ridefinirne il codice o almeno spiegare con precisione le modifiche necessarie. Esercizio 3 (punti 4) Si scriva un sottoprogramma ricorsivo che riceva come parametri un array di interi e un intero non negativo che indica il numero di elementi dell array su cui operare a partire dal primo (si assuma che tale numero sia sempre non superiore al numero di elementi effettivamente presenti) e fornisca come risultato la sommatoria di tali elementi. NB: è fortemente preferibile che ad ogni chiamata ricorsiva il sottoprogramma non allochi un proprio array locale.

3 Esercizio 4 (punti 5) Si considerino i seguenti programmi C (gli #include necessari sono omessi): Programma 1 void main( ) { pid_t pid, miopid, pidpadre; int i, stato_exit, stato_wait; pidpadre = getpid( ); for (i = 1; i <= 3; i++) { pid=fork( ); if (pid == 0) { miopid=getpid( ); printf("sono il processo figlio %i esimo del processo %i con pid %i \n", i, pidpadre, miopid); printf("termino \n\n"); stato_exit=i; exit(stato_exit); else { printf("ho creato il processo figlio %i esimo il cui pid è%i \n\n ", i, pid); pid = wait (&stato_wait); printf("è terminato il processo figlio %i esimo \n", i); printf("il pid del figlio e' %i, lo stato e' %i\n",pid,stato_wait/256); Programma 2 void main( ) { pid_t pid, miopid, pidpadre; int i, stato_exit, stato_wait; pidpadre = getpid( ); for (i = 1; i <= 3; i++) { pid=fork( ); if (pid == 0) { miopid=getpid( ); printf("sono il processo figlio %i esimo del processo %i con pid %i \n", i, pidpadre, miopid); printf("termino \n\n"); stato_exit=i; exit(stato_exit); else { printf("ho creato il processo figlio %i esimo il cui pid è%i \n\n ", i, pid); pid = waitpid (pid, &stato_wait); printf("è terminato il processo figlio %i esimo \n", i); printf("il pid del figlio e' %i, lo stato e' %i\n", pid, stato_wait/256);

4 Programma 3 void main( ) { pid_t pid_ret, pid[4], miopid, pidpadre; int i, stato_exit, stato_wait; pidpadre = getpid( ); for (i = 1; i <= 3; i++) { pid[i] = fork( ); if (pid[i] == 0) break; for (i = 1; i <= 3; i++) { if (pid[i] == 0) { miopid=getpid( ); printf("sono il processo figlio %i esimo del processo %i con pid %i \n", i, pidpadre, miopid); printf("termino \n\n"); stato_exit=i; exit(stato_exit); else if (pidpadre == getpid( )) { printf("ho creato il processo figlio %i esimo il cui pid è%i \n\n ", i, pid[i]); pid_ret= waitpid (pid[i], &stato_wait); printf("è terminato il processo figlio %i esimo \n", i); printf("il pid del figlio e' %i, lo stato e' %i\n", pid_ret, stato_wait/256); Si assuma che ogni processo venga generato e termini correttamente senza errori. Si supponga inoltre che il S.O assegni il pid 500 al padre e numeri di pid a seguire per i figli creati dal padre. Si dica, giustificando brevemente la risposta, se i tre programmi o due tra essi sono tra loro equivalenti nel senso che l insieme di tutte le possibili risposte dei tre o due programmi coincidono: se anche una sola possibile risposta di un processo non è possibile nell altro i processi non si considerano equivalenti. Nel caso si ritenga che essi siano equivalenti si indichino alcune delle possibili risposte ad essi comuni (almeno 3, se ne sono possibili 3 o più). Per risposta si intende l output completo fornito da padre e figli. Se invece si ritiene che due tra loro o tutti e tre non siano equivalenti si indichino alcune risposte per ognuno dei 3 programmi evidenziando quali tra esse non sarebbero possibili per gli altri o per un altro dei due rimanenti. In sostanza si dimostri la diversità tra i programmi evidenziando i comportamenti diversi ma anche le eventuali riposte che potrebbero comunque essere fornite da tutti e tre o due di essi.

5 Soluzioni Soluzione dell Esercizio 1

6 Stack Valore attuale dello stackpointer Link dinamico di F2 Indirizzo di base del record di attivazione corrente, ossia di F2 = Precedente valore dello SP zzz /*indirizzo di ritorno a F1*/ P /*parametro di F2*/ DP /*variabile locale di F1*/ Link dinamico di F1 Indirizzo di base del record di attivazione di F1 = Precedente valore dello SP Indirizzo di base del record di attivazione del main yyy /*indirizzo di ritorno al main*/ /*Risultato di F1*/ = 5 y /* variabile locale del main */ x /* variabile globale*/ = 3 Heap a. Stato della memoria subito dopo la chiamata di F2

7 Stack Valore attuale dello stackpointer Indirizzo di base del record di attivazione del main y /* variabile locale del main */ = 8 x /* variabile globale*/ = 3 5 Heap b. stato della memoria appena prima della terminazione del main Al ritorno al main da parte di F1 le due celle allocate nello heap sono diventate inaccessibili e quindi garbage, come risulta evidente dalla figura b.

8 Soluzione dell Esercizio 2 E opportuno utilizzare i sottoprogrammi di libreria per la gestione dei file e delle stringhe. E inoltre utile adattare in modo semplice la procedura di inserimento in ordine di un elemento in una lista in modo che il tipo degli elementi sia la stringa e quindi il confronto tra stringhe avvenga mediante la procedura di libreria strcmp. # include stdlib.h # define LunghStr 30 typedef char TipoElemento [LunghStr]; struct EL { TipoElemento Info; structel *Prox; ; typedef structel ElemLista; typedef ElemLista *ListaDiElem; void Inizializza (ListaDiElem *Lista) /* prototipo della funzione*/; void InserisciInOrdine(ListaDiElem *Lista, TipoElemento Elem) { ElemLista *Punt, *PuntCorrente, *PuntPrecedente; PuntPrecedente = NULL; PuntCorrente = *Lista; while (PuntCorrente!= NULL && strcmp( Elem, PuntCorrente >Info) > 0) { PuntPrecedente = PuntCorrente; PuntCorrente = PuntCorrente->Prox; Punt = malloc(sizeof(elemlista)); strcpy (Punt >Info, Elem); Punt >Prox = PuntCorrente; if (PuntPrecedente)!= NULL PuntPrecedente >Prox = Punt; /* Inserisci internamente alla lista */ else *Lista = Punt; /* Inserisci in testa alla lista */

9 ListaDiElem CostruisciLista ( ) { TipoElemento linea; FILE *ft; ListaDiElem ListRis if ((ft = fopen("testo", "r")) == NULL) printf("il file non può essere aperto\n"); else { Inizializza ( &ListRis); while (fgets(linea, LunghStr,ft)!= NULL) InserisciInOrdine(&ListRis, linea); fclose(ft); return (ListRis); Soluzione dell Esercizio 3 int SommaRic (int numelem, int seq [ ]) { if (numelem == 0) return 0 else return (seq[0] + SommaRic (numelem -1, &seq[1])

10 Soluzione dell Esercizio 4 I primi due programmi sono del tutto equivalenti, a dispetto del fatto che il secondo impieghi la primitiva waitpid invece della semplice wait. Infatti il processo padre ad ogni iterazione del ciclo genera un figlio, ma prima di generarne altri si mette in attesa; quindi non può che ricevere l avviso di terminazione del figlio appena generato, l unico vivo o zombie- esistente. Quindi le possibili uscite saranno tutte del tipo sono il processo figlio 1 esimo del processo 500 con pid 501 termino ho creato il processo figlio 1 esimo il cui pid è 501 è terminato il processo figlio 1 esimo il pid del figlio e' 501, lo stato e' 1 sono il processo figlio 2 esimo del processo 500 con pid 502 termino ho creato il processo figlio 2 esimo il cui pid è 502 è terminato il processo figlio 2 esimo il pid del figlio e' 502, lo stato e' 2. E però possibile che per ogni figlio generato il padre esegua l istruzione di stampa che precede l attesa prima che il figlio inizi o termini l esecuzione. Si possono perciò verificare, in ambo i casi, anche uscite del tipo ho creato il processo figlio 1 esimo il cui pid è 501 sono il processo figlio 1 esimo del processo 500 con pid 501 termino è terminato il processo figlio 1 esimo il pid del figlio e' 501, lo stato e' 1

11 sono il processo figlio 2 esimo del processo 500 con pid 502 termino ho creato il processo figlio 2 esimo il cui pid è 502 è terminato il processo figlio 2 esimo il pid del figlio e' 502, lo stato e' 2. oppure ancora sono il processo figlio 1 esimo del processo 500 con pid 501 ho creato il processo figlio 1 esimo il cui pid è 501 termino è terminato il processo figlio 1 esimo il pid del figlio e' 501, lo stato e' 1 sono il processo figlio 2 esimo del processo 500 con pid 502 termino ho creato il processo figlio 2 esimo il cui pid è 502 è terminato il processo figlio 2 esimo il pid del figlio e' 502, lo stato e' 2. Il comportamento del Programma 3 è invece diverso e presenta una gamma di possibili risposte molto più ampia, tra cui compaiono anche quelle fornite dai primi due programmi. Precisamente: I tre figli del programma padre possono scrivere il loro output in qualsiasi ordine relativo perché non è detto che vadano in esecuzione nello stesso ordine in cui sono generati Il padre scriverà i suoi messaggi ho creato il processo figlio x esimo il cui pid è 50x è terminato il processo figlio x esimo

12 il pid del figlio e' 50x, lo stato e' x comunque nell ordine x = 1, 2, 3 anche se esso non fosse l ordine di terminazione dei figli poiché è il padre che li attende in ordine grazie all uso della waitpid Le frasi prodotte dai vari figli possono essere intercalate con quelle prodotte dal padre in qualsiasi ordine, fermo restando che essi devono stampare la frase termino prima che il padre possa rendersi conto, e quindi notificare, la loro terninazione, ciò che avviene dopo la waitpid. NB Si noti che il primo ciclo for viene eseguito per intero solo dal padre, mentre il primo figlio ne esce alla prima iterazione, il secondo alla seconda, il terzo appena prima di ultimare l ultima; ognuno ha pid[i] = 0 solo per il proprio valore di i. Inoltre i fligli 2 e 3 eseguiranno il secondo ciclo for alcune volte senza eseguire nessuna istruzione del suo corpo.