Politecnico di Milano

Dipartimento di Elettronica, Informazione e Bioingegneria

prof.ssa Anna Antola prof.ssa Donatella Sciuto
prof. Luca Breveglieri prof. Roberto Negrini
prof. Giuseppe Pelagatti prof.ssa Cristina Silvano

AXO – Architettura dei Calcolatori e Sistemi Operativi

esame di giovedì 22 settembre 2016

Cognome___________________________ Nome __________________

Matricola ___________________________ Firma __________________

Istruzioni
Scrivere solo sui fogli distribuiti. Non separare questi fogli.
È vietato portare all’esame libri, eserciziari, appunti, calcolatrici e telefoni cellulari. Chiunque fosse trovato in
possesso di documentazione relativa al corso – anche se non strettamente attinente alle domande proposte
– vedrà annullata la propria prova.
Non è possibile lasciare l’aula conservando il tema della prova in corso.
Tempo a disposizione: 1h:30m (una parte) 3h:00m (completo).

punteggio
approssimativo I parte † II parte † completo †

esercizio 1 6

esercizio 2 6

esercizio 3 4

esercizio 4 5

esercizio 5 5

esercizio 6 6

voto finale

ATTENZIONE: alcuni esercizi sono suddivisi in parti.

AXO – esame di giovedì 22 settembre 2016 pagina 1 di 24

esercizio n. 1 – linguaggio macchina

prima parte – traduzione da C a linguaggio macchina

Si deve tradurre in linguaggio macchina simbolico (assemblatore) MIPS il frammento di programma C ripor-
tato sotto. Il modello di memoria è quello standard MIPS e le variabili intere sono da 32 bit. Non si tenti
di accorpare od ottimizzare insieme istruzioni C indipendenti. Si facciano le ipotesi seguenti:
− il registro “frame pointer” fp non è in uso
− le variabili locali sono allocate nei registri o in pila, secondo le convenzioni note
− vanno salvati (a cura del chiamante o del chiamato, secondo il caso) solo i registri necessari
Si chiede di svolgere i tre punti seguenti (usando le varie tabelle predisposte nel seguito), preferibilmente in
ordine di elenco:
1. Si descriva il segmento dei dati statici: si traducano in linguaggio macchina le dichiarazioni delle varia-
bili globali e si diano gli spiazzamenti delle variabili globali rispetto al registro global pointer gp.
2. Si descrivano l’area di attivazione della funzione flip e l’allocazione delle variabili locali nei registri del
processore.
3. Si risponda brevemente, nello spazio assegnato, alle domande elencate.
4. Si traduca in linguaggio macchina il codice della funzione flip, limitatamente alla porzione di codice nel
riquadro, tenendo conto di quanto già detto rispondendo ai tre punti precedenti

/∗ costanti e variabili globali ∗/

#define DIM 4
int val = 0
int vect [DIM]

/∗ funzione flip ∗/
int flip (int ∗ i) {

/∗ variabili locali ∗/
int count, temp

/∗ parte esecutiva ∗/
for (count = 1; count <= DIM; count++) {
temp = vect [count – 1]
vect [DIM – count] = temp
if (temp == val) break /∗ for loop truncation ∗/
} /∗ end for ∗/

return count

} /∗ flip ∗/

flip (vect) /∗ chiamata a flip in main ∗/

AXO – esame di giovedì 22 settembre 2016 pagina 2 di 24

 punto 1 – codice MIPS della sezione dichiarativa globale (num. righe non signif.)

.data // seg. dati statici – 0x 1000 0000

punto 1 – segmento dati statici (numero di righe non significativo)

contenuto spiazzamento
indirizzo
simbolico rispetto a gp

indirizzi alti

0x 1000 0000 0x 8000 indirizzi bassi

AXO – esame di giovedì 22 settembre 2016 pagina 3 di 24

 punto 2 – area e registri di FLIP (numero di righe non significativo)

area di attivazione di FLIP

spiazz. rispetto
contenuto simbolico
a stack pointer
indirizzi alti

indirizzi bassi

allocazione delle variabili locali

di FLIP nei registri

variabile locale registro

