ZADANIE: Zaprojektuj operację PUSH i POP dla stosu, do którego będą zapisywane i odczytywane dane z rejestru A. (25pkt)
ROZWIĄZANIE:
Przyjmujemy, że mamy następujące rejestry:
SP - wskaźnik stosu
SMAX - adres o 1 wyższy od ustalonej górnej wartości granicznej stosu SMIN - adres o 1 niższy od ustalonej dolnej wartości granicznej stosu Wszystkie te rejestry mają po n bitów.
warunki:
z = (SMAX[0] XNOR SP[0]) AND (SMAX[1] XNOR SP[1]) AND … AND (SMAX[n] XNOR SP[n]) czyli wartość SP ma być równa SMAX (stos pełny)
x = (SMIN[0] XNOR SP[0]) AND (SMIN[1] XNOR SP[1]) AND … AND (SMIN[n] XNOR SP[n]) czyli wartość SP ma być równa SMIN (stos pusty)
Zakładamy też, że do przerzutników z i x wartości zapisywane są tylko przed wykonaniem instrukcji PUSH i POP.
PUSH:
C2t1(~z): MAR←SP, PAO start
C2t2(~x): A←A+MBR
C2t0(~z): MBR←A
zapis
C2t3(~x): F←0
C2t1(~z): SP←SP+1, PAO start
C2t2(~z): M←MBR
POP_v2
zapis
C2t3(~z): F←0
C2t0(~x): A←0, MAR←SP, PAO
C2t2(~z): M(SP)←MBR
POP
start odczyt
C2t3(~z): F←0
C2t0(~x): A←0, PAO start
C2t1(~x): MBR←M, SP←SP-1
PUSH_v2:
odczyt
C2t2(~x): A←A+ MBR
C2t0(~z): MBR←A, SP←SP+1
C2t1(~x): MBR←M(SP),
C2t3(~x): F←0
SP←SP-1
Przy *_v2 przyjmujemy, że mamy połączenie pozwalające przypisać SP do MAR
(biorąc pod uwagę możliwe różnice w ilości bitów SP i MAR, chyba że przyjmiemy, że są takiej samej wielkości - co jest raczej najbardziej sensowne).
---------------------------------------
Przywołanie systemu operacyjnego (supervisor call)
Dodajemy w cyklu przerwania dodatkową flagę SV którą sprzwdzamy w cyklu wykonania. A jako że mamy "zaprojektuj funkcję" to trzeba chyba dodać adres bezadresowy powiedzmy SVC który będzie brzmiał:
c2q7~pt0mbrX (nie wiem który bit mbru mamy wolny, powiedzmy ze 14): SV<-1
c2q7~pt0mbr14:-
c2q7~pt0mbr14:-
c2q7~pt0mbr14: R<-1.
Zaimplementować sprzętowy stos i sterowanie do niego:
Zaproponowałbym przyłączenie powiedzmy rejestru na 16 słów do MBR w formie takiej samej jak PAO (tylko MBR ma do niego dostęp). Wskaźnik SP do chodzenia po stosie, flagi z = stos pełny (SP = 1111) - czterowejściowy AND i
x = stos pusty(SP = 0000) - czterowejściowy NOR
Odpadają nam wtedy pierdoły związane z adresami i XNORy:
PUSH:
c2t2~x: A<-A+MBR
c2t0~z: MBR<-A
c2t3~x: F<-0
c2t1~z: SP<-SP+1, STOS start zapis
RESET:
c2t2~z: STOS(SP)<-MBR
c2t0: SP<-0
c2t3~z: F<-0
c2t1: -
POP:
c2t2: -
c2t0~x: A<-0, STOS start odczyt
c2t3: F<- 0
c2t1~x: MBR<-STOS(SP), SP<-SP-1
rozkaz JS, adresowanie pośrednie, gdzie adres składa się z samych jedynek ma wywołać pułapkę: zapisać zawartość akumulatora do rejestru OUT i wywoływać przerwanie DB - 16wejściowa bramka AND
c2q5pt0DB: OUT <- A
c2q5pt1DB:
c2q5pt2DB: IEN<-1
c2q5pt3DB: R<-1
ADD 0 BRA 0 AND 0 JS 0 wywołuje przerwanie
C2t0((MBR0 v ... v MBR15) v ~(q0 v q2 v q3 v q5)): D1 <- 0, D2 <- 0, D3 <- 0, D4 <- 0
C2t0q0 ~MBR: D1 <- 1
C2t0q3 ~MBR D1: D2 <- 1
C2t0q3 ~MBR D2: D2 <- 0
C2t0q2 ~MBR D1 D2: D3 <- 1
C2t0q2 ~MBR ((~D1 v ~D2) v D3): D3 <- 0, D1 <- 0, D2 <- 0
C2t0q5 ~MBR D1 D2 D3: D4 <- 1
C2t3 D1 D2 D3 D4: R <- 1, D1 <- 0, D2 <- 0, D3 <-0, D4 <-0
---------------------------------------------------------------------------
Zaprojektuj układ realizujący operacje (przy założeniu że jest dostępny jeden sumator) A=WE, B=WE, WY=A, WY=B, A=B, B=A, A=2*A, B=2*B, WY=A+B
1) A = WE
t0 : ADR0 = 2, ADR1 = 0
8) B = 2*B
t0 : ADR0 = 1, ADR1 = 0
t1 : LDA = 1
t0 : ADR0 = 2, ADR1 = 0
t1 : LDA = 1
6) B = A
t1 : LDA = 1
2) B = WE
t0 : ADR0 = 0, ADR1 = 1
t2 : LDR = 1
t0 : ADR0 = 1, ADR1 = 1
t1 : LDB = 1
t3 : ADR0 = 3, ADR1 = 1
t2 : LDB = 1
7) A = 2*A
t4 : LDB = 1
3) WY = A
t0 : ADR0 = 0, ADR1 = 1
9) WY = A + B
t0 : ADR2 = 0
t1 : LDB = 1
t0 : LDR = 1
4) WY = B
t2 : LDR = 1
t1 : ADR2 = 1
t0 : ADR2 = 2
t3 : ADR0 = 3, ADR1 = 0
5) A = B
t4 : LDA = 1
…………………………
a) A = WE:
t0: adr4 = 10
Da się to zrobić szybciej,
t0: adr1 = 0, adr2 = 00
f) WY = C:
inaczej?
t1: LDa = 1
t0: adr4 = 11
h) WY = A+B:
b) B = WE:
g) A = A + B + C:
t0: adr3 = 00
t0: adr1 = 0, adr2 = 01
t0: adr3 = 00
t1: LDr = 1
t1: LDb = 1
t1: LDr = 1
t2: adr4 = 01
c) C = WE:
t2: adr1 = 1, adr2 = 00
i) A = A+1:
t0: adr1 = 0, adr2 = 10
t3: LDa = 1, adr3 = 01
t0: adr3 = 10
t1: LDc = 1
t4: LDr = 1
t1: LDr = 1
d) WY = A:
t5: adr = 1, adr2 = 00
t2: adr1 = 1, adr2 = 00
t0: adr4 = 00
t6: LDa = 1
t3: LDa = 1, adr3 = 0
e) WY = B:
---------------------------------
AND:
C2q3t0 : MAR <- MBR, PAO start odczyt
C2q4t2 : M <- MBR
C2q3t1 : MBR <- M
lub
C2q3t2 : A <- A /\ MBR
c2q4t0 : MAR <- MBR
STA:
c2q4t1 : MBR <- AC
C2q4t0 : MAR <- MBR,
c2q4t2 : M <- MBR
C2q4t1: MBR <- A, PAO start zapis
c2q4t3 : F <- 0
BRA 0 spowoduje wykonanie operacji SKIP z zapisem PC w rejestrze A Wprowadzamy dodatkowy przerzutnik MZ , do którego przez 16-wejściową bramkę or , podpinamy część MBR.
W cyklu pobrania rozkazu w t3, zapisujemy do niego wyjście bramki i go zamykamy. W tym przypadku wartość rejestr MZ wygląda tak : MBR = 0 → MZ = 0…….. MBR = 1 → MZ = 1
Czemu 16? 16 daje nam pełne bezpieczeństwo w t2 pobrania rozkazu MBR[0-3] zostaje zerowany, więc część rozkazowa nic nam nie popsuje, a jednocześnie cała 16 daje nam odpowiedni wynik przy adresowaniu pośrednim.
c2q2t0(~MZ): PC ‹- PC + 1
c2q2t1(~MZ): MBR ‹- PC, A ‹ 0
c2q2t2(~MZ): A ‹- A + MBR
c2q2t3(~MZ): F← 0 , R←0
lub
c2q2t0: jeśli MBR = 0 to PC ← PC + 1, w przeciwnym przypadku PC ← MBR
c2q2t1: jeśli MBR = 0 to MBR ← PC, A ← 0 w przeciwnym przypadku MBR = 0
c2q2t2: jeśli MBR != 0 to A ← A + MBR
c2q2t3: F<- 0 , R<-0
2 Do procesora z wykładów: dołożono jeszcze jedną pamięć RAM i przerzutnik Z, trzeba tak zrobić sterowanie, by w pierwszej pamięci były rozkazy a w drugiej dane 5. dwie pamięci RAM: jedna użytkownika, druga systemowa. Dodany rejestr S. Napisać sterowanie 2i5.jp
----------------------------------------------------------------------
ZADANIE: sumowanie wektora, bez instrukcji ISZ, ale dodawanie ma autonastępnikowanie. 22pkt (5pkt) ROZWIĄZANIE:
ORG 30 (określamy, gdzie zaczyna się wykonywanie instrukcji) 20 50 (adres wektora liczb)
21 -n (długość wektora)
22 suma
…
30 CLA (zerujemy akumulator)
31 STA 22 (zapisujemy wartość sumy do M[22])
32 LDA 22 (wczytujemy wartość sumy częściowej)
33 ADD, *, +, 20 (adres argumentu zapisany w M[20], zwiększamy po wykonaniu rozkazu zawartość M[20]) 34 STA 22 (zapisujemy sumę częściową)
35 LDA 21 (ładujemy M[21] do akumulatora)
36 INC (zwiększamy zaw. akumulatora)
37 STA 21 (zapisujemy M[21])
38 SZA 21 (sprawdzamy czy M[21] jest {już} zerem, jeśli tak, wykona się SKIP, jeśli nie, @39) 39 BRA 32 (skok do @32)
40 … (dalsze instrukcje)
…
50 dane
…
50+(n-1)
ZADANIE: ISZ 0,sprawdzic, zapis akumulatora w pc, kasowanie akumulatora, kasowanie sterowania c2q6t0(~MZ): MBR←A
c2q6t1(~MZ): PC←MBR
c2q6t2(~MZ): A←0
c2q6t3(~MZ): F←0, R←0
ZADANIE: BRA 0 › ma skoczyć do miejsca z rejestru A (pośrednio i bezpośrednio) DB: 16 bitowa bramka NOR, do ktorej podpinamy MBR, czyli wykrywa same 0
bezposrednio
t0 p DB : MBR ← A
t0~p DB : MBR ← A
t1 p DB : MAR ← MBR, PAO s/o
t1~p DB : PC ← MBR
t1 p DB : MBR ← M
posrednio:
t2 p DB : PC ← MBR
ZADANIE: rozkaz JS, adresowanie pośrednie, gdzie adres składa się z samych jedynek ma wywołać pułapkę: zapisać zawartość akumulatora do rejestru OUT i wywoływać przerwanie MZ to przerzutnik podlaczony do MBR wykrywajacy 1 (MBR0 & MBR1…) OUT to rejestr podlaczony do MBR (nie wiem czy taki jest, wiec go tworze) t0 p MZ: MBR ← A
t1 p MZ: OUT ← MBR, R ← 1
lub
0: MAR ← MBR, PAO s/o
t1: MBR ← M
t2 MZ: MBR < A
t3 MZ: OUT ← MBR, R ← 1
1) opisać typy systemów magistralowych 25pkt (25pkt)
Magistrala - łącze multipleksowane w czasie.
Podziały:
*ze względu na kierunek transmisji danych:
jednokierunkowa (np. adresowa)
dwukierunkowa (np. danych)
*ze względu na sposób transmisji:
szeregowa
równoległa (szybsza, ale wymaga lepszej synchronizacji)
*typy systemów:
z jedną magistralą: procesor<>RAM<>urz. we/wy
z dwiema magistralami: procesor<>RAM, procesor<>urz. we/wy z wieloma magistralami: procesor<>RAM, procesor<>układy we/wy, układy we/wy<>urządzenia we/wy
*magistrala systemowa najczęściej składa się z 3 magistral: sterującej (jednokierunkowa, zarządzana przez procesor)
adresowej (jednokierunkowa, zarządzana przez procesor)
danych (dwukierunkowa)
2) opisać adresowanie indeksowe 8pkt (8pkt)
Wykorzystujemy rejestr indeksowy, w którym podana jest wartość przesunięcia.
Aby obliczyć adres efektywny, procesor musi dodać ją do argumentu rozkazu.
Adresowanie podobne do adresowania z rejestrem bazowym.
3) opisać układy arbitrażu 15pkt (15pkt)
Układ arbitrażu - urządzanie nadzorujące, służy do wyboru urządzenia które w danym momencie ma być nadrzędne.
Prosty przykład to arbitraż, gdzie procesor kolejno lub losowo przydziela urządzeniom dostęp do magistrali.
Rozwiązanie proste, ale mało efektywne, dlatego używa się specjalne układy arbitrażowe.
-arbiter przydziela dostęp urządzeniom w zależności od priorytetu, w ten sposób urządzenia wymagające częstszego dostępu lub szybszego dostępu częściej go otrzymują.
-arbiter otrzymuje żądania od urządzeń i na ich podstawie przydziela dostęp
-urządzenia same między sobą rozdzielają dostęp
-urządzenia wysyłają żądania, jeśli jest tylko jedno w danym czasie, uzyskuje dostęp, jeśli kilka, muszą ponowić żądanie.