laborator 6. subsistemul de memorie pentru calculatoarele...

Laborator 6. Subsistemul de memorie pentru calculatoarele numerice

În structura unui calculator numeric memoria constituie o componentă de bază. Există o mare varietatede moduri de organizare a memoriilor operative (interne) ale calculatoarelor numerice. În aceastălucrare vom considera câteva noţiuni privind memoriile calculatoarelor numerice (CN), modurile deadresare cele mai frecvent utilizate şi unele probleme legate de proiectarea memoriilor interne, a unormemorii de tip LIFO (Last In First Out) sau FIFO (First In First Out).

1. Noţiuni elementare

Datele sub formă binară sunt păstrate în CN într-o reţea de elemente bistabile, care formează memoriacalculatorului. Din punct de vedere fizic, vom considera numai memoriile semiconductoare.

Memoria unui CN trebuie să satisfacă următoarele cerinţe:• locaţiile care păstrează fiecare cifră binară să fie în mod unic adresabile;• să existe posibilitatea de citire a stării fiecărei locaţii de memorie.

La unele memorii, nu este posibilă modificarea conţinutului, ci numai citirea acestuia. Acestea senumesc memorii ROM (Read Only Memories). Memoriile cu posibilităţi de citire şi modificare aconţinutului celulelor elementare se numesc memorii RAM (Random Access Memories). Acestedenumiri s-au păstrat, deşi atât memoriile ROM cît şi RAM oferă posibilitatea de acces aleator lacelulele acestora. Spre deosebire de ROM, memoriile RAM cu semiconductori sunt volatile.Conţinutul acestora, se pierde la întreruperea alimentării cu energie.

Primul nivel de organizare a unei memorii, este gruparea unui număr de celule elementare sub formaunui "cuvânt". Lungimea cuvintelor este o caracteristică importantă a unui calculator. Un cuvânt culungimea de 8 cifre binare (biţi) se numeşte octet (byte). Cuvântul reprezintă unitatea minimă deinformaţie accesibilă la un moment dat.

Selectarea unui anumit cuvânt de memorie, se poate face după conţinut (memorii asociative) sau dupăadresa acestui cuvânt. Fiecare cuvânt de memorie are o adresă unică. Cuvintele care formează memoriaau adrese succesive. Identificarea unui cuvânt din memorie, se realizează prin decodificarea adreseiacestuia. Domeniul cuprins între prima şi ultima adresă formează dimensiunea memoriei. 210 = 1024cuvinte formează 1K cuvinte de memorie, iar 220 cuvinte formează 1M cuvinte.

2. Interpretarea conţinutului cuvintelor de memorie

Conţinutul unui cuvânt de memorie este un şir de cifre binare care pot primi diferite interpretări:• date numerice ca entitate de sine stătătoare;• date numerice făcând parte dintr-o entitate formată din mai multe cuvinte;• date codificate, pentru care s-au predefinit anumite interpretări;• cod instrucţiune, care va fi transmis calculatorului, decodificat şi interpretat pentru identificarea

unor operaţii specifice, care vor fi efectuate de către calculator.

În majoritatea calculatoarelor este imposibilă identificarea tipului de informaţii dintr-un cuvânt prinsimpla examinare a conţinutului acestuia. În mod firesc, apare întrebarea: cum poate calculatorulinterpreta corect conţinutul memoriei? În starea iniţială, calculatorul trebuie să fie în regim de citireşi interpretare a instrucţiunilor, deci primul cuvânt adresat trebuie să conţină un cod de instrucţiune.În continuare, algoritmul implementat în program va determina interpretarea cuvintelor dememorie.

Pentru a facilita accesul la date şi instrucţiuni se prevede un registru de acces date RA şi un registru deacces instrucţiuni PC. Prin păstrarea codurilor instrucţiunilor în cuvinte succesive de memorie serezolvă problema formării în PC a adreselor de instrucţiuni. Trebuie găsită o modalitate de iniţializare aPC, apoi conţinutul său va fi incrementat după citirea fiecărei instrucţiuni.

"Aranjarea" în memorie a cuvintelor ce conţin date, se poate face într-o mare varietate de moduri.Pentru a facilita accesul la diferitele structuri de date, unitatea centrală de prelucrare trebuie să asigureo mare flexibilitate în formarea adreselor de citire a datelor. Pentru anumite structuri tipice (deexemplu: structuri de tip stivă), se pot prevedea registre separate pentru adresare.

3. Moduri de adresare

Există o mare varietate de procedee pentru formarea adreselor de acces a datelor. În continuare, le vomenumera pe cele mai uzuale. Pentru claritatea expunerii vom considera codul unei instrucţiuni memoratîntr-un cuvânt de memorie şi, de asemenea, o adresă poate fi păstrată într-un cuvânt. Deci instrucţiunilecare implică a adresă de memorie, se vor păstra în două cuvinte succesive. Se va considera o unitatearitmetică şi logică (UAL) cu mai multe registre generale (RG) în care se pot păstra operanzi sauadrese de operanzi. Prin (RG) vom înţelege conţinutul registrului RG.

Mod 1. Adresare directă prin registre.

RG conţine operandul.

Mod 2. Adresare indirectă prin registre.

RG conţine adresa operandului.

Mod 3. Adresare prin registre cu autoincrementare.

RG conţine adresa operandului. După efectuarea operaţiei se incrementează RG.

MEM RG

Instrucţiune Operand

Operand

MEMMEM RG

Instrucţiune Adresă operand RA

MEMMEM RG

(PC) RAInstrucţiune Adresă operand Operand

(RG)+1