AXO – esame di giovedì 22 settembre 2016 pagina 4 di 24

 punto 3 – rispondere sinteticamente alle domande seguenti (nello spazio assegnato)

La funzione FLIP ha un argomento: dove viene allocato ?

Qual è il valore dell’argomento della funzione FLIP al momento della chiamata in MAIN ?

punto 4 – codice MIPS di FLIP - solo blocco nel riquadro (num. righe non signif.)

AXO – esame di giovedì 22 settembre 2016 pagina 5 di 24

seconda parte – processo di assemblaggio
Dati i due moduli assemblatore seguenti, si compilino le tre tabelle seguenti relative a:
1. i due moduli oggetto prodotti dall’assemblatore
2. le basi di rilocazione del codice e dei dati dei moduli (per ragioni di impaginazione la tabella 2 compare
prima della tabella 1)
3. la tabella globale dei simboli

modulo MAIN modulo SUBMOD

.data .data
VETT: .space 40 X: .word 5
BYTE: .space 4 .text
COPY: .space 4 .globl SUBMOD
.text SUBMOD: lw $t3, COPY
.globl MAIN lw $t4, VETT
MAIN: j SUBMOD LOOP: sub $t4, $t4, $t3
lw $t1, VETT bne $t4, $0, LOOP
sb $t1, BYTE sw $t4, X
li $t0, VETT SMEND: beq $0, $0, MAIN
sw $t0, COPY
addi $t0, $0, 1
MEND: syscall

Si noti che “li” è una pseudo-istruzione, da espandere in istruzioni macchina native, come noto.

Regola generale per la compilazione di tutte le tabelle contenenti codice:

• i codici operativi e i nomi dei registri vanno indicati in formato simbolico
• tutte le costanti numeriche all’interno del codice vanno indicate in esadecimale, senza prefisso 0x, e di
lunghezza giusta per il codice che rappresentano
esempio: un’istruzione come addi $t0, $t0, 15 è rappresentata come addi $t0, $t0, 000F
• nei moduli oggetto i valori numerici che non possono essere indicati poiché dipendono dalla rilocazione
successiva, vanno posti a zero e avranno un valore definitivo nel codice eseguibile
esempio: lw $t0, RIL diventa lw $t0, 0000($gp) nell’oggetto e diventa lw $t0, nnnn($gp)
nell’eseguibile, dove RIL è un simbolo rilocabile che si riferisce a un dato globale e nnnn è il valore op-
portunamente calcolato durante la generazione dell’eseguibile

(2) – posizione in memoria dei moduli

MAIN SUBMOD

base del testo: base del testo:

base dei dati: base dei dati:

AXO – esame di giovedì 22 settembre 2016 pagina 6 di 24

 (1) – moduli oggetto
modulo MAIN modulo SUBMOD

dimensione testo: dimensione testo:

dimensione dati: dimensione dati:

testo testo

indirizzo istruzione indirizzo istruzione

dati dati

indirizzo contenuto (in esadecimale) indirizzo contenuto (in esadecimale)

tabella dei simboli tabella dei simboli

tipo può essere T (testo) oppure D (dato) tipo può essere T (testo) oppure D (dato)
simbolo tipo valore simbolo tipo valore

tabella di rilocazione tabella di rilocazione

indirizzo cod. operativo simbolo indirizzo cod. operativo simbolo

AXO – esame di giovedì 22 settembre 2016 pagina 7 di 24

 (3) – tabella globale dei simboli
simbolo valore iniziale base valore finale

Non si richiedono né la tabella globale dei dati né il codice eseguibile.

AXO – esame di giovedì 22 settembre 2016 pagina 8 di 24

AXO – esame di giovedì 22 settembre 2016 pagina 9 di 24
esercizio n. 2 – struttura e controllo del processore
prima parte – struttura del processore
Sono dati il seguente frammento di codice macchina MIPS (simbolico), che comincia l’esecuzione all’indirizzo
indicato, i valori iniziali specificati per alcuni registri, e il contenuto (e relativo indirizzo) di alcune parole della
memoria dati.

