Architektura Komputerów I Rozwiązania List Zadań

Transkrypt

Architektura Komputerów I
semestr letni 2007/2008
Rozwiązania List Zadań
Opracowali:
Hejduk Przemysław
Maślej Damian
Korekta:
mgr Bartosz Wojciechowski
Należy pamiętać, że praca może zawierać błędy,
mijać sie z prawdą lub być niekompletna,
ale za to autorzy nie ponoszą żadnej odpowiedzialności.
Architektura Komputerów
Hejduk Przemysław
Maślej Damian
1 z 38
Lista 1 – IEEE 754
• Zad 1.
a) 0+
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 - - s
exponent
mantissa
g
r
s
01 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 - - s
exponent
mantissa
g
r
s
b) - nieskończoność
1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 - - s
exponent
mantissa
g
r
s
+ nieskończoność
0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 - - s
exponent
mantissa
g
r
s
c) – 9.625
Dzielimy liczbę przez 2 i zapisujemy:
-9.625 = 4,8125 x 21
4,8125 = 2,40625 x 22
2,40625 = 1,203125 x 23
Kodujemy część ułamkową, odcinając po drodze część całkowitą
0,203125 x 2 = 0,40625
0
0,40625 x 2 = 0,8125
0
0,8125 x 2 = 1,625
1
0,625 x 2 = 1,25
1
0,25 x 2 = 0,5
0
0,5 x 2 = 1,0
1
Wykładnik to 3+127= 130
1 1 0 0 0 0 0 1 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
s
exponent
mantissa
g
r
s
d) 0.1875 = 1.5 x 2-3
Kodujemy część ułamkową
0.5 x 2 = 1.0
1
Wykładnik to -3+127 = 124
0 0 1 1 1 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
s
exponent
mantissa
g
Hejduk Przemysław
Maślej Damian
2 z 38
r
s
e) 30.5
30.5 = 1,90625 x 24
Kodujemy część ułamkową
0,90625 x 2 = 1,8125
0,8125 x 2= 1,625
0,625 x 2 = 1,25
0,25 x 2 = 0,5
0,5 x 2 = 1,0
Wykładnik to 4 +127 = 131
0 1 0 0 0 0 0 1 1 1 1 1 0
s
exponent
-2.2
-2.2= -1.1 x 21
0.1 x 2 = 0.2
0.2 x 2 = 0.4
0.4 x 2 = 0.8
0.8 x 2 = 1.6
0.6 x 2 = 1.2
0.2 x 2 = 0.4
0.4 x 2 = 0.8
0.4 x 2 = 1.6
1 1 0 0 0 0 0 0 0 0 0 0 1
1
1
1
0
1
1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
mantissa
g
r
s
f)
s
exponent
0
0
0
1
1
0
0
1
1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 1
mantissa
g
r
s
g) qNaN
x 1 1 1 1 1 1 1 1 1 x x x x x x x x x x x x x x x x x x x x x x - - s
exponent
mantissa
g
r
s
h) sNaN
x 1 1 1 1 1 1 1 1 0 x x x x x x x x x x x x x x x x x x x x x x - - s
exponent
mantissa
g
r
s
i)
21,(3)
Kodujemy 21 jako 10101
Kodujemy 0,(3) jako 0,010101010101…
10101,0101010101… = 1,0101010101… x 24
Wykładnik to 4 + 127 = 131
1 0 0 0 0 0 1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
s
exponent
mantissa
g
Hejduk Przemysław
Maślej Damian
3 z 38
r
s
• Zad 2.
a) C780 0007
C
7
8
0
0
0
0
7
1 1 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 - - s
exponent
mantissa
g
r
s
Wykładnik odciążamy, robimy z niego liczbę przeciwną I dociążamy.
Mantysę negujemy i dodajemy jeden.
1 0 1 1 0 1 1 1 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 1 0 - - s
exponent
mantissa
g
r
s
b) 8F80 000F
8
F
8
0
0
0
0
F
1 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 - - s
exponent
mantissa
g
r
s
1 1 1 0 1 1 1 1 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 1 0 - - s
exponent
mantissa
g
r
s
c) 3FFF FFFB
3
F
F
F
F
F
F
B
0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 - - s
exponent
mantissa
g
r
s
0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 - - s
exponent
mantissa
g
r
s
d) 8780 0004
8
7
8
0
0
0
0
4
1 0 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 - - s
exponent
mantissa
g
r
s
1 1 1 1 0 1 1 1 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 - - s
exponent
mantissa
g
Hejduk Przemysław
Maślej Damian
4 z 38
r
s
• Zad 3. poprawność rozwiązania nie gwarantowana
a) zaokrąglenie przez obcięcie
tabela jest taka sama dla liczb ujemnych jak I dodatnich
przed zaokrągleniem
po zaokrągleniu (23 bit mantysy)
0
0
0
0
0
0
1
0
0
1
0
0
0
1
1
0
1
0
0
0
1
0
1
0
1
1
0
0
1
1
1
0
Średni błąd standaryzowany =
różnica dziesiętna
0
1 v -1
2 v -2
3 v -3
4 v -4
5 v -5
6 v -6
7 v -7
0
b) zaokrąglenie do + inf
- tabela dla liczb dodatnich
0
0
0
0
0
0
1
0
0
1
0
0
0
1
1
0
1
0
0
1
1
0
1
1
1
1
0
1
1
1
1
1
0
1
2
3
4
3
2
1
- tabela dla liczb ujemnych
0
0
0
0
0
1
0
1
0
0
1
1
1
0
0
1
0
1
1
1
0
1
1
1
0
1
2
3
4
5
6
7
0
0
0
0
0
0
0
0
2,93
Hejduk Przemysław
Maślej Damian
5 z 38
c) zaokrąglenie do - inf
- tabela dla liczb ujemnych
0
0
0
0
0
1
0
1
0
0
1
1
1
0
0
1
0
1
1
1
0
1
1
1
0
0
0
0
1
1
1
1
0
-1
-2
-3
-4
-3
-2
-1
- tabela dla liczb dodatnich
0
0
0
0
0
1
0
1
0
0
1
1
1
0
0
1
0
1
1
1
0
1
1
1
0
0
0
0
0
0
0
0
0
-1
-2
-3
-4
-5
-6
-7
2,93
d) zaokrąglenie do najblizszej
- tabela dla liczb ujemnych i dodatnich
0
0
0
0
0
0
1
0
0
1
0
0
0
1
1
0
1
0
0
1
1
0
1
1
1
1
0
1
1
1
1
1
0
1 v -1
2 v -2
3 v -3
4 v -4
3 v -3
2 v -2
1 v -1
0
- standardu ieee nie używa się do przechowywania danych o kwotach pieniężnych, gdyż w
tego typu danych wymagana jest bezwzględna dokładność. W bankowości do
przechowywania kwot pieniężnych używa się reprezentacji dziesiętnych.
Hejduk Przemysław
Maślej Damian
6 z 38
• Zad 4.
Nie, gdyż, 0 nie jest liczbą znormalizowaną a poza tym mamy równanie (gdzie A i B to części
ułamkowe liczb)
1, · 2 1, · 2 1, · 2
1, · 2 0
Dla dowolnego B i Y liczba nigdy nie będzie równa zero
• Zad 5.
Ogólna reprezentacja liczby zmiennoprzecinkowej:
S E E E E E MMMMM
s
exponent
mantissa
Obciążenie jest równe 15, czyli zakres wykładnika od -14 do 16
+ inf
0 1 1 1 1 1 0 0 0 0 0
s
exponent
mantissa
- inf
1 1 1 1 1 1 0 0 0 0 0
s
exponent
mantissa
qNaN
x
1 1 1 1 1 1 x x x x
s
exponent
mantissa
sNaN
x
1 1 1 1 1 0 x x x x
s
exponent
mantissa
max
0 1 1 1 1 0 1 1 1 1 1
s
exponent
mantissa
min
1 1 1 1 1 0 1 1 1 1 1
s
exponent
mantissa
Hejduk Przemysław
Maślej Damian
7 z 38
• Zad 6.
a) A = (550)16 B = (4E0)16
A = (550)16= (010101010000)2 = 1,0101010000 x 210
B = (4E0)16 = (010011100000)2 = 1,0011100000 x 210
W standardzie IEEE754 są 4 oficjalne standardy zaokrągleń, do +inf, do –inf, do zera i do najbliższej
A w IEEE 754:
0 1 0 0 0 1 0 0 1 0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
s
exponent
mantissa
g
r
s
A z bitami GRS :
0 1 1 0 0 1 0 1 0 1 0 1 0 0
s
exponent
mantissa
g
r
s
A zaokrąglone do zera
0 1 1 0 0 1 0 1 0 1 0
s
exponent
mantissa
A zaokrąglone do -inf
0 1 1 0 0 1 0 1 0 1 0
s
exponent
mantissa
A zaokrąglone do +inf
0 1 1 0 0 1 0 1 0 1 1
s
exponent
mantissa
A zaokrąglone do najblizszej
0 1 1 0 0 1 0 1 0 1 1
s
exponent
mantissa
B w IEEE 754
0 1 0 0 0 1 0 0 1 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
s
exponent
mantissa
g
B z bitami GRS:
0 1 1 0 0 1 0 0 1 1 1 0 0 0
s
exponent
mantissa
g
r
s
B zaokrąglone do zera
0 1 1 0 0 1 0 0 1 1 1
s
exponent
mantissa
B zaokrąglone do -inf
0 1 1 0 0 1 0 0 1 1 1
s
exponent
mantissa
Hejduk Przemysław
Maślej Damian
8 z 38
r
s
B zaokrąglone do +inf
0 1 1 0 0 1 0 0 1 1 1
s
exponent
mantissa
B zaokrąglone do najblizszej
0 1 1 0 0 1 0 0 1 1 1
s
exponent
mantissa
1) dodawanie / odejmowanie
2) mnożenie
3) dzielenie
Hejduk Przemysław
Maślej Damian
9 z 38
Każdą z podanych operacji na każdym poziomie wykonywanie, należy wykonywać na 35 bitach
(łącznie z bitami G,R,S, których wartości na samych początku są zerami). Zaokrąglenia wg wybranego
standardu należy wykonać po 3, a przed 4 krokiem.
Hejduk Przemysław
Maślej Damian
10 z 38
Lista 2 – Architektura listy rozkazów
•
Zad 1.
a)
i.
Operacja
2b
Tryb
1b
Dana
5b
Operacja
2b
Tryb
1b
Dana
13b
Operacja
2b
Tryb
1b
Dana
29b
ii.
iii.
Hejduk Przemysław
Maślej Damian
11 z 38
b)
============================ OR =====
sta R3
=> akumulator ląduje w R3
nand R1
=> negujemy akumulator /// akumulator=zanegowany_start
sta
=> akumulator (zanegowany_start) ląduje w R2
R2
nand R3
=> w R3 jest start a W R1 zanegowany_start więc wynik nand-a to FF
nand src
=> do akumulatora wrzucamy zanegowany src
nand R2
=> w R2 mamy zanegowany_start, w akumulatorze zanegowane src,
więc wynikiem nand-a będzie OR(start, src)
=========================== ADD =====
sta
R2
nand R1
nand R2
sta
=> wrzucamy do rejestru warunku FF z akumulatora
R8
nand R1
=> negujemy akumulator (jest w nim 00)
STA R9
=> do rejestru C ląduje 0
cadc R2
=> do akumulatora ląduje wynik 0+start+0
cadc src
=> do akumulatora ląduje start + src +0
Hejduk Przemysław
Maślej Damian
12 z 38
=========================== SUB =====
sta
R2
nand R1
nand R2
sta
=> wrzucamy do rejestru warunku FF z akumulatora
R8
nand R1
STA R9
cadc src
=> do akumulatora ląduje wynik 0+src+0
nand R1
=> w akumulatorze zanegowana druga liczba
cadc R2
=> w akumulatorze R2+zanegowane_src +0
=========================== INC =====
sta
R2
nand R1
nand R2
sta R8
=> do R8 (COND) wrzucamy FF
sta R9
=> do R9 wrzucamy FF, więc C (R9[0]) = 1
nand R1
=> negujemy akumulator /// akumulator = 00
cadc R2
=> COND != 0, więc akumulator = 00 + R2(start) + C (1) = start + 1
Hejduk Przemysław
Maślej Damian
13 z 38
=========================== XOR=====
R2
R2
R4
R3
sta R2
=> w R2 ląduje start
nand R1
nand R2
=> w R2 jest 0 lub 1 a W R1 1 lub 0 więc wynik nand-a to 1
sta
=> wrzucamy do rejestru warunku 1 z akumulatora
R8
nand R1
STA R9
cadc src
=> do akumulatora ląduje wynik 0+src+0
sta R3
=> w R3 mamy src
nand R2
=> wynik negacji src i startu ląduje w akumulatorze
sta R4
=> akumulator do R4
nand R2
=> wynik negacji R2 i R4 w akumulatorze
sta R2
=> wynik negacji R2 i R4 w R2
nand R1
nand R2
=> w R2 jest 0 lub 1 a W R1 1 lub 0 więc wynik nand-a to 1
nand R1
cadc R4
=> w akumulatorze ląduje R4
nand R3
=> w akumulatorze ląduje nand z R3 i R4
nand R2
=> w akumulatorz ląduje wynik XOR = A xor src
Hejduk Przemysław
Maślej Damian
14 z 38
=========================== PUSH =====
sta
R2
nand R1
nand R2
nand R28
=> akumulator = !R28
nand R1
=> akumulator = R28
INC R1
=> akumulator = R28+1
sta R28
=> R28++
sta
R2
nand R1
nand R2
nand Ri
=> akumulator = !Ri
nand R1
=> akumulator = Ri
sta [R28]
=> na szczyt stosu odkładamy wartość z Ri
=========================== DEC =====
sta
R2
nand R1
sta
=> R3 = zanegowany_start
R3
nand R2
sta R8
=> do R8 (COND) wrzucamy FF
sta R9
=> do R9 wrzucamy FF, więc C (R9[0]) = 1
nand R1
=> negujemy akumulator /// akumulator = 00
cadc R3
=> COND != 0, więc akumulator = R3(zanegowany_start) + C (1)
nand R1
=> negujemy akumulator /// akumulator = start - 1
Hejduk Przemysław
Maślej Damian
15 z 38
=========================== POP =====
sta
R2
nand R1
nand R2
nand [R28]
=> akumulator = ![R28]
nand R1
=> akumulator = [R28]
sta Ri
=> Ri = wartość na szczycie stosu
sta
R2
nand R1
nand R2
nand R28
=> akumulator = !R28
nand R1
=> akumulator = R28
DEC R1
=> akumulator = R28 – 1
sta R28
=> R28--
• Zad 4.
============================ NEG =====
not R1,Rk
=> do R1 wrzucamy negację Rk
not R2,R0
=> do R2 wrzucamy FF (czyli -1 w U2)
sub R1,R2,Rm
=> do Rm wrzucamy !Rk - (-1) (w U2) czyli !Rk+1 (!Rk w U2)
============================ ADD =====
NEG Rk,R1
sub Rm,R1,Rn
=> Rn = Rm – (–Rk) = Rm+Rk
Hejduk Przemysław
Maślej Damian
16 z 38
============================ AND =====
not R1, Rk
not R2, Rm
=> do R1 wrzucamy negację Rm
or R1,R2,Rn
=> sumujemy logicznie zaprzeczenia Rk i Rm
not Rn, Rn
=> negujemy Rn, bo Rk + Rm = !(!Rk * !Rm)
============================ MOVE =====
not Rm, Rk
=> do Rm wrzucamy negację Rk
not Rm, Rm
=> negujemy Rm
alternatywnie
SUB Rk, R0, Rm ;
=> Rm=Rk-0
Hejduk Przemysław
Maślej Damian
17 z 38
• Zad 5.
============================ SILNIA =====
br R6, LICZ
=> jeśli R6!=0 to skok do LICZ
move R8, R0
=> R8 = 00
not R7, R0
=> R7 = FF
neg R7
=> negujemy FF w U2 (R7 = 01)
br R7, KONIEC
=> jeśli R7!=0 to skok do KONIEC
LICZ:
move R8, R6
=> do R8 przypisujemy wartość R6
move R9, R6
not R7, R0
=> do R7 przypisujemy FF czyli -1 w U2
add R9, R7, R9
=> dekrementujemy R9 w U2
add R9, R7, R9
=> dekrementujemy R9
move R10, R9
move R11, R8
POWROT:
move R8, R11
MNOZENIE:
add R11, R8, R11
=> dodajemy w mnożeniu
add R9, R7, R9
br R9, MNOZENIE
=> jeśli R9 != 0 to powrót do MNOZENIE
add R10, R7, R10
move R9, R10
=> do R9 przypisujemy zdekrementowaną wartość R10
br R9, POWROT
=> jeśli R9 != 0 to powrót do POWROT
KONIEC:
Hejduk Przemysław
Maślej Damian
18 z 38
============================ FIBONACCI =====
br R6, LICZ
=> jeśli R6!=0 to skok do LICZ
move R8, R0
=> R8 = 00
not R7, R0
neg R7
br R7, KONIEC
=> jeśli R7!=0 to skok do KONIEC
LICZ:
not R7, R0
move R11, R6
add R11, R7, R11
=> R11--;
br R11, LICZ2
=> jeśli R11!=0 to skok do LICZ2
move R10, R6
br R10, KONIEC
=> przechodzimy do KONIEC, wartość=1
LICZ2:
move R8, R0
=> R8 = 00
not R9, R0
=> R9 = FF
neg R9
DODAWANIE:
add R8, R9, R10
=> dodajemy R10 = R8 + R9
move R8, R9
=> R8 = R9
move R9, R10
=> R9 = R10
add R11, R7, R11
=> R11--;
br R11, DODAWANIE => powrot
KONIEC:
Hejduk Przemysław
Maślej Damian
19 z 38
Lista 3 – organizacja pamięci
• Zad 1.
Strona ma ustaloną wielkość, a wielkość segmentu zależy od zapotrzebowań procesu.
Liczba stron jest ustalona i wynosi rozmiar_dostępnej_pamięci/wielkość_strony.
Ilość segmentów zależy od ich wielkości i dostępnej pamięci, więc nie jest stała bo
segmenty mogą mieć różne wielkości.
W segmentacji użytkownik określa numer segmentu i odległość w segmencie,
natomiast w stronicowaniu użytkownik określa pojedynczy adres, dzielony następnie
przez sprzęt na numer strony i odległość.
Fragmentacja wewnętrzna występuje w stronicowaniu (gdy przydzielana pamięć jest
większa niż zamawiana).
Fragmentacja zewnętrzna występuje w segmentacji (gdy suma wolnych obszarów w
pamięci wystarcza na spełnienie zamówienia, ale nie tworzą one spójnego obszaru,
przez co nie mogą zostać przydzielone procesowi).
• Zad 2.
Po usunięciu procesów P2 i P4 pamięć będzie wyglądała następująco:
P1
250
P3
150
W 280
P5
200
W
168
W
632
A po wprowadzeniu P6, P7, P8 i P9 w zależności od algorytmu następująco:
(a) pierwsze wpasowanie (ang. first fit — FF) – wrzucamy kolejne procesy w pierwsze
wolne obszary, do których się zmieszczą.
P1
250
P6 P8 W
140 80 60
P3
150
P9 W
110 58
P5
200
P7
200
W
432
(b) najlepsze wpasowanie (ang. best fit — BF) – wrzucamy kolejne procesy w
najmniejsze wolne obszary, do których się zmieszczą.
P1
250
P7
200
P8
80
P3
150
P6
140
W
28
P5
200
P9
110
W
522
(c) najgorsze wpasowanie (ang. worst fit — WF) – wrzucamy kolejne procesy w
największe wolne obszary.
P1
250
P9
110
W
170
P3 150
W
168
P5
200
P6
140
P7
200
P8
80
W
212
Hejduk Przemysław
Maślej Damian
20 z 38
• Zad 3.
Pamięć początkowo będzie wyglądała następująco:
W
100
W
500
W
200
W
300
W
600
A po wprowadzeniu procesów w zależności od algorytmu następująco:
(a) pierwsze wpasowanie (ang. first fit — FF) – wrzucamy kolejne procesy w pierwsze
wolne obszary, do których się zmieszczą.
P
209
W
100
P
120
W
171
W
200
P
420
W
300
W
180
UWAGA!! Brak miejsca dla procesu o rozmiarze 430
(b) najlepsze wpasowanie (ang. best fit — BF) – wrzucamy kolejne procesy w
najmniejsze wolne obszary, do których się zmieszczą.
P
420
W
100
W
80
P
120
P
209
W
80
P
430
W
91
W
170
(c) najgorsze wpasowanie (ang. worst fit — WF) – wrzucamy kolejne procesy w
największe wolne obszary.
P
420
W
100
W
80
W
200
P
209
W
300
P
120
W
271
UWAGA!! Brak miejsca dla procesu o rozmiarze 430
Najlepiej zagospodarował pamięć algorytm BF, ponieważ tylko przy nim zmieściły
się wszystkie procesy.
• Zad 4.
Jeden element typu char zajmuje 1 bajt pamięci, więc przy 16 bajtowych stronach
zadeklarowanie tej tablicy zajmie 4 strony:
Nr.
1
2
3
4
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
[0,0]
[2,0]
[4,0]
[6,0]
[0,1]
[2,1]
[4,1]
[6,1]
[0,2]
[2,2]
[4,2]
[6,2]
[0,3]
[2,3]
[4,3]
[6,3]
[0,4]
[2,4]
[4,4]
[6,4]
[0,5]
[2,5]
[4,5]
[6,5]
[0,6]
[2,6]
[4,6]
[6,6]
[0,7]
[2,7]
[4,7]
[6,7]
[1,0]
[3,0]
[5,0]
[7,0]
[1,1]
[3,1]
[5,1]
[7,1]
[1,2]
[3,2]
[5,2]
[7,2]
[1,3]
[3,3]
[5,3]
[7,3]
[1,4]
[3,4]
[5,4]
[7,4]
[1,5]
[3,5]
[5,5]
[7,5]
[1,6]
[3,6]
[5,6]
[7,6]
[1,7]
[3,7]
[5,7]
[7,7]
a) matrix[i][j] = (i)*8+j;
Nr.
1
2
3
4
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
0
16
32
48
1
17
33
49
2
18
34
50
3
19
35
51
4
20
36
52
5
21
37
53
6
22
38
54
7
23
39
55
8
24
40
56
9
25
41
57
10
26
42
58
11
27
43
59
12
28
44
60
13
29
45
61
14
30
46
62
15
31
47
63
Hejduk Przemysław
Maślej Damian
21 z 38
zamiana LIFO
Stan
Komórki
bufora
Błąd
tabeli
TLB
początek
x,x,x
[0,0]
1,x,x
TAK
[0,1]
1,x,x
[0,2]
1,x,x
:
:
:
:
:
:
:
:
:
[0,7]
1,x,x
[1,0]
1,x,x
[1,1]
1,x,x
:
:
:
:
:
:
:
:
:
[1,7]
1,x,x
[2,0]
1,2,x
TAK
[2,1]
1,2,x
:
:
:
:
:
:
:
:
:
[3,7]
1,2,x
[4,0]
1,2,3
TAK
[4,1]
1,2,3
:
:
:
:
:
:
:
:
:
[5,7]
1,2,3
[6,0]
1,2,4
TAK
[6,1]
1,2,4
:
:
:
:
:
:
:
:
:
[7,6]
1,2,4
[7,7]
1,2,4
Liczba błędów:
4
Współczynnik trafień:
(64-4)/64 = 60/64 = 94%
zamiana LRU
Stan
Komórki
bufora
Błąd
tabeli
TLB
początek
x,x,x
[0,0]
1,x,x
TAK
[0,1]
1,x,x
[0,2]
1,x,x
:
:
:
:
:
:
:
:
:
[0,7]
1,x,x
[1,0]
1,x,x
[1,1]
1,x,x
:
:
:
:
:
:
:
:
:
[1,7]
1,x,x
[2,0]
1,2,x
TAK
[2,1]
1,2,x
:
:
:
:
:
:
:
:
:
[3,7]
1,2,x
[4,0]
1,2,3
TAK
[4,1]
1,2,3
:
:
:
:
:
:
:
:
:
[5,7]
1,2,3
[6,0]
4,2,3
TAK
[6,1]
4,2,3
:
:
:
:
:
:
:
:
:
[7,6]
4,2,3
[7,7]
4,2,3
Liczba błędów:
4
(64-4)/64 = 60/64 = 94%
Hejduk Przemysław
Maślej Damian
22 z 38
b) matrix[j][i] = (i)*8+j;
Nr.
1
2
3
4
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
0
2
4
6
8
10
12
14
16
18
20
22
24
26
28
30
32
34
36
38
40
42
44
46
48
50
52
54
56
58
60
62
1
3
5
7
9
11
13
15
17
19
21
23
25
27
29
31
33
35
37
39
41
43
45
47
49
51
53
55
57
59
61
63
zamiana LIFO
Stan
Komórki
bufora
Błąd
tabeli
TLB
początek
x,x,x
[0,0]
1,x,x
TAK
[1,0]
1,x,x
[2,0]
1,2,x
TAK
[3,0]
1,2,x
[4,0]
1,2,3
TAK
[5,0]
1,2,3
[6,0]
1,2,4
TAK
[7,0]
1,2,4
[0,1]
1,2,4
[1,1]
1,2,4
[2,1]
1,2,4
[3,1]
1,2,4
x7
[4,1]
1,2,3
TAK
[5,1]
1,2,3
[6,1]
1,2,4
TAK
[7,1]
1,2,4
Liczba błędów:
18
(64-18)/64 = 46/64 = 72%
zamiana LRU
Stan
Komórki
bufora
Błąd
tabeli
TLB
początek
x,x,x
[0,0]
1,x,x
TAK
[1,0]
1,x,x
[2,0]
1,2,x
TAK
[3,0]
1,2,x
[4,0]
1,2,3
TAK
[5,0]
1,2,3
[6,0]
4,2,3
TAK
[7,0]
4,2,3
[0,1]
4,1,3
TAK
[1,1]
4,1,3
[2,1]
4,1,2
TAK
[3,1]
4,1,2
x7
[4,1]
3,1,2
TAK
[5,1]
3,1,2
[6,1]
3,4,2
TAK
[7,1]
3,4,2
Liczba błędów:
32
(64-32)/64 = 32/64 = 50%
Hejduk Przemysław
Maślej Damian
23 z 38
• Zad 5.
W przypadku gdy, adres strony znajduje się w buforze asocjacyjnym całkowity czas
dostępu do pamięci wynosi 100ns + 20ns = 120ns, natomiast w przypadku braku
adresu strony czas wynosi 100ns + 20ns + 100ns = 220ns.
Wzór na średni czas dostępu dla powyższych danych przy współczynniku trafień β:
β * 120ns + (1- β) * 220ns
a) 0,8 * 120ns + 0,2 * 220ns = 140ns
b) 0,9 * 120ns + 0,1 * 220ns = 130ns
• Zad 6.
Jedno zadanie zajmuje w pamięci 8 stron każda po 1024 bajty czyli wielkość pamięci
którą zajmuje jedno zadanie jest równa 213 bajtów. Są 32 ramki, czyli zarazem pamięć
może pomieścić 32 strony, czyli 4 zadania, a więc rozmiar pamięci fizycznej jest równy
4 razy 213 bajtów czyli rozmiar pamięci fizycznej jest równy czyli w sumie 215 bajtów.
Selektor strony składa się z 5 bitów, gdyż stron jest 25. Jedna strona zajmuje 210
bajtów. Więc offset jest 10 bitowy, selektor strony 5 bitowy więc adres liniowy składa
się z 15 bitów. Natomiast adres logiczny składa się z 10 bitów offsetu i 3 bitów
selektora strony danego zadania. Czyli w sumie ma 13 bitów.
• Zad 7.
Adres logiczny jest pamiętany jako nr_segmentu:odległość_w_segmencie, tak więc
dla przykładu: adres logiczny 0:430 odpowiada adresowi fizycznemu 219+430=649
a) 0:430 => 649
b) 1:11 => 2311
c) 1:10 => 2310
d) 2:500 => błąd (odległość w segmencie jest większy od rozmiaru segmentu)
e) 3:400 => 1727
f) 4:112 => błąd (odległość w segmencie jest większy od rozmiaru segmentu)
Hejduk Przemysław
Maślej Damian
24 z 38
• Zad 8.
Segmentacja stronicowana polega podziale pamięci na strony, strony są grupowane w tablice
stron, w których znajdują się adresy stron w pamięci fizycznej, natomiast tablice stron są
grupowane w segmenty.
Hejduk Przemysław
Maślej Damian
25 z 38
Lista 4 – Pamięć Podręczna
• Zad 1.
Pamięć jest podręczna jest 4-drożna, więc w każdym bloku występują 4 linie. Pojedyncza linia
zawiera 16 bajtów, a ponieważ bloków jest 64 to w sumie rozmiar pamięci podręcznej jest
równy 64*16bajtów*4= 212B (4096B)
Adres logiczny ma postać
X X X X X Y Y Y Y Y Y Y Y Y Y Y
5 bitów
11 bitów
5 bitów bo aby zapisać numer ramki potrzeba 25 bitów (bo są 32 ramki)
11 bitów to przesunięcie w ramce (offset) bo ramka ma rozmiar 211B
Adres rzeczywisty ma 16 bitów
• Zad 2.
Pojemność bufora jest równa ilości linii pomnożonej przez rozmiar linii czyli
a) 256*32 = 213 bajtów
b) 512*64 = 215 bajtów
c) 1024*128 = 217 bajtów
Indeks słowa:
a) 256 linii : 2 (ilość linii na blok) = 128 bloków
Indeks bloku = log2 128 = 7 bitowy
Jedna linia ma rozmiar 32 bajtów, słowo jest 2-bajtowe, więc w 1 linii mieści się 16
słów, więc aby zaadresować dane słowo potrzeba 4 bitów bo 24=16
Etykieta adresu = rozmiar_adresu_fizycznego-indeks_bloku-indeks_slowa=32-7-4=21
b) 512 linii : 4 (ilość linii na blok) = 128 bloków
Indeks bloku = log2 128 = 7 bitowy
Jedna linia ma rozmiar 64 bajtów, słowo jest 2-bajtowe, więc w 1 linii mieszczą się 32
słowa, więc aby zaadresować dane słowo potrzeba 5 bitów bo 25=32
c) 1024 linii : (8 ilość linii na blok) = 128 bloków
Indeks bloku = log 2 128 = 7 bitowy
Jedna linia ma rozmiar 128 bajtów, słowo jest 4-bajtowe, więc w 1 linii mieszczą się
32 słowa, więc aby zaadresować dane słowo potrzeba 5 bitów bo 25=32
Hejduk Przemysław
Maślej Damian
26 z 38
• Zad 3.
Sterownik pamięci wypełnia pojedynczą linię pamięci podręcznej w trybie zapisu blokowego
4 słów 64 bitowych, więc rozmiar pojedynczej linii powinien być równy 4*64bity = 32 Bajty
W jednym bloku znajdują się 2 linie, bo pamięć podręczna jest dwudrożna. Bloków jest 8
więc w sumie mamy 16 linii. Każda linia ma rozmiar 32 bajtów więc całkowity rozmiar
pamięci podręcznej jest równy 29 bajtów.
Przestrzeń adresowa wynosi 216 bajtów = rozmiar adresu fizycznego to 16 bitów.
Indeks bloku ma rozmiar log2 8 = 3bity.
Indeks słowa ma rozmiar 5 bitów, bo rozmiar linii to 32 bajty (25)
Więc etykieta adresowa = 16 – 3 – 5 = 8b
Hejduk Przemysław
Maślej Damian
27 z 38
• Zad 4.
Przestrzeń adresowa pewnego procesora wynosi 244 bajtów, czyli M=44. Adres bazowy
strony fizycznej jest 32-bitowy, więc może zaadresować 232 stron, czyli M-N=32. Tak więc
N=12, czyli strona ma rozmiar 212 bajtów.
Pamięć podręczna L2 ma pojemność równa rozmiarowi 8 stron, czyli 212 *23=215 bajtów.
Sterownik pamięci L2 realizuje wypełnienie linii w trybie transferu blokowego 4 słów 32bitowych, więc jedna linia ma rozmiar 4*32bity = 27bitów = 24 bajtów
Jeśli pamięć będzie zorganizowana jako czterodrożna/dwudrożna to jedna linia pamięci
powinna zawierać 16 / 16 bajtów a w każdym bloku powinno być 4/2 linie.
Indeks słowa jest 4 bitowy, bo rozmiar linii wynosi 24 bajtów.
W L2 mamy 24 bajtów na linię, więc rozmiar bloku wynosi 26 / 25 bajtów. Ilość bloków to
rozmiar pamięci podręcznej podzielony przez rozmiar bloku, czyli 29 / 210. Indeks bloku
(cache index) powinien więc zawierać 9 /10 bitów.
Etykieta adresu (line label ) to całkowita przestrzeń adresowa pomniejszona o indeks słowa i
indeks bloku (44 – 4 – 9/10), czyli 31 / 30 bitów.
Hejduk Przemysław
Maślej Damian
28 z 38
• Zad 5
Rysunek przedstawia algorytm
wyznaczania linijki w pamięci
zorganizowanej w cztery kanały (4
linijki w jednej sekcji). Przy takiej
organizacji, w katalogu cache
każdym czterem linijkom
stanowiącym sekcję, są przypisane
trzy bity LRU (B0-B2). W trakcie
kolejnych odczytów danych z linijek
w sekcji, bity LRU są ustawiane w
następujący sposób:
-B0 jest 1 gdy ostatni dostęp do kanału 0 lub kanału 1 okazał się trafieniem
-B1 jest 1 jeśli trafiony był kanał 0 lub zeruje jeśli kanał 1
-B0 jest 0 się jeśli trafienie było w kanale 2 lub 3
-B2 jest 1 jeśli trafienie było w kanale 2, zeruje jeśli w kanale 3
Algorytm LRU z wykorzystaniem 6 bitów.
Rejestry używane do reprezentacji informacji to B0, B1, B2, B3, B4, B5
B0
B2
B4
B1
B3
B5
00
01
10
11
L1
L2
L3
L4
0
1
0
1
1
1
W powyższym przykładzie najrzadziej używane było L1 (nie ma go na liście)
Hejduk Przemysław
Maślej Damian
29 z 38
• Zad 6
W dwupoziomowej inkluzywnej pamięci podręcznej, po jednoczesnym wypełnieniu, ich linie
zostały zamarkowane jako E (exclusive). Jak zmieni sie markowanie linii :
a) po wykonaniu kolejnego odczytu:
(L1) E (L2) E
b) po wykonaniu zapisu:
(L1) M (L2) E
Hejduk Przemysław
Maślej Damian
30 z 38
(L1) I (L2) I
c) po zainicjowaniu transmisji DMA do pamięci głównej (zapis)
Obie pamięci zmieniają zamarkowanie, bo przechodzę po bitach mesi obu pamięci
podręcznych aby dojść do głównej
d) po chybieniu przy odczycie w L1 i jednoczesnym trafieniu w L2
(L1) E (L2) E
Hejduk Przemysław
Maślej Damian
31 z 38
HIERARCHIA
L1
/
\
L2
/
\
MEMORY
// Każdy obiekt zawarty w wyższej warstwie jest również obecny w warstwie niższej
• Zad 7
Pamięć L1 działa w trybie WO, a pamięć L2 w trybie CB
a) Zapis
L1 E L2 M
b) Odczyt
L1 S L2 E
c) Zainicjowanie
transmisji DMA
(odczyt)
L1 S L2 E
d) Zainicjowanie
transmisji DMA
(zapis)
L1 I L2 I
Hejduk Przemysław
Maślej Damian
32 z 38
• Zad 8
a) z przeplotem
Mamy ośmiodrożną pamięć podręczną, czyli w jednym bloku mamy 8 linii.
Rozmiar 1 linii to 256B czyli rozmiar jednego bloku to 8*256B = 2048B = 2KB
Pamięć podręczna składa się z 64KB/2KB = 32 bloków.
Linii jest w sumie 32 bloki* 8 linii = 256 linii
Indeks bloku jest 5 bitowy, natomiast 8 bitowy jest indeks słowa więc odległość między
pierwszymi bajtami bloków to 2(5+8) B = 213 B
A A A A A A A A A A A A A A A A A A A A A A A A A B B B B B S S S S S S S S
Indeks bloku
Etykieta adresu
Indeks słowa
b) bez przeplotu
B B B B B A A A A A A A A A A A A A A A A A A A A A A A A A S S S S S S S S
Indeks bloku
Etykieta adresu
Indeks słowa
W tym przypadku odległość między pierwszymi bajtami bloków to 28bajtów
Hejduk Przemysław
Maślej Damian
33 z 38
Lista 5 – Tryb chroniony i przewidywanie rozgałęzień
• ZAD 1
Rozwiązanie podano dla procesorów firmy Intel
wskaźnik stosu aktualny
2b B
int f[b]
10B
char e10]
2B
int d
EBP (wskaźnik ramki)
4B
Adres powrotu
4B
*a
2B
b
2B
c
EBP – wartość wskaźnika ramki stosu
Hejduk Przemysław
Maślej Damian
34 z 38
• ZAD 2
1) Tryb rzeczywisty
Można zaadresować 2 20 = 1MB
Pamięć jest podzielona na segmenty po: 64kB (rozmiar rejestrów)
Występuje tylko segmentacja
Adres się składa z selektora segmentu i przesunięcia | 16*S + P|
2) Tryb chroniony – segmentowanie i stronicowanie
Każdy segment ma swoją tablicę stron.
Selektor segmentu jest 16-bitowy
Przesunięcie 32 bity
• ZAD 3
Mamy 10000 instrukcji, co 10 jest skokiem więc mamy 1000 skoków. Instrukcja i trafiony skok
zajmują po 1 cyklu.
a) 5 etapów 80%
80% z 1000 to 800, więc 200 skoków zajmuje po 5 cykli (bo 5 etapów)
W sumie mamy 9800 cykli + 200 skoków po 5 cykli czyli w sumie 10800 cykli
b) 20 etapów 90%
90% z 1000 to 900, więc 100 skoków zajmuje po 20 cykli (bo 20 etapów)
W sumie mamy 9900 cykli + 100 skoków po 20 cykli czyli w sumie 11900 cykli
• ZAD 4
a)222 bajtów = 4MB
22 bity to jest offset
Selektor segmentu to pozostałe 10 bitów
Ponieważ adres 32 bitowy
Wiec 10 bitów na określenie strony czyli 210 stron
Każda strona = 1 deskryptor wiec rozmiar tablicy deskryptorów to 210 * 4bajty = 212 bajtów.
b) mamy 4-kilobajtowe strony, dlatego offset jest zapisany na 12 bitach bo 212 to 4kb
Jest jeden katalog, który przechowuje deskryptory tablic stron, czyli deskryptorów w katalogu jest
210. Rozmiar deskryptora to 4B, czyli rozmiar katalogu to 212B.
Mamy 210 tablic stron, a w każdej tablicy stron mamy 210 deskryptorów po 4B, czyli w sumie tablice
stron zajmują 222B
Rozmiar pamięci niezbędny do przechowywania wszystkich tablic stron, to rozmiar katalogu i rozmiar
tablic stron czyli 222B + 212B
Hejduk Przemysław
Maślej Damian
35 z 38
• ZAD 5
Adres wirtualny – ilość bitów potrzebna do zaadresowania segmentu – ilość bitów adresu bitów
potrzebna do zaadresowania deskryptorów stron = 40 -3 – 12= 25 Przestrzeń adresów liniowych czyli
rozmiar obszaru pamięci, którą adresują adresy liniowe.
Po odjęciu 16 bitów indeksu w tablicy stron pozostaje nam offset czyli przesunięcie na stronie równe
9 bitów.
Offset zajmuje 9 bitów. Bity adresu fizycznego bez offsetu tworzą adres bazowy strony. Więc 32-9=23
Hejduk Przemysław
Maślej Damian
36 z 38
• ZAD 6
a)
b)
c)
d)
… nttnt (t)
… ttnnt (n)
… ntntt (t)
… ttntn (t)
Szukamy ostatniej pary powtórzonych skoków, jeżeli jest to tt, to następnym skokiem będzie t a jeżeli
nn, to następnym skokiem będzie n.
Hejduk Przemysław
Maślej Damian
37 z 38
Mamy nadzieję, że przedstawione powyżej
rozwiązania, pomogą w zrozumieniu zawiłości
Architektury Komputerów I
Serdecznie dziękujemy za sprawdzenie
poprawności i korektę błędów
mgr Bartoszowi Wojciechowskiemu
Hejduk Przemysław
Maślej Damian
38 z 38

Architektura Komputerów I Rozwiązania List Zadań

Transkrypt

Podobne dokumenty

Klasa GL terenowa typ 164 2006

Klasa CL Coupé typ 216 2006

SLR McLaren Roadster typ 199 2004

Viano Marco Polo Samochód kempingowy typ 639 2003

Sterowany radiem model samochodu firmy Nikko serii Evolution

EP 9V/320mAh Akumulator

Whitenergy akumulator do Fuji NP-40 600mAh

Kliknij aby pobrać dokument w formacie PDF - Moto

akumulator standardowy JMT 51913

akumulator bezobsługowy JMT YTX14-BS (WP14-B)