Mod 4. Adresare indirectă prin registre cu autoincrementare.

RG conţine adresa adresei operandului. După citirea adresei operandului se incrementează RG.

Mod 5. Adresare prin registre cu autodecrementare.

RG după decrementare conţine adresa operandului.

Mod 6. Adresare indirectă prin registre cu autodecrementare.

RG după decrementare conţine adresa adresei operandului.

Mod 7. Adresare imediată.

Cuvântul următor instrucţiunii conţine operandul.

Mod 8. Adresare absolută directă.

Cuvântul următor instrucţiunii conţine adresa operandului.

Adresa op.

MEM

(RG)+1

Adresa ad. Operand

MEMMEM RG

Instrucţiune RA r

MEM

(RG)-1Adresa ad. OperandrInstr.

MEM

(PC)RG

RA

Operand

(PC)r InstrucţiuneMEM

Operand


Adresă op. rRAr MEM

Adresa op

MEM

(RG)-1Adresa ad. Operand

MEMr rrRAInstr.

MEM

(PC)RG

Mod 9. Adresare indexată.

Cuvântul următor instrucţiunii conţine adresa de bază, iar un registru general conţine valoarea deindexare. Suma dintre adresa de bază şi valoarea de indexare formează adresa operandului.

Mod 10. Adresare indexată indirectă.

Suma dintre adresa de bază şi valoarea de indexare formează adresa adresei operandului.

Mod 11. Adresare relativă

Cuvântul următor instrucţiunii conţine o valoare (deplasament) care se adună la PC actualizat pentru aforma adresa operandului.

Mod 12. Adresare relativă indirectă.

PC actualizat se adună cu deplasamentul pentru a forma adresa adresei operandului.

Operand

MEM

MEM RG

Instrucţiune Valoare index

(PC)+1r Adresă bază

o

Operand

MEM

MEM RG

Instrucţiune Val. index

(PC)+1r Adresă bază

orAdresă op.

MEM


(PC)+1r Deplasament

or(PC)+2r Instrucţiunea următoare Operand

MEM

Adresă op.

MEM


(PC)+1r Deplasament

OperandMEM

or(PC)+2r Instrucţiunea următoare

Mod 13. Adresare relativă indexată.

PC actualizat adunat cu conţinutul registrului index formează adresa operandului.

Mod 14. Adresare relativă indexată indirectă.

PC actualizat adunat cu valoarea de indexare formează adresa adresei operandului.

Mod 15. Adresare autorelativă

Cuvântul următor instrucţiunii conţine deplasamentul care se adună cu valoarea actualizată a PC pentrua forma adresa următoarei instrucţiuni. Modurile de adresare analizate se referă la o memorie internă,de capacitate relativ mare, capabilă să păstreze programele utilizatorului, sistemul de operare. Fiind omemorie RAM, orice cuvânt este accesibil în acelaşi interval de timp.

Mod 16. Adresare directă prin IS

O stivă, sau o memorie LIFO se caracterizează prin faptul că datele sunt plasate "în vârful stivei", pestedatele existente deja în stivă, "deplasându-le în jos" pe acestea. Îndepărtarea unui cuvânt se face tot dinvârf, "deplasând în sus" datele rămase în stivă. Diferitele forme de implementare a facilităţilor de lucrucu stiva, oferite de cele mai multe microprocesoare existente până în prezent, au readus în actualitateaceasta problemă. Unele microprocesoare includ în structura lor o stivă de dimensiuni relativ mici,pentru salvarea adreselor de reîntoarcere din subrutine, sau chiar pentru păstrarea temporară a datelor.Altele permit definirea şi manipularea în memoria internă (externămicroprocesorului) a unor stive.

O stivă "pură" permite efectuarea operaţiilor "PUSH" - prin care se introduce un cuvânt în vârfulstivei şi "POP" - prin care se extrage ultimul cuvânt introdus. Noi vom considera cazul în care stivaeste în memoria internă a calculatorului şi există posibilitatea de adresare relativă faţă de indicatorul



MEM

Adresă op.

MEMr Val. Index

RG



MEMr Val. Index

RG

Instrucţiune Jump

Deplasament

o

MEM

Cuvânt următorAdresăPC

(PC)r Instrucţiunea PUSH Rr Adresă r (IS)-1 r ( R )MEM IS MEM

stivei, IS. Vom nota prin R un registru oarecare (PC, RA, RG, etc.). Conţinutul registrului R estememorat la adresa obţinută prin decrementarea lui IS. În R se introduce conţinutul locaţiei adresatede IS şi apoi se incrementează IS. Sensul în care stiva "creşte" şi "descreşte" este arbitrar. În cazulnostru stiva creşte în "sus", spre adres mici.

Mod 17. Adresare relativă la IS

Adresa din stivă a operandului se obţine prin adunarea deplasamentului conţinut în cuvântul următorinstrucţiunii cu IS. IS rămâne neschimbat. Utilizarea structurilor de tip stivă s-a dovedit a fi deosebit deeficientă în operaţii ca:

• memorarea adresei de reîntoarcere (valoarea curentă a PC), la chemarea unei proceduri;• restaurarea PC la terminarea unei proceduri;• salvarea şi restaurarea registrelor interne, variabile temporare, în cazul apelurilor de proceduri;• transferul parametrilor la chemarea procedurilor;• păstrarea variabilelor locale, cu utilizare temporară, în stivă; aceasta duce la o utilizare eficientă

a memoriei;• scrierea rutinelor reentrante - reintrarea în execuţie a unei rutine înainte de a se fi terminat