contenuto
indirizzo codice assemblatore registro
iniziale
0x 0000 0880 beq $t2, $t1, 64 $t0 0x000F C422
sw $t2, 0x0080($t1) $t1 0x0C04 08C0
lw $t1, 0xAAA0($t2) $t2 0x0C04 50CA
add $t2, $t2, $t1

memoria dati
indirizzo parola
0x001F C4CC 0xAAAA 2001
0x0040 08A0 0xFFFF AAAA
0x0C04 0940 0xFEEE CCCC
0x0C04 FB6A 0x0000 A000
0x0C04 FE0C 0x3333 CCCC

A. Calcolare il valore del registro $t2, mostrando i valori utilizzati per il calcolo, al termine dell’esecuzione
della sequenza di istruzioni sopra riportata nel caso di esecuzione su processore:

- singolo ciclo (monociclo)

- pipeline (multiciclo) senza gestione dei conflitti di dato e di controllo

- pipeline (multiciclo) con gestione dei conflitti di dato e di controllo

B. Si faccia riferimento a un processore pipeline senza gestione dei conflitti di dato e di con-
trollo e allo schema “processore pipeline e formato dei registri interstadio”
Si consideri il ciclo di clock in cui l’esecuzione delle istruzioni nei vari stadi è la seguente:

IF istruzione non specificata

ID add $t2, $t2, $t1
EX lw $t1, 0xAAA0($t2)
MEM sw $t2, 0x0080($t1)
WB beq $t2, $t1, 64

1) Indicare qual è il ciclo di clock considerato:

2) Calcolare l’indirizzo della parola di memoria referenziata da sw:

5) Completare le tabelle della pagina seguente:

AXO – esame di giovedì 22 settembre 2016 pagina 10 di 24

I campi Istruzione e di tipo NumeroRegistro possono essere indicati in forma simbolica, tutti gli altri in esa-
decimale (omettendo il prefisso 0x implicito).
segnali all’ingresso dei registri di interstadio
(subito prima del fronte di SALITA del clock)
IF ID EX MEM
registro IF/ID registro ID/EX registro EX/MEM registro MEM/WB
.WB.MemtoReg .WB.MemtoReg .WB.MemtoReg

*****************
.WB.RegWrite .WB.RegWrite .WB.RegWrite

*****************
.M.MemWrite .M.MemWrite

.M.MemRead .M.MemRead

.M.Branch .M.Branch

.PC .PC .PC

****************
.istruzione .(Rs)

.(Rt) .(Rt)

.Rt .R .R

*****************
.Rd

.imm/offset esteso .ALU_out .ALU_out

**************** *****************
.EX.ALUSrc .Zero .DatoLetto

*****************
.EX.RegDest

segnali relativi al RF (subito prima del fronte di DISCESA interno al ciclo di clock)
RF.RegLettura1 RF.RegScrittura RF.DatoLetto1
****************** ****************** ******************
RF.RegLettura2 RF.DatodaScrivere RF.DatoLetto2
****************** ****************** ******************

segnali di altre unità funzionali (subito prima del fronte di SALITA del clock)
Mem.indirizzo RegWrite

MemWrite RegDest

MemtoReg

AXO – esame di giovedì 22 settembre 2016 pagina 11 di 24

 seconda parte – gestione di conflitti e stalli
Si consideri la seguente sequenza di istruzioni appartenente al codice precedente (di cui viene fornito per
comodità di analisi anche il diagramma multiciclo teorico).

1. sw $t2, 0x0080($t1)
2. lw $t1, 0xAAA0($t2)
3. add $t2, $t2, $t1

    ciclo di clock 
    1  2  3  4  5  6  7  8  9  10  11  12  13 

1  IF  ID    EX  MEM  WB                 

istruzione 

2    IF  ID    EX  MEM  WB                 

3      IF  ID    EX  MEM  WB               

Si risponda alle domande seguenti, facendo l’ipotesi che la pipeline abbia esclusivamente dei cammini di
propagazione EX/EX e MEM/EX:

a) si riportino in tabella 1 – prime tre colonne – le dipendenze di dato che risultano essere conflitti
b) si disegni in Tabella 2 il diagramma temporale della pipeline, mettendo in evidenza gli eventuali cam-
mini di propagazione che possono essere attivati per risolvere i conflitti, e gli stalli eventualmente da in-
serire affinché la propagazione sia efficace
c) si indichino in Tabella 1 – ultima colonna – i cammini di propagazione effettivamente attivati e gli
stalli associati

  Tabella 1 (numero di righe non significativo) 
istruzione  registro  cammino di propagazione
  istruzione 
da cui dipende  coinvolto  e stalli 

         

         

         

         

Tabella 2 
  1  2  3  4  5  6  7  8  9  10  11  12  13  14 

1                             

2                             

3                             

AXO – esame di giovedì 22 settembre 2016 pagina 12 di 24

AXO – esame di giovedì 22 settembre 2016 pagina 13 di 24
 esercizio n. 3 – logica digitale
primo punto

Sia dato il circuito sequenziale composto da due bistabili master-slave di tipo D (D1, Q1 e D2, Q2 dove D è
l’ingresso del bistabile e Q è lo stato / uscita del bistabile), con un ingresso I, e una uscita U, descritto
dalle equazioni logiche seguenti:

D1 = I !Q1 + I Q2 U = Q1 Q2
D2 = I Q1 + I Q2
Si chiede di completare il diagramma temporale riportato qui sotto. Si noti che:
• si devono trascurare completamente i ritardi di propagazione delle porte logiche AND, OR e NOT, e i ri-
tardi di commutazione dei bistabili
• il bistabile è il tipo master-slave la cui struttura è stata trattata a lezione, con uscita che commuta sul
fronte di discesa del clock

diagramma temporale da completare

                                                         

I  0                                                       

                                                         

D1                                                         

                                                         

Q1  0                                                       

                                                         

D2                                                         

                                                         

Q2  0                                                       

                                                         

U                                                         

                                                         

CLK                                                         

AXO – esame di giovedì 22 settembre 2016 pagina 14 di 24

secondo punto

Dimostrare coi teoremi della logica, che avremmo anche potuto definire D2 in questo altro modo equivalente:
(il numero delle righe non è significativo.)

D2 = I ( (Q2 xor Q1) + Q2 Q1)

AXO – esame di giovedì 22 settembre 2016 pagina 15 di 24

