<?xml version="1.0"?>
<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="en">
	<id>https://so.v2.cs.unibo.it/wiki/index.php?action=history&amp;feed=atom&amp;title=Prova_teorica_2017.01.18</id>
	<title>Prova teorica 2017.01.18 - Revision history</title>
	<link rel="self" type="application/atom+xml" href="https://so.v2.cs.unibo.it/wiki/index.php?action=history&amp;feed=atom&amp;title=Prova_teorica_2017.01.18"/>
	<link rel="alternate" type="text/html" href="https://so.v2.cs.unibo.it/wiki/index.php?title=Prova_teorica_2017.01.18&amp;action=history"/>
	<updated>2026-05-05T04:10:37Z</updated>
	<subtitle>Revision history for this page on the wiki</subtitle>
	<generator>MediaWiki 1.35.5</generator>
	<entry>
		<id>https://so.v2.cs.unibo.it/wiki/index.php?title=Prova_teorica_2017.01.18&amp;diff=1944&amp;oldid=prev</id>
		<title>FedericoB: /* Esercizio g.2 */ aggiunta risposta esercizio 2</title>
		<link rel="alternate" type="text/html" href="https://so.v2.cs.unibo.it/wiki/index.php?title=Prova_teorica_2017.01.18&amp;diff=1944&amp;oldid=prev"/>
		<updated>2017-06-18T20:17:19Z</updated>

		<summary type="html">&lt;p&gt;&lt;span dir=&quot;auto&quot;&gt;&lt;span class=&quot;autocomment&quot;&gt;Esercizio g.2: &lt;/span&gt; aggiunta risposta esercizio 2&lt;/span&gt;&lt;/p&gt;
&lt;table class=&quot;diff diff-contentalign-left diff-editfont-monospace&quot; data-mw=&quot;interface&quot;&gt;
				&lt;col class=&quot;diff-marker&quot; /&gt;
				&lt;col class=&quot;diff-content&quot; /&gt;
				&lt;col class=&quot;diff-marker&quot; /&gt;
				&lt;col class=&quot;diff-content&quot; /&gt;
				&lt;tr class=&quot;diff-title&quot; lang=&quot;en&quot;&gt;
				&lt;td colspan=&quot;2&quot; style=&quot;background-color: #fff; color: #202122; text-align: center;&quot;&gt;← Older revision&lt;/td&gt;
				&lt;td colspan=&quot;2&quot; style=&quot;background-color: #fff; color: #202122; text-align: center;&quot;&gt;Revision as of 20:17, 18 June 2017&lt;/td&gt;
				&lt;/tr&gt;&lt;tr&gt;&lt;td colspan=&quot;2&quot; class=&quot;diff-lineno&quot; id=&quot;mw-diff-left-l4&quot; &gt;Line 4:&lt;/td&gt;