execuţia precedentă (de exemplu, ca rezultat al unei întreruperi);• scrierea rutinelor recursive (o rutină care se apelează pe ea însăşi direct, s-au printr-un lanţ de

apeluri succesive a altor rutine care cheamă în final rutina recursivă;• evaluarea expresiilor aritmetice.

4. Organizarea unei memorii de tip coadă (FIFO)

O memorie de tip coadă, sau FIFO, se caracterizează prin faptul că citirea datelor se efectuează înordinea înscrierii lor, iar explorarea acestei memorii se face circular. Înscrierea, respectiv citireadatelor se face întotdeauna la locaţia următoare. Memoriile de tip FIFO se utilizează în general camemorii tampon (buffer) în aplicaţii ca:

• cuplarea unor echipamente cu viteze de transfer diferite;• telecomunicaţii;• citirea în avans a instrucţiunilor pentru optimizarea accesului la memorie şi creşterea vitezei de

execuţie.

Noi vom considera proiectarea unei unităţi de legătură între un calculator şi un echipament periferic deieşire astfel încât fiecare să funcţioneze cu eficienţămaximă (Fig.14.1).

(PC)r Instrucţiunea POP R r Adresă r(IS)+1

( R )MEM IS MEM

IS

(PC)+1 Deplasament

(PC)r Instrucţiune r AdresăMEM

r oo OperandMEM

Semnificaţia semnalelor din figurile 14. 1 şi 14.2 este următoarea:• CDISP – calculator disponibil;• MDISP – memorie disponibilă;• CSTROB – solicitare date de la calculator;• MSTROB – solicitare date de la memorie;• ULCIT – ultima operaţie, ULCIT = 1 pentru citire şi ULCIT = 0 pentru scriere;• NUMEG – egalitate numărător de adresă citire şi numărător de adresă scriere.

Calculatorul trimite datele "în rafală" cu o rată de transfer ridicată; acestea sunt preluate de coada dememorare (UL) şi trimise apoi într-un ritm uniform spre dispozitiv. Deci UL trebuie prevăzută cu omemorie unde vor fi păstrate temporar datele şi o unitate de comandă care asigură transferul între celedouă echipamente. Funcţiile pe care trebuie să le realizeze UL sunt:

• asigură dialogul cu calculatorul pentru prelucrarea datelor;• asigură dialogul cu dispozitivul de ieşire;

CalculatorULCDISP

CSTROB CSTROB

CDISPDispozitiv

de ieşire

Fig 14.1 Schema bloc

CDISP

A

ULCIT

B

ULCIT

C

NUMEG NUMEG

D

E

SCRIESINCR

CSTROB

MDISP

MSTROB

F CINCR

1 0

DA

NU

NU

NU

NU

DA

0

1

Fig.14.2 Principiul de funcţionare UL

A A0 n - 1

-

IN IN0 n - 1

-

RMIm x n

Y Y0 m - 1

-

D D0 n - 1

-

WE WE0 n - 1

-

• asigură gestiunea memoriei tampon pentru a preveni scrierea dacă este plină sau citirea dacăeste goală;

• controlează continuu transferul dintre cele două echipamente;• asigură transferul datelor către dispozitiv într-o secvenţă corectă.

Dimensiunea memoriei depinde de aplicaţie şi poate fi determinată statistic, prin simulare, construireaşi analiza unui model analitic, etc. Vom considera o memorie de 32 cuvinte de patru biţi, realizate cucircuite Xilinx RAM 32x4 .

Pentru proiectarea UL existămai multe soluţii:• se utilizează două numărătoare, unul conţine adresa curentă pentru citire, celălalt adresa curentă

pentru scriere. Utilizând un sumator (ex: X74_283) se detectează condiţia de memorie goală(numărător citire = numărător scriere) sau plină (nr. scriere = nr. citire-1). Cele douănumărătoare (adrese) sunt multiplexate pentru a adresa memoria.

• se utilizează un indicator (un bistabil) care indică întotdeauna ultima operaţie. Se detecteazăegalitatea celor două numărătoare şi se deduce dacă memoria este plină sau goală funcţie deultima operaţie.

Dialogul calculator - UL şi UL - dispozitiv este asemănător: ori de câte ori există un cuvânt detransmis se emite semnalul DISP care este menţinut până la primirea semnalului STROB.Organigrama care descrie algoritmul de funcţionare a unităţii de comandă este prezentată în fig.14.2. Înstarea A se aşteaptă cerere de preluare date de la calculator. În starea B, se testează dacă memoria esteplină. Dacă nu este plină, în starea D se preiau datele de la calculator şi se incrementează numărătorulde adresă pentru scriere memorie. În starea C se testează dacă memoria este goală. Dacă memoria estegoală se revine în starea A. Dacă memoria este plină sau nu este goală se trece în starea E unde setrimit datele către dispozitivul de ieşire (ex. un monitor). Dacă dispozitivul nu este pregătit se revine înstarea A. În starea F se incrementează numărătorul de adresă pentru citire memorie.

5. Organizarea unei memorii asociative

Memoria asociativă permite, pe lângă operaţiile întâlnite în utilizarea memoriilor cu citire/scriere,stabilirea adresei oricărei informaţii memorate în cadrul componentei cu ajutorul conţinutului acesteia.Acest regim este numit mod de lucru asociativ şi el este util în căutarea anumitor valori şi se utilizeazăfrecvent în sistemele de memorie. Schema de principiu a unei memorii asociative integrate (RMI) este:

A0 - An-1 : semnale pentru modul asociativ;D0 - Dn-1 : ieşiri de date;IN0 - INn-1 : intrări de date;Y0 - Ym-1 : ieşiri/intrări de selecţie;

0WE – 1-nWE : semnale pentru citire/scriere.

Schema logică a celulei de memorie şi a circuitelor de acces este prezentată în figura următoare:

Xilinx Corporation2100 Logic DriveSan Jose, CA 95124

Project: CELMEMSheet: CELMEM1Date: 4/7/01

Date Last Modified: 4/7/1

Fj, 0

Fj, n-1

Fj, 1

Yj

Dm-1, iD0, i

Dj

Dj, i

~Ai

INi

~WEi

Qj, i~Qj, i

Rj, i

Sj, i

NOR2

NOR2

INV

INV

INV

NO

R2

NO

R2

AND

2

AND

2

NOR2

AND

2

AND

2

OR

2

AND2

NOR3

INV

INV

AND

3

Pentru modul de lucru asociativ stabilim:

0A =i

0WE =i

Semnalele Yj = 1 arată poziţiile din memorie pentru care căutarea a avut succes.Pentru modul citire/scriere stabilim:

1A =j

1Y j =

şi WEi = 1 pentru citiresau WEi = 0 pentru scriere

6. Memorii ROM şi RAM

Memoriile ROM sunt memorii permanente (păstrează informaţiile permanent) şi permit doar citireainformaţiei. Ele au evoluat foarte mult ajungând la capacităţi destul de mari şi cu posibilitateareprogramării conţinutului lor de un număr mare de ori. Memoriile RAM sunt memorii cu acces aleatorşi citire/scriere.Ele sunt de două tipuri:

• statice: informaţia se păstrează intactă pe tot timpul funcţionării sistemului;• dinamice: informaţia se deteriorează în timpul funcţionării sistemului şi de aceea trebuie

reîmprospătată la anumite intervale de timp specificate în datele de catalog ale memoriei.Timpii de acces şi lucru cu memoriile sunt date de catalog iar pe baza lor se implementează toateschemele de lucru cu memoria calculatorului. Componentele de memorie cu citire/scriere pot fi uniportsau multiport (au porturi multiple astfel încât se pot efectua mai multe operaţii în acelaşi timp).

6.1. Proiectarea unui modul de memorie

De multe ori un calculator numeric are o memorie internă de capacitate mai mare decât acomponentelor de memorie folosite. De asemenea lungimea cuvântului de date a unui calculator estemai mare decât a cuvântului citit/scris din/într-o componentă de memorie integrată. Din acesteconsiderente memoria internă a calculatorului se construieşte sub formă de module de memorie.

În cadrul unui modul memoria este organizată în rânduri şi coloane. La un moment dat cuvântul dedate este citit sau scris de pe sau pe un anumit rând. Adresa primită de la procesor sau alt dispozitivce doreşte să lucreze cu memoria este folosită astfel:

• primii cei mai puţin semnificativi j biţi de adresă sunt folosiţi pentru a adresa componentele dememorie de pe un anumit rând (o componentă de memorie are capacitatea 2j cuvinte de w biţipentru toate componentele de memorie mai puţin cele dinamice la care j este dublul număruluide biţi de adresă);

• ultimii cei mai semnificativi k biţi de adresă sunt folosiţi pentru a selecta rândul în care segăseşte adresa de memorie internă (cu ajutorul unui decodificator).

Numărul de componente de memorie de pe un rând (numărul de coloane) este dat de raportul dintrelungimea cuvântului de memorie internă a calculatorului şi lungimea cuvântului de date din cadrulcomponentei de memorie integrată.

Gestiunea modulului este efectuată de o schemă de comandă ca în figura de mai jos:

RCM - reţea de memorie integratăSCD - schemă de comandăMPA - multiplexor de adreseGCR - generator de cereri de reîmprospătareNR - numărător de adrese de reîmprospătareCAM - cereri de acces la memorie

R/ WR - cereri de citire/scriere

MPA, GCR, NR, RAS , CAS– pentru memoriile dinamice.

6.2. Proiectarea unităţii de comandă pentru memoria cache6.2.1. Tehnici de scriere

• Write-Back: se scrie şi se citeşte doar în/din memoria cache iar în caz de pagină negăsită serealizează salvarea paginii de memorie cache care se înlocuieşte în memoria principală (deunde a fost adusă) apoi pagina de memorie principală cerută de procesor va fi scrisă în loculpaginii de cache salvate. Dacă nu se cunoaşte faptul că pagina de cache care se înlocuieşte cunoua pagină a fost sau nu modificată, atunci se salvează pagina de cache întotdeauna; dacă sefoloseşte un bit de „modify” (sau „dirty”) care este setat la prima scriere a paginii cache, atuncise testează acest bit şi pagina de cache este salvată în memoria principală numai dacă pagina afost modificată. Transferarea blocurilor de memorie se realizează ori de câte ori apare un nouacces de pagină cache negăsită („cache fault page”).

• Write-Through: se citeşte doar din cache, se scrie însă şi în cache şi în memoria principală. Numai este nevoie de salvarea paginii de cache iar translatarea blocurilor se efectuează numaipentru accese de citire (la scriere, chiar şi pentru „page fault” se scrie în cache şi în memoriaprincipală, sau numai în memoria principală).

RCM

A - Aj j + k + 1

SCDWERASCAS

NR

GCR

MPA

Adresa Date

CAM

R/WR

A - A0 j - 1

6.2.2. Tehnici de translatare (mapare) a adreselor

a). Mapare directăUn bloc de memorie principală din orice grup de blocuri din memoria principală se poate plasa înmemoria cache doar pe acceaşi poziţie ca cea din cadrul grupului de memorie principală.