esercizio n. 4 – processi e parallelismo
Si consideri il programma C seguente (gli “#include” e le inizializzazioni dei mutex sono omessi):

pthread_mutex_t out = PTHREAD_MUTEX_INITIALIZER

sem_t old
int global = 0

void ∗ zero (void ∗ arg) {

int finish = 0
pthread_mutex_lock (&out)
sem_wait (&old)
global++ /∗ statement A ∗/
pthread_mutex_unlock (&out)
return NULL
} /∗ end zero ∗/

void ∗ ten (void ∗ arg) {

int finish = 0
pthread_mutex_lock (&out)
sem_post (&old) /* statement B */
pthread_mutex_unlock (&out)
sem_wait (&old)
finish = 10 /∗ statement C ∗/
return NULL
} /∗ end ten ∗/

void main ( ) {
pthread_t th_0, th_1, th_2
sem_init (&old, 0, 0)
pthread_create (&th_1, NULL, ten, NULL)
sem_post (&old)
pthread_create (&th_0, NULL, zero, NULL)
pthread_create (&th_2, NULL, ten, NULL)
pthread_join (th_0, NULL)
pthread_join (th_1, NULL) /∗ statement D ∗/
pthread_join (th_2, NULL)
return
} /∗ end main ∗/

AXO – esame di giovedì 22 settembre 2016 pagina 16 di 24

Si completi la tabella qui sotto indicando lo stato di esistenza della variabile locale nell’istante di
tempo specificato da ciascuna condizione, così: se la variabile esiste, si scriva ESISTE; se non esiste, si
scriva NON ESISTE; e se può essere esistente o inesistente, si scriva PUÒ ESISTERE. Ogni casella della
tabella va riempita in uno dei tre modi (non va lasciata vuota).

variabile locale
condizione
finish in th_0 finish in th_1

subito dopo stat. A

subito dopo stat. C in th_2

subito dopo stat. D

Si completi la tabella qui sotto, indicando i valori delle variabili globali (sempre esistenti) nell’istante
di tempo specificato da ciascuna condizione. Il valore della variabile va indicato così:
• intero, carattere, stringa, quando la variabile ha un valore definito; X quando è indefinita
• se la variabile può avere due o più valori, li si riporti tutti quanti
• il semaforo può avere valore positivo o nullo (non valore negativo)
Si badi bene alla colonna “condizione”: con “subito dopo statement X” si chiede il valore (o i valori) che la
variabile ha tra lo statement X e lo statement immediatamente successivo del thread indicato.

variabili globali
condizione
old global

subito dopo stat. A

subito dopo stat. B in th_2

subito dopo stat. C in th_1

Questo sistema NON PUÒ ANDARE IN STALLO. Nel riquadro sotto, si spieghi brevemente il motivo:

AXO – esame di giovedì 22 settembre 2016 pagina 17 di 24

esercizio n. 5 – gestione della memoria
Si consideri una memoria fisica di 32 K byte disponibile per i processi di modo U, con i parametri
MIN_FREE = 2 e MAX_FREE = 3. In memoria c’è un processo P in esecuzione.

domanda 1 – si sono verificati i seguenti eventi:

• il processo P ha eseguito un servizio exec di un programma che inizia nella prima pagina di codice
(NPV = pc0)
• il processo P ha eseguita una fork creando il processo Q
• il processo P ha scritto nella prima pagina di dati dinamici
Si mostrino lo stato della memoria e dello swap file, e lo stato delle liste LRU.

memoria fisica (solo modo U)

NPF NPV NPF NPV NPF NPV NPF NPV

0 1 2 3

4 5 6 7

swap file

liste LRU
attivazioni active inactive

iniziale irrilevante (pagine di P prima di exec) irrilevante (pagine di P prima di exec)

finale

TLB (solo righe di modo U)

(completare inserendo le pagine in ordine virtuale di pagina)

NPV NPF D A NPV NPF D A

domanda 2 – si sono verificati i seguenti eventi:

• è avvenuta una commutazione di contesto che ha messo in esecuzione il processo Q
• il processo Q ha eseguito un servizio exec di un programma che inizia nella seconda pagina di codice
Si mostrino lo stato della memoria e dello swap file.

memoria fisica (solo modo U)

NPF NPV NPF NPV NPF NPV NPF NPV

0 1 2 3

4 5 6 7

swap file

AXO – esame di giovedì 22 settembre 2016 pagina 18 di 24

domanda 3 – si sono verificati i seguenti eventi:
• il processo Q ha continuamente letto la pagina di codice e scritto nella pagina di pila per un periodo di
tempo durante il quale il daemon kswapd è stato eseguito 4 volte
• successivamente il processo Q ha scritto nella pagina qd0
Si mostrino lo stato della memoria e dello swap file, e lo stato delle liste LRU.

memoria fisica (solo modo U)

NPF NPV NPF NPV NPF NPV NPF NPV

0 1 2 3

4 5 6 7

swap file

liste LRU
attivazioni active inactive

dopo
domanda 2

dopo
domanda 3

domanda 4 – si sono verificati i seguenti eventi:

• il processo Q ha scritto la pagina qd1
Si mostrino lo stato della memoria e dello swap file.

memoria fisica (solo modo U)

NPF NPV NPF NPV NPF NPV NPF NPV

0 1 2 3

4 5 6 7

swap file

AXO – esame di giovedì 22 settembre 2016 pagina 19 di 24

 esercizio n. 6 – nucleo e componenti del SO

prima parte – scheduling dei processi

// programma prova.c
main ( ) {
pid1 = fork ( )
if (pid1 == 0) { // codice eseguito da Q
execl (“/acso/prog_x”, “prog_x”, NULL)
exit (-1)
} /∗ if ∗/
write (fd, vet,50)
pid1 = waitpid (pid1, &status, 0)
exit (0)
} /∗ prova ∗/

// programma prog_x.c
pthread_mutex_t GATE = PTHREAD_MUTEX_INITIALIZER
sem_t GO
void ∗ ONE (void ∗ arg) { void ∗ TWO (void ∗ arg) {
sem_wait (&GO) pthread_mutex_lock (&GATE)
pthread_mutex_lock (&GATE) sem_post (&GO)
sem_post (&GO) pthread_mutex_unlock (&GATE)
pthread_mutex_unlock (&GATE) sem_wait (&GO)
sem_wait (&GO) sem_post (&GO)
return NULL return NULL
} /∗ FIRST ∗/ } /∗ LAST ∗/
main ( ) { // codice eseguito da S e Q
pthread_t TH_1, TH_2
sem_init (&GO, 0, 0)
pthread_create (&TH_1, NULL, ONE, NULL)
pthread_create (&TH_2, NULL, TWO, NULL)
pthread_join (TH_2, NULL)
pthread_join (TH_1, NULL)
exit (1)
} /∗ main ∗/

Un processo S esegue il programma prog_x e un processo P esegue il programma prova. Il processo S

crea i thread TH1 e TH2, mentre il processo P crea il processo Q. Il processo Q esegue una mutazione di
codice che non va a buon fine.
Si simuli l’esecuzione dei processi (fino a udt = 100) così come risulta dal codice dato, dagli eventi indicati e
ipotizzando che il processo P non abbia ancora eseguito la fork. Si completi la tabella riportando quanto
segue:
• 〈 PID, TGID 〉 di ogni processo che viene creato
• 〈 identificativo del processo-chiamata di sistema / libreria 〉 nella prima colonna, dove necessario e in
funzione del codice proposto
• in ciascuna riga lo stato dei processi al termine del tempo indicato; si noti che la prima riga della
tabella potrebbe essere solo parzialmente completata
NOTA BENE:
• si considerino solo le funzioni marcate in grassetto nel codice dato
• l’esecuzione della funzione exec non sospende il processo

AXO – esame di giovedì 22 settembre 2016 pagina 20 di 24

 TABELLA DA COMPILARE (numero di colonne non significativo)
identificativo simbolico
Idle S P
del processo
PID 1 2 3

evento/processo-chiamata TGID 1 2 3

S – sem_init 0 pronto esec pronto

10

interrupt da RT_clock,
scadenza quanto di 20
tempo

30 pronto pronto esec pronto pronto

40

50

25 interrupt da stdout,
60
scritti solo 25 caratteri

70

80

90

100

AXO – esame di giovedì 22 settembre 2016 pagina 21 di 24

 seconda parte – struttura e moduli del nucleo
Dato un processo Q, si consideri la funzione di libreria NPTL  mutex_lock  e la sua implementazione
tramite  futex. 
Caso A: chiamata di mutex_lock ed esecuzione senza invocazione di system_call
Indicare l’invocazione di tutti i moduli di libreria e eventualmente di SO per la gestione dell’evento e il conte-
nuto delle pile utente e di sistema nell’istante di tempo immediatamente precedente al ritorno al codice u-
tente successivo a mutex_lock.
NOTAZIONE da usare per i moduli: > (invocazione), nome_modulo (esecuzione), < (ritorno)

IL NUMERO DI RIGHE VUOTE NELLE TABELLE QUI SOTTO NON È SIGNIFICATIVO

processo modo modulo

W piena

piena

ubase_Q piena

uStack_Q

sbase_Q

sStack_Q

AXO – esame di giovedì 22 settembre 2016 pagina 22 di 24

 Caso B: chiamata di mutex_lock ed esecuzione con invocazione di system_call
Indicare l’invocazione di tutti i moduli di libreria e eventualmente di SO per la gestione dell’evento che si
svolgono nel contesto del processo Q. Mostrare il relativo contenuto delle pile utente e di sistema.
NOTAZIONE da usare per i moduli: > (invocazione), nome_modulo (esecuzione), < (ritorno)

IL NUMERO DI RIGHE VUOTE NELLE TABELLE QUI SOTTO NON È SIGNIFICATIVO

processo modo modulo

W piena

piena

ubase_Q piena

uStack_Q

sbase_Q

sStack_Q

AXO – esame di giovedì 22 settembre 2016 pagina 23 di 24

AXO – esame di giovedì 22 settembre 2016 pagina 24 di 24