&lt;td colspan=&quot;2&quot; class=&quot;diff-lineno&quot;&gt;Line 4:&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td class='diff-marker'&gt; &lt;/td&gt;&lt;td style=&quot;background-color: #f8f9fa; color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #eaecf0; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;/td&gt;&lt;td class='diff-marker'&gt; &lt;/td&gt;&lt;td style=&quot;background-color: #f8f9fa; color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #eaecf0; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td class='diff-marker'&gt; &lt;/td&gt;&lt;td style=&quot;background-color: #f8f9fa; color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #eaecf0; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;# '''Perché un algoritmo di rimpiazzamento a stack non soffre dell’anomalia di Belady?''' &amp;lt;br&amp;gt; L'anomalia di Belady consiste nel aumento del page fault al aumentare dei frame in memoria. Se un algoritmo è a stack vuol dire che fissato una stringa di riferimento, in qualsiasi instante t l'insieme delle pagine con n frame è un sottoinsieme del insieme della pagine con n+1 frame. Quindi i page fault non possono aumentare perchè comunque è presente il set di pagine che era presente anche con n frame più un addizionale pagina.&lt;/div&gt;&lt;/td&gt;&lt;td class='diff-marker'&gt; &lt;/td&gt;&lt;td style=&quot;background-color: #f8f9fa; color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #eaecf0; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;# '''Perché un algoritmo di rimpiazzamento a stack non soffre dell’anomalia di Belady?''' &amp;lt;br&amp;gt; L'anomalia di Belady consiste nel aumento del page fault al aumentare dei frame in memoria. Se un algoritmo è a stack vuol dire che fissato una stringa di riferimento, in qualsiasi instante t l'insieme delle pagine con n frame è un sottoinsieme del insieme della pagine con n+1 frame. Quindi i page fault non possono aumentare perchè comunque è presente il set di pagine che era presente anche con n frame più un addizionale pagina.&lt;/div&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td class='diff-marker'&gt;−&lt;/td&gt;&lt;td style=&quot;color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #ffe49c; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;# '''Perché si può usare un meccanismo di crittografia simmetrica nella gestione delle capability di accesso alle risorse?'''&lt;/div&gt;&lt;/td&gt;&lt;td class='diff-marker'&gt;+&lt;/td&gt;&lt;td style=&quot;color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #a3d3ff; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;# '''Perché si può usare un meccanismo di crittografia simmetrica nella gestione delle capability di accesso alle risorse?''' &lt;ins class=&quot;diffchange diffchange-inline&quot;&gt;&amp;lt;br&amp;gt; Possiamo usare la crittografia simmetrica per la gestione delle capability se queste sono salvate nella parte di memoria utente del processo. Non dovendo trasmettere la chiave attraverso la rete possiamo utilizzare crittografia simmetrica.&lt;/ins&gt;&lt;/div&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td class='diff-marker'&gt; &lt;/td&gt;&lt;td style=&quot;background-color: #f8f9fa; color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #eaecf0; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;# '''Quali operazioni svolge il processore per la gestione di un interrupt e quali invece sono a carico del kernel del sistema operativo?''' &amp;lt;br&amp;gt; Il processore si occupa, all'attivazione della linea elettronica dell interrupt di recuperare dalla memoria in locazioni fisse l'indirizzo delle istruzioni di gestione degli interrupt. In seguito carica questo indirizzo nel program counter e quindi &amp;quot;salta&amp;quot; a queste istruzioni attivando la modalità di esecuzione kernel mode. &amp;lt;br&amp;gt; Le routine di gestione degli interrupt fanno parte del codice kernel e si occupano di gestire opportunamente le operazioni necessarie in base al tipo di interrupt. Per esempio operazioni come eseguire lo scheduler o recuperare l'output di un device.&lt;/div&gt;&lt;/td&gt;&lt;td class='diff-marker'&gt; &lt;/td&gt;&lt;td style=&quot;background-color: #f8f9fa; color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #eaecf0; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;# '''Quali operazioni svolge il processore per la gestione di un interrupt e quali invece sono a carico del kernel del sistema operativo?''' &amp;lt;br&amp;gt; Il processore si occupa, all'attivazione della linea elettronica dell interrupt di recuperare dalla memoria in locazioni fisse l'indirizzo delle istruzioni di gestione degli interrupt. In seguito carica questo indirizzo nel program counter e quindi &amp;quot;salta&amp;quot; a queste istruzioni attivando la modalità di esecuzione kernel mode. &amp;lt;br&amp;gt; Le routine di gestione degli interrupt fanno parte del codice kernel e si occupano di gestire opportunamente le operazioni necessarie in base al tipo di interrupt. Per esempio operazioni come eseguire lo scheduler o recuperare l'output di un device.&lt;/div&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td class='diff-marker'&gt; &lt;/td&gt;&lt;td style=&quot;background-color: #f8f9fa; color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #eaecf0; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;# '''Perche’ il mascheramento degli interrupt non si può utilizzare per creare sezioni critiche in sistemi multicore o multiprocessore?''' &amp;lt;br&amp;gt; Il mascheramento degli interrupt previene l'interruzione del esecuzione del processo corrente e il context switch a un altro processo e di conseguenza la non atomicità delle istruzioni che stava eseguendo il processo. &amp;lt;br&amp;gt; Anche disabilitando gli interrupt (è uguale se su un solo processore o su tutti) c'è comunque la possibilità che altro codice eseguito in ''parallelismo reale'' vada in concorrenza con quello dove si sta cercando di ottenere una sezione critica.&lt;/div&gt;&lt;/td&gt;&lt;td class='diff-marker'&gt; &lt;/td&gt;&lt;td style=&quot;background-color: #f8f9fa; color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #eaecf0; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;# '''Perche’ il mascheramento degli interrupt non si può utilizzare per creare sezioni critiche in sistemi multicore o multiprocessore?''' &amp;lt;br&amp;gt; Il mascheramento degli interrupt previene l'interruzione del esecuzione del processo corrente e il context switch a un altro processo e di conseguenza la non atomicità delle istruzioni che stava eseguendo il processo. &amp;lt;br&amp;gt; Anche disabilitando gli interrupt (è uguale se su un solo processore o su tutti) c'è comunque la possibilità che altro codice eseguito in ''parallelismo reale'' vada in concorrenza con quello dove si sta cercando di ottenere una sezione critica.&lt;/div&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td class='diff-marker'&gt; &lt;/td&gt;&lt;td style=&quot;background-color: #f8f9fa; color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #eaecf0; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;# '''Per quali tipi di processo l’algoritmo di schedulazione round-robin è efficiente e per quali no?''' &amp;lt;br&amp;gt; L'algoritmo di schedulazione round-robin è efficente per i processi I/O bound in quanto è ''fair'', cioè permette a tutti i processi il diritto di esecuzione entro un certo lasso di tempo. Può non essere efficiente per i processi CPU bound che hanno tempi di esecuzione lunghi e il round robin li costringe a ritardare il loro completamento. Inoltre un processo CPU bound potrebbe essere interrotto quando manca davvero poco al suo termine ma il time slice è terminato oppure necessita di I/O.Il processo viene messo in coda e bisognerà aspettare l'esecuzione di tutti gli altri processi prima di poter finire l'esecuzione.Uno scheduler shortest remaining time first avrebbe invece rimesso subito in esecuzione il processo CPU bound se il tempo di esecuzione previsto rimanente era davvero ridotto.&lt;/div&gt;&lt;/td&gt;&lt;td class='diff-marker'&gt; &lt;/td&gt;&lt;td style=&quot;background-color: #f8f9fa; color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #eaecf0; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;# '''Per quali tipi di processo l’algoritmo di schedulazione round-robin è efficiente e per quali no?''' &amp;lt;br&amp;gt; L'algoritmo di schedulazione round-robin è efficente per i processi I/O bound in quanto è ''fair'', cioè permette a tutti i processi il diritto di esecuzione entro un certo lasso di tempo. Può non essere efficiente per i processi CPU bound che hanno tempi di esecuzione lunghi e il round robin li costringe a ritardare il loro completamento. Inoltre un processo CPU bound potrebbe essere interrotto quando manca davvero poco al suo termine ma il time slice è terminato oppure necessita di I/O.Il processo viene messo in coda e bisognerà aspettare l'esecuzione di tutti gli altri processi prima di poter finire l'esecuzione.Uno scheduler shortest remaining time first avrebbe invece rimesso subito in esecuzione il processo CPU bound se il tempo di esecuzione previsto rimanente era davvero ridotto.&lt;/div&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;/table&gt;</summary>
		<author><name>FedericoB</name></author>
	</entry>
	<entry>
		<id>https://so.v2.cs.unibo.it/wiki/index.php?title=Prova_teorica_2017.01.18&amp;diff=1934&amp;oldid=prev</id>
		<title>FedericoB: /* Esercizio g.2 */ aggiunta risposta domanda 1</title>
		<link rel="alternate" type="text/html" href="https://so.v2.cs.unibo.it/wiki/index.php?title=Prova_teorica_2017.01.18&amp;diff=1934&amp;oldid=prev"/>
		<updated>2017-06-15T20:22:15Z</updated>

		<summary type="html">&lt;p&gt;&lt;span dir=&quot;auto&quot;&gt;&lt;span class=&quot;autocomment&quot;&gt;Esercizio g.2: &lt;/span&gt; aggiunta risposta domanda 1&lt;/span&gt;&lt;/p&gt;
&lt;table class=&quot;diff diff-contentalign-left diff-editfont-monospace&quot; data-mw=&quot;interface&quot;&gt;
				&lt;col class=&quot;diff-marker&quot; /&gt;
				&lt;col class=&quot;diff-content&quot; /&gt;
				&lt;col class=&quot;diff-marker&quot; /&gt;
				&lt;col class=&quot;diff-content&quot; /&gt;
				&lt;tr class=&quot;diff-title&quot; lang=&quot;en&quot;&gt;
				&lt;td colspan=&quot;2&quot; style=&quot;background-color: #fff; color: #202122; text-align: center;&quot;&gt;← Older revision&lt;/td&gt;
				&lt;td colspan=&quot;2&quot; style=&quot;background-color: #fff; color: #202122; text-align: center;&quot;&gt;Revision as of 20:22, 15 June 2017&lt;/td&gt;
				&lt;/tr&gt;&lt;tr&gt;&lt;td colspan=&quot;2&quot; class=&quot;diff-lineno&quot; id=&quot;mw-diff-left-l3&quot; &gt;Line 3:&lt;/td&gt;
&lt;td colspan=&quot;2&quot; class=&quot;diff-lineno&quot;&gt;Line 3:&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td class='diff-marker'&gt; &lt;/td&gt;&lt;td style=&quot;background-color: #f8f9fa; color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #eaecf0; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;==Esercizio g.2==&lt;/div&gt;&lt;/td&gt;&lt;td class='diff-marker'&gt; &lt;/td&gt;&lt;td style=&quot;background-color: #f8f9fa; color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #eaecf0; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;==Esercizio g.2==&lt;/div&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td class='diff-marker'&gt; &lt;/td&gt;&lt;td style=&quot;background-color: #f8f9fa; color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #eaecf0; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;/td&gt;&lt;td class='diff-marker'&gt; &lt;/td&gt;&lt;td style=&quot;background-color: #f8f9fa; color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #eaecf0; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td class='diff-marker'&gt;−&lt;/td&gt;&lt;td style=&quot;color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #ffe49c; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;# '''Perché un algoritmo di rimpiazzamento a stack non soffre dell’anomalia di Belady?'''&lt;/div&gt;&lt;/td&gt;&lt;td class='diff-marker'&gt;+&lt;/td&gt;&lt;td style=&quot;color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #a3d3ff; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;# '''Perché un algoritmo di rimpiazzamento a stack non soffre dell’anomalia di Belady?''' &lt;ins class=&quot;diffchange diffchange-inline&quot;&gt;&amp;lt;br&amp;gt; L'anomalia di Belady consiste nel aumento del page fault al aumentare dei frame in memoria. Se un algoritmo è a stack vuol dire che fissato una stringa di riferimento, in qualsiasi instante t l'insieme delle pagine con n frame è un sottoinsieme del insieme della pagine con n+1 frame. Quindi i page fault non possono aumentare perchè comunque è presente il set di pagine che era presente anche con n frame più un addizionale pagina.&lt;/ins&gt;&lt;/div&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td class='diff-marker'&gt; &lt;/td&gt;&lt;td style=&quot;background-color: #f8f9fa; color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #eaecf0; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;# '''Perché si può usare un meccanismo di crittografia simmetrica nella gestione delle capability di accesso alle risorse?'''&lt;/div&gt;&lt;/td&gt;&lt;td class='diff-marker'&gt; &lt;/td&gt;&lt;td style=&quot;background-color: #f8f9fa; color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #eaecf0; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;# '''Perché si può usare un meccanismo di crittografia simmetrica nella gestione delle capability di accesso alle risorse?'''&lt;/div&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td class='diff-marker'&gt; &lt;/td&gt;&lt;td style=&quot;background-color: #f8f9fa; color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #eaecf0; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;# '''Quali operazioni svolge il processore per la gestione di un interrupt e quali invece sono a carico del kernel del sistema operativo?''' &amp;lt;br&amp;gt; Il processore si occupa, all'attivazione della linea elettronica dell interrupt di recuperare dalla memoria in locazioni fisse l'indirizzo delle istruzioni di gestione degli interrupt. In seguito carica questo indirizzo nel program counter e quindi &amp;quot;salta&amp;quot; a queste istruzioni attivando la modalità di esecuzione kernel mode. &amp;lt;br&amp;gt; Le routine di gestione degli interrupt fanno parte del codice kernel e si occupano di gestire opportunamente le operazioni necessarie in base al tipo di interrupt. Per esempio operazioni come eseguire lo scheduler o recuperare l'output di un device.&lt;/div&gt;&lt;/td&gt;&lt;td class='diff-marker'&gt; &lt;/td&gt;&lt;td style=&quot;background-color: #f8f9fa; color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #eaecf0; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;# '''Quali operazioni svolge il processore per la gestione di un interrupt e quali invece sono a carico del kernel del sistema operativo?''' &amp;lt;br&amp;gt; Il processore si occupa, all'attivazione della linea elettronica dell interrupt di recuperare dalla memoria in locazioni fisse l'indirizzo delle istruzioni di gestione degli interrupt. In seguito carica questo indirizzo nel program counter e quindi &amp;quot;salta&amp;quot; a queste istruzioni attivando la modalità di esecuzione kernel mode. &amp;lt;br&amp;gt; Le routine di gestione degli interrupt fanno parte del codice kernel e si occupano di gestire opportunamente le operazioni necessarie in base al tipo di interrupt. Per esempio operazioni come eseguire lo scheduler o recuperare l'output di un device.&lt;/div&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td class='diff-marker'&gt; &lt;/td&gt;&lt;td style=&quot;background-color: #f8f9fa; color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #eaecf0; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;# '''Perche’ il mascheramento degli interrupt non si può utilizzare per creare sezioni critiche in sistemi multicore o multiprocessore?''' &amp;lt;br&amp;gt; Il mascheramento degli interrupt previene l'interruzione del esecuzione del processo corrente e il context switch a un altro processo e di conseguenza la non atomicità delle istruzioni che stava eseguendo il processo. &amp;lt;br&amp;gt; Anche disabilitando gli interrupt (è uguale se su un solo processore o su tutti) c'è comunque la possibilità che altro codice eseguito in ''parallelismo reale'' vada in concorrenza con quello dove si sta cercando di ottenere una sezione critica.&lt;/div&gt;&lt;/td&gt;&lt;td class='diff-marker'&gt; &lt;/td&gt;&lt;td style=&quot;background-color: #f8f9fa; color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #eaecf0; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;# '''Perche’ il mascheramento degli interrupt non si può utilizzare per creare sezioni critiche in sistemi multicore o multiprocessore?''' &amp;lt;br&amp;gt; Il mascheramento degli interrupt previene l'interruzione del esecuzione del processo corrente e il context switch a un altro processo e di conseguenza la non atomicità delle istruzioni che stava eseguendo il processo. &amp;lt;br&amp;gt; Anche disabilitando gli interrupt (è uguale se su un solo processore o su tutti) c'è comunque la possibilità che altro codice eseguito in ''parallelismo reale'' vada in concorrenza con quello dove si sta cercando di ottenere una sezione critica.&lt;/div&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td class='diff-marker'&gt; &lt;/td&gt;&lt;td style=&quot;background-color: #f8f9fa; color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #eaecf0; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;# '''Per quali tipi di processo l’algoritmo di schedulazione round-robin è efficiente e per quali no?''' &amp;lt;br&amp;gt; L'algoritmo di schedulazione round-robin è efficente per i processi I/O bound in quanto è ''fair'', cioè permette a tutti i processi il diritto di esecuzione entro un certo lasso di tempo. Può non essere efficiente per i processi CPU bound che hanno tempi di esecuzione lunghi e il round robin li costringe a ritardare il loro completamento. Inoltre un processo CPU bound potrebbe essere interrotto quando manca davvero poco al suo termine ma il time slice è terminato oppure necessita di I/O.Il processo viene messo in coda e bisognerà aspettare l'esecuzione di tutti gli altri processi prima di poter finire l'esecuzione.Uno scheduler shortest remaining time first avrebbe invece rimesso subito in esecuzione il processo CPU bound se il tempo di esecuzione previsto rimanente era davvero ridotto.&lt;/div&gt;&lt;/td&gt;&lt;td class='diff-marker'&gt; &lt;/td&gt;&lt;td style=&quot;background-color: #f8f9fa; color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #eaecf0; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;# '''Per quali tipi di processo l’algoritmo di schedulazione round-robin è efficiente e per quali no?''' &amp;lt;br&amp;gt; L'algoritmo di schedulazione round-robin è efficente per i processi I/O bound in quanto è ''fair'', cioè permette a tutti i processi il diritto di esecuzione entro un certo lasso di tempo. Può non essere efficiente per i processi CPU bound che hanno tempi di esecuzione lunghi e il round robin li costringe a ritardare il loro completamento. Inoltre un processo CPU bound potrebbe essere interrotto quando manca davvero poco al suo termine ma il time slice è terminato oppure necessita di I/O.Il processo viene messo in coda e bisognerà aspettare l'esecuzione di tutti gli altri processi prima di poter finire l'esecuzione.Uno scheduler shortest remaining time first avrebbe invece rimesso subito in esecuzione il processo CPU bound se il tempo di esecuzione previsto rimanente era davvero ridotto.&lt;/div&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;/table&gt;</summary>
		<author><name>FedericoB</name></author>
	</entry>
	<entry>
		<id>https://so.v2.cs.unibo.it/wiki/index.php?title=Prova_teorica_2017.01.18&amp;diff=1921&amp;oldid=prev</id>
		<title>FedericoB: Creata pagina e aggiunte risposte a domande 3,4,5 esercizio g.2</title>
		<link rel="alternate" type="text/html" href="https://so.v2.cs.unibo.it/wiki/index.php?title=Prova_teorica_2017.01.18&amp;diff=1921&amp;oldid=prev"/>
		<updated>2017-06-15T08:55:39Z</updated>

		<summary type="html">&lt;p&gt;Creata pagina e aggiunte risposte a domande 3,4,5 esercizio g.2&lt;/p&gt;
&lt;p&gt;&lt;b&gt;New page&lt;/b&gt;&lt;/p&gt;&lt;div&gt;[http://www.cs.unibo.it/~renzo/so/compiti/2017.01.18.ris.pdf link al compito]&lt;br /&gt;
&lt;br /&gt;
==Esercizio g.2==&lt;br /&gt;
&lt;br /&gt;
# '''Perché un algoritmo di rimpiazzamento a stack non soffre dell’anomalia di Belady?'''&lt;br /&gt;
# '''Perché si può usare un meccanismo di crittografia simmetrica nella gestione delle capability di accesso alle risorse?'''&lt;br /&gt;
# '''Quali operazioni svolge il processore per la gestione di un interrupt e quali invece sono a carico del kernel del sistema operativo?''' &amp;lt;br&amp;gt; Il processore si occupa, all'attivazione della linea elettronica dell interrupt di recuperare dalla memoria in locazioni fisse l'indirizzo delle istruzioni di gestione degli interrupt. In seguito carica questo indirizzo nel program counter e quindi &amp;quot;salta&amp;quot; a queste istruzioni attivando la modalità di esecuzione kernel mode. &amp;lt;br&amp;gt; Le routine di gestione degli interrupt fanno parte del codice kernel e si occupano di gestire opportunamente le operazioni necessarie in base al tipo di interrupt. Per esempio operazioni come eseguire lo scheduler o recuperare l'output di un device.&lt;br /&gt;
# '''Perche’ il mascheramento degli interrupt non si può utilizzare per creare sezioni critiche in sistemi multicore o multiprocessore?''' &amp;lt;br&amp;gt; Il mascheramento degli interrupt previene l'interruzione del esecuzione del processo corrente e il context switch a un altro processo e di conseguenza la non atomicità delle istruzioni che stava eseguendo il processo. &amp;lt;br&amp;gt; Anche disabilitando gli interrupt (è uguale se su un solo processore o su tutti) c'è comunque la possibilità che altro codice eseguito in ''parallelismo reale'' vada in concorrenza con quello dove si sta cercando di ottenere una sezione critica.&lt;br /&gt;
# '''Per quali tipi di processo l’algoritmo di schedulazione round-robin è efficiente e per quali no?''' &amp;lt;br&amp;gt; L'algoritmo di schedulazione round-robin è efficente per i processi I/O bound in quanto è ''fair'', cioè permette a tutti i processi il diritto di esecuzione entro un certo lasso di tempo. Può non essere efficiente per i processi CPU bound che hanno tempi di esecuzione lunghi e il round robin li costringe a ritardare il loro completamento. Inoltre un processo CPU bound potrebbe essere interrotto quando manca davvero poco al suo termine ma il time slice è terminato oppure necessita di I/O.Il processo viene messo in coda e bisognerà aspettare l'esecuzione di tutti gli altri processi prima di poter finire l'esecuzione.Uno scheduler shortest remaining time first avrebbe invece rimesso subito in esecuzione il processo CPU bound se il tempo di esecuzione previsto rimanente era davvero ridotto.&lt;/div&gt;</summary>
		<author><name>FedericoB</name></author>
	</entry>
</feed>