Cum se realizează căutarea ?Există o tabelă directă (TD), asociată MC, care păstrează etichete reprezentând AGP-ul fiecăruibloc de memorie din MC, astfel că se compară AGP-ul adresei AMP furnizată de procesor cueticheta AGP din TD citită cu ABL-ul adresei AMP. Dacă valorile coincid atunci blocul există încache, iar dacă nu se va translata blocul ABL furnizat de procesor. Implementarea se prezintă înfigura de mai jos:

b). Maparea asociativăUn bloc de memorie principală se poate plasa pe orice poziţie în memoria cahe. Schema se prezintă înfigura de mai jos:

Cum se realizează căutarea ?Există o tabelă asociativă (TA, bazată pe o memorie de căutare asociativă după conţinut) asociată MC,care păstrează etichete reprezentând ABLP-ul fiecărui bloc de memorie din MC. Astfel că, se caută înTA, după ABLP (AMP) şi dacă există o etichetă cu valoarea ABLP, se va furniza adresa ABLC pentrupoziţia etichetei respective în TA. Dacă nu, atunci se va înlocui un bloc din MC conform unui algoritmde înlocuire: LRU, fifo, adresă aleatoare, etc. Implementarea este prezentată în figura următoare:

c). Maparea set-asociativă

Memoria principală se consideră împărţită în grupuri de capacitate MC. Fiecare grup, ca şi MC, seconsideră împărţit în seturi de blocuri de lungime d după cum se poate observa în figura de mai jos:

