Prove scritte 2019 - Revision history

Flecart: /* Esercizio g.1 (da controllare) */

2023-03-26T18:04:13Z

Esercizio g.1 (da controllare)

Flecart: /* Soluzione proposta 1 */

2023-03-26T18:03:58Z

Soluzione proposta 1

Flecart: /* Soluzione proposta 1 */

2023-03-26T18:03:08Z

Soluzione proposta 1

Flecart: /* Esercizio g.1 */

2023-03-25T22:13:08Z

Esercizio g.1

Flecart: /* Esame 18/06/2019 */

2023-03-25T22:12:17Z

Esame 18/06/2019

Flecart: /* Esame 18/06/2019 */

2023-03-25T22:10:38Z

Esame 18/06/2019

Flecart: /* Esame 14/02/2019 */

2023-03-25T22:09:59Z

Esame 14/02/2019

Gio: /* Esercizio c2 */

2023-01-17T16:09:27Z

Esercizio c2

Flecart: /* Esercizio c.2 (da controllare) */

2023-01-17T15:12:10Z

Esercizio c.2 (da controllare)

Flecart: /* Esercizio c.1 (controllato) */

2023-01-17T15:09:26Z

Esercizio c.1 (controllato)

@@ Line 400: / Line 400: @@
 </source>
-== Esercizio g.1 (da controllare) ==
+== Esercizio g.1 ==
 In un sistema monoprocessore mostrare un caso nel quale l'algoritmo di scheduling FIFO e quello Round
 Robin producano la stessa sequenza di esecuzione (per evitare casi banali si richiede che siano presenti almeno 3

@@ Line 405: / Line 405: @@
 processi e ognuno faccia almeno due operazioni di I/O).
-=== Soluzione proposta 1 ===
+=== Soluzione proposta 1 (da controllare) ===
 * Proposta [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 23:13, 25 March 2023 (CET)

← Older revision		Revision as of 18:03, 26 March 2023
Line 408:		Line 408:

	* Proposta [[User:Flecart\|Flecart]] ([[User talk:Flecart\|talk]]) 23:13, 25 March 2023 (CET)		* Proposta [[User:Flecart\|Flecart]] ([[User talk:Flecart\|talk]]) 23:13, 25 March 2023 (CET)
		+	[[File:Solution20190214g1.jpg]]\

	= Esame 28/05/2019 =		= Esame 28/05/2019 =

@@ Line 400: / Line 400: @@
 </source>
-== Esercizio g.1 ==
+== Esercizio g.1 (da controllare) ==
 In un sistema monoprocessore mostrare un caso nel quale l'algoritmo di scheduling FIFO e quello Round
 Robin producano la stessa sequenza di esecuzione (per evitare casi banali si richiede che siano presenti almeno 3
 processi e ognuno faccia almeno due operazioni di I/O).
 = Esame 28/05/2019 =

@@ Line 151: / Line 151: @@
 # In questi casi tutte le istruzioni vengono eseguite con la massima autorità, con problemi di sicurezza nel caso un utente estraneo prenda il controllo del sistema o rischio di commettere gravi errori semplicemente sbagliando a digitare un comando.
-== Esame 18/05/2019 ==
+= Esame 18/05/2019 =
 [http://www.cs.unibo.it/~renzo/so/compiti/2019.05.18.tot.pdf 2019.05.18.tot.pdf]
-=== Esercizio c.1 (da controllare) ===
+== Esercizio c.1 (da controllare) ==
 * Controllato dall'utente ? in data ?
@@ Line 271: / Line 271: @@
 </source>
-=== Esercizio c.2 (da controllare) ===
+== Esercizio c.2 (da controllare) ==
 <source lang="c">
 unsigned procs_in = 0;
@@ Line 303: / Line 303: @@
 </source>
-=== Esercizio g.1 (da controllare) ===
+== Esercizio g.1 (da controllare) ==
 ==== Domanda a) ====
 Poiché lo scheduler è non-preemptive, una volta assegnata la CPU ad un dato processo, questi non viene cambiato finché non ha terminato. Visto il vincolo nel testo della consegna, una volta concluso il processo corrente si hanno solo due scelte: selezionare il più recente processo A o il più recente processo B.
@@ Line 319: / Line 320: @@
 [[File:Epson 25082020151034.jpg]]
-=== Esercizio g.2 (da controllare) ===
+== Esercizio g.2 (da controllare) ==
 # Basso, perché vengono generate molte page trap. Così facendo i processi direttamente interessati devono attendere il caricamento delle pagine di memoria ed essere posti in attesa, riducendo l'utilizzazione della CPU.
@@ Line 326: / Line 327: @@
 # Come voci di una directory che puntano allo stesso inode (laddove il file system sia basato su inode) o più in generale allo stesso FCB (File Control Block). Per determinare se un dato FCB non è più linkato da nessuna voce (entry) si utilizza un contatore che rappresenta il numero corrente di riferimenti; quando questo diventa 0, il FCB può essere eliminato dal file system.
-== Esame 14/02/2019 ==
+= Esame 14/02/2019 =
 [https://www.cs.unibo.it/~renzo/so/compiti/2019.02.14.tot.pdf Testo d'esame].
-=== Esercizio c.1 (da controllare) ===
+== Esercizio c.1 (da controllare) ==
 * Controllato dall'utente [[User:Acsor|Acsor]] ([[User talk:Acsor|talk]]) in data 16:03, 2 September 2020 (CEST). Ritengo sia: corretto
@@ Line 359: / Line 360: @@
 </source>
-=== Esercizio c.2 (controllato) ===
+== Esercizio c.2 (controllato) ==
 <source lang="python">
@@ Line 399: / Line 400: @@
 </source>
-=== Esercizio g.1 ===
+== Esercizio g.1 ==
 In un sistema monoprocessore mostrare un caso nel quale l'algoritmo di scheduling FIFO e quello Round
 Robin producano la stessa sequenza di esecuzione (per evitare casi banali si richiede che siano presenti almeno 3
 processi e ognuno faccia almeno due operazioni di I/O).
-== Esame 28/05/2019 ==
+= Esame 28/05/2019 =
 [http://www.cs.unibo.it/~renzo/so/compiti/2019.05.18.tot.pdf 2019.05.18.tot.pdf]
-=== Esercizio c.1 (da controllare) ===
+== Esercizio c.1 (da controllare) ==
 <source lang="c">
@@ Line 436: / Line 437: @@
 <br>
-=== Esercizio c.1 (da controllare) ===
+== Esercizio c.1 (da controllare) ==
 <source lang="c">
 monitor storage{
@@ Line 466: / Line 467: @@
 </source>
-== Esame 15/07/2019 ==
+= Esame 15/07/2019 =
 [http://www.cs.unibo.it/~renzo/so/compiti/2019.07.15.tot.pdf 2019.07.15.tot.pdf]
-=== Esercizio c.1 ===
+== Esercizio c.1 ==
 # Verifica del 18/05/2020 dell'utente [[User:Acsor|Acsor]]. Ritengo sia: corretto
@@ Line 517: / Line 518: @@
 </source>
-=== Esercizio c.2 (da controllare) ===
+== Esercizio c.2 (da controllare) ==
 Viene ritornata x stessa, in un numero di iterazioni pari a length(x). Il calcolo viene svolto tramite message passing tra processi client e processo server; [http://www.treccani.it/magazine/lingua_italiana/domande_e_risposte/grammatica/grammatica_030.html quest'ultimo] opera una sorta di iterazione inoltrando a se stesso il messaggio spedito da un client finché x != "".
 Se più processi chiamano la funzione dilemma() allo stesso tempo, ciò non causa disagi nel calcolo del risultato finale. Infatti l'identificatore del processo cliente destinatario è memorizzato in pid, e protratto fino alla chiamata in cui x == "". Inoltre la presenza di molteplici richieste non causa sovrapposizione, posto che asend() memorizzi il contenuto di messaggi in sospeso in una coda FIFO.
-== Esame 13/09/2019 ==
+= Esame 13/09/2019 =
 Testo: [https://www.cs.unibo.it/~renzo/so/compiti/2019.09.13.tot.pdf 2019.09.13.tot.pdf].
-=== Esercizio c.1 (controllato) ===
+== Esercizio c.1 (controllato) ==
 * Controllato dal professor Davoli durante la lezione del 19/05/2020.
 * Controllato dall'utente [[User:Acsor|Acsor]] ([[User talk:Acsor|talk]]) in data 19:13, 1 September 2020 (CEST).
@@ Line 567: / Line 568: @@
 </source>
-=== Esercizio c.2 ===
+== Esercizio c.2 ==
 * Controllato da [[User:Flecart|Flecart]] ([[User talk:Flecart|talk]]) 16:12, 17 January 2023 (CET)
@@ Line 589: / Line 590: @@
 </source>
-=== Esercizio c.2 (da controllare) ===
+== Esercizio c.2 (da controllare) ==
 L'output dei due processi è printare in modo alterno 0, 1, 0, 1....
@@ Line 619: / Line 620: @@
 </source>
-=== Esercizio g.1 (da controllare) ===
+== Esercizio g.1 (da controllare) ==
 * Controllato dall'utente ? in data ?
 * ...
@@ Line 627: / Line 628: @@
 [[File:2019-09-13-g1.jpg | 768px]]
-=== Esercizio g.2 (da controllare) ===
+== Esercizio g.2 (da controllare) ==
 # Le opzioni per comunicare con le periferiche di IO sono solitamente due: polling (sondaggio) e interrupt. Mediante il polling il sistema verifica costantemente lo stato dei dispositivi di IO prendendo azione quando esso cambia, con gli interrupt sono i dispositivi stessi a notificare il cambiamento del loro stato. Poiché fare polling significa eseguire ciclicamente delle istruzioni che svolgano il controllo, ricevere degli interrupt è più efficiente perché nello stesso tempo è possibile svolgere altro lavoro utile.
@@ Line 633: / Line 634: @@
 # Quando bisogna svolgere un'operazione di swap-in (caricamento di una pagina dalla memoria secondaria a quella primaria) e di swap-out (inversa alla precedente). L'algoritmo di rimpiazzamento è invocato durante un'operazione di swap-in che vede la memoria centrale completamente occupata: in tal caso sarà necessario individuare una pagina da spostare in memoria secondaria.
 # Vantaggi: dimensioni del file eseguibile finale ridotte, in quanto non è richiesto mantenere all'interno dello stesso una copia delle procedure di cui ci si serve; risparmio in memoria centrale: per un dato simbolo appartenente ad una data libreria, è possibile riservare un solo spazio in memoria condiviso da più processi che ne hanno bisogno. Svantaggi: versionamento, ovvero l'installazione di versioni più aggiornate della stessa libreria in conflitto con quelle meno recenti: tale problema è risolto mediante la definizione precisa di numeri di versione delle librerie e la specificazione delle dipendenze (rispetto ad un dato numero di versione).
 = Esame 2019/01/15 =

@@ Line 1: / Line 1: @@
-== Esame 18/06/2019 ==
+= Esame 18/06/2019 =
 [http://www.cs.unibo.it/~renzo/so/compiti/2019.06.18.tot.pdf 2019.06.18.tot.pdf]
-=== Esercizio c.1 (da controllare) ===
+== Esercizio c.1 (da controllare) ==
 <source lang="c">
 monitor pg{
@@ Line 43: / Line 43: @@
 <br>
-=== Esercizio c.1 (da controllare) ===
+== Esercizio c.1 (da controllare) ==
 <source lang="c">
 monitor taon {
@@ Line 72: / Line 72: @@
 <br>
-=== Esercizio c.2 ===
+== Esercizio c.2 ==
 **non è l'esercizio corretto**
 <source lang="c">
@@ Line 113: / Line 113: @@
 <br>
-=== Esercizio g.1 (sbagliato) ===
+== Esercizio g.1 (sbagliato) ==
   <nowiki>
 x = long_compute()/short_compute()
@@ Line 126: / Line 126: @@
 <br>
-=== Esercizio g.1 ===
+== Esercizio g.1 ==
   <nowiki>
 P1(start=0): 5ms CPU, 5ms IO, 5ms CPU, 5ms IO, 2ms CPU
@@ Line 145: / Line 145: @@
-=== Esercizio g.2 (da controllare) ===
+== Esercizio g.2 (da controllare) ==
 # Può richiedere supporto hardware. Se implementato con contatori o stack questi devono essere aggiornati ad ogni riferimento alla memoria. L'intero sistema viene appesantito e rallentato.
 # Il journaling si assicura che i dati sul filesystem siano consistenti, ma non aggiornati. Assicura la coerenza dei dati, ma non la perdita dei file se il filesystem si danneggia.

← Older revision		Revision as of 16:09, 17 January 2023
Line 694:		Line 694:
	* Altro deadlock che può capitare è quando uno stesso processo è presente più volte all'interno di senders, in questo caso ricevo solo una volta, è impossibile che riesca a ricevere una altra volta.		* Altro deadlock che può capitare è quando uno stesso processo è presente più volte all'interno di senders, in questo caso ricevo solo una volta, è impossibile che riesca a ricevere una altra volta.
	* Per esempio basterebbe avere come input un (ANY, 1), e ricevere il primo messaggio da 1, e, nonostante soddisfi le specifiche, si avrebbe un deadlock.		* Per esempio basterebbe avere come input un (ANY, 1), e ricevere il primo messaggio da 1, e, nonostante soddisfi le specifiche, si avrebbe un deadlock.
		+
		+
		+	* Soluzione proposta [[User:Flecart\|Flecart Friend]] cedo, la proprietà intellettuale di questa soluzione a flecart.
		+
		+	Doveri avere risolto gli ultimi due casi di deadlock descritti sopra con questo codice
		+
		+	<syntaxhighlight lang="C">
		+	void ms_send(pid dest, msg_t msg){
		+	asend(<getpid(),msg>,dest);
		+	while(true){
		+	<pid,msg>=arecv(dest);
		+	if(msg==ACK){
		+	break;
		+	}
		+	}
		+	}
		+
		+	ms_recv(int n, pid senders, msg_t msgs){
		+	msg_t cached[MAXPID];
		+	queue<int> any;
		+	for(int i=0;i<MAXPID;i++){
		+	cached[i]=NULL;
		+	}
		+	for(int i=0;i<n;i++){
		+	if(senders[i]==ANY)any.push(i);
		+	else left++;
		+	}
		+	while(left>0 && any.size()>0){
		+	<pid,msg>=arecv(ANY);
		+	//diamo priorità a quelli non any
		+	for(int i=0;i<n;i++){
		+	if(senders[i]==ANY)continue;
		+	if(msgs[i]==NULL and senders[i]==pid){
		+	msgs[i]=msg;
		+	asend(<getpid(),ACK>,sender);
		+	left--;
		+	msg=NULL;
		+	break;//break for
		+	}
		+	}
		+	if(msg!=NULL){
		+	//aggiungiamo agli any
		+	if(any.size()>0){
		+	current_index=q.pop();
		+	msgs[current_index]=msg;
		+	asend(<getpid(),ACK>,sender);
		+	}else{
		+	//se no mettiamo in cached
		+	cached[pid]=msg;
		+	}
		+	}
		+	}
		+	for(int i=0;i<MAXPID;i++){
		+	if(cached[i]!=NULL){
		+	asend(<i,cached[i]>,getpid());
		+	}
		+	}
		+	}
		+
		+
		+	</syntaxhighlight>