Cum se realizează căutarea ?Există o tabelă set-asociativă (TSA) formată din „s” seturi de tabele asociative, asociate MC, carepăstrează etichete reprezentând AGP-ul şi ABLP-ul fiecărui bloc de memorie din MC. Astfel că secaută asociativ în setul

12 −ASETTA după AGP ! ABLP (! reprezintă concatenare) din AMP. Dacăexistă o etichetă egală cu valoarea de căutare, se va furniza adresa ABLC pentru poziţia eticheteirespective în setul respectiv, dacă nu atunci se va înlocui un bloc din setul respectiv din MC, setprecizat de ASET-ul lui AMP, conform unui algoritm de înlocuire: LRU, FIFO, aleator etc.Implementarea se prezintă în figura de mai jos.

Deci, în cazul mapării set-asociative, un bloc de MP se poate plasa pe orice poziţie în cadrulaceluiaşi set din MC ca cel din MP căruia îi aparţine. Avem mapare directă la nivel de seturi şi

mapare asociativă în cadrul setului (cu specificarea că un bloc din setul „i” din MC poate aparţineoricărui bloc din oricare set „i” dintr-un grup din MP).

6.2.3. Implementarea unităţii de comandă a memoriei cache

Implementarea unităţii de comandă a memoriei cache se realizează respectând diagrama de mai jos:

Diagramele pentru algoritmii de salvare şi translatare sunt prezentaţi mai jos:

6.3. Proiectarea unităţii de comandă pentru memoria principală

În timp ce memoriile SRAm folosite la memoria cache sunt mai uşor de interfaţat la viteze mari,memoriile DRAM (Dynamic Random Access Memory) folosite la memoria principală oferă capacităţimult mai mari la preţuri mai mici, însă timpul de acces la ele este mai mare iar interfaţarea lor este maicomplexă. Spre deosebire de memoria cache unde era nevoie de un singur semnal de „chip enable”(CE), memoria principală are nevoie de două semnale:

• RAS (Row Address Strobe) – selectarea adresei de linie,• CAS (Column Address Strobe) – selectarea adresei de coloană.

Necesitatea reîmprospătării memoriei („refresh”) este un alt factor care măreşte timpul de acces lamemoria principală, deoarece memoria principală este de tip DRAM, spre deosebire de memoria cachecare este de tip SRAM. Pentru simulare se va folosi o memorie RAM de 1024 locaţii a câte 8 biţi.Memoria primeşte semnale de comandă de la unitatea de comandă a memoriei principale (UCMP). MPrăspunde la semnalele de comandă cu o întârziere definită de timpii de acces pentru scriere respectivcitire. Organigrama de implementare a controller-ului de memorie principală respectă diagramaurmătoare:

6.4. Implementarea subsistemului ierarhizat de memorie cache – principală

`define WB 1'b1`define WT 1'b0`define MCR 1'b1`define MCW 1'b0`define MPR 1'b1`define MPW 1'b0`define READ 1'b1`define WRITE 1'b0`define ADDR_C 3:0`define DIMCACHE 16`define BLOCK_CACHE_SIZE 2`define OFFSET_BLOCK_SIZE 1`define TAG_OFFSET_BLOCK 0:0`define TAG_AMC 4:0

// TAG_AMC = ADDR_C + OFFSET_BLOCK_SIZE`define NR_CACHE_ENTRIES 32

// NR_CACHE_ENTRIES = 2^(TAG_AMC+1)`define ADDR 9:0`define ADDRWIDTH 10

// 10 biti de linii de adresa furnizati de procesor`define DRAM_SIZE 1024

// 2^ADDRWIDTH = marimea memoriei principale`define ROW_COL 5`define TAG_ROW_COL 4:0

// 5 biti adresa liniei sau coloanei din memorie`define DATA 7:0`define DATAWIDTH 8`define TAG 8:0// TAG (9 biti) = ADDRWIDTH - OFFSET_BLOCK_SIZE// TAG = (marimea in bytes a nr. unui bloc din memoria principala)

`define INSTR_WIDTH 20// INSTR_WIDTH = 1 (WBT) +1 (RW) + ADDRWIDTH + DATAWIDTH`define NR_TEST_INSTR 11

`define REFRESH_MEMORY_DELAY 50// 50 nanoseconds ?

`define REFRESH_HALF_PERIOD 150

`define CACHE_READ_DELAY 10`define CACHE_WRITE_DELAY 15`define RAM_READ_DELAY 40`define RAM_WRITE_DELAY 40

`define ROW_SEND_DELAY 20`define COL_SEND_DELAY 20

`define MASTER_CLOCK_PERIOD 5

module main_module;

reg [ÀDDR] RA;reg memrq, RW, WBT;wire mprdy, mcrdy;wire [`TAG_AMC] amc;wire CE, MCRW , MC_OE;wire [ÀDDR] amp;wire DRAMSEL, MPRW;// wire [`DATA] RD;wire [`DATA] MPDataOut;wire [`DATA] CacheDataOut;wire [`TAG_ROW_COL] ram_addr;wire ras, cas, WE, OE;wire clk;reg [ÌNSTR_WIDTH-1:0] Codes[0:`NR_TEST_INSTR-1];reg [ÌNSTR_WIDTH-1:0] Code;integer i,j,k;

initialbegin

for (i=0; i<`DRAM_SIZE; i=i+1) mp.DRAM_MEMORY[i] = 8'b00000000;for (i=0; i<`NR_CACHE_ENTRIES; i=i+1) mc.CACHE_MEMORY[i] = 8'b00000000;$readmemb("cod.001", Codes);$display("");ucmc.clear_LRU_TA;

endalways @(posedge clk)

beginfor (i=0;i<`NR_TEST_INSTR;i=i+1)

begin$display("");Code=Codes[i];$display("Command %0d: time RW WBT adresa value", i+1);

$display(" %0d %b %b %b %b", $time,Code[18],Code[19],Code[17:8],Code[7:0]);

$display("");

$display("MAIN MODULE: memrq <- 1");memrq = 1;

@(posedge clk); //synchronizing with cache//$display("MAIN MODULE: waiting mcrdy signal");wait (mcrdy==1);$display("MAIN MODULE: memrq <- 0"); memrq = 0;#1; //waiting for memrq to propagate

$display("Adresa blocului din MP . Valorile din cache. LRU");for (k=0;k<`DIMCACHE;k=k+1)

begin$display("%b %d", ucmc.TA[k], ucmc.LRU[k]);for (j=0;j<`BLOCK_CACHE_SIZE;j=j+1)

$display(" %b ",mc.CACHE_MEMORY[k*`BLOCK_CACHE_SIZE+j]);

end$display("");

end$finish;

end

clock clock(clk);ucmc ucmc(clk, Code[17:8], Code[7:0], memrq, Code[18], Code[19], mprdy, mcrdy, amc, CE,

MCRW, MC_OE, amp, DRAMSEL, MPRW);mc mc(clk, amc, CE, MCRW, MC_OE, MPDataOut, CacheDataOut);ucmp ucmp(clk, amp, DRAMSEL, MPRW, 1'b0, mprdy, ram_addr, ras, cas, WE, OE);mp mp(clk, ram_addr, ras, cas, WE, OE, CacheDataOut, MPDataOut);

endmodule

module ucmc(clk, RA, ValueIn, memrq, RW, WBT, mprdy, mcrdy, amc, CE, MCRW , MC_OE, amp,DRAMSEL, MPRW);

input clk;input [`ADDR] RA;input [`DATA] ValueIn;input memrq, RW, WBT, mprdy;output mcrdy;output [`TAG_AMC] amc;output CE, MCRW, MC_OE;output [`ADDR] amp;output DRAMSEL, MPRW;

reg mcrdy;reg [`TAG_AMC] amc;reg CE, MCRW, MC_OE;

reg [ÀDDR] amp;reg DRAMSEL, MPRW;

reg [ÀDDR_C] ablc;reg gasit;reg [`TAG] TA[0:`DIMCACHE-1]; // tabela asociativareg [ÀDDR_C] LRU[0:`DIMCACHE-1]; // tabela de prioritati

task cauta_RA_in_TA;reg gasit_tmp;//reg [ÀDDR_C] i;integer i;

begini=0;gasit_tmp = 0;while (gasit_tmp==0 && i<`DIMCACHE)

beginif (TA[i] == RA[ÀDDRWIDTH-1:ÒFFSET_BLOCK_SIZE]) gasit_tmp=1'b1;else i = i+1;

endablc = i; gasit = gasit_tmp;

if (gasit==1)begin$display("Am gasit un RA in TA. ablc = %d", ablc);

endend

endtask

task cauta_un_nou_index;reg zero_gasit;//reg [ÀDDR_C] i;integer i;

begini=0;zero_gasit = 0;while (zero_gasit==0 && i<`DIMCACHE)

beginif (LRU[i]==0) zero_gasit = 1'b1;else i = i+1;

endablc = i;

if (zero_gasit==1'b1)begin$display("Am gasit un zero in LRU pe pozitia %d",i);$display("");

endend

endtask

task salveaza_din_MC_in_MP;reg [`TAG_OFFSET_BLOCK] cbl;reg [`TAG] ablp;

beginmain_module.mc.DataIn = main_module.MPDataOut;main_module.mp.DataIn = main_module.CacheDataOut;$display("Salvez din MC in MP blocul de cache nr. %d",ablc);cbl = 0; ablp = TA[ablc];while (cbl < `BLOCK_CACHE_SIZE-1)

beginamc = {ablc, cbl};amp = {ablp, cbl};MCRW = `MCR; MC_OE = 1; CE = 1;#`CACHE_READ_DELAY; CE = 0;wait (mprdy==1);

//$display("Signalling DRAM to write");MPRW = `MPW;DRAMSEL = 1; // do some RAM op

#`RAM_WRITE_DELAY;wait (mprdy==1);

DRAMSEL = 0; //ok, end of RAM opcbl = cbl + 1;

end// cbl = `BLOCK_CACHE_SIZE-1amc = {ablc, cbl};amp = {ablp, cbl};MCRW = `MCR; MC_OE = 1; CE = 1;#`CACHE_READ_DELAY; CE = 0;wait (mprdy==1);

MPRW = `MPW;DRAMSEL = 1; // do some RAM op

#`RAM_WRITE_DELAY;wait (mprdy==1);

DRAMSEL = 0; //ok, end of RAM op

$display("Am salvat din MC in MP");$display("");

endendtask

task translateaza_din_MP_in_MC;reg [`TAG] ablp;reg [`TAG_OFFSET_BLOCK] cbl;begin

main_module.mc.DataIn = main_module.MPDataOut;main_module.mp.DataIn = main_module.CacheDataOut;cbl = 0; ablp = RA[`ADDRWIDTH-1:`OFFSET_BLOCK_SIZE];$display("Translatez din MP in MC blocul din MP cu nr. %d", ablp);while (cbl < `BLOCK_CACHE_SIZE-1)

beginamp = {ablp,cbl};wait (mprdy==1);

//$display("Signalling DRAM to read");MPRW = `MPR;DRAMSEL = 1; // do some RAM op

#`RAM_READ_DELAY;wait (mprdy==1);

DRAMSEL = 0; //ok, end of RAM op

amc = {ablc, cbl};MCRW = `MCW; MC_OE = 0; CE = 1;#`CACHE_WRITE_DELAY; CE = 0;cbl = cbl + 1;

endamp = {ablp,cbl};wait (mprdy==1);

MPRW = `MPR;DRAMSEL = 1; // do some RAM op#`RAM_READ_DELAY;

wait (mprdy==1);DRAMSEL = 0; //ok, end of RAM op

amc = {ablc, cbl};MCRW = `MCW; MC_OE = 0; CE = 1;#`CACHE_WRITE_DELAY; CE = 0;

$display("Am translatat din MP in MC");$display("");

endendtask

task actualizare_LRU;integer contor_LRU;begin

contor_LRU = 0;while (contor_LRU < `DIMCACHE)

beginif (LRU[contor_LRU]!=0) LRU[contor_LRU] = LRU[contor_LRU]-1;contor_LRU = contor_LRU + 1;

endLRU[ablc] = `DIMCACHE-1; // The last used block is marked

$display("Am actualizat LRU");$display("");

endendtask

task clear_LRU_TA;integer contor;begin

contor = 0;while (contor < `DIMCACHE)

beginLRU[contor] = 0; //clear LRUTA[contor] = contor;contor = contor + 1;

end

endendtask

always @(posedge clk)begin$display("Cache emitting mcrdy");mcrdy = 1; CE = 0; DRAMSEL = 0;#1; //waiting for signals to propagate//$display("UCMC: waiting memrq");wait (memrq==1);$display("cache mcrdy = 0 (Cache operation in progress)");mcrdy = 0;cauta_RA_in_TA;if (gasit==1) //cache hit

begin$display("Cache HIT");if (RW==`READ)

beginMC_OE = 1; amc = {ablc, RA[`TAG_OFFSET_BLOCK]};$display("trying to read from cache address %d", amc);MCRW = `MCR; CE = 1;#`CACHE_READ_DELAY; CE = 0;

endif (RW==`WRITE)

beginMC_OE = 0; amc = {ablc, RA[`TAG_OFFSET_BLOCK]};$display("trying to write in cache address %d", amc);main_module.mc.DataIn = ValueIn;MCRW = `MCW; CE = 1;#`CACHE_WRITE_DELAY; CE = 0;if (WBT == `WT)begin

wait (mprdy==1);main_module.mp.DataIn = ValueIn;amp = RA; MPRW = `MPW; DRAMSEL = 1; //request RAM to write#`RAM_WRITE_DELAY;wait (mprdy==1); //wait for RAM to finishDRAMSEL=0;

endend

actualizare_LRU;end

else //cache missbegin

$display("Cache MISS");if ((WBT == `WT) && (RW==`WRITE))begin

$display("WBT = WT and RW = WRITE");wait (mprdy==1);main_module.mp.DataIn = ValueIn;amp = RA; MPRW = `MPW; DRAMSEL = 1; //request RAM to write#`RAM_WRITE_DELAY;wait (mprdy==1); //wait for RAM to finish

DRAMSEL=0;end

elsebegin

cauta_un_nou_index; //dupa algoritmul LRUif (WBT == `WB) salveaza_din_MC_in_MP;translateaza_din_MP_in_MC;TA[ablc] = RA[`ADDRWIDTH-1:`OFFSET_BLOCK_SIZE]; //actualizare tabela

translatareif (RW==`READ)begin

MC_OE = 1; amc = {ablc, RA[`TAG_OFFSET_BLOCK]};MCRW = `MCR; CE = 1;#`CACHE_READ_DELAY; CE = 0;

endif (RW==`WRITE)begin

MC_OE = 0; amc = {ablc, RA[`TAG_OFFSET_BLOCK]};main_module.mc.DataIn = ValueIn;MCRW = `MCW; CE = 1;#`CACHE_WRITE_DELAY; CE = 0;

endactualizare_LRU;

endend

endendmodule

module mc(clk, amc, CE, MCRW, MC_OE, DataIn, DataOut);input clk;input [`TAG_AMC] amc;input CE, MCRW, MC_OE;input [`DATA] DataIn;output [`DATA] DataOut;reg [`DATA] DataOut;reg [`DATA] CACHE_MEMORY[0:`NR_CACHE_ENTRIES-1];

always @(posedge clk)begin

wait (CE==1);if ((MCRW==`MCR) && (MC_OE==1))

beginDataOut = CACHE_MEMORY[amc];$display("MC module: value %d READ from %d", DataOut, amc);#`CACHE_READ_DELAY;

endif (MCRW==`MCW)

begin$display("MC module: value %d WRITE to %d", DataIn, amc);CACHE_MEMORY[amc] = DataIn;#`CACHE_WRITE_DELAY;

endend

endmodule

module ucmp(clk, amp, DRAMSEL, MPRW, DMA_access, mprdy, ram_addr, ras, cas, WE, OE);input clk;input [ÀDDR] amp;input DRAMSEL, MPRW; // dinspre controlerul de cacheinput DMA_access;output mprdy; //spre controlerul de CACHEoutput [`TAG_ROW_COL] ram_addr; //adresa de coloana sau de linieoutput ras, cas, WE, OE; //spre memoria principala

reg mprdy;reg [`TAG_ROW_COL] ram_addr;reg ras, cas, WE, OE;reg refresh;

always @(posedge clk)begin#`REFRESH_HALF_PERIOD refresh=1; //using internal timer for refresh#`REFRESH_HALF_PERIOD refresh=0;

end

task scrie_in_MP;beginif (DRAMSEL==1)

begin$display("UCMP: scrie in MP la adresa %d", amp);//$display("UCMP: sending the row bits");ram_addr = amp[ÀDDRWIDTH-1:`ROW_COL];WE = 1; OE = 0; cas = 0; ras = 1;#`ROW_SEND_DELAY;//$display("UCMP: sending the col bits");ram_addr = amp[`TAG_ROW_COL];WE = 1; OE = 0; ras = 0; cas = 1;#`COL_SEND_DELAY;WE = 0; OE = 0; ras = 0; cas = 0; // done

endend

endtasktask citeste_din_MP;

beginif (DRAMSEL==1)begin

$display("UCMP: Citeste din MP de la adresa %d", amp);//$display("UCMP: sending the row bits");ram_addr = amp[ÀDDRWIDTH-1:`ROW_COL];WE = 0; OE = 1; cas = 0; ras = 1;#`ROW_SEND_DELAY;//$display("UCMP: sending the col bits");ram_addr = amp[`TAG_ROW_COL];WE = 0; OE = 1; ras = 0; cas = 1;#`COL_SEND_DELAY;WE = 0; OE = 0; ras = 0; cas = 0;

endend

endtask

task do_refresh;begin

$display("time %d ---- REFRESH in progress...", $time);#`REFRESH_MEMORY_DELAY;// just waitrefresh = 0; $display("time %d ---- REFRESH DONE.", $time);

endendtask

always @(posedge clk)begin

if (refresh == 1)begin

mprdy = 0;do_refresh;//$display("Am facut un refresh ");//$display("");

endelse

if (DMA_access==0)beginmprdy = 1; cas = 0; ras = 0;#1; //wait for mprdy to propagatemprdy = 0;if (MPRW === `MPR)beginciteste_din_MP;//$display("UCMP: Am citit din MP");//$display("");end

if (MPRW === `MPW)beginscrie_in_MP;//$display("UCMP: Am scris in MP");//$display("");end

endend

endmodule

module mp(clk, ram_addr, ras, cas, WE, OE, DataIn, DataOut);input clk;input [`TAG_ROW_COL] ram_addr;input ras, cas, WE, OE;input [`DATA] DataIn;output [`DATA] DataOut;reg [`DATA] DataOut;

reg [`TAG_ROW_COL] ram_addr_row;

reg [`TAG_ROW_COL] ram_addr_col;reg [`ADDR] full_dram_address; // address = {row column}reg [`DATA] DRAM_MEMORY[0:`DRAM_SIZE-1];always @(posedge clk)

begin//$display("Sunt in MP la inceput %b %b",WE,OE);//$display("");wait (ras==1);ram_addr_row = ram_addr;//$display("MP: RAS received . ram_addr = %d", ram_addr);wait (cas==1);

begin//$display("MP: CAS received . ram_addr = %d", ram_addr);//$display("WE, OE = %d, %d", WE, OE);ram_addr_col = ram_addr;full_dram_address = {ram_addr_row, ram_addr_col};if (OE==1)

beginDataOut = DRAM_MEMORY[full_dram_address];$display("MP module: value %d READ from %d", DataOut,

full_dram_address);#`RAM_READ_DELAY;

endif (WE==1)

begin$display("MP module: value %d WRITE to %d", DataIn, full_dram_address);DRAM_MEMORY[full_dram_address] = DataIn;#`RAM_WRITE_DELAY;

endend

endendmodule

module clock(clk);output clk;reg clk;initial clk=0;always #`MASTER_CLOCK_PERIOD clk=~clk;

endmodule

7. Probleme

1. Să se proiecteze în Xilinx memoria coadă prezentată la punctul 4.2. Să se proiecteze în Xilinx celula de memorie asociativă prezentată la punctul 5.3. Să se implementeze în Xilinx subsistemul ierarhizat de memorie cache-principală prezentat la

punctul 6.4.

laborator 6. subsistemul de memorie pentru calculatoarele...

Documents