Arhitectura Sistemelor de Calcul - Universitatea din Oradea

UNIVERSITATEA DIN ORADEA – FACULTATEA DE ȘTIINȚE
Arhitectura Sistemelor
de Calcul
[suport de curs]
Lect. univ. dr. Horea Oros
[an univ. 2009­2010]
[Lucrarea reprezintă suportul de curs pentru disciplina “Arhitectura Sistemelor de Calcul”
din planul de învățământ al studenților de la specializările Informatică anul I.]

Cuprins
1. Introducere ................................................................................................................. 5
Scurtă istorie a evoluției sistemelor de calcul ............................................................ 5
Modelul von Neumann .................................................................................................. 7
Modelul System Bus (magistrală sistem) .................................................................... 7
Niveluri ale maşinilor de calcul .................................................................................... 8
Un sistem de calcul tipic ............................................................................................. 12
Supercalculatoare ........................................................................................................ 13
Concluzii ....................................................................................................................... 14
2. Reprezentarea datelor ............................................................................................. 15
Introducere .................................................................................................................. 15
Reprezentarea numerelor în virgulă fixă .................................................................. 15
Reprezentarea numerelor în virgulă mobilă ............................................................. 24
Coduri de caractere ..................................................................................................... 34
Concluzii ....................................................................................................................... 37
3. Logica digitală .......................................................................................................... 39
Logică combinațională ................................................................................................ 39
Tabele de adevăr ......................................................................................................... 40
Porți logice ................................................................................................................... 41
Algebră booleană ......................................................................................................... 43
Forma sumă de produse şi diagrame logice .............................................................. 45
Forma produs de sume ............................................................................................... 47
Componente digitale ................................................................................................... 48
Logică secvențială ....................................................................................................... 58
Flip‐flop ........................................................................................................................ 58
Maşini cu număr finit de stări .................................................................................... 58
4. Aritmetică ................................................................................................................. 59
Introducere .................................................................................................................. 59
Adunarea şi scăderea numerelor în virgulă fixă ....................................................... 59
Înmulțirea şi împărțirea numerelor în virgulă fixă .................................................. 65
Aritmetică în virgulă mobilă ....................................................................................... 70
Studiu de caz: Aritmetica BCD .................................................................................... 71
Concluzie ...................................................................................................................... 75
5. Arhitectura setului de instrucțiuni ......................................................................... 76
Introducere .................................................................................................................. 76
Componentele hardware ale arhitecturii setului de instrucțiuni (ASI) .................. 76
ARC – „A RISC Computer” ........................................................................................... 82
Pseudo‐operații ........................................................................................................... 89
Exemple de programe în limbaj de asamblare ......................................................... 89
Variații în arhitecturile sistemelor de calcul şi în modul de adresare .................... 90
Accesarea datelor în memorie – moduri de adresare .............................................. 92
Link‐editarea subrutinelor şi stivă ............................................................................ 93
Intrare‐ieşire în limbaj de asamblare ........................................................................ 98
Studiu de caz – ASI pentru Maşina Virtuală Java .................................................... 100
Concluzie .................................................................................................................... 101

6. Limbaje şi maşină ................................................................................................... 102
Introducere ................................................................................................................ 102
Procesul de compilare ............................................................................................... 102
Procesul de asamblare .............................................................................................. 108
Link‐editare şi încărcare ........................................................................................... 115
Un exemplu de programare ...................................................................................... 119
Macrouri ..................................................................................................................... 120
Concluzii ..................................................................................................................... 122
7. Comunicații ............................................................................................................. 124
Modemuri ................................................................................................................... 124
Medii de transmisie ................................................................................................... 126
Arhitecturi de rețea: LAN .......................................................................................... 129
Erori de comunicație şi coduri corectoare de erori ................................................ 133
Arhitecturi de rețea: Internet ................................................................................... 141
Concluzii ..................................................................................................................... 147

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
1. Introducere
Arhitectura calculatoarelor (AC) se ocupă cu comportamentul funcțional al
sistemelor de calcul aşa cum este văzut de programator. Aici sunt incluse aspecte
cum ar fi: dimensiunea tipurilor de date (de ex. folosirea a 16 cifre binare pentru
reprezentarea unui întreg) şi tipurile de operații ce sunt permise (de ex. adunarea,
scăderea şi apelul de subrutine).
Organizarea calculatoarelor se ocupă cu relațiile structurale care nu sunt vizibile
programatorului, cum ar fi interfețele cu dispozitivele periferice, frecvența de ceas şi
tehnologiile utilizate pentru memorie.
În acest curs vom discuta atât despre arhitectură cât şi despre organizare, termenul
„arhitectură” va include atât arhitectura cât şi organizarea sistemelor de calcul.
În arhitectura calculatoarelor apare conceptul de nivel. Ideea este că există mai
multe niveluri la care poate fi privit un sistem de calcul, de la nivelul de sus unde
rulează programele până la nivelul de jos format din tranzistori şi circuite integrate.
Între aceste două niveluri există o serie de niveluri intermediare.
Scurtă istorie a evoluţiei sistemelor de calcul
Încă din secolul XVI existau mecanisme mecanice
pentru controlul unor operații complexe de
exemplu cilindrii care se roteau într‐o cutie
muzicală şi produceau melodii. Maşinile ce
efectuau calcule au apărut în secolul următor.
Blaise Pascal (1632‐1662) a creat un calculator
mecanic pentru a‐l ajuta pe tatăl său, care se ocupa
cu strângerea taxelor, la efectuarea calculelor.
Calculatorul lui Pascal se numea „Pascaline”.
De abia în secolul XIX, Charles Babbage (1791‐1871) reuşeşte să proiecteze o
maşină de calcul care reunea conceptul de control mecanic şi calcule mecanice într‐
un singur dispozitiv care are toate componentele esențiale dintr‐un calculator
modern aşa cum îl cunoaştem astăzi. Babbage este considerat „bunicul”
calculatoarelor şi nu „părintele” pentru că el nu a construit efectiv maşina respectivă
ci doar a proiectat‐o. Babbage a creat o maşină de calcul pentru calcularea unor
tabele matematice folosite la vremea respectivă în navigație şi munca ştiințifică.
Tabelele de până atunci conțineau numeroase erori. Maşina lui Babbage putea citi
date din intrare, putea stoca date, efectua calcule, producea date la ieşire şi efectua
controlul automat al operațiilor maşinii. Acestea sunt funcțiile de bază ce există în
orice calculator modern din zilele noastre. Babbage a creat un prototip pentru acest
motor diferenţial, care evalua polinoame folosind metoda diferențelor finite.
Succesul acestui motor a dus la proiectarea unui motor mult mai complex şi anume
motorul analitic, care era mult mai sofisticat, avea mecanisme pentru ramificare
5

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
(luarea de decizii) şi mecanisme pentru a fi programat folosind cartele perforate în
stilul cunoscut sub numele de războiul de ţesut al lui Jacquard. Motorul analitic a
fost proiectat dar nu a fost realizat efectiv la vremea respectivă datorită faptului ca
nu exista tehnologia necesară. O versiunea a motorului diferențial al lui Babbage a
fost realizat efectiv la Muzeul Ştiinței din Londra în 1991 şi poate fi văzut şi astăzi.
Următorul pas important în evoluția sistemelor de calcul s‐a făcut după un secol în
timpul celui de‐al doilea război mondial când submarinele germane produceau
Aliaților pagube semnificative în Atlantic. Aceste submarine primeau ordinele de la
baze din Germania criptat. Criptarea se realiza cu ajutorul unei maşini de calcul
numite ENIGMA produsă de Siemens AG. Procesul de criptare era cunoscut de mult
timp dar decriptarea mesajelor, fără cunoaşterea codului secret folosit la criptare,
era o operație foarte dificilă. Alan Turing (1912‐1954) şi alți oameni de ştiință din
Anglia au reuşit să „spargă” codurile produse de ENIGMA. Turing a transformat
criptografia dintr‐o artă practicată de oameni obişnuiți pentru a descifra limbi vechi
de mult dispărute (hieroglifele egiptenilor) într‐o ramură a matematicii. Turing a
creat o maşină de decriptare numită Colossus. Implicarea lui Turing în acest proiect
nu este foarte bine documentată datorită confidențialității care a planat asupra
acestui proiect.
În aceeaşi perioadă J. Presper Eckert şi John Mauchly au creat o maşină pentru
calculul tabelelor balistice pentru armata SUA. Rezultatul a fost ENIAC (Electronic
Numerical Integrator And Computer). ENIAC era format din 18000 de tuburi vidate,
care formau partea de calcul a maşinii. Programarea şi introducerea datelor se
efectuau cu ajutorul unor întrerupătoare şi prin schimbarea unor cabluri. Nu exista
conceptul de program stocat şi nu exista unitate centrală de memorie. A devenit
operațional de abia în 1946 şi a fost folosit timp de nouă ani, fiind considerat un
succes.
După succesul cu ENIAC, lui Eckert şi Mauchly li s‐a alăturat John von Neumann
(1903‐1957). Împreună au proiectat o maşină de calcul cu program stocat numită
6

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
EDVAC. În 1947 Maurice Wilkes (Universitatea Cambridge) a construit o maşină de
calcul cu program stocat numită EDSAC.
Modelul von Neumann
Calculatoarele digitale convenționale au o bază comună care îi este atribuită lui
von Neumann. Modelul von Neumann constă în cinci componente majore la fel ca în
figură. Unitatea de intrare furnizează instrucțiuni şi date sistemului, care sunt
stocate ulterior în Unitatea de Memorie. Instrucțiunile şi datele sunt procesate de
Unitatea Aritmetică şi Logică (ULA) sub controlul Unităţii de Control. Rezultatele
sunt trimise la Unitatea de Ieşire. ULA şi UC poartă denumirea generică de CPU
(Unitate Centrală de Procesare).
Programul stocat este cel mai important aspect al modelului von Neumann. Un
program este stocat în memoria calculatorului împreună cu datele ce sunt
procesate. Înainte de apariția calculatoarelor cu program stocat, programele erau
stocate pe medii externe cum ar fi cartele perforate. În calculatorul cu program
stocat programul poate fi manipulat ca şi cum ar reprezenta date. Aceasta a dus la
apariția compilatoarelor şi sistemelor de operare şi face posibilă marea versatilitate
a calculatoarelor moderne.
Modelul System Bus (magistrală sistem)
Calculatoarele moderne se bazează pe modelul von Neumann. Totuşi acest model a
fost organizat (restructurat, simplificat) într‐un alt model şi anume modelul System
Bus. Acest model împarte sistemul de calcul în trei subunități: CPU, Memorie şi
Intrare‐Ieşire. Această îmbunătățire a modelului von Neumann combină ULA şi
unitatea de control într‐o singură unitate funcțională (CPU – Central Processing
Unit). Intrarea şi ieşirea sunt combinate de asemenea într‐o singură unitate.
Caracteristica principală a modelului System Bus este comunicarea între diferitele
componente care se face printr‐o cale numită magistrală sistem, formată din
magistrala de date (care transportă informația transmisă), magistrala de adrese
(care identifică unde este trimisă informația) şi magistrala de control (care descrie
aspecte ce țin de modul în care este trimisă informația). Există de asemenea şi
7

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
magistrala de energie (curent electric) pentru alimentarea electrică a
componentelor, care nu este prezentată în figură dar prezența ei se subînțelege.
Unele arhitecturi pot avea o magistrală de intrare‐ieşire separată.
Fizic, magistralele sunt formate din colecții de fire grupate pe funcții. O magistrală
de 32 de biți are 32 de fire separate, fiecare transmițând un bit de date. Magistrala
sistem este un grup de magistrale individuale clasificate după funcțiile lor.
Magistrala de data transportă datele între diferitele componente ale sistemului.
Unele sisteme au magistrale de date separate pentru transportul datelor la/de la
procesor (data‐in şi data‐out). Magistralele, cel mai frecvent, transportă datele într‐
un singur sens la un moment dat.
Dacă magistrala trebuie partajată de diferitele entități care comunică, atunci aceste
entități trebuie să aibă adrese distincte. În unele sisteme de calcul toate adresele
sunt adrese de memorie indiferent dacă fac parte din memoria calculatorului sau
sunt dispozitive de I/E. Pe de altă parte, unele sisteme au adrese separate pentru
adresele de intrare‐ieşire ale dispozitivelor de I/E.
O adresă de memorie, sau locație, identifică locația de memorie la care sunt stocate
datele. În timpul unei operații de citire sau scriere de memorie, adresa de magistrală
conține adresa locației de memorie de la care se vor citi datele sau la care se vor
scrie datele. Termenii „citire” respectiv „scriere” se referă la CPU care citeşte datele
din memorie şi scrie datele în memorie. Dacă datele se citesc din memorie atunci
magistrala de date conține valoarea citită de la adresa de memorie respectivă. Dacă
datele se scriu în memorie atunci magistrala de date conține valoarea care se va
scrie în memorie.
Magistrala de control coordonează accesul la magistrala de date şi la magistrala de
adrese şi direcționează datele spre diferite componente.
Niveluri ale maşinilor de calcul
La fel ca orice sistem complex, un calculator poate fi privit din mai multe perspective
sau niveluri de la nivelul cel mai de sus, nivelul utilizator până la nivelul cel mai de
jos, nivelul circuitelor integrate. Fiecare nivel reprezintă o abstractizare a
calculatorului. Probabil că succesul calculatoarelor se datorează şi gradului la care
aceste niveluri de abstractizare sunt separate (independente) unele de altele. Un
utilizator care rulează o aplicație de tehnoredactare pe un calculator nu trebuie să
8

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
ştie nimic despre modul în care aplicația respectivă a fost programată. De asemenea
programatorul nu trebuie să ştie nimic despre porțile logice din structura unui
calculator. O modalitate interesantă în care această separare a nivelurilor a fost
exploatată este dezvoltarea de sisteme compatibile „în sus”.
Compatibilitatea „în sus” – invenția tranzistorilor a dus la o dezvoltare rapidă a
hardware‐ului pentru calculatoare, dar o dată cu această dezvoltare a apărut
problema compatibilității. Utilizatorii doreau să utilizeze cele mai noi şi mai rapide
calculatoare dar fiecare model nou de calculator avea o arhitectură nouă iar
software‐ul vechi nu mai rula pe calculatoare noi. Această problemă a
compatibilității hardware/software a devenit atât de acută încât utilizatorii amânau
achiziționarea de calculatoare noi datorită costurilor ridicate de rescriere a soft‐ului
pentru a rula pe noul hardware. Conversia soft‐ului vechi pentru a rula pe
hardware‐ul nou dura destul de mult.
IBM a inventat şi implementat conceptul de „familie de maşini” începând cu seria
360. Calculatoare mai performante din aceeaşi familie puteau rula programe scrise
pentru maşini mai puțin performante şi mai vechi fără a modifica acele programe ‐
compatibilitatea „în sus”.
Nivelurile
Figura prezintă cele şapte niveluri din cadrul unui sistem de calcul, de la nivelul
utilizator până la nivelul circuitelor integrate. Pe măsură ce coborâm nivelurile
devin tot mai puțin abstracte şi se expune tot mai mult din structura internă.
Nivelul de sus
Nivelul de jos
Nivel utilizator: programele de aplicaţie
Limbaje de nivel înalt
Limbaj de asamblare / cod maşină
Control
Unităţile funcţionale (memorie, ULA etc.)
Porţi logice
Tranzistori şi circuite integrate
Nivel utilizator sau nivelul programelor de aplicaţie
9

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Este nivelul cu care suntem cel mai familiarizați. La acest nivel utilizatorul
interacționează cu calculatorul prin rularea programelor de aplicație. Utilizatorul
vede calculatorul prin intermediul programelor de aplicație. Structura internă sau
structurile de nivel jos sunt foarte puțin vizibile.
Nivelul limbajelor de nivel înalt
Este nivelul cu care interacționează cei care programează într‐un limbaj de nivel
înalt (Pascal, C, C++, Java, C#). Programatorul vede doar limbajul şi nu detaliile de
nivel jos. Programatorul vede tipurile de date, instrucțiunile limbajului de nivel înalt
dar nu vede exact cum sunt implementate acele date şi instrucțiuni la nivel maşină.
Compilatorul este cel care face asocierea între tipurile de date şi instrucțiunile de la
nivelul limbajului de programare şi hardware‐ul maşinii. Programele scrise într‐un
limbaj de nivel înalt pot fi recompilate pe diferite maşini şi probabil că vor rula fără
probleme (spunem că programele sursă scrise în aceste limbaje de programare sunt
portabile). Această compatibilitate poartă numele de compatibilitate la nivel de
cod sură. Acest nivel nu are o legătură foarte mare cu maşina propriu‐zisă pentru
care este translatat codul sursă. Compilatorul transformă codul sursă în
instrucţiuni maşină.
Nivelul limbajului de asamblare / limbajului maşină
Limbajul maşină se ocupă cu problemele de hardware cum ar fi registre şi transferul
de date între aceştia. Colecția de instrucțiuni maşină pentru un anumit calculator
poartă numele de set de instrucţiuni al maşinii. Codul maşină este format doar din
cifre binare. Programarea folosind doar cifre binare este foarte dificilă aşa că printre
primele programe de calculator care au fost create a fost asamblorul care
transformă mnemonice de limbaj obişnuite cum ar fi MOVE, ADD, SUB în secvența
corespunzătoare în limbaj maşină (cod maşină). Acest limbaj în care există
corespondențe unu‐la‐un cu codul maşină se numeşte limbaj de asamblare.
Ca rezultat al acestei separări a nivelurilor putem avea maşini ce diferă în
implementarea de nivel jos dar care au acelaşi set (sau sub‐set sau super‐set) de
instrucțiuni. Aceasta a permis IBM să proiecteze seria IBM 360 care garanta faptul
că programele vechi rulează pe sisteme noi (compatibilitate în sus). Acest tip de
compatibilitate este cunoscută sub numele de compatibilitate binară deoarece codul
binar rulează nemodificat pe oricare membru al familiei de sisteme. Acesta a fost în
mare parte motivul pentru succesul seriei IBM 360.
Intel a accentuat această compatibilitate la nivel binar. Programele scrise pentru
procesorul 8086 rulau nemodificate şi pe 80186, 80286, 80386, 80486, Pentium.
Există şi alte familii de procesoare care au un alt set de instrucțiuni incompatibile cu
familii diferite. Transportul programelor pe acele procesoare nu este un proces la fel
de simplu.
Nivelul control
Unitatea de control este cea care efectuează transferul de date între registre. Pentru
aceasta foloseşte semnale de control care transferă datele dintr‐un registru într‐
10

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
altul, eventual printr‐un circuit logic care eventual poate să transforme datele.
Unitatea de control interpretează instrucțiunile maşinii una câte una, determinând
transferul de date între registre sau o altă acțiune.
Modul în care se realizează aceasta nu trebuie să privească pe programatorul în
limbaj de asamblare. Familia de procesoare 8086 este proiectată în aşa fel încât
fiecare membru al familiei poate executa setul original 8086 şi în plus orice alte
instrucțiuni suplimentare (noi) implementate pentru membrul respectiv al familiei.
Prin urmare un program scris pentru 8086 va rula pe orice alt procesor din familie.
Unitatea de control se poate implementa în două moduri: hardware, mod în care
semnalele de control sunt generate dintr‐un bloc de componente cu logică digitală;
software, mod în care un microprogram scris într‐un limbaj de nivel jos şi
implementat în hardware interpretează instrucțiunile maşină. Acest microprogram
se numeşte firmware pentru că are atât elemente hardware cât şi software.
Firmware‐ul se execută în microcontrolere.
Nivelul unităţilor funcţionale
Transferul de date între registre şi alte operații implementate de unitatea de control
transferă date în şi din unitățile funcționale (registre interne a CPU, ULA, memoria
principală). Unitățile funcționale execută operațiile esențiale pentru sistemul de
calcul.
Nivelul porţilor logice şi al tranzistorilor
Nivelul cel mai de jos este nivelul porților logice şi nivelul tranzistorilor. La acest
nivel încă se vede funcționalitatea de la nivelurile superioare. Unitățile funcționale
sunt construite din porți logice iar porțile logice sunt construite din tranzistori.
Porțile logice implementează operațiile logice la nivelul cel mai de jos, operații pe
care se bazează funcționalitatea calculatorului. La nivelul cel mai de jos calculatorul
este format din tranzistori dar la acest nivel funcționarea calculatorului este
exprimată în termeni de tensiuni ale curentului electric (voltaj), propagarea
semnalului, efecte cuantice toate fiind la un nivel foarte jos.
Interacţiunea dintre niveluri
Uneori separarea dintre niveluri este foarte vagă. O nouă arhitectură poate avea o
implementare completă pentru instrucțiuni cu numere în virgulă mobilă, pe când o
altă implementare mai minimalistă poate avea doar implementarea operațiilor cu
numere întregi. Instrucțiunile cu numere reale sunt înlocuite cu secvențe de
instrucțiuni în limbaj maşină care imită (emulează) instrucțiunile cu numere reale.
Aşa se întâmplă cu microprocesoarele care au ca opțiune coprocesorul matematic
pentru operațiile cu numere reale. Instrucțiunile ce emulează operațiile cu numere
reale sunt stocate în ROM (Read‐Only Memory). Nivelul limbaj de asamblare şi
nivelurile superioare privesc ambele implementări identic singura diferență fiind
viteza de execuție. Orice emulare funcționează mai încet. Se poate emula întregul set
11

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
de instrucțiuni al unui sistem de calcul pe un alt sistem de calcul. Un astfel de
software se numeşte emulator.
Perspectiva programatorului – arhitectura set de instrucţiuni
Programatorul în limbaj de asamblare este preocupat de limbajul de asamblare şi de
unitățile funcționale ale sistemului de calcul. Colecția de mulțimi de instrucțiuni şi
unități funcționale se numeşte arhitectura set de instrucțiuni (Instruction Set
Architecture ‐ ISA) a sistemului de calcul.
Perspectiva arhitectului de sisteme de calcul
Arhitectul de sisteme de calcul trebuie să aibă o perspectivă asupra sistemului de la
toate nivelurile. Arhitectul care se concentrează pe proiectarea calculatorului este
preocupat de cerințele de performanță şi este constrâns de costuri. Performanța
poate fi specificată prin viteza de execuție, capacitatea de stocare sau alți parametri.
Costul poate fi reflectat în bani, dimensiune, greutate sau consum de energie.
Design‐ul propus de un arhitect de sisteme de calcul trebuie să încerce să atingă
țelurile de performanță şi în acelaşi timp să respecte constrângerile de buget.
Aceasta necesită de multe ori compromisuri între diferitele niveluri ale sistemului
de calcul.
Un sistem de calcul tipic
Calculatoarele moderne au evoluat de la „monştri” anilor 50, 60 la calculatoare mult
mai mici şi mai performante. Cu toate inovațiile tehnologice apărute între timp, cele
cinci unități de bază din modelul von Neumann se pot identifica şi astăzi în
calculatoarele moderne.
Unitatea de intrare: tastatură, mouse.
Unitate de ieşire: monitor, imprimantă.
Unitatea aritmetică şi logică şi unitatea de control = CPU
Unitatea de memorie: RAM, hard‐disk, discheta, CD‐ROM.
12

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Nucleul unui calculator modern este conținut pe placa de bază. Placa de bază conține
circuite integrate, sloturi pentru plăci de extensie şi cabluri pentru conectarea
acestora.
Supercalculatoare
Unul din motivele pentru care supercalculatoarele dispar este progresul tehnologic
în domeniul calculatoarelor ceea ce face ca sistemele de calcul obişnuite să atingă o
putere de calcul ce reprezintă o fracțiune importantă din puterea de calcul a
supercalculatoarelor, la un preț foarte mic ce şi‐l permite aproape oricine. Raportul
preț/performanță pentru calculatoarele desktop este foarte bun datorită
comercializării acestor calculatoare pe scară largă. Supercalculatoarele nu se pot
vinde în cantități foarte mari aşa că acestea au un raport preț/performanță mare.
13

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Mark I – Universitatea Manchester, lansat în 21 iunie 1948. (a nu se confunda cu Harvard Mark I,
donat Universității Harvard de către IBM în august 1944)
Gordon Moore – co‐fondatorul Intel (1968), la ora actuală „Chairman Emeritus of
the board” este cunoscut pe plan mondial prin celebra „lege a lui Moore”. În 1965 el
a prevăzut că în fiecare an se va dubla numărul de tranzistori ce pot fi puşi într‐un
chip de calculator. În 1975 şi‐a actualizat previziunea spunând că la fiecare doi ani
se va dubla numărul tranzistorilor dintr‐un chip. Această lege a devenit un principiu
care a ghidat industria semiconductorilor în a furniza chip‐uri tot mai performante
cu costuri tot mai scăzute. Investițiile într‐o uzină ce produce microprocesoare sunt
enorme. Moore spunea că cel mai urât coşmar al său ar fi ca într‐o zi să se trezească
şi omenirea să nu mai aibă nevoie de mai multă putere de calcul.
Concluzii
AC se ocupă cu acele aspecte ale sistemelor de calcul ce sunt vizibile pentru
programator, în timp ce organizarea calculatoarelor se ocupă cu aspectele ce sunt la
un nivel fizic şi nu sunt foarte vizibile pentru programator. De‐a lungul timpului
programatorii trebuiau să se ocupe de fiecare aspect al calculatorului – Babbage cu
dispozitive mecanice, ENIAC cu cabluri şi conectori. Pe măsură ce calculatoarele au
devenit mai sofisticate, conceptul de nivel al maşinii a devenit tot mai important,
permițând calculatoarelor să aibă comportament extern respectiv intern foarte
diferit, gestionând complexitatea prin intermediul nivelurilor stratificate. Cea mai
importantă inovație care face posibilă aceasta este programul stocat, care este
încarnat în modelul von Neumann. Modelul von Neumann este cel pe care îl vedem
în ziua de astăzi în calculatoarele convenționale.
14

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
2. Reprezentarea datelor
Introducere
La începuturile apariției calculatoarelor existau o serie de mituri în ceea ce priveşte
calculatoarele. Un mit era că un calculator este o maşină uriaşă de calculat. Chiar şi
la vremea respectivă calculatoarele puteau face mult mai mult decât nişte calcule.
Un alt mit era că un calculator poate face „orice”. Astăzi ştim că există clase de
probleme care sunt de nerezolvat chiar şi pentru cele mai performante
calculatoarele create după modelul von Neumann. Adevărul în legătura cu
calculatoarele este undeva pe la jumătatea distanței dintre cele două mituri.
Noi suntem familiarizați cu operații ale calculatorului ce nu sunt aritmetice: grafică,
audio sau chiar mişcarea mouse‐ului. Indiferent de tipul de informație ce este
prelucrată de calculator, informația trebuie reprezentată sub formă de 0 şi 1.
Aceasta ridică imediat problema reprezentării informației respective în calculator
(codificarea datelor ‐ encoding). Orice informație trebuie reprezentată într‐un mod
sistematic, neambiguu.
Noi folosim în mod curent reprezentarea zecimală pentru numere pentru că este
reprezentarea pe care o cunoaştem cel mai bine, dar folosirea informației binare
pentru transmiterea datelor s‐a folosit încă înainte de apariția calculatoarelor sub
forma codului Morse.
În continuarea vom prezenta câteva din cele mai simple moduri de codificare a
informației: reprezentarea numerelor în virgulă fixă cu semn şi fără semn,
reprezentarea numerelor reale (în virgulă mobilă) şi reprezentarea caracterelor.
Vom vedea că întotdeauna există mai multe moduri în care pot fi codificate datele,
fiecare mod fiind util într‐un anumit context.
Vom vedea că deciziile în legătură cu numărul de biți pe care o arhitectură
particulară îi foloseşte pentru reprezentarea unor întregi (de exemplu 32 de biți) au
o consecință importantă asupra numărului de valori ce pot fi reprezentate şi asupra
operațiilor ce se pot efectua. Suma a două valori întregi reprezentate pe 32 de biți s‐
ar putea să nu se poată reprezenta pe 32 de biți ceea ce duce la o condiție numită
depăşire (overflow).
Reprezentarea numerelor în virgulă fixă
Într‐un sistem de numerație cu virgulă fixă, fiecare număr are acelaşi număr de cifre
iar „punctul” zecimal este întotdeauna în aceeaşi poziție. De exemplu 0.23, 5.12,
9.11. În aceste exemple fiecare număr e format din trei cifre iar punctul zecimal este
poziționat după prima cifră. În sistemul de numerație binar putem scrie de
asemenea astfel de numere: 11.10, 01.10 şi 00.11. Diferența dintre reprezentarea
numerelor cu virgulă fixă pe hârtie respectiv în calculator este că în calculator
punctul zecimal nu se scrie nicăieri el se consideră că se afla într‐o anumită poziție.
Se spune că punctul zecimal se află doar în mintea programatorului.
15

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Interval şi precizie la numerele cu virgulă fixă
O reprezentare cu virgulă fixă poate fi caracterizată prin intervalul de valori
reprezentabile (adică distanța dintre cel mai mic şi cel mai mare număr) şi precizia
(adică distanța dintre două numere consecutive). Pentru exemplu zecimal de mai
sus (cu trei cifre) intervalul este [0.00, 9.99] iar precizia este 0.01. Eroare în acest
caz este ½ din diferența dintre două numere consecutive. Astfel eroarea este 0.01/2
= 0.005. Astfel, putem reprezenta orice număr din intervalul [0.00, 9.99] cu o
precizie de 0.005.
Putem observa că există un compromis între interval şi precizie. Dacă luăm
intervalul [000, 999] se pot reprezenta numere dintr‐un interval mai mare dar şi
eroarea este mai mare. De asemenea dacă considerăm intervalul [.000, .999]
eroarea este .001.
În fiecare din cele trei cazuri numărul de numere reprezentabile este 1000,
indiferent unde punem punctul zecimal.
Intervalul nu este obligatoriu să înceapă cu 0. Un sistem zecimal de reprezentare a
numerelor cu două cifre poate avea intervalul [00, 99] sau intervalul [‐50, +49] sau
[‐99, 0]. Despre reprezentarea numerelor negative vom discuta mai mult într‐un alt
paragraf.
Intervalul şi precizia sunt două aspecte importante în arhitectura calculatoarelor
pentru că ambele sunt finite în implementarea arhitecturii dar infinite în realitate,
aşa că utilizatorul trebuie să fie conştient de limitări în momentul în care încearcă să
reprezinte informație externă într‐o formă internă.
Axioma asociativităţii din algebră nu este întotdeauna valabilă în
reprezentarea datelor
Ştim de la algebră că (a+b)+c = a + (b+c). Aceasta este axioma asociativității.
Dacă considerăm un sistem în virgulă fixă cu o singură cifră zecimală intervalul de
valori ce poate fi reprezentat este [‐9, 9]. Dacă considerăm a=7, b=4 şi c=‐3 atunci
vom constata că a + (b+c) = 7+(4+ ‐3) = 7+1=8 ceea cea este corect şi (a+b)+c =
(7+4)+(‐3)= 11+ ‐3, dar 11 nu este o valoare reprezentabilă în acest sistem aşa că va
fi trunchiată la 1 şi rezultatul final va fi ‐2 ceea ce este greşit. Aşadar, chiar dacă
rezultatul final corect (8) poate fi reprezentat dacă într‐un calcul intermediar apare
o depăşire rezultatul final nu va mai fi corect.
Pentru a rezolva această problemă nu se poate face nimic practic cu excepția
detectării depăşirii şi a informării utilizatorului de apariția ei.
Baze de numeraţie
În această secțiune vom vedea cum se lucrează cu baze de numerație diferite,
concentrându‐ne atenția asupra bazelor 2 (binar), 8 (octal) şi 16 (hexazecimal).
16

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Baza unui sistem de numerație defineşte intervalul de valori posibile pentru cifrele
ce pot fi folosite. În baza zece cifrele sunt {0, 1, …, 9}. Calculatorul foloseşte baza 2
pentru reprezentarea datelor.
Forma generală pentru determinarea valorii zecimale a unui număr în baza k
reprezentat în virgulă fixă este:
n−1
∑
Valoare = b ⋅k
i=−m i
i
Valoare cifrei din poziția i este dată de bi. Avem n cifre la partea întreagă şi m cifre la
partea zecimală.
Exemplu: să se evalueze numărul (541.25)10, unde indicele 10 reprezintă baza.
Avem, n=3, m=2 şi k=10.
5 x 102 + 4 x 101 + 1 x 100 + 2 x 10 ‐1 + 5 x 10 ‐2 = (500)10 + (40)10 + (1)10 + (2/10)10 +
(5/100)10 = (541.25)10
Putem considera un alt exemplu în baza 2 (1010.01)2 unde, n=4, m=2 şi k=2:
1 x 23 + 0 x 22 + 1 x 21 + 0 x 20 + 0 x 2 ‐1 + 1 x 2 ‐2 = (8)10 + (0)10 + (2)10 + (0)10 +
(0/2)10 + (1/4)10
De aici rezultă o modalitate de conversie dintr‐o bază arbitrară în baza 10 folosind
metoda polinomială.
În această modalitate de reprezentare a numerelor în baza 2 introducem noțiunile
de bit cel mai semnificativ (bitul din stânga prin convenție) respectiv bit cel mai
puţin semnificativ (bitul din dreapta prin convenție).
Conversii între baze
Am văzut cum se face conversia din baza 2 în baza 10 (metoda polinomială).
Conversia inversă din baza 10 în baza 2 este puțin mai complicată. Cea mai simplă
metodă de conversie este să convertim partea întreagă şi partea zecimală separat.
De exemplu vrem să convertim 23.375 din baza 10 în baza 2.
Conversia părții întregi se face prin împărțiri succesive la baza în care se face
conversia şi prin reținerea resturilor (metoda resturilor). Primul rest obținut
reprezintă cifra cea mai puțin semnificativă a numărului întreg convertit. La a două
împărțire deîmpărțitul este câtul de la împărțirea precedentă. Procesul se continuă
până se obține câtul zero.
17

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Putem converti orice număr din baza 10 în orice altă bază prin împărțiri succesive la
baza în care se face conversia.
Conversia părții fracționare se face prin metoda înmulțirii. Partea fracționară este
mai mică decât 1 iar prin înmulțirea cu 2 rezultatul va fi mai mic decât 2 aşa că
partea întreagă a acestui rezultat va fi chiar cifra cea mai semnificativă a părții
fracționare a numărului în baza 2. La pasul următor se înmulțeşte cu 2 partea
fracționară a rezultatului obținut la pasul precedent şi aşa mai departe până
obținem partea fracționară 0 sau până când obținem numărul de cifre dorit.
Multiplicatorul este baza în care se face conversia.
Rezultatul final va fi (23.375)10 = (10111.011)2
Fracţii periodice
Cu toate că această metodă de conversie funcționează pentru orice baze, se poate
întâmpla ca să se piardă o parte din precizie în timpul conversiei. Nu toate fracțiile
neperiodice din baza 10 au o reprezentarea neperiodică în baza 2. De exemplu
(0.2)10 = (0.(0011))2. Aşadar 0.2 din baza 10 este o fracție periodică în baza 2.
18

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
De ce se întâmplă aceasta? O fracție neperiodică din baza 10 se poate reprezenta sub
forma i/10 k = i/(5 kx2 k) = j/2 k, unde j = i/5 k. Aşadar 5 k trebuie să fie un factor al lui i.
Reprezentare binară – reprezentare zecimală
Majoritatea calculatoarelor folosesc intern baza 2 pentru reprezentarea datelor şi
operațiilor aritmetice. Totuşi există unele calculatoare care folosesc intern baza 10
pentru reprezentarea datelor aşa că nu suferă de problema conversiilor prezentată
mai sus. Metoda folosirii interne a bazei 10 nu este numai pentru evitarea erorilor
ce pot apărea la conversii ci şi pentru a evita procesul de conversie la unitățile de
intrarea şi ieşire, proces pentru care se alocă destul de mult timp.
Reprezentări în binar, octal şi hexazecimal
Numerele binare reflectă reprezentarea internă efectivă a numerelor în majoritatea
sistemelor de calcul. Totuşi această modalitatea de scriere a numerelor are
dezavantajul că numerele folosesc mult mai multe cifre decât în alte baze de
numerație. Numerele în baza 2 se reprezintă ca şiruri lungi de 0 şi 1. Bazele 8 şi 16
se folosesc mult mai des pentru scrierea şi afişarea numerelor din reprezentarea
internă pentru că aceste două numere reprezintă puteri ale lui 2 şi conversia din
baza 2 în aceste baze se poate face foarte repede şi foarte simplu printr‐un procedeu
pe care îl vom descrie în continuare. Există o serie de avantaje practice pentru
reprezentarea numerelor în aceste două baze.
Cifrele bazei 8 sunt {0, 1, …, 7} iar cifrele bazei 16 sunt {0, 1, …, 9, A, B, C, D, E, F}
unde A este o cifră care corespunde valorii zecimale 10, B lui 11, …, F lui 15.
Baza 2 Baza 8 Baza 10 Baza 16
0 0 0 0
1 1 1 1
19

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
10 2 2 2
11 3 3 3
100 4 4 4
101 5 5 5
110 6 6 6
111 7 7 7
1000 10 8 8
1001 11 9 9
1010 12 10 A
1011 13 11 B
1100 14 12 C
1101 15 13 D
1110 16 14 E
1111 17 15 F
Din tabel se vede că avem nevoie de 3 biți pentru a reprezenta orice cifră din baza 8
şi de 4 biți pentru a reprezenta orice cifră din baza 16. În general este nevoie de k
biți pentru a reprezenta toate cifrele bazei 2 k.
Pentru a converti un număr din baza 2 în baza 8 creăm grupe de câte 3 cifre binare
începând de la punctul zecimal spre stânga şi înspre dreapta. Dacă ultima grupă nu
este completă se adaugă zero. Fiecare astfel de triplet se converteşte direct în baza
8, în cifra corespunzătoare.
De exemplu:
(10110)2 = (010)2(110)2 = (2)8(6)8 = (26)8.
Pentru a converti în baza 16 se procedează analog numai că în loc de grupe de câte 3
cifre binare se creează grupe de câte 4 cifre.
Exemplu:
(10110110)2 = (1011)2(0110)2 = (B)16(6)16 = (B6)16.
Pentru a converti un număr dintr‐o bază x într‐o altă bază y (unde x şi y sunt diferite
de 10) prima dată se face conversia din baza x în baza 10 (prin metoda polinomială)
iar mai apoi din baza 10 în baza y prin metoda împărțirii pentru partea întreagă şi
prin metoda înmulțirii pentru partea zecimală.
Operaţiile aritmetice ale calculatorului
Vom prezenta modul în care se efectuează adunările binare pentru că această
operație este importantă în reprezentarea numerelor binare cu semn. Adunarea
binară se face similar cu modul în care facem adunarea zecimală, aşa cum se vede în
figură:
20

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Două numere A şi B sunt adunate de la dreapta la stânga, creând o sumă şi un
„carry” în fiecare poziție. Din moment ce avem două cifre în momentul în care le
adunăm avem patru situații diferite 0+0, 0+1, 1+0 şi 1+1. Pentru fiecare din aceste
patru situații apare şi un „carry” a cărui valoare poate fi tot 0 sau 1 aşa că în total
sunt opt situații ce trebuie considerate la adunare, situații ce sunt ilustrate în figură.
Dacă avem la dispoziție opt biți pentru reprezentarea numerelor atunci numărul
total de numere ce pot fi reprezentate este 256. Până acum am luat în calcul doar
numerele pozitive dar evident trebuie să putem reprezenta şi numere negative. În
continuare vom trece în revistă patru moduri de reprezentare a numerelor cu semn
în baza 2.
Numere cu semn în virgulă fixă
Cele patru moduri de reprezentare a numerelor cu semn în virgulă fixă sunt:
magnitudine cu semn, complement față de unu, complement față de doi şi notația cu
exces. Vom prezenta fiecare din aceste moduri de reprezentare folosind numere
întregi pentru exemple. De‐a lungul prezentării se poate consulta tabelul de mai jos
în care apar reprezentările tuturor numerelor pe trei biți în toate cele patru moduri.
Zecimal Fără Magn. Comp. 1 Comp. 2 Exces 4
semn cu semn
7 111 ‐ ‐ ‐ ‐
6 110 ‐ ‐ ‐ ‐
5 101 ‐ ‐ ‐ ‐
4 100 ‐ ‐ ‐ ‐
3 011 011 011 011 111
2 010 010 010 010 110
1 001 001 001 001 101
+0 000 000 000 000 100
‐0 ‐ 100 111 000 100
‐1 ‐ 101 110 111 011
21

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
‐2 ‐ 110 101 110 010
‐3 ‐ 111 100 101 001
‐4 ‐ ‐ ‐ 100 000
1. Magnitudine cu semn
Este cea mai familiară reprezentare pentru noi întrucât o folosim la
reprezentarea numerelor în baza 10. Semnul plus sau minus în stânga numărului
indică dacă numărul este pozitiv sau negativ (+1210 sau ‐1210). În reprezentarea
magnitudine cu semn în baza 2, cel mai semnificativ bit este folosit ca bit de
semn. Bitul 0 semnifică număr pozitiv, iar bitul 1 semnifică număr negativ.
Restul biților reprezintă valoarea absolută a numărului.
Exemplu de reprezentare pe 8 biți:
(+12)10 = (00001100)2
(‐12)10 = (10001100)2
Numărul negativ se formează prin simpla schimbare a bitului de semn din 0 în 1.
Pentru zero există două reprezentări (zero pozitiv şi zero negativ): (00000000)2,
(10000000)2
Pe 8 biți există 256 secvențe binare diferite, iar din acestea doar 255 reprezintă
numere distincte pentru că +0 şi ‐0 reprezintă acelaşi număr.
2. Complement faţă de unu
Operația complement față de unu este foarte simplu de efectuat: se convertesc
toți biții din 0 în 1 şi din 1 în 0. Dacă bitul cel mai semnificativ este 0 numărul
este pozitiv, dacă este 1 numărul este negativ, la fel ca şi la reprezentarea
magnitudine cu semn. Această operație de schimbare a biților din 0 în 1 şi din 0
în 1 poartă numele de complementare. Aici avem următoarele reprezentări
pentru valorile din exemplu precedent, tot pe 8 biți:
(+12)10 = (00001100)2
(‐12)10 = (11110011)2
Şi aici avem tot două reprezentări pentru zero aşa că numărul de numere
distincte reprezentabile pe 8 biți este tot 255. Acest mod de reprezentare nu este
foarte des folosit datorită faptului că este greu de efectuat operația de
comparație atunci când există două reprezentări pentru zero.
3. Complement faţă de doi
Se formează într‐un mod asemănător cu complementul față de unu dar în plus se
mai adună 1. Dacă rezultă un „carry out” de la cel mai semnificativ bit atunci acel
bit se ignoră. Şi în această reprezentare dacă bitul cel mai semnificativ este 0
avem de a face cu un număr pozitiv, iar dacă este 1 avem de a face cu un număr
negativ. Avantajul acestui mod de reprezentare este că aici nu avem două
reprezentări pentru 0.
(+0)10 = (00000000)2
22

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Complementul față de unu este (11111111)2 iar adunarea lui 1 ne dă:
(00000000)2 aşadar (‐0)10 = (00000000)2
Fiind o singură reprezentare pentru zero, în complement față de doi putem
reprezenta pe 8 biți 256 de valori distincte.
Exemplu:
(+12)10 = (00001100)2
(‐12)10 = (11110100)2
Numărul de numere pozitive reprezentabile este egal cu numărul de numere
negative reprezentabile (dacă îl considerăm pe zero număr pozitiv). Pe opt biți
putem reprezenta în complement față de doi numerele cu semn din intervalul: [‐
128, 127]. Pentru numărul ‐128 nu putem să găsim numărul pozitiv
corespunzător. Dacă încercăm să facem acest lucru vom obține: (‐
128)10=(10000000)2, prin complementare față de unu obținem (01111111)2 iar
prin adunarea lui 1 obținem (10000000)2, adică numărul inițial.
În calculatoarele convenționale această reprezentare se foloseşte cel mai
frecvent.
4. Reprezentare în exces
Aici numărul este tratat ca număr fără semn, dar valoarea este „deplasată” prin
scăderea unei valori (excesul). Cea mai mică valoare din această reprezentare
(cea care are toți biții zero) va fi opusul excesului iar celelalte secvențe de biți
vor fi numerele în ordine crescătoare. În reprezentarea exces numărul este de
fapt suma dintre complementul față de doi al său şi o valoare numită „exces”.
Acum vom reprezenta din nou valorile (+12)10 şi (‐12)10 pe opt biți folosind
reprezentarea exces 128. Un umăr în forma exces 128 se obține prin adunarea
lui 128 la numărul original şi prin crearea versiunii binare fără semn a lui.
Pentru (+12)10
Calculăm (128 + 12 = 140)10 şi rezultă secvența de biți (10001100)2.
Pentru (‐12)10 calculăm (‐12 + 128 = 116)10 ceea ce în baza 2 este (01110100)2.
Valoarea folosită pentru exces nu are o importanță numerică deosebită, ea fiind
folosită doar pentru deplasarea reprezentării numerelor în complement față de
doi.
Şi aici zero are o singură reprezentare, deoarece reprezentarea în exces este
doar o versiune deplasată a reprezentării în complement față de doi.
Pentru exemplul precedent, valoarea de exces este aleasă în aşa fel încât are
reprezentarea în baza doi identică cu cel mai mic număr negativ pe care vrem să
îl reprezentăm, ceea ce are ca efect ca secvențele de biți să fie sortate crescător
dacă sunt interpretate ca numere fără semn. Astfel cel mai mic număr negativ
este (‐128)10 = (00000000)2 iar cel mai mare număr pozitiv pe opt biți este
(+127)10=(11111111)2.
Această reprezentare simplifică efectuarea comparațiilor între numere, deoarece
secvențele de biți pentru numerele negative, interpretate ca valori fără semn,
sunt mai mici decât secvențele de biți pentru numerele pozitive interpretate de
asemenea ca valori fără semn.
23

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Reprezentarea zecimală codificat binar (BCD – Binary Coded Decimal)
Numerele pot fi reprezentate folosind baza 10 dar codificarea să se facă în baza 2
astfel încât fiecare cifră din baza 10 ocupă patru poziții binare. Aceasta se numeşte
codificare BCD. Există 10 cifre şi 16 secvențe binare diferite de lungime 4 aşa că
rezultatul este că 6 secvențe sunt nefolosite. În figură sunt patru cifre zecimale aşa
că avem 10 4 = 10000 secvențe de biți valide cu toate că există 2 16 = 65536 secvențe
de biți distincte pe 16 biți.
Cu toate că unele secvențe de biți sunt nefolosite, formatul BCD este folosit în
calculatoare şi aplicații de bussines. În această reprezentare sunt mai puține
probleme în reprezentarea fracțiilor neperiodice în baza 10 (fracții ce nu au o
reprezentare neperiodică în baza 2). Nu este nevoie de a se face conversia la intrare
din baza 10 în baza 2 şi nici la ieşire din baza 2 în baza 10.
Efectuarea operațiilor aritmetice asupra numerelor BCD cu semn nu este foarte
evidentă. Cu toate că suntem obişnuiți să folosim pentru baza 10 reprezentarea
magnitudine cu semn, în sistemele de calcul se foloseşte o altă metodă pentru
reprezentarea numerelor în baza 10. În sistemul de numerație complement față de
9, numerele pozitive sunt reprezentate în BCD dar cifra cea mai din stânga este mai
mică decât 5 pentru numere pozitive şi mai mare sau egală decât 5 pentru numerele
negative. Numărul negativ în complement față de 9 se formează prin scăderea din 9
a fiecărei cifre. De exemplu, numărul +301 din baza 10 este reprezentat ca 0301
(sau mai simplu 301) atât în complement față de 9 cât şi complement față de 10, aşa
cum se vede în figura de mai sus la punctul a). Complementul față de 9 negativ al lui
este 9698 ceea ce se obține prin scăderea din 9 a fiecărei cifre lui 0301 (figură
punctul b)).
Complementul față de 10 negativ se obține adunând valoare 1 la complementul față
de 9 negativ, prin urmare reprezentarea în complement față de 10 a lui ‐301 este
9698 +1 = 9699 (figură punctul c)). Pentru acest exemplu, intervalul de numere
pozitive ce se pot reprezenta este [0, 4999] iar numerele negative sunt [5000, 9999].
Reprezentarea numerelor în virgulă mobilă
În reprezentarea numerelor cu virgulă fixă numărul de cifre din partea stângă,
respectiv din partea dreaptă a punctului zecimal este fixat. În virgulă fixă e nevoie
de multe cifre pentru a reprezenta un interval de valori care să aibă o importanță
practică. De exemplu, un calculator care poate reprezenta numere până la un trilion
24

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
în virgulă are nevoie de cel puțin 40 de biți în partea stângă a virgulei deoarece 2 40
este aproximativ 10 12 . Dacă acelaşi calculator vrea să reprezinte în virgulă fixă 1/un
trilion atunci are nevoie 40 de cifre binare în partea dreaptă a punctului zecimal,
ceea ce duce la un total de 80 de cifre binare.
În practică apar numere mult mai mari şi mult mai mici decât cele menționate mai
sus, ceea ce măreşte şi mai mult resursele ce trebuie să le aloce calculatorul pentru
reprezentarea lor. Nu numai că trebuie alocate mai multe resurse acestor
reprezentări de numere dar şi calculele se vor efectua mai lent dacă folosim
reprezentări cu atât de multe cifre binare. Totuşi, atunci când lucrăm cu numere
foarte mari, nu avem nevoie de o precizie foarte mare iar când lucrăm cu numere
foarte mici nu avem nevoie de intervale mari. Putem mări eficiența prin reținerea
doar a preciziei de care e nevoie.
Interval şi precizie în reprezentarea numerelor în virgulă mobilă
Reprezentarea în virgulă mobilă permite reprezentarea unui interval mult mai mare
de numere cu un număr mai mic de cifre prin separarea cifrelor folosite pentru
precizie de cifrele folosite pentru interval.
Exemplu: Reprezentarea în virgulă mobilă în baza 10 a numărului lui Avogadro:
+6,023x10 23 .
Aici, intervalul este reprezentat de o putere a lui 10 iar precizia este reprezentată de
numărul în virgulă fixă 6,023. În acest context numărul în virgulă fixă se numeşte
mantisă sau significand al numărului. Astfel, un număr în virgulă mobilă poate fi
caracterizat printr‐un triplet de numere: semn, exponent şi mantisă.
Intervalul este determinat în primul rând de numărul de cifre din exponent (aici se
folosesc două) şi de baza folosită (aici este baza 10) iar precizia este determinată în
primul rând de numărul de cifre din mantisă (aici sunt patru). Astfel, tot numărul
poate fi reprezentat prin semn şi şase cifre, două pentru exponent şi patru pentru
mantisă. În figura de mai jos este prezentat modul în care tripletul semn, exponent şi
mantisă ar putea fi formatat în calculator.
Această modalitate de grupare a celor trei elemente vom vedea că este utilă în
momentul în care se compară două numere reprezentate în virgulă mobilă. Punctul
zecimal nu este stocat pentru că acesta întotdeauna este în aceeaşi poziție în cadrul
mantisei (punctul zecimal este doar în mintea programatorului).
Dacă avem nevoie de un interval mai mare şi suntem dispuşi să sacrificăm pentru
aceasta precizia, atunci putem folosi doar trei cifre pentru mantisă iar pentru
25

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
exponent, în loc de două cifre să folosim trei. În felul acesta mărim intervalul fără să
mărim numărul de cifre folosite pentru reprezentarea numărului. O altă modalitate
de mărire a intervalului este de a mări baza ceea ce duce şi la mărirea preciziei
pentru numerele mici dar şi la scăderea preciziei pentru numerele mari.
Compromisul între interval şi precizie este un avantaj important în reprezentarea
numerelor în virgulă mobilă, dar precizia redusă poate provoca în anumite situații
neplăceri.
Normalizare şi bitul ascuns
O problemă la reprezentarea numerelor în virgulă mobilă este că acelaşi număr
poate fi reprezentat în mai multe moduri, ceea ce face ca operațiile de comparație şi
cele aritmetice să fie dificile.
De exemplu:
3584.1 x 10 0 = 3.5841 x 10 3 = .35841 x 10 4 .
Pentru a evita această problemă a reprezentării multiple, numerele în virgulă fixă
sunt păstrate în forma normalizată. Punctul zecimal este deplasat la stânga sau la
dreapta astfel încât să fie în stânga celei mai semnificative cifre, iar exponentul este
ajustat în consecință. În exemplul de mai sus ultima formă a numărului este forma
normalizată. Numărul zero nu poate fi reprezentat astfel, aşa că pentru zero se face
o excepție: toate cifrele din mantisă sunt egale cu 0.
Dacă mantisa este reprezentată în baza 2 atunci evident vom avea cifra cea mai
semnificativă a numărului 1 (cifra cea mai din stânga). Majoritatea formatelor în
virgulă mobilă (inclusiv IEEE 754) nu salvează acest bit. Această cifră nu trebuie
stocată pentru că se subînțelege că este acolo. Consecința este că avem un bit
suplimentar pentru precizie. Acest bit cel mai semnificativ se numeşte bitul ascuns.
De exemplu, dacă mantisa în formă normalizată este .11010, atunci e suficient să se
stocheze 1010. Bitul cel mai semnificativ (din stânga) este trunchiat.
Reprezentarea numerelor în virgulă mobilă în calculator
Vom proiecta un format simplu de stocare a numerelor în virgulă mobilă pentru a
ilustra factorii importanți care intervin. Pentru mantisă vom folosi o reprezentare în
magnitudine cu semn, cu un bit pentru semn şi trei cifre hexazecimale pentru
mantisă. Exponentul va fi reprezentat ca număr pe 3 biți în exces‐4 cu baza 16.
Forma normalizată a numărului are punctul zecimal în stânga celor trei cifre
hexazecimale. Biții vor fi combinați în felul următor: bitul de semn este bitul din
stânga, urmat de 3 biți pentru exponent, urmați de cele trei cifre hexazecimale ale
mantisei. Baza şi punctul zecimal nu vor fi stocate în această formă.
Motivul pentru care am ales această reprezentare este ca să se poată efectua cu
uşurință operațiile de comparație în forma împachetată (egalitate, inegalitate, mai
mic sau egal, mai mare sau egal).
26

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Bitul de
semn
Pentru a‐l reprezenta pe (358)10 în acest format procedăm în felul următor:
Primul pas este convertirea numărului în virgulă fixă din baza originală într‐un
număr în virgulă fixă în baza țintă. Conversia numărului din baza 10 în baza 16 se
face astfel:
Câtul Restul
358/16 = 22 6
22/16 = 1 6
1/16 = 0 1
Astfel, (358)10 = (166)16. Următorul pas este convertirea numărului în virgulă fixă în
număr în virgulă mobilă:
(166)16 = (166.)16 x 16 0 . (Expresia 16 0 ne sugerează faptul că avem de a face cu baza
16, pe când numărul 16 trebuie interpretat în baza 10 – de fapt (16 0)10 = (10 0)16).
Următorul pas este normalizarea numărului:
(166.)16 x 16 0 = (.166)16 x 16 3 .
Ultimul pas este completarea biților numărului. Numărul este pozitiv aşa că punem
bitul 0 ca bit de semn. Exponentul este 3, dar îl reprezentăm în exces 4, aşa că
secvența de biți pentru exponent se calculează în felul următor:
011 (+3)10
Exces 4 + 100 (+4)10
Exponent exces 4= 111
În final, fiecare cifră în baza 16 este reprezentată în binar ca: 1=0001, 6=0110,
6=0110. Secvența de biți va fi:
Bitul de
semn (+)
Trei biţi
pentru
exponent
0 1 1 1 0 0 0 1 0 1 1 0 0 1 1 0
3
Exponentul
Punctul zecimal
1 6 6
27
Trei cifre în baza 16
Partea zecimală

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Punctul zecimal nu este reprezentat explicit în secvența de biți. Prezența acestuia
este sub‐înțeleasă. În memoria calculatorului secvența de biți va fi:
0111000101100110, fără spații între biții consecutivi, aşa cum apar în figură.
Folosirea reprezentării exces 4 pentru exponent în loc de complement față de 2
simplifică operațiile de adunare şi scădere a numerelor în virgulă mobilă. Pentru a
aduna sau a scădea două numere normalizate reprezentate în virgulă mobilă,
exponentul mai mic trebuie mărit la exponentul mai mare (aceasta păstrează
intervalul). Astfel, numărul mai mic nu va mai fi în formă normalizată. Pentru a
determina care exponent este mai mare, trebuie să tratăm secvența de biți ca un
număr fără semn şi să facem comparația. Folosind reprezentarea exces 4, cel mai
mic exponent este ‐4, adică 000. Cel mai mare exponent este +3, adică 111. Restul
secvențelor de biți, pentru ‐3, ‐2, ‐1, 0, 1, 2 vor fi 001, 010, 011, 100, 101 şi 110.
Dacă avem o secvență de biți pentru (358)10, împreună cu o descriere a
reprezentării în virgulă mobilă, putem determina cu uşurință numărul. Bitul de
semn este 0, ceea ce înseamnă că numărul este pozitiv. Exponentul în forma fără
semn este (+7)10, dar din moment ce folosim exces 4, trebuie să scădem 4 din el şi
obținem exponentul real (+7‐4 =+3)10. Fracția se grupează în cifre hexazecimale de
câte 4 biți fiecare, obținând (0166)16. Concluzionând (+.166 x 16 3)16 = (358)10.
Acum, să presupunem că la partea fracționară sunt permişi doar 10 biți, în loc de 12
cum era mai sus. Întrebarea este cum se schimbă reprezentarea. O variantă ar fi să
rotunjim fracția şi să ajustăm exponentul pe măsură. O altă variantă, pe care o şi
descriem în continuare, este să trunchiem biții cei mai puțin semnificativi prin
eliminarea lor şi astfel evităm ajustarea exponentului, aşa că numărul pe care îl
reprezentăm este de fapt:
0 1 1 1 0 0 0 1 0 1 1 0 0 1 x x
Bitul de
semn (+)
3
Exponentul
1 6 4
Dacă biții lipsă sunt interpretați ca fiind 0, atunci această secvență de biți reprezintă
(.164 x 16 3)16.
Această metodă de trunchiere produce o eroare neuniformă, din moment ce valorile
00, 01, 10, 11 sunt toate tratate ca 0, aşa că eroarea este în intervalul [0, (.003)16].
Indiferent ce format folosim pentru reprezentarea numerelor în virgulă mobilă, acel
format trebuie cunoscut de toți cei care vor să stocheze respectiv să obțină valorile
reprezentate. IEEE (Institute of Electrica land Electronics Engineers), a standardizat
formatele de reprezentare în virgulă mobilă. Standardul IEEE 754 pentru
reprezentarea numerelor în virgulă mobilă este standardul universal acceptat şi
folosit. Acest standard îl vom prezenta într‐un paragraf ulterior.
28
Partea zecimală

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Erori în reprezentarea numerelor în virgulă mobilă
Faptul că precizia finită introduce erori înseamnă că ar trebui să analizăm cât de
mare este acea eroare (prin eroare înțelegem distanța dintre două numere
consecutive reprezentabile), şi dacă eroarea este acceptabilă pentru aplicația
noastră. De exemplu, o sursă potențială de erori este reprezentarea numărului un
milion ca număr real în virgulă mobilă şi scăderea din el de un milion de ori a valorii
1. La sfârşit poate să rămână tot un milion dacă eroarea este mai mare decât 1.
Pentru a caracteriza eroarea, intervalul şi precizia folosim următoarele notații:
b baza
s numărul de cifre semnificative ale părții fracționare
M cel mai mare exponent
m cel mai mic exponent
Numărul de cifre semnificative ale părții fracționare este reprezentat de s, ceea ce
este diferit de numărul de biți din partea fracționară dacă baza este diferită de 2 (de
ex. în baza 16 e nevoie de 4 biți pentru reprezentarea fiecărei cifre). Dacă baza este
2 k atunci e nevoie de k biți pentru reprezentarea fiecărei cifre. Folosirea unui bit 1
ascuns măreşte valoarea lui s cu 1 cu toate că nu măreşte numărul de numere
reprezentabile. În exemplul precedent, există trei cifre semnificative la partea
fracționară a numărului în baza 16 şi există 12 biți ce formează cele trei cifre. Există
trei biți în exponentul reprezentat în exces 4, ceea ce permite reprezentarea oricărui
exponent din intervalul [‐2 2, 2 2‐1]. Pentru acest caz, b = 16, s = 3, M = 3 şi m = ‐4.
În reprezentarea numerelor în virgulă mobilă sunt cinci caracteristici pe care le
luăm în considerare: numărul de numere reprezentabile, numerele cu cea mai mare
respectiv cea mai mică mantisă şi dimensiunea celei mai mari respectiv a celei mai
mici diferențe dintre două numere succesive.
Numărul de numere reprezentabile poate fi determinat după formula de mai jos:
Bitul de semn poate lua două valori (A). Numărul total de exponenți este indicat la
poziția (B). Nu toate secvențele de biți sunt valide în toate reprezentările.
Standardul IEEE 754 pentru reprezentarea numerelor reale în virgulă mobilă, are
cel mai mic exponent ‐126 cu toate că exponentul, fiind reprezentat pe 8 biți, poate
29

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
reprezenta numerele negative până la ‐128. Secvențele de biți ce nu pot fi folosite
sunt rezervate pentru numere speciale: zero şi infinit.
Prima cifră a părții fracționare poate lua orice valoare cu excepția lui zero, în
reprezentare normalizată (cu excepția utilizării bitului ascuns) aşa cum este indicat
de valoarea (b­1) din poziția (C). Restul cifrelor părții fracționare pot lua orice
valoare din cele b valori ale cifrelor bazei aşa cum este indicat de valoarea b s­1 din
poziția (D). Dacă se foloseşte bitul ascuns, atunci poziția C este eliminată şi poziția D
este înlocuită cu b s . Avem nevoie şi de o reprezentare pentru zero şi pentru asta
apare şi poziția (E).
Cel mai mic număr reprezentabil are cel mai mic exponent şi cea mai mică formă
normalizată diferită de zero. Prima cifră trebuie să fie diferită de zero. Şi, din
moment ce 1 este cea mai mică valoare ce poate fi plasată rezultă că cea mai mică
valoare reprezentabilă este b ­1 . Numărul cu cea mai mică magnitudine este atunci:
b mb ­1 = b m­1. Numărul cu cea mai mare magnitudine are cel mai mare exponent şi cea
mai mare parte fracționară adică: b M (1­b ­s ).
Ca exemplu, să considerăm reprezentarea în virgulă mobilă în care avem un bit de
semn, un exponent pe 2 biți reprezentat în exces 2 şi o parte fracționară în baza 2
reprezentată pe 3 biți în formă normalizată în care bitul cel mai semnificativ este
vizibil (adică nu este ascuns). Reprezentarea lui zero este secvența de biți 000000.
În figura de mai jos sunt prezentate toate numerele ce pot fi reprezentate în acest
format.
Se observă că între 0 şi primul număr reprezentabil este o distanță destul de mare;
aceasta se întâmplă pentru că reprezentarea normalizată nu suportă secvențe de
biți ce corespund numerelor dintre zero şi primul număr reprezentabil.
Cel mai mic număr reprezentabil este cel pentru care exponentul şi partea
fracționară au cele mai mici valori. Cel mai mic exponent este ‐2 şi cea mai mică
parte fracționară normalizată este (.100)2. Cel mai mic număr reprezentabil este b m
x b ­1 = b m­1 =2 ‐2‐1 =1/8.
Cel mai mare număr reprezentabil este cel pentru care exponentul şi partea
fracționară au cele mai mari valori. Cea mai mare parte fracționară este cea pentru
care toți biții sunt egali cu 1, adică număr care este cu 2 ‐3 mai mic decât 1, din
moment ce are trei cifre la partea fracționară. Cel mai mare număr reprezentabil
este b M x (1‐b ­s ) = 2 1 x (1 – 2 ‐3 ) = 7/4.
30

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Cea mai mică diferență dintre două numere reprezentabile succesive se obține
atunci când exponentul are cea mai mică valoare şi cel mai semnificativ bit al părții
fracționare se modifică, adică b m x b ­s = b m­s = 2 ‐2‐3 = 1/32.
Cea mai mare diferență dintre două numere reprezentabile succesive se obține
atunci când exponentul are cea mai mare valoare iar cel mai semnificativ bit al părții
fracționare se modifică, adică b M x b ­s = b M­s = 2 1‐3 = ¼.
Numărul de secvențe de biți care reprezintă numere valide este mai mic decât
numărul total de secvențe de biți, datorită normalizării. Numărul de numere
reprezentabile este format din cinci părți (aşa cum am discutat mai sus). La
stabilirea acestui număr se ține cont de bitul de semn, exponentul, prima cifră
semnificativă, restul cifrelor şi secvența de biți pentru zero. Aceasta se calculează
după formula:
2 x ((M ­ m) + 1) x (b ‐ 1) x b s‐1 + 1 = 2 x (1 ‐ ( ‐ 2) + 1) x (2 ‐ 1) x 2 3‐1 + 1 = 33.
Se observă că diferențele dintre două numere succesive sunt mici pentru numere
mici şi sunt mari pentru numerele mari. Eroarea relativă este aproximativ aceeaşi
pentru toate numerele. Dacă facem raportul dintre diferența dintre două numere
mari şi un număr mare respectiv raportul dintre diferența dintre două numere mici
şi un număr mic vom observa că rapoartele sunt aceleaşi.
Distanţă mare
Număr mare
Distanţă mică
Număr mic
Aici s‐a folosit reprezentarea pentru un „număr mic”, în locul reprezentării pentru
cel mai mic număr deoarece diferența dintre zero şi primul număr reprezentabil
este un caz particular.
Exemplu:
Să se convertească (9.375 x 10 ‐2)10 în baza 2 notație ştiințifică. Rezultatul trebuie să
aibă forma x.yy x 2 z .
Prima dată convertim numărul din reprezentarea în virgulă mobilă în reprezentarea
în virgulă fixă prin mutarea punctului zecimal cu două poziții la dreapta şi obținem:
0.09375. Mai apoi convertim numărul din baza zece reprezentare virgulă fixă în
baza 2 reprezentare virgulă fixă prin metoda înmulțirii:
31

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
.09375 x 2 = 0.1875
.1875 x 2 = 0.375
.375 x 2 = 0.75
.75 x 2 = 1.5
.5 x 2 = 1.0
Astfel (.09375)10 = (.00011)2.
La sfârşit convertim numărul din reprezentarea în virgulă mobilă în forma
normalizată în baza 2: .00011 = .00011 x 2 0 = 1.1 x 2 ‐4.
Standardul IEEE 754 pentru reprezentarea în virgulă mobilă
Există numeroase moduri de reprezentare a numerelor în virgulă mobilă, o parte
din acestea fiind trecute deja în revistă. Fiecare reprezentare are propriile
caracteristici în ceea ce priveşte intervalul, precizia şi numărul de numere
reprezentabile. Pentru a îmbunătăți portabilitatea software‐ului şi pentru a asigura
o uniformitatea a calculelor cu numere reprezentate în virgulă mobilă, a fost
dezvoltat standardul IEEE 754 pentru reprezentarea numerelor binare în virgulă
mobilă (în 1985). Toate arhitecturile noi oferă suport pentru acest standard.
Standardul IEEE 754, aşa cum îl vom descrie în continuare, trebuie să fie suportat de
sistemul de calcul şi nu de întreg hardware‐ul. Aşadar se poate folosi o combinație
hardware‐software pentru a respecta standardul.
Există două formate principale în acest standard: precizie simplă şi precizie dublă.
În figura de mai jos se prezintă schematic cele două formate:
Formatul în simplă precizie ocupă 32 de biți, iar formatul în dublă precizie ocupă 64
de biți.
Bitul de semn este bitul cel mai semnificativ (bitul din stânga). Urmează exponentul
pe 8 biți reprezentat în exces 127 pentru care secvențele de biți 00000000
respectiv 11111111 sunt rezervate pentru cazuri speciale. Pentru formatul în dublă
precizie exponentul se reprezintă pe 11 biți în exces 1023. Urmează partea
fracționară reprezentată pe 23 de biți şi există un bit ascuns în stânga punctului
zecimal aşa că rezultă un total de 24 de biți pentru significand. La formatul în dublă
32

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
precizie de asemenea este un bit ascuns ceea ce duce la un total de 53 de biți pentru
significand. Pentru ambele formate, numerele sunt normalizate.
Există cinci tipuri de numere ce pot fi reprezentate: numere normalizate diferite de
zero, „zero pur‐curat” reprezentat prin secvența 00000000 în exponent şi toți biții
egali cu zero la partea fracționară. Bitul de semn poate fi 0 sau 1 ceea ce înseamnă că
există două reprezentări pentru zero +0 şi ‐0.
Infinit are o reprezentare în care exponentul conține secvența de biți rezervată
11111111 iar partea fracționară conține doar zerouri, bitul de semn fiind 0 sau 1.
Infinit este util atunci când trebuie tratate situații de depăşire sau când trebuie să
dăm o reprezentare validă unui număr diferit de zero ce a fost împărțit la zero. Dacă
zero este împărțit la zero sau infinit este împărțit la infinit rezultatul este nedefinit.
Aceasta se reprezintă prin formatul NaN (Not a Number) în care exponentul conține
secvența de biți rezervată 11111111, iar significandul este diferit de zero în timp ce
bitul de semn poate fi 0 sau 1. NaN poate fi produs şi prin încercarea de a extrage
rădăcina pătrată din ‐1.
Aşa cum se întâmplă cu toate formele normalizate, există o diferență mare între zero
şi primul număr reprezentabil. Folosirea reprezentării denormalizate („zero
murdar”) permite reprezentarea unor numere din acest interval (cuprins între zero
şi primul număr reprezentabil). Bitul de semn poate fi 0 sau 1, exponentul conține
secvența de biți rezervată 00000000 ceea ce reprezintă ‐126 pentru precizie simplă
şi ‐1022 pentru preciziei dublă, iar significandul conține secvența de biți efectivă
pentru magnitudinea numărului. Aici nu există bit ascuns. Reprezentarea
denormalizată nu este o reprezentare nenormalizată. Diferența este că există o
singură reprezentare pentru fiecare număr denormalizat şi o infinitate de
reprezentări pentru forma nenormalizată.
În figura de mai jos dăm câteva exemple de numere reprezentate în virgulă mobilă.
Exemplele de la (a) la (h) sunt exemple de numere reprezentate cu formatul precizie
simplă, iar exemplu (i) este reprezentarea unui număr în precizie dublă.
33

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
În exemplul (a) signifcandul este 1.101 dar este reprezentată explicit doar partea
fracționară 101. Exemplu (b) foloseşte cel mai mic exponent (precizie simplă) care
este ‐126 iar exemplul (c) foloseşte cel mai mare exponent (precizie simplă) care
este 127.
Exemplele (d) şi (e) ilustrează două reprezentări pentru zero. Exemplul (f) prezintă
o secvență de biți pentru reprezentarea lui infinit. Exemplul (g) este un număr
denormalizat. Exemplu (h) prezintă reprezentarea lui NaN care poate fi pozitiv sau
negativ. Ultimul exemplu (i) prezintă reprezentarea lui 2 ‐128 în dublă precizie.
Pe lângă reprezentările în precizie simplă şi dublă există şi formatele single
extended şi double extended. Formatele extinse nu sunt vizibile utilizatorului, dar
acestea sunt folosite pentru a reține un număr mai mare de precizie internă la
efectuarea calculelor pentru a reduce efectul de eroare de rotunjire. Formatele
extinse măresc lărgimea exponenților şi a părții fracționare cu un număr de biți ce
poate varia de la o implementare la alta. De exemplu, formatul single extended
adaugă cel puțin trei biți la exponent şi opt biți la partea fracționară. Formatul
double extended are de regulă 80 de biți cu 15 biți la exponent şi 64 de biți la partea
fracționară.
O implementare a IEEE 754 trebuie să furnizeze cel puțin precizie simplă, celelalte
formate sunt opționale. Rezultatul oricărei operații cu numere în virgulă mobilă
trebuie să fie corect până la jumătate de bit din bitul cel mai puțin semnificativ al
părții fracționare. Aceasta înseamnă că în timpul operațiilor trebuie reținuți câțiva
biți suplimentari pentru precizie (numiți biți gardă) şi trebuie să fie o metodă
potrivită pentru rotunjirea rezultatului intermediar la numărul de biți al fracției.
Există patru moduri de rotunjire în standardul IEEE 754. Unul din moduri
rotunjeşte înspre zero, altul înspre infinit iar altul rotunjeşte înspre minus infinit.
Modul implicit rotunjeşte la cel mai apropiat număr reprezentabil. În jumătate din
cazuri rotunjirea se va face la numărul pentru care cifra cea mai puțin semnificativă
este pară. De exemplu, 1.01101 se rotunjeşte la 1.0110 pe când 1.01111 se
rotunjeşte la 1.1000.
Coduri de caractere
Spre deosebire de numerele reale, numărul de caractere este finit. Un set de
caractere complet poate fi reprezentat cu ajutorul unui număr mic de biți/caracter.
În continuare vom descrie trei dintre cele mai obişnuite reprezentări pentru
caractere: ASCII, EBCDIC şi Unicode.
Setul de caractere ASCII
ASCII = American Standard Code for Information Interchange este prezentat în
figura de mai jos.
Este un cod pe şapte biți ceea ce permite reprezentarea a 2 7 =128 de caractere
diferite. Pozițiile de la 00 la 1F şi poziția 7F sunt caractere speciale de control
34

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
folosite pentru transmisii, controlul tipăririi şi alte scopuri care nu au legătură cu
textul obişnuit. Restul caracterelor sunt toate caractere afişabile: litere, cifre,
semne de punctuație, spațiu. Cifrele de la 0 la 9 apar una după alta, la fel şi
literele mari, respectiv mici. Această organizare simplifică manipularea
caracterelor. Pentru a schimba reprezentarea unei cifre în valoarea ei numerică
trebuie să scădem din codul cifrei valoarea hexazecimal (30)16. Pentru a obține
codul literei mici atunci când ştim codul literei mari corespunzătoare trebuie să
adunăm la codul literei mici valoarea hexazecimal (20)16. Caracterul care
reprezintă litera A are codul (41)16, iar caracterul care reprezintă litera a are
codul (61)16.
Setul de caractere EBCDIC
Problema cu setul de caractere ASCII este că pot fi reprezentate doar 128 de
caractere, ceea ce este o limitare destul de drastică pentru multe tastaturi care
au multe alte caractere în plus față de literele mari şi mici. Codul EBCDIC
(Extended Binary Coded Decimal Interchange Code) este un cod pe 8 biți folosit
intens pe calculatoare mainframe IBM.
Codul ASCII se reprezintă pe 7 biți dar se stochează pe 8 (un caracter/byte). De
cele mai multe ori se adaugă un bit suplimentar de regulă în poziția cea mai
semnificativă o octetului. Prin urmare folosirea codului EBCDIC nu necesită în
realitatea mai mulți biți. În schimb la transmiterea serială a datelor bitul
suplimentar are un impact mai mare. În figura de mai jos prezentăm codul
35

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
EBCDIC. Se poate observa că există unele poziții care nu au atribuit un caracter.
Acele poziții pot fi folosite pentru caractere speciale la nivel de aplicație.
Codul de
caractere
EBCDIC
EBCDIC este un
cod pe 8 biţi
Setul de caractere Unicode
Codurile de caractere ASCII şi EBCDIC suportă setul de caractere „Latin”. Pe
lângă acest set de caractere ce conține literele de la a la z există o serie de alte
seturi de caractere în diferite limbi (chineză, japoneză, arabă etc.) Evident că nu
se poate face o asociere simplă, unu‐la‐unu, de la codul ASCII la orice set de
caractere aşa că s‐a creat un standard pentru caractere universal numit Unicode
care suportă majoritatea caracterelor din cele mai importante limbi.
Unicode este un standard în permanentă dezvoltare. Se schimbă pe măsură ce
noi seturi de caractere sunt introduse şi pe măsură ce seturile de caractere
existente evoluează şi reprezentarea lor se perfecționează.
Unicode a fost creat pentru a permite schimbul, procesarea şi afişarea textelor
scrise în diferite limbi şi în diferite discipline tehnice din lumea modernă. De
asemenea suportă texte clasice şi istorice din multe limbi scrise.
Standardul Unicode foloseşte 16 biți pentru reprezentarea caracterelor şi în anul
2005 a ajuns la versiunea 4.
Unicode atribuie un număr unic pentru fiecare caracter, este independent de
platformă, independent de aplicație, independent de limbă.
Fundamental, un calculator lucrează numai cu numere. Pentru a stoca în memorie
litere sau alte semne, este necesar ca fiecărui caracter să‐i fie asignat un număr.
Înainte de inventarea Unicode‐ului, au existat sute de sisteme diferite de codare
pentru asignarea acestor numere. Dar, nici unul dintre acestea nu a fost satisfăcător,
36

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
neputând codifica suficiente caractere: de exemplu, numai Uniunea Europeană
necesită mai multe codificări diferite pentru a acoperi toate limbile existente în
cadrul ei. Nici măcar pentru o singură limbă, cum ar fi limba engleză, nu a existat un
singur sistem de codare adecvat pentru toate literele, semnele de punctuație şi
simbolurile tehnice uzuale.
De asemenea, sistemele de codare existente intră deseori în conflict între ele
deoarece, două sisteme diferite pot utiliza acelaşi număr pentru două caractere
diferite sau pot utiliza numere diferite pentru acelaşi caracter. Calculatoarele, în
special serverele, sunt nevoite să suporte mai multe sisteme diferite de codare; de
aceea, de fiecare dată când datele sunt transferate între platforme cu sisteme
diferite de codare, apare riscul coruperii lor.
Unicode schimbă toate acestea!
Unicode furnizează un număr unic pentru fiecare caracter, indiferent de platformă,
aplicație sau limba folosită. Standardul Unicode a fost adoptat de multe companii de
vârf, cum ar fi Apple, HP, IBM, JustSystem, Microsoft, Oracle, SAP, Sun, Sybase,
Unisys şi multe altele. De asemenea, Unicode este necesar standardelor moderne ca
de exemplu XML, Java, ECMAScript (JavaScript), LDAP, CORBA 3.0, WML etc. şi
reprezintă implementarea oficială a standardului ISO/IEC 10646. Unicode este
suportat de multe sisteme de operare, navigatoare moderne de internet şi multe alte
produse. Apariția standardului Unicode precum şi disponibilitatea instrumentelor
care îl suportă, reprezintă cea mai semnificativă tendință spre globalizarea
dezvoltării de software.
Utilizarea Unicode în aplicațiile client‐server sau multi‐tier precum şi în situri web
oferă, pe lângă simplificarea arhitecturii, şi scăderi semnificative ale costului
comparativ cu seturile tradiționale de caractere. Unicode permite ca o aplicație sau
un sit web unice să poată fi utilizate simultan şi fără modificări pe platforme şi în
țări diferite, folosind diverse limbi, permițând totodată şi transferul datelor între
sisteme diferite fără pericolul coruperii lor.
Pentru mai multe detalii consultați sit‐ul www.unicode.org
Concluzii
Datele în calculator sunt reprezentate sub formă de biți ce pot fi recunoscuți şi
interpretați în diferite moduri: ca întregi, ca numere în virgulă fixă, ca numere în
virgulă mobilă sau ca şi caractere. Codurile de caractere cum sunt ASCII, EBCDIC şi
Unicode au dimensiuni finite şi pot fi reprezentate în totalitate pe un număr finit de
biți. Numărul de biți folosiți pentru reprezentarea numerelor este de asemenea finit
ceea ce înseamnă că putem reprezenta doar o submulțime a numerelor reale (mai
exact raționale). Aceasta duce la noțiunile de interval, precizie şi eroare. Intervalul
defineşte cea mai mică şi cea mai mare valoare ce poate fi reprezentată. Aceste două
valori sunt determinate de baza şi numărul de biți ai exponentului reprezentării în
virgulă mobilă. Precizia este determinată de numărul de biți folosiți în
37

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
reprezentarea magnitudinii (excluzând biții din exponent în reprezentarea
numerelor în virgulă mobilă). Eroarea apare în reprezentarea în virgulă a numerelor
datorită faptului că există numere reale în intervalul dintre două numere
reprezentabile consecutive.
38

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
3. Logica digitală
În acest capitol vom trece în revistă câteva principii de bază ale logicii digitale,
principii ce pot fi aplicate în proiectarea calculatoarelor digitale. La început vom
discuta despre logică combinațională, în care deciziile logice se iau doar în funcție de
combinații ale intrărilor. După care, vom trece în revistă logica secvențială în care
deciziile se iau în funcție de intrările curente şi intrările mai vechi. Prin înțelegerea
acestor principii de bază vom putea proiecta circuite logice cu ajutorul cărora se pot
construi calculatoare complete. Vom începe cu partea fundamentală a calculatorului
digital, unitatea combinațională logică.
Logică combinaţională
O unitate combinațională logică (UCL) transformă o mulțime de intrări într‐o altă
mulțime de ieşiri conform uneia sau a mai multor funcții. Ieşirile UCL sunt calculate
strict ca funcție a intrărilor, iar ieşirile sunt actualizate imediat ce intrările se
schimbă. Un model de bază pentru UCL este dat în figura de mai jos.
O mulțime de intrări i0 – in, vor determina ca UCL să producă o mulțime de ieşiri
conform funcțiilor f0, f1,…, fm. Într‐un UCL nu există un feedback de la ieşire înspre
intrare.
Intrările şi ieşirile unui UCL au de regulă două valori: high şi low. Când valorile sunt
luate dintr‐o mulțime finită, circuitele care le folosesc sunt numite digitale. Un
circuit digital electronic primeşte intrări şi furnizează ieşiri în care 0 volți (0 V) se
consideră ca fiind valoarea low, iar +5 V este considerată valoarea high. Această
convenție nu este folosită peste tot: circuitele de viteză mare folosesc de regulă
voltaje mai joase; unele circuite ale calculatoarelor operează în domeniul analog, în
care sunt permise o continuitate de valori. O aplicație în care circuitele analogice ar
fi mai potrivite este simularea zborurilor, din moment ce circuitele analogice
aproximează mai exact mecanica unui avion, față de circuitele analogice.
Cu toate că majoritatea calculatoarelor digitale sunt binare, există şi circuite multi‐
valoare. Un mediu de transmisie capabil să transmită mai mult de două valori poate
fi mai eficient la transmiterea informației decât un mediu care transmite doar două
valori. Un circuit digital multi‐valoare este diferit față de un circuit analog prin aceea
că un circuit multi‐valoare poate lua o valoarea dintr‐o mulțime finită, pe când un
circuit analogic poate lua o infinitate de valori. Utilizarea circuitelor multi‐valoare
39

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
are o utilitate teoretică, dar în practică este dificilă crearea acestor circuite capabile
de a face distincție între mai mult de două valori.
Noi ne vom concentra atenția doar pe circuitele binare digitale, în care sunt permise
doar două valori pentru intrare sau ieşire.
Tabele de adevăr
În 1854 George Boole a publicat o lucrare importantă în legătură cu o algebră
pentru reprezentarea logicii. Boole era interesat în scoaterea în evidență a
matematicii gândirii şi a dezvoltat o reprezentare a informației factuale cum ar fi:
„Uşa este deschisă” sau „Uşa nu este deschisă”. Algebra lui Boole a fost dezvoltată
mai departe de Claude Shannon în forma pe care o folosim astăzi. În algebra
Booleană, presupunem existența unui postulat de bază şi anume că o variabilă
binară ia o singură valoare care poate fi 0 sau 1. Această valoare corespunde
voltajelor de 0 respectiv +5 menționate mai sus. Atribuirea se poate face şi în ordine
inversă. Pentru a înțelege comportamentul circuitelor digitale, putem abstractiza
corespondența fizică cu voltaje şi să considerăm doar valorile simbolice 0 şi 1.
O contribuție importantă a lui Boole a fost tabelele de adevăr, care prezintă relații
într‐un format tabelar. Să considerăm o cameră în care sunt două întrerupătoare A
şi B, ce controlează un bec Z. Un întrerupător poate fi sus altul jos sau ambele
întrerupătoare pot fi sus, respectiv jos. Când un singur întrerupător este sus becul
este aprins. Când ambele întrerupătoare sunt sus sau jos becul este stins.
Se poate construi o tabelă de adevăr care enumeră toate valorile posibile pe care le
pot avea cele două întrerupătoare, aşa cum se vede în figura de mai sus. În tabel, un
întrerupător primeşte valoarea 0 dacă este jos şi valoarea 1 dacă este sus. Becul este
aprins atunci când valoarea lui Z este 1.
Într‐o tabelă de adevăr, toate combinațiile posibile de variabile binare de la intrare
sunt enumerate şi o valoare corespunzătoare de 0 sau 1 este atribuită fiecărei
combinații. În tabela de adevăr din figura de mai sus, ieşirea Z depinde de variabilele
din intrare A şi B. Pentru fiecare combinație de variabile din intrare există două
valori pe care Z le poate avea: 0 şi 1. Putem alege o altă configurație pentru
întrerupătoare, în care becul este aprins doar atunci când ambele întrerupătoare
sunt sus sau jos, situație în care tabela de adevăr se transformă în:
40

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Legarea firelor între întrerupătoare ar trebui de asemenea să se modifice. Pentru
două valori de intrare există 2 2 = 4 combinații şi 2 4 = 16 posibilități de atribuire a
valorilor de ieşire.
Porţi logice
Dacă enumerăm toate atribuirile de setări posibile pentru întrerupătoare cu două
intrări vom obține 16 atribuiri prezentate în tabelul de mai jos:
Aceste funcții se numesc funcții logice Booleene. O parte din funcții au nume
speciale. Funcția AND produce valoarea 1 doar când A şi B au valoarea 1, pe când
funcția OR produce valoarea 1 (true) atunci când cel puțin una din valorile lui A sau
B este 1. Vom considera că valoarea unei funcții este false atunci când are valoarea
0. Există şi funcțiile False şi True. Semnul + într‐o expresie Booleană semnifică OR
logic şi nu implică adunarea aritmetică. Juxtapunerea a două variabile, de ex. AB,
semnifică operația AND logic între cele două variabile.
Funcțiile A şi B nu fac altceva decât să repete valorile lui A respectiv B din intrare, pe
când funcțiile A şi B , complementează valorile lui A şi B, producând 0 atunci când
41

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
valoarea din intrare este 1 şi invers. În general o bară deasupra unui termen denotă
operația de complementare, prin urmare funcțiile NAND şi NOR sunt complemente
ale funcțiilor AND şi OR. Funcția XOR are valoarea 1 (true) atunci când una din
valorile din intrare are valoarea 1 iar cealaltă valoarea 0. Funcția XNOR este
complementul funcției XOR.
O poartă logică este un dispozitiv fizic ce implementează o funcție Booleană simplă.
Funcțiile prezentate în tabelul de mai sus au reprezentări sub formă de simboluri ca
porți logice, o parte din aceste simboluri fiind prezentate mai jos. Pentru fiecare
funcție, A şi B sunt intrări binare şi F este ieşirea.
În figura de mai sus porțile AND şi OR se comportă exact aşa cum am descris. Buffer‐
ul nu face altceva decât să copieze intrarea în ieşire. Cu toate că buffer‐ul nu are o
semnificație logică, el are un rol practic important şi anume acela de amplificator,
permițând unui singur semnal să controleze mai multe porți logice. Poarta NOT
(numită şi invertor) complementează intrarea. Cerculețul din vârful triunghiului
denotă operația de complementare.
Tot în figura de mai sus sunt prezentate porțile logice NAND, NOR, XOR şi XNOR,
împreună cu tabla operației.
Simbolurile logice din figura de mai sus sunt doar formele de bază, existând o serie
de variante care sunt folosite adesea. De exemplu putem avea porți logice cu mai
mult de două intrări aşa cum se vede în figura de mai jos (a).
42

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Cerculețul denotă complementare şi după cum se vede (b) poate fi plasat nu numai
la ieşire ci şi la intrare pentru a complementa intrarea. În funcție de tehnologia
folosită , unele porți logice pot produce două ieşiri complementate. Simbolul logic
corespunzător pentru această situație prezintă ambele ieşiri, aşa cum se vede în
figura de mai sus (c).
Algebră booleană
În tabelul de mai jos sunt prezentate câteva proprietăți ale algebrei Booleene ce pot
fi aplicate expresiilor booleene logice. Postulatele (cunoscute sub numele de
postulatele lui Huntington) sunt axiomele algebrei Booleene, aşa că nu au nevoie de
demonstrație. Teoremele pot fi demonstrate folosind postulatele. Fiecare relație
prezentată are atât o formă AND cât şi o formă OR datorită principiului dualității.
Forma duală se obține prin interschimbarea lui AND cu OR.
43

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Proprietatea de comutativitate spune că ordinea în care apar două variabile într‐o
funcție AND sau OR nu este relevantă. Datorită principiului dualității, proprietatea
de comutativitate are o formă AND (AB = BA) şi o formă OR (A+B = B + A). Sensul
postulatelor şi teoremelor se poate deduce din tabel.
În tabela de adevăr de mai jos este demonstrată legea lui DeMorgan:
Figura de mai sus prezintă echivalența unei porți OR cu o poartă NAND, echivalență
la care se poate ajunge cu legea lui DeMorgan.
44

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Pentru a obține completitudine computațională (posibilitatea de a crea orice circuit
logic cu porțile logice disponibile) nu este nevoie de toate porțile logice prezentate
până acum. Trei mulțimi de porți logice complete computațional sunt: {AND, OR,
NOT}, {NAND}, {NOR} (există şi altele).
Echivalența funcțională între diferite porți logice este importantă din punct de
vedere practic pentru că un tip de poartă logică poate avea caracteristici de operare
mai bune pentru o anumită tehnologie.
Forma sumă de produse şi diagrame logice
Acum vom implementa o funcție mai complexă decât simplele porți logice şi anume
funcția majoritate cu trei intrări descrisă de tabela de adevăr de mai jos.
Minterm
Index
0
1
2
3
4
5
6
7
A B C F
0 0 0 0
0 0 1 0
0 1 0 0
0 1 1 1
1 0 0 0
1 0 1 1
1 1 0 1
1 1 1 1
Funcția majoritate (care poate primi la intrare un număr impar de valori) are
valoare 1 (true) atunci când mai mult de jumătate din intrări sunt 1 şi valoarea 0 în
caz contrar, aşa cum este ilustrat cu ajutorul balanței din figură. Aceasta este o
operație obişnuită folosită în anumite aplicații atunci când ieşirile mai multor
circuite identice care operează asupra aceloraşi date, sunt comparate şi cel mai
mare număr de valori similare determină ieşirea (poate fi considerată o „votare”).
Din moment ce nici una din porțile logice prezentate până acum nu implementează
funcția majoritate în mod direct, vom transforma funcția într‐o ecuație AND‐OR cu
două niveluri iar mai apoi vom implementa funcția folosind porți logice din
mulțimea {AND, OR, NOT}. Vor fi două niveluri pentru că un nivel de variabile
asupra cărora se aplică operația AND va fi urmată de un alt nivel la care se aplică
operația OR. Ecuația booleană care descrie funcția majoritate are valoarea true de
fiecare dată când F este true în tabela de adevăr.
O modalitate de a reprezenta ecuațiile logice este folosirea formei sumă de produse,
ce poate fi definită ca o colecție de expresii formate prin operația OR şi fiecare
termen al expresiei este format din variabile asupra cărora se aplică operația AND.
Ecuația logică booleană care exprimă funcția majoritate este:
F = ABC
+ ABC
+ ABC
+ ABC
Semnul '+' semnifică OR iar juxtapunerea AND.
45
1
0 0
0-side 1-side
A balance tips to the left or
right depending on whether
there are more 0’s or 1’s.

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Prin examinarea ecuației observăm că poate este implementată cu patru porți logice
AND cu trei intrări, iar ieşirile acestor patru porți logice AND vor fi conectate la
intrarea unei porți logice OR cu patru intrări aşa cum este prezentat în figura de mai
jos.
În figură este prezentat modul de reprezentare a situației când este conexiune
respectiv când aceasta lipseşte, mod care este prezentat şi în figura de mai jos.
Atunci când un produs conține exact o instanță a fiecărei variabile, într‐o anumită
formă, complementată sau nu, acesta se numeşte mintermen. Un mintermen are
valoarea 1 pentru o singură linie din tabela de adevăr – adică, un număr minim de
termeni (unul) va face funcția true. Ca alternativă, funcția este uneori scrisă ca sumă
logică peste intrările true. Ecuația pentru funcția majoritate poate fi rescrisă sub
forma: F = ∑ 3,
5,
6,
7 .
Această formă este potrivită pentru forma canonică a ecuației Booleene, care
conține doar mintermeni.
46

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Forma produs de sume
Ca dual la forma sumă de produse, o ecuație Booleană poate fi reprezentată în forma
produs de sume. O astfel de ecuație conține o colecție de variabile asupra cărora se
aplică operația OR iar asupra rezultatele operațiilor OR se aplică operație AND. O
metodă de a obține forma produs de sume este de a porni de la complementul
formei sumă de produse şi de a aplica teorema DeMorgan. De exemplu, dacă ne
referim din nou la tabela de adevăr a funcției majoritate, complementul se obține
prin selectarea termenilor care produc 0 le ieşire, aşa cum se vede în ecuația de mai
jos.
F = ABC
+ ABC
+ ABC
+ ABC
Complementarea ambelor părți va duce la: F = ABC
+ ABC
+ ABC
+ ABC
, iar prin
aplicarea teoremei DeMorgan în forma W + X + Y + Z = W X Y Z vom obține:
F = ( ABC)(
ABC)(
ABC)(
ABC)
. Aplicând din nou teorema DeMorgan în forma:
WXYZ = W + X + Y + Z vom obține:
F = ( A + B + C)(
A + B + C)(
A + B + C)(
A + B + C)
Această ultimă ecuație este în forma produs de sume şi conține patru maxtermeni,
în care fiecare variabilă apare o singură dată în forma complementată sau nu. Un
maxtermen, de ex. (A+B+C), are valoarea 0 pentru o singură linie din tabela de
adevăr. Adică, este true pentru numărul maxim de linii din tabela de adevăr fără a se
reduce la funcția trivială care are valoarea true întotdeauna. O ecuație care este
formată numai din maxtermeni în forma produs de sume, se spune că este în forma
canonică produs de sume. Un circuit OR‐AND care implementează ecuația este
prezentat în figura de mai jos:
Forma OR‐AND este logic echivalentă cu forma AND‐OR.
47

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Un motiv pentru utilizare formei produs de sume față de forma sumă de produse
este acela că aceasta ar putea duce la o ecuație Booleană mai mică. O ecuație
Booleană mai mică implică un circuit mai simplu.
Contorul de poarta este o măsură a complexității unui circuit şi se obține prin
numărarea tuturor porților logice. Contorul de intrări poartă este o altă măsură
pentru complexitatea unui circuit şi se obține prin numărarea tuturor intrărilor în
toate porțile logice ce alcătuiesc circuitul.
Componente digitale
Circuitele digitale de nivel înalt sunt create de regulă cu ajutorul unor colecții de
porți logice numite componente şi nu cu porți logice simple. Aceasta permite ca într‐
o anumită măsură gradul de complexitate al circuitului să fie abstractizată şi de
asemenea se simplifică procesul de modelare a comportamentului circuitelor şi
procesul de caracterizare a performanțelor acestora. Aici vom prezenta câteva din
cele mai uzuale circuite.
Niveluri de integrare
Până acum ne‐am concentrat atenția asupra circuitelor logice combinaționale. Din
moment ce am prezentat doar porți logice individuale înseamnă că am lucrat la
nivelul de integrare la scală mică (small scale integration ‐ SSI), în care există 10
până la 100 de componente/chip. (Aici termenul de „componentă” are un alt înțeles
şi anume se referă la tranzistori şi alte elemente discrete). Cu toate că uneori în
practică e nevoie să lucrăm la acest nivel de integrare jos, de obicei pentru circuitele
cu performanțe ridicate, microelectronica ne permite să lucrăm la un nivel de
integrare mult mai mare. În nivelul de integrare medie (medium scale integration ‐
MSI) pe un chip apar între 100 şi 1000 de componente. În nivelul de integrare mare
(large scale integration ‐ LSI) avem un număr cuprins între 1000 şi 10000 de
componente iar în nivelul de integrare foarte mare (very large scale integration ‐
VLSI) avem peste 10000 de componente. Nu există nişte limite foarte fixe pentru
diferitele niveluri de integrare, dar este important să facem această distincție pentru
compararea complexității relative a circuitelor.
Multiplexor
Un multiplexor (MUX) este o componentă care conectează o serie de intrări la o
singură ieşire. O diagramă bloc şi tabela de adevăr corespunzătoare pentru un MUX
4‐la‐1 sunt prezentate mai jos.
48

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Ieşirea F va avea valoarea intrării selectate de liniile de control A şi B. De exemplu,
dacă AB = 00, atunci valoarea de pe linia D0 (0 sau 1) va apărea la F. Circuitul AND‐
OR corespunzător este prezentat în figura de mai jos:
Atunci când se proiectează circuite ce folosesc MUX, se foloseşte forma abstractizată
(cutia neagră) în locul formei detaliate din figura de mai sus. Astfel putem
abstractiza o parte din detalii atunci când proiectăm circuite complexe.
MUX poate fi folosit pentru a implementa funcții Booleene. În figura de mai jos un
MUX 8‐la‐1 implementează funcția majoritate.
49

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Datele de intrare sunt luate direct din tabela de adevăr a funcției majoritate, iar
datele de intrare pentru control sunt atribuite variabilelor A, B şi C. MUX
implementează funcția majoritate prin transmiterea unui 1 de la intrarea fiecărui
mintermen la ieşire. Intrarea 0 marchează porțiuni din MUX care nu sunt necesare
pentru implementarea funcției, iar rezultatul – o serie de porți logice rămân
neutilizate. Cu toate că porțiuni din MUX sunt aproape întotdeauna neutilizate în
implementarea funcțiilor Booleene, multiplexoarele sunt folosite pe scară largă
pentru că ele simplifică procesul de proiectare, iar modularitatea lor simplifică
implementarea.
Ca un alt exemplu, să considerăm implementarea unei funcții de trei variabile
folosind un MUX 4‐la‐1. În figura de mai jos este prezentată o tabelă de adevăr cu
trei variabile şi un MUX 4‐la‐1 care implementează funcția F. Vom permite ca datele
de intrare să fie luate din mulțimea {0, 1, C, C } iar gruparea se obține aşa cum este
prezentat în tabela de adevăr. Atunci când AB = 00, F = 0, indiferent de valoarea lui
C. Când AB = 01, F = 1, indiferent de valoarea lui C. Când AB = 10, F = C iar când AB =
11, F = C . Astfel putem implementa o funcție cu trei variabile folosind un MUX cu
două variabile.
50

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Demultiplexor
Demultiplexorul (DEMUX) este opusul multiplexorului. O diagramă bloc pentru un
demultiplexor 1‐la‐4 şi tabela de adevăr corespunzătoare sunt prezentate în figura
de mai jos.
Un DEMUX trimite singura intrare, D, la un din ieşiri Fi, confirm valorilor intrărilor
de control. Circuitul corespunzător un DEMUX este prezentat în figura de mai jos:
Rolul unui DEMUX este de a transmite date de la o singură intrare la mai multe
ieşiri, de ex. chemare celui mai apropiat lift prin simpla apăsare a unui buton.
DEMUX nu este folosit de regulă la implementarea funcțiilor Booleene, cu toate că se
poate face şi acest lucru.
Decodor
Un decodor transformă o codificare logică într‐o locația spațială. Exact una din
ieşirile decodorului este high (valoarea logică 1), fiind determinat de configurația
51

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
intrărilor de control. O diagramă bloc şi o tabelă de adevăr pentru un decodor 2‐la‐4
sunt prezentate în figura de mai jos.
Diagramă logică asociată care implementează decodorul este prezentată în figura de
mai jos:
Un decodor poate fi folosit pentru a controla alte circuite, dar uneori nu este potrivit
pentru activarea altor circuite. Din acest motiv, adăugăm o intrare de activare
decodorului, care determină toate ca toate ieşirile să fie 0 dacă este aplicat la intrare
un 0. (Între un DEMUX şi un decoder cu intrarea 1 există o echivalență logică).
O aplicație pentru decodor este la translatarea adreselor de memorie în locații fizice.
Decodoarele pot fi folosite şi la implementarea funcțiilor Booleene. Din moment ce
fiecare linie de la ieşire corespunde unui alt mintermen, o funcție poate fi
implementată prin efectuarea operației OR logic asupra ieşirilor ce corespund
mintermenilor reali ai funcției. De exemplu, în figura de mai jos, un decodor 3‐la‐8
implementează funcția majoritate. Ieşirile neutilizate rămân deconectate.
52

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Encoder cu prioritate
Un encoder transformă o mulțime de intrări într‐o codificare binară şi poate fi privit
ca opusul unui decoder. Un encoder cu prioritate este un tip de encoder, la care este
impusă o ordine în valorile de intrare. O diagramă bloc şi tabela de adevăr
corespunzătoare este prezentată în figura de mai jos pentru un encoder cu
prioritate 4‐la‐2.
O schemă de prioritate este impusă asupra intrărilor în care Ai are o prioritate mai
mare decât Ai+1. Ieşire, formată din doi biți, poate lua valorile 00, 01, 10 sau 11 în
funcție de care intrări sunt active (au valoarea logică 1) şi de prioritatea lor relativă.
Când nu este activă nici o intrare, ieşirea va avea o valoarea implicită în care A0 are
prioritate (F0F1 = 00).
Encoderul cu prioritate este folosit ca arbitru pentru diferite dispozitive ce folosesc
aceleaşi resurse. Diagrama unui circuit ce reprezintă un encoder cu prioritate 4‐la‐2
este prezentată în figura de mai jos.
53

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Tablouri logice programabile
Un tablou logic programabil (progammable logic array ‐ PLA) este o componentă
formată dintr‐o matrice AND configurabilă urmată de o matrice OR configurabilă. În
figura de mai jos este prezentat un PLA cu trei intrări şi două ieşiri. Cele trei intrări
A, B şi C şi complementele lor sunt disponibile la intrările fiecăreia din cele opt porți
AND care generează 8 termeni (fiecare termen fiind un produs). Ieşirile porților
AND sunt disponibile la intrarea fiecărei porți OR care generează funcțiile F0 şi F1.
O siguranță (engl. fuse) programabilă este plasată în fiecare punct de intersecție în
matricile AND şi OR. Matricile sunt configurate pentru diferite funcții prin
54

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
dezactivarea siguranțelor. Atunci când o siguranță este dezactivată la o intrare într‐
o poartă AND, poarta AND se comportă ca şi cum intrarea este întotdeauna 1.
Analog, o intrare dezactivată la o poartă OR în PLA se comportă ca şi cum intrarea
este întotdeauna 0.
Ca exemplu de utilizare a PLA, vom implementa funcția majoritate folosind un PLA
3x2 (trei variabile de intrare x două ieşiri). În figura de mai jos este prezentat în
mod simplificat PLA‐ul corespunzător.
Cele şase intrări în fiecare poartă AND aici sunt reprezentate printr‐o singură linie
iar cele opt intrări în fiecare din cele două porți OR sunt reprezentate de asemenea
printr‐o singură linie (pentru simplitate). Cercurile din punctele de intersecția a
liniilor indică locul în care sunt făcute conexiunile. Din figură se observă că funcția
majoritate este implementată folosind doar jumătate din PLA, cealaltă jumătate fiind
disponibilă pentru implementarea altei funcții.
PLA‐urile sunt componentele cele mai des folosite în cadrul circuitelor digitale. Un
avantaj al utilizării PLA‐urilor este că au doar câteva intrări şi câteva ieşiri, iar
numărul porților logice dintre intrări şi ieşiri este mare. Este importantă
minimizarea numărului de conexiuni la limitele unui circuit pentru a modulariza un
sistem în componente discrete care sunt proiectate şi implementate separat.
Un PLA se poate reprezenta ca o cutie neagră aşa cum se vede mai jos (pentru a
respecta principiul modularității).
55

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Exemplu: sumator cu propagare de transport
Ca un exemplu al modului în care un PLA este folosit la proiectarea circuitelor
digitale vom considera în continuare un circuit care adună două numere binare.
Adunarea binară se efectuează similar cu modul în care efectuăm adunarea zecimală
aşa cum se vede în figura de mai jos.
Două numere binare A şi B sunt adunate de la dreapta la stânga şi se formează
pentru fiecare poziție o sumă şi un transport (engl. carry). Doi biți de intrare şi un
carry‐in trebuie adunați la fiecare poziție, astfel încât trebuie să avem în vedere 8
combinații posibile, aşa cum se vede în tabela de adevăr de mai jos.
Tabela de adevăr de mai sus descrie un element numit sumator complet, prezentat
schematic în figura de mai sus. Un sumator incomplet (engl. half adder) ar putea fi
56

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
folosit pentru adunarea celor mai puțin semnificativi biți, pentru că în acea poziție
nu avem carry‐in. Un sumator incomplet adună doi biți şi produce o sumă şi un
transport (carry‐out).
Putem înlănțui patru sumatori compleți pentru a forma un sumator suficient de
mare pentru adunarea unor numere reprezentate pe 4 biți. Schema unui astfel de
circuit este prezentată în figura de mai jos.
Sumatorul din partea dreaptă are un carry‐in egal cu zero.
Se poate observa că o anumită sumă nu poate fi calculată până când nu a fost
calculat transportul de la sumatorul complet precedent. Circuitul se numeşte
sumator cu propagare de transport pentru că valorile corecte pentru bitul de
transport se propagă prin circuit de la dreapta la stânga. Cu toate că circuitul pare a
fi paralele, în realitate biții sumă sunt calculați serial de la dreapta la stânga. Acesta
este un dezavantaj important al circuitului.
O modalitate de a proiecta sumatori compleți este utilizarea unui tablou logic
programabil.
57

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Logică secvenţială
Flip­flop
Maşini cu număr finit de stări
58

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
4. Aritmetică
Introducere
După ce am prezentat modul de reprezentare a numerelor în calculator vom trece în
revistă cele patru operații fundamentale ce pot fi efectuate cu aceste numere:
adunarea, scăderea, înmulțirea şi împărțirea. Prima dată vom prezenta modul în
care aceste operații se efectuează asupra numerelor reprezentate în virgulă fixă iar
mai apoi asupra numerelor reprezentate în virgulă mobilă.
Adunarea şi scăderea numerelor în virgulă fixă
Vom trece în revistă adunare şi scăderea atât a numerelor cu semn cât şi a
numerelor fără semn. Ne vom concentra mai mult pe numerele reprezentate în
complement față de doi datorită faptului că această reprezentare este folosită
aproape în exclusivitate în sistemele moderne de calcul. Vom trece în revistă şi
operațiile efectuate cu numere reprezentate în complement față de unu (acestea au
o importanță în domenii cum ar fi rețelistica) şi în BCD (importante pentru
calculatoarele de buzunar).
Adunarea şi scăderea în complement faţă de 2
Vom prezenta adunarea numerelor cu semn reprezentate în complement față de doi.
În mod implicit vom prezenta şi scăderea pe baza principiului:
a­b = a+(­b).
Putem obține opusul unui număr prin complementarea lui (şi adunarea lui 1 dacă
reprezentarea este în complement față de doi). Acest fapt este important pentru
hardware întrucât nu e nevoie de crearea de hardware specializat pentru operațiile
de scădere.
Vom modifica interpretarea pe care o dăm rezultatelor operațiilor de adunare atunci
când adunăm două numere reprezentate în complement față de doi. Pentru aceasta
vom considera figura de mai jos:
59

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Atunci când adunăm două numere reprezentate pe axa numerelor reale, numerele
pot fi oricât de mari sau oricât de mici. Aşadar, pe axa numerelor reale se pot
reprezenta oricâte numere. În figura de mai sus sunt prezentate circular toate
numerele reprezentate în complement față de 2 pe 3 biți împreună cu echivalentul
lor zecimal.
Folosind acest cerc putem aduna sau scădea numere prin traversarea cercului în
sensul acelor de ceasornic (pentru adunare) sau invers (pentru scădere). Numerele
pot fi scăzute prin complementarea față de 2 a descăzutului şi adunarea la scăzător.
Trebuie remarcat că poate să apară situația de depăşire în cazul adunării unor
operanzi cu acelaşi semn. Depăşirea apare atunci când se face trecerea de la +3 la ‐4
în timpul unei operații de adunare şi de la ‐4 la +3 în timpul unei operații de scădere.
Urmează două exemple de adunare a unor numere reprezentate în complement față
de doi pe 8 biți, prima dată două numere pozitive iar mai apoi un umăr pozitiv şi
unul negativ:
00001010 (+10)10
+ 00010111 (+23)10
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
00100001 (+33)10
00000101 (+5)10
+ 11111110 (‐2)10
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
Elimin (1) 00000011 (+3)10
Transportul produs la bitul cel mai semnificativ este eliminat la adunarea în
complement față de doi. O situație similară este atunci când adunăm două numere
negative şi avem transport la poziția cea mai semnificativă:
11111111 (‐1)10
+ 11111100 (‐4)10
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
Elimin (1) 11111011 (‐5)10
60

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Bitul de transport de la poziția cea mai semnificativă este eliminat pentru că
sistemul de numerație este modular ‐ „se întoarce” de la cel mai mare număr pozitiv
la cel mai mic număr negativ.
Cu toate că la operația de adunare poate apare un transport la poziția celui mai
semnificativ bit aceasta nu însemnă întotdeauna că rezultatul este greşit. La ambele
exemple de mai sus rezultatul este corect cu toate că avem un transport în poziția
celui mai semnificativ bit.
Depăşire
Atunci când adunăm două numere mari cu acelaşi semn poate să apară situația de
depăşire, adică rezultatul nu se poate reprezenta pe numărul de biți folosiți în
reprezentare. De exemplu numerele (+80)10 şi (+50)10 reprezentate pe opt biți în
complement față de doi. Rezultatul ar trebui să fie (+130)10 dar, aşa cum vedem mai
jos, rezultatul este (‐126)10.
01010000 (+80)10
+ 00110010 (+50)10
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
10000010 (‐126)10
Cel mai mare număr ce se poate reprezenta pe 8 biți în complement față de 2 este
127 aşa că este evident că 130 nu poate fi reprezentat. Rezultatul interpretat ca
număr fără semn pe 8 biți este într‐adevăr 130.
În general, dacă se adună două numere cu semn opus, atunci nu poate să apară
depăşire. Motivul intuitiv pentru acest rezultat este că valoarea absolută a
rezultatului nu poate fi mai mare decât valoare absolută a operandului mai mare
(cel pozitiv). Aşadar, putem da definiția depăşirii la complement față de 2:
Dacă numerele care se adună au acelaşi semn şi rezultatul are semn opus, atunci are
loc depăşire şi rezultatul nu este corect. Dacă numerele ce se adună au semne opuse
atunci nu apare niciodată depăşire. O metodă alternativă de depistare a depăşirii
este: dacă transportul în bitul cel mai semnificativ diferă de transportul ce iese de la
bitul cel mai semnificativ atunci şi numai atunci avem depăşire.
Dacă un număr pozitiv se scade dintr‐un număr negativ şi rezultatul este pozitiv, sau
dacă un număr negativ se scade dintr‐un număr pozitiv şi rezultatul este negativ,
atunci avem depăşire. Dacă numerele ce se scad au acelaşi semn atunci nu va apare
niciodată depăşire.
Implementarea hardware a unor sumatori şi a unor scăzători
În figura de mai jos este prezentat un sumator cu propagare de transport de patru
biți.
61

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Două numere A şi B se adună de la dreapta la stânga, creând o sumă şi un transport
la fiecare poziție binară reprezentată printr‐un sumator complet. Sumatorul este
modelat după modul în care efectuăm operație de adunare normală.
În figura de mai jos patru sumatori cu propagare de transport sunt înlănțuiți pentru
a crea un sumator pe 16 biți. Sumatorul complet din partea dreaptă are ca transport
de intrare valoarea zero.
Scăderea numerelor binare se face într‐un mod similar cu adunarea. Putem scădea
un număr dintr‐altul prin efectuarea operației într‐o coloană la un moment dat,
scăzând cifrele descăzutului bi din cifrele scăzătorului ai, pe măsură ce mergem de la
dreapta la stânga. La fel ca şi în scăderea zecimală, dacă descăzutul este mai mare
decât scăzătorul sau dacă este un împrumut de la o cifră precedentă atunci
împrumutul trebuie să se propage la următorul bit semnificativ. Figura de mai jos
prezintă tabela de adevăr şi un circuit pentru scădere.
62

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Scăzători compleți pot fi înlănțuiți pentru a forma scăzători cu împrumut în acelaşi
mod ca şi sumatorii compleți. În figura de mai jos este prezentat un scăzător cu
împrumut pe patru biți format din patru scăzători compleți:
O metodă alternativă pentru a implementa scăderea este de a forma complementul
față de doi negat al descăzutului şi să‐l adunăm la scăzător. Circuitul de mai jos
efectuează atât adunarea cât şi scăderea unor numere reprezentate pe patru biți în
complement față de doi prin permiterea ca intrările bi să fie complementate atunci
când vrem să facem scădere.
63

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Linia de control ADD / SUBSTRACT determină care funcție este efectuată. Bara
deasupra lui ADD indică faptul că operația ADD este activă atunci când semnalul
este low sau zero. Dacă valoare de control este 0 atunci intrările ai şi bi sunt
transmise prin sumator iar suma este generată la ieşirile si. Dacă semnalul de
control 1, atunci intrările ai sunt transmise sumatorului nemodificate iar intrările bi
vor fi complementate de către poarta XOR înainte de a fi transmise sumatorului.
Pentru a forma complementul față de doi negativ, trebuie să adunăm 1
complementului față de unu negativ, ceea ce se realizează prin setarea lui c0 la 1.
Astfel, putem folosi hardware‐ul folosit pentru adunare şi la scădere.
Adunare şi scădere în complement faţă de unu
Reprezentarea în complement față de unu nu se mai foloseşte în ziua de astăzi prea
mult în calculatoarele moderne dar s‐a folosit cândva – la primele calculatoare.
Adunarea în complement față de unu este tratată diferit de adunarea în complement
față de doi: transportul care iese la poziția bitului cel mai semnificativ nu este
eliminat, ci este adunat înapoi la poziția bitului cel mai puțin semnificativ aşa cum se
vede în figura de mai jos:
64

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Pentru a vizualiza mai bine motivul pentru care e nevoie de „end‐arround‐carry”
prin examinarea cercului numerelor reprezentate pe 3 biți în complement față de
unu.
În acest cerc sunt două poziții pentru zero. Atunci când adunăm două numere,
traversăm atât +0 cât şi ‐0, aşa că trebuie să compensăm faptul că zero este parcurs
de două ori. „End‐arround‐carry” avansează rezultatul cu o poziție pentru această
situație.
Înmulţirea şi împărţirea numerelor în virgulă fixă
Înmulțirea şi împărțirea numerelor reprezentate în virgulă fixă poate fi efectuată cu
operații de adunare, scădere şi deplasare. În continuare vom prezenta metode
pentru efectuarea acestor operații atât pentru numere fără semn cât şi pentru cele
cu semn.
Înmulţirea numerelor fără semn
Înmulțirea numerelor binare fără semn se face într‐un mod similar cu modul în care
facem operație cu creionul pe hârtie. În figura de mai jos prezentăm modul în care se
realizează acest proces pentru doi întregi fără semn:
Fiecare bit al multiplicatorului determină dacă multiplicandul, deplasat în mod
corespunzător spre stânga este adunat la rezultatul final. Dacă înmulțim două
65

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
numere fără semn reprezentate pe n biți rezultatul va avea lungimea de 2n biți. În
figura de mai sus înmulțirea a doi operanzi pe patru biți va produce un rezultat pe
opt biți. Dacă înmulțim două numere cu semn reprezentate pe n biți, rezultatul se va
reprezenta pe maxim 2(n­1)+1 = 2n­1 biți.
Mai jos prezentăm schema pentru o implementare hardware pentru înmulțirea
întregilor pe 4 biți, în care este un sumator pe patru biți, o unitate de control, trei
registre de patru biți şi un registru de un bit pentru transport.
Pentru a înmulți două numere, multiplicandul este plasat în registrul M,
multiplicatorul este plasat în registrul Q iar registre A şi C se setează la zero. În
timpul înmulțirii, bitul cel mai puțin semnificativ al multiplicatorului determină
dacă multiplicandul este adunat la produs la fiecare pas. După ce multiplicandul este
adunat la produs, multiplicatorul şi registrul A sunt deplasate la dreapta simultan.
Figura de mai jos prezintă procesul de înmulțire.
66

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Inițial C şi A au valoarea zero, iar M şi Q conțin multiplicandul respectiv
multiplicatorul. Bitul cel mai din dreapta al lui Q este 1, aşa că multipicatorul M este
adunat la produs în registrul A. Registre A şi Q formează produsul pe 8 biți, dar în
registrul A se adună multiplicandul. După ce M este adunat la A, registre A şi Q sunt
deplasați la dreapta. Din moment ce A şi Q sunt legați pentru a forma produsul de 8
biți, bitul cel mai din dreapta al lui A este deplasat în bitul cel mai din stânga (cel mai
semnificativ) al lui Q. Bitul cel mai din dreapta al lui Q este eliminat, C este deplasat
în bitul cel mai semnificativ al lui A şi C devine zero.
Procesul continuă pentru toți biții din multiplicator. La a doua iterație, bitul cel mai
din dreapta al lui Q este din nou 1, aşa că multiplicandul este adunat la A şi
combinația C/A/Q este deplasată la dreapta. La ultima iterație, bitul cel mai din
dreapta al lui Q este 1 aşa că M este adunat la A şi combinație C/A/Q este deplasată
la dreapta. Produsul este conținut în registre A şi Q, în care A conține partea cea mai
semnificativă iar Q conține partea cea mai puțin semnificativă.
Împărţirea numerelor fără semn
La împărțirea binară, încercăm să scădem împărțitorul din deîmpărțit, folosind
numărul minim de biți în deîmpărțit. Din figura de mai jos reiese că (11)2 nu încape
în 0 sau 01, dar încape în 011.
Împărțirea binară în calculator poate fi rezolvată similar, numai că singurul mod în
care putem să decidem dacă împărțitorul „încape” în deîmpărțit este de a face
efectiv operația de scădere şi să verificăm dacă rezultatul este negativ. Dacă
rezultatul este negativ atunci scăderea trebuie anulată prin adunarea înapoi a
împărțitorului.
În figura de mai jos prezentăm schema unui divizor serial pentru numere pe patru
biți.
67

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Aici avem un sumator de 5 biți, o unitate de control, un registru de 4 biți pentru
deîmpărțitul Q şi două registre de 5 biți pentru împărțitorul M respectiv pentru
restul A. Registre de 5 biți sunt folosiți pentru A şi M în locul unor registre de 4 biți,
datorită faptului că e nevoie de un bit suplimentar care să indice semnul rezultatului
intermediar. Cu toate că această metodă de împărțire este pentru numere fără semn,
este folosită şi operația de scădere aşa că putem obține şi rezultate negative, iar
bitul suplimentar este pentru bitul de semn.
Pentru a împărți două numere pe 4 biți, deîmpărțitul este plasat în registrul Q,
împărțitorul este plasat în registrul M iar registrul A şi bitul cel mai semnificativ al
lui M sunt setate la zero. Bitul cel mai semnificativ al lui A determină dacă
împărțitorul este adunat la deîmpărțit la fiecare pas. Aceasta este necesar pentru a
restaura deîmpărțitul atunci când rezultatul este negativ. Când rezultatul este
pozitiv, cel mai puțin semnificativ bit al lui Q este setat la 1, ceea ce indică faptul că
împărțitorul „încape” în deîmpărțit.
În figura de mai jos este prezentat procesul de împărțire.
68

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Înmulţirea şi împărţirea numerelor cu semn
Dacă aplicăm metodele de înmulțire şi împărțire descrise pentru numere fără semn
la numere cu semn, vom întâmpina unele probleme. Considerăm înmulțirea lui ‐1 cu
1 folosind o reprezentare pe 4 biți aşa cum este în figura de mai jos:
Ceea ce se produce este echivalentul lui +15 reprezentat pe 8 biți. Ceea ce s‐a
întâmplat a fost că bitul de semn nu s‐a propagat înspre stânga, înspre bitul de
semn. Aceasta nu este o problemă pentru numerele negative care oricum au bitul de
semn 0.
O soluție este prezentată în figura de mai sus, în care fiecare produs parțial este
extins la lățimea rezultatului şi doar primii 8 biți mai puțin semnificativi sunt
reținuți. Dacă ambii operanzi sunt negativi, atunci semnele extinse pentru ambii
operanzi, reținând tot primii 8 biți mai puțin semnificativi.
69

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Aritmetică în virgulă mobilă
Operațiile aritmetice cu numere reprezentate în virgulă mobilă pot fi efectuate
folosind metodele descrise pentru numerele reprezentate în virgulă fixă, cu câteva
ajustări. În continuare vom prezenta modul în care se fac aceste operații în baza 2 şi
baza 10.
Adunarea şi scăderea numerelor în virgulă mobilă
Aritmetica pentru numerele reale diferă de aritmetică pentru întregi întrucât
trebuie tratat atât exponentul cât şi mantisa operanzilor. La fel ca şi la aritmetica în
baza 10 utilizând notație ştiințifică, exponenții operanzilor trebuie să fie egalizați
pentru adunare şi scădere. Părțile fracționare sunt apoi adunate sau scăzute iar
rezultatul se normalizează.
Acest proces de ajustare a părții fracționare şi rotunjirea poate duce la pierderea de
precizie în rezultat. Să considerăm adunarea a două numere reale fără semn (.101 x
2 3 + .111 x 2 4 ) în care partea fracționară are trei cifre semnificative. Prima dată vom
ajusta exponentul mai mic pentru a fi egal cu cel mai mare şi vom modifica în
consecință partea fracționară. Astfel vom avea: .101 x 2 3 = .010 x 2 4 , pierzând astfel
.001 x 2 3 din precizie în acest proces. Suma care rezultă este:
(.010 + .111) x 2 4 = 1.001 x 2 4 = .1001 x 2 5
iar rotunjind la 3 cifre semnificative avem: .100 x 2 5 , pierzând încă .001 x 2 4 din
precizie.
Numerele reale au o structură complicată (mantisa este păstrată în reprezentare
magnitudine cu semn, exponentul este reprezentat în exces iar bitul de semn este
separat) dar această structură permite realizarea operațiilor de comparație (, =)
fără a fi necesară despachetarea numărului. Înaintea unei operații de adunare,
numărul trebuie despachetat din reprezentarea internă (IEEE754): exponentul şi
mantisa trebuie extrase, trebuie efectuate operațiile iar mai apoi rezultatul trebuie
renormalizat şi rotunjit iar secvența de biți este reîmpachetată în formatul intern.
La comparare bitul de semn este cel mai important şi prin urmare este bitul cel mai
semnificativ în formatul IEEE754. După aceea cel mai important în compararea a
două numere reale este exponentul, din moment ce o modificare de ± 1în exponent
schimbă numărul cu un factor de 2 (în baza 2), pe când o schimbare ± 1 chiar şi în
cel mai semnificativ bit al părții fracționare va avea un efect mai mic asupra
numărului.
Pentru a ține cont de bitul de semn, fracțiile reprezentate în magnitudine cu semn
sunt reprezentate ca întregi şi sunt convertite în complement față de 2. După
operația de adunare sau scădere în complement față de 2, apare nevoia de a
normaliza rezultatul şi de a ajusta bitul de semn. Rezultatul este mai apoi convertit
înapoi în forma magnitudine cu semn.
70

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Înmulţirea şi împărţirea numerelor în virgulă mobilă
Înmulțirea şi împărțirea numerelor reprezentate în virgulă mobilă se face similar cu
adunarea şi scăderea numerelor reprezentate în virgulă mobilă, cu excepția că
semnul, exponentul şi mantisa rezultatului pot fi calculate separat. Dacă operanzii
au acelaşi semn, atunci semnul rezultatului este pozitiv. Semne diferite vor produce
semnul rezultatului negativ. Exponentul rezultatului înainte de normalizare se
obține prin adunarea exponenților operanzilor sursă la înmulțire şi prin scăderea
lor la împărțire. Se efectuează operația dorită şi urmează normalizarea.
Să considerăm că folosim fracții pe 3 biți pentru a efectua operația în baza 2: (+.101
x 2 2 ) x (‐.110 x 2 ‐3 ). Semnul operanzilor diferă, ceea ce înseamnă că semnul
rezultatului va fi negativ. Efectuăm înmulțire aşa că adunăm exponenții şi rezultatul
va fi 2+ ‐3 = ‐1. Înmulțim partea fracționară, ceea ce ne dă .01111. Normalizarea
produsului şi reținerea a doar 3 biți va produce ‐.111 x 2 ‐2 .
Un alt exemplu, (+.110 x 2 5) / (+.100 x 2 4). Operanzii au acelaşi semn, cea ce
înseamnă că rezultatul va avea semn pozitiv. Scădem exponenții şi obținem 5 – 4 = 1.
Împărțim fracțiile, ceea ce se poate face în mai multe moduri. Dacă tratăm fracțiile
ca întregi fără semn, atunci vom avea 110/100 = 1 rest 10. Ceea ce dorim este o
secvență contiguă de biți ce reprezintă fracția în loc de valori separate pentru cât şi
rest, aşa că putem scala deîmpărțitul la stânga cu două poziții, ceea ce ne dă:
11000/100 = 110. După aceea deplasăm rezultatul la dreapta cu două poziții şi
obținem 1.10. În concluzie, rezultatul împărțirii lui (+.110 x 2 5 ) la (+.100 x 2 4 ) este
(+1.10 x 2 1 ). După normalizare, rezultatul final este: (+.110 x 2 1 ).
Studiu de caz: Aritmetica BCD
Aritmetica în calculatoarele de buzunar se face în baza 10, în loc de baza 2. Aceste
calculatoare trebuie să fie mici şi ieftine aşa că numerele se reprezintă în BCD
folosind patru biți pentru fiecare cifră zecimală. Reprezentarea în baza 2 ar necesita
conversii de baze pentru care e nevoie de resurse destul de mari. O unitatea
aritmetică şi logică de 4 biți poate face operațiile aritmetice serial, cifră cu cifră.
Calculatorul HP9100A, care a apărut în anii ’60 efectua operații aritmetice
elementare: adunare, scădere, înmulțire şi împărțire, precum şi rădăcina pătrată, e x,
71

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
ln x şi log x, funcții trigonometrice şi alte funcții, toate folosind aritmetica în baza 10.
Calculatorul putea afişa 10 cifre semnificative dar toate calculele se făcea folosind
12 cifre, ultimele două cifre (cele mai puțin semnificative) fiind folosite pentru
trunchieri şi erori de rotunjire. Cu toate că acest calculator în ziua de astăzi pare o
relicvă, metodele aritmetice sunt încă relevante.
În continuare vom prezenta tehnicile generale pentru efectuarea adunării şi scăderii
în virgulă fixă şi mobilă folosind BCD.
Adunare şi scădere BCD
Să considerăm adunarea numerelor (+255)10 şi (+63)10 reprezentate în BCD.
Fiecare cifră BCD ocupă patru biți şi adunarea se efectuează cifră cu cifră (nu bit cu
bit), de la dreapta la stânga, aşa cum am face în mod obişnuit. Rezultatul (+318)10
este produs tot în format BCD.
Scăderea în BCD se efectuează similar cu modul în care se efectuează scăderea în
complement față de doi (se adună opusul descăzutului) cu excepția faptului că se
foloseşte complement față de 10 în loc de complement față de 2.
La efectuarea operației (255 + (‐63) = 192)10, formăm complementul față de 9 al lui
63 după care adunăm 1 pentru a obține complementul față de 10.
Adunarea se poate acum efectua aşa cum este prezentat în figura de mai jos:
72

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Transportul ce iese de la cea mai semnificativă cifră este eliminat, la fel ca şi la
adunarea în complement față de doi.
Spre deosebire de reprezentarea în complement față de doi nu putem să examinăm
bitul cel mai semnificativ pentru a determina semnul. În complement față de 10,
numărul este pozitiv dacă cifra BCD din stânga (cea mai semnificativă) este între 0 şi
4. Dacă este între 5 şi 9 atunci numărul este negativ. Secvența de biți pentru 4 este
0100 iar pentru 5 este 0101. Ambele secvențe au bitul cel mai semnificativ 0 dar, cu
toate acestea, cifra 4 înseamnă număr pozitiv iar cifra 5 deja înseamnă număr
negativ. Dacă folosim exces 3 pentru a codifica fiecare cifră, atunci bitul din stânga
va indica semnul. În figura de mai jos este prezentată această codificare:
Un sumator complet BCD trebuie să adune două cifre BCD şi un transport şi trebuie
să producă o cifră BCD ca rezultat al adunării şi un transport la ieşire, toate
reprezentate în exces 3. În figura de mai jos este prezentat un astfel de sumator care
foloseşte sumatoare complete în complement față de doi.
73

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Cifrele BCD reprezentate în exces 3 sunt adunate în cele patru sumatoare complete
în complement față de doi din partea superioară. Din moment ce fiecare operand
este reprezentat în exces 3, rezultatul este în exces 6. Pentru a stoca rezultatul în
exces 3, trebuie să scădem 3 din rezultat. Ca o alternativă putem aduna 13 la rezultat
pentru că 16 – 3 = 16 + 13 într‐o reprezentare pe patru biți, eliminând transportul
care iese de la bitul cel mai semnificativ. În figura de mai sus am folosit această
ultimă alternativă, unde 1310 = 11012 este adunat la rezultat. Aceasta funcționează
doar dacă nu avem transport. Când avem transport, atunci trebuie să mai scădem 10
(sau să adunăm 6) din rezultat şi să producem un transport. Aici am adunat 310 =
00112 ceea ce are acelaşi efect cu adunarea (6+13) % 16 = 3.
Pentru a efectua scăderi BCD, putem crea un scăzător în complement față de 10
folosind scăzători compleți în baza 10. Ca o alternativă putem crea complementul
față de 10 negativ al descăzutului şi să aplicăm o operație de adunare BCD. În figura
de mai jos prezentăm calculul (21‐34 = ‐13)10 folosind această ultimă metodă de
scădere pentru numere formate din patru cifre.
Complementul față de 10 negativ al lui 34 este adunat la 21, ceea ce ne dă 9987 în
complement față de 10, ceea ce este (‐13)10 în magnitudine cu semn.
Adunarea şi scăderea BCD a numerelor în virgulă mobilă
Să considerăm o reprezentare în virgulă mobilă în baza 10 cu exponentul
reprezentat pe două cifre în magnitudine cu semn şi mantisa reprezentată pe 8 cifre
în magnitudine cu semn. Un exemplu de ceea ce vede utilizatorul ar putea fi: ‐
.37100000 x 10 ‐12 , care este în forma normalizată.
Un calculator foloseşte intern o reprezentare în complement față de 10 atât pentru
exponent cât şi pentru partea fracționară. Pentru exemplul de mai sus
74

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
reprezentarea în complement față de 10 ar fi: 88 pentru exponent şi 62900000
pentru partea fracționară. Folosind reprezentarea în exces 3 în binar va rezulta
exponentul 1011 1011 şi partea fracționară: 1001 0101 1100 0011 0011 0011 0011
0011. Din moment ce folosim bitul cel mai din stânga pentru semn, exponentul
variază între ‐50 şi 49 iar partea fracționară între ‐.50000000 şi +.49999999.
Dacă încercăm să reprezentăm +.9 în baza 10, atunci suntem din nou în impas
pentru că bitul cel mai din stânga al este folosit pentru semn. Adică, nu putem folosi
1100 ca cifră cea mai semnificativă, deoarece, cu toate că e reprezentarea în exces 3
a lui 9, fracția va apărea ca fiind negativă. Pentru aceasta avem o soluție mai bună:
folosim complementul față de 10 pentru aritmetica în baza 10 la exponent şi folosim
reprezentarea în magnitudine cu semn pentru partea fracționară.
Pentru a concluziona: Folosim reprezentarea în complement față de 10 pentru
exponent deoarece este întreg şi folosim reprezentarea în magnitudine cu semn în
baza 10 pentru partea fracționară. Un bit de semn separat este alocat pentru partea
fracționară, aşa că fiecare cifră poate lua oricare din cele 10 valori de la 0 la 9 (cu
excepția primei cifre, care nu poate fi zero) aşa că acum putem reprezenta +.9.
Exponentul trebuie reprezentat în exces 50 pentru a putea face mai uşor
comparațiile. Exemplul precedent va arăta intern astfel:
Bitul de semn: 1
Exponentul: 0110 1011
Fracția: 0110 1010 0100 0011 0011 0011 0011 0011 0011
Este reprezentat în exces 3, cu două cifre pentru exponent în exces 50.
Pentru a aduna două numere în aceasta reprezentare, trebuie să parcurgem aceeaşi
paşi ca şi pentru reprezentarea în baza 2 a numerelor reprezentate în virgulă
mobilă. Vom ajusta exponentul şi partea fracționară a operandului mai mic până
când exponenții ambilor operanzi sunt egali. Dacă diferența dintre exponenți este
atât de mare încât partea fracționară a operandului mai mic este deplasat complet la
dreapta atunci operandul mai mic este tratat ca zero. După ajustarea părții
fracționare mai mici, convertim unul sau ambii operanzi din reprezentarea în
magnitudine cu semn în complement față de 10 în funcție de operația pe care o
facem: adunare sau scădere şi în funcție de semnul operanzilor.
Concluzie
Aritmetica în calculatoare poate fi efectuată exact la fel cum procedăm atunci când
efectuăm adunare zecimală cu creionul pe hârtie, luând în calcul baza de numerație.
Reprezentarea în complement față de 2 sau complement față de 10 se foloseşte de
regulă pentru întregi, iar reprezentarea în magnitudine cu semn se foloseşte de
regulă pentru fracții datorită dificultății manipulării fracțiilor pozitive şi negative
într‐o manieră uniformă.
Se poate îmbunătăți performanța operațiilor aritmetice prin folosirea unor algoritmi
specializați.
75

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
5. Arhitectura setului de instrucţiuni
Introducere
În continuare vom trece în revistă un subiect important pentru arhitectura
calculatoarelor şi anume: limbajul înțeles de hardware‐ul sistemului de calcul numit
limbaj maşină. Despre limbajul maşină se discută de regulă în termenii limbajului
de asamblare asociat, care este echivalent din punct de vedere funcțional limbajului
maşină corespunzător, cu excepția faptului că limbajul de asamblare foloseşte nume
intuitive cum ar fi: Move, Add, Jump în locul cuvintelor binare ale limbajului maşină.
(Programatorii înțeleg mult mai simplu instrucțiuni de forma "Add r0, r1, r2" decât
secvențe de genul 0110101110101101.)
Pentru a descrie limbajul de asamblare şi programare în limbaj de asamblare, vom
folosi ca model arhitectural maşina ARC, care este o simplificare a arhitecturii
SPARC de la SUN.
Componentele hardware ale arhitecturii setului de instrucţiuni (ASI)
ASI a unui sistem de calcul prezintă programatorului în limbaj de asamblare o
viziune asupra sistemului de calcul care include tot hardware‐ul accesibil
programatorului şi instrucțiunile care manipulează datele în hardware. În
continuare vom prezenta componentele hardware aşa cum sunt văzute de
programatorul în limbaj de asamblare.
Modelul „Magistrală sistem”
Scopul magistralei este de a reduce numărul de interconexiuni dintre procesor şi
subsistemele sale. În loc să aibă căi de comunicație separate între memorie şi
dispozitivele de I/E, procesorul este interconectat cu memoria şi fiecare dispozitiv
de I/E printr‐o magistrală sistem partajată. Într‐un sistem mai complex ar putea
exista magistrale separate între procesor (CPU) şi memorie şi între procesor şi
dispozitivele de I/E.
Nu toate componentele sunt conectate la magistrala sistem în acelaşi mod.
Procesorul generează adrese care sunt plasate pe magistrala de adrese iar memoria
recepționează adresele de la magistrala de adrese. Memoria nu generează niciodată
76

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
adrese, iar procesorul nu recepționează niciodată adrese aşa că săgețile
corespunzătoare din figura de mai sus sunt unidirecționale.
Scenariul obişnuit este: utilizatorul scrie programul într‐un limbaj de programare de
nivel înalt, compilatorul îl traduce în limbaj de asamblare. Asamblorul traduce
programul din limbaj de asamblare în program în cod maşină, program care este
stocat pe disc. Înainte de execuție, programul în cod maşină este încărcat de pe disc
în memoria principală de către sistemul de operare.
În timpul execuției fiecare instrucțiune este adusă pe rând în unitatea aritmetică şi
logică din memorie, împreună cu datele necesare pentru execuția ei. Datele de ieşire
ale programului sunt plasate pe un dispozitiv cum ar fi un display video sau pe disc.
Toate aceste operații sunt orchestrate de unitatea de control. Comunicația între cele
trei componente (CPU, memorie, I/E) se realizează prin magistrale.
Instrucțiunile se execută în unitatea aritmetică şi logică (UAL), cu toate că
instrucțiunile şi datele sunt stocate inițial în memorie. Aceasta înseamnă că
instrucțiunile şi datele trebuie încărcate din memorie în registre UAL iar rezultatul
trebuie stocat înapoi în memorie.
Memoria
Este formată dintr‐o colecție de registre numerotate consecutiv (adresați), fiecare
registru poate stoca în mod normal un octet. Fiecare registru are o adresă numită
locație de memorie. Termenii bit respectiv byte (octet) au acelaşi înțeles pentru
orice arhitectură în schimb termenul cuvânt depinde de procesor. Dimensiuni tipice
pentru un cuvânt sunt: 16, 32, 64 sau 128 biți, cel mai des în ziua de astăzi, în
sistemele de calcul actuale folosindu‐se cuvinte de 32 de biți.
Într‐un sistem de calcul în care adresarea se face la nivel de octet, cel mai mic obiect
ce poate fi referit în memorie este octetul, cu toate că există instrucțiuni care citesc
şi scriu cuvinte formate din mai mulți octeți. Cuvintele formate din mai mulți octeți
sunt stocate ca secvențe de octeți şi sunt adresate prin octetul cuvântului care are
77

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
adresa cea mai mică. Majoritatea sistemelor actuale au instrucțiuni care pot accesa
octeți, jumătăți de cuvânt, cuvinte şi cuvânt dublu.
Atunci când se folosesc cuvinte formate din mai mulți octeți, există două variante
pentru stocare octeților în memorie: cel mai semnificativ octet la adresa cea mai
mică, adică big­endian, sau cel mai puțin semnificativ octet la adresa cea mai mică,
adică little­endian.
Exemple pentru cele două variante sunt date în figura de mai jos în care sunt
prezentate cuvinte formate din patru octeți:
Octeții într‐un cuvânt format din mai mulți octeți sunt stocați la adrese consecutive
aşa cum se vede în figura de mai sus. Dacă avem de a face cu memorie adresabilă la
nivel de octet fiecare octet poate fi adresat prin adresa lui specifică. Cuvântul format
din patru octeți se accesează prin referențierea adresei octetului cu cea mai mică
adresă (x în figură). Aceasta este valabil indiferent dacă varianta de stocare este
little­endian sau big­endian.
În continuare vom folosi memoria prezentată în figura de mai jos.
Această memorie are un spațiu de adresare de 32 de biți, ceea ce înseamnă că un
program poate accesa un octet din memorie oriunde în intervalul 0..2 32 ‐1. Spațiul de
78

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
adresare este împărțit pentru arhitectura noastră în regiuni distincte care sunt
folosite pentru sistemul de operare, pentru intrare‐ieşire, programul utilizator, stiva
sistemului, care formează harta memoriei aşa cum este prezentată în figură. Harta
memoriei diferă de la o implementare la alta, acesta fiind unul din motivele pentru
care un program compilat pentru acelaşi tip de procesor s‐ar putea să nu fie
compatibil de la un sistem la altul.
Primii 2048 de octeți sunt rezervați pentru sistemul de operare. Spațiu utilizator
este locul în care se încarcă programele şi poate creşte de la poziția 2048 până
întâlneşte stiva sistem. Stiva sistem începe la locația 2 31‐4 şi poate creşte înspre
adrese mai mici. Spațiul de adresare de la 2 31 la 2 32 ‐1 este rezervat pentru
dispozitivele de intrare‐ieşire. Din moment ce dispozitivele de intrare‐ieşire sunt
tratate ca locații de memorie, comenzile obişnuite de citire şi scriere în memorie pot
fi folosite pentru citirea şi scrierea dispozitivelor.
Trebuie făcută distincția între adresă şi date. O adresă are 32 de biți iar un cuvânt
este tot 32 de biți dar nu sunt acelaşi lucru. O adresă este un pointer la o locație de
memorie care conține date. O adresă de memorie de n biți poate specifica 2 n
elemente aşa că dimensiunea memoriei ce poate fi accesată depinde de numărul de
biți rezervați pentru adrese de memorie ce pot fi plasate de procesor pe magistrala
de adrese.
Microprocesorul
Microprocesorul este format dintr‐o secțiune de date care conține registre şi
Unitatea Aritmetică şi Logică (UAL) şi o secțiune de control care interpretează
instrucțiunile şi efectuează transferul între registre aşa cum este prezentat în figura
de mai jos.
Secțiunea de date se mai numeşte Datapath.
Unitatea de control este responsabilă de executarea instrucțiunilor programului, ce
sunt stocate în memorie principală. (Vom considera că instrucțiunile sunt
interpretate una câte una). Există două registre care formează interfața între
unitatea de control şi unitatea de date, numite Program Counter (PC – contor
program) şi Instruction Register (IR – registru instrucțiune). PC conține adresa
79

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
instrucțiunii care se execută. Instrucțiunea indicată de PC este extrasă din memorie
şi este stocată în IR unde este interpretată. Paşii pe care îi efectuează unitatea de
control la execuția unui program sunt:
1. Extrage din memorie următoare instrucțiune ce se va executa
2. Decodifică codul operației
3. Citeşte operandul (operanzii) din memorie, dacă există
4. Execută instrucțiunea şi stochează rezultatul
5. Salt la pasul 1.
Acesta este ciclul extragere­execuţie.
Unitatea de control este responsabilă pentru coordonarea diferitelor unități în
execuția unui program. Aceasta ia decizii în legătură cu modul în care se comportă
restul sistemului.
Datapath‐ul este format dintr‐o colecție de registre numite register file, şi din UAL
aşa cum se vede în figura de mai jos:
Register file poate privit ca o memorie mică şi rapidă separată de memoria
sistemului, care este folosită pentru stocarea temporară în timpul operațiilor
aritmetice. Dimensiunea acestuia este de obicei cuprinsă între câteva registre până
la câteva mii. Fiecare registru are alocată o adresă la fel ca şi memoria începând de
la zero. Aceste „adrese” de registre sunt mult mai mici decât adresele de memorie.
Pentru un register file ce conține 32 de registre dimensiunea adresei este de 5 biți.
Diferența majora dintre register file şi memorie este că e conținut în microprocesor
şi de aceea este mult mai rapid. Din acest motiv programele ce folosesc intens
registre sunt mult mai rapide decât programele ce folosesc intens memoria, chiar
dacă e nevoie de mai multe operații cu registre decât cu memorie pentru a efectua o
operație.
80

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Setul de instrucţiuni este o colecție de instrucțiuni pe care procesorul poate să le
execute şi acestea definesc procesorul. Setul de instrucțiuni este diferit de la un
procesor la altul. Aceste instrucțiuni diferă prin dimensiunea instrucțiunilor, tipul
operațiilor pe care le permit, tipul operanzilor asupra cărora operează şi tipul
rezultatelor generate. Această compatibilitate la nivel de set de instrucțiuni este în
contrast cu compatibilitatea limbajelor de programare de nivel înalt cum sunt C,
Pascal. Programele scrise în aceste limbaje pot rula aproape nemodificate pe multe
procesoare dacă sunt recompilate pentru procesorul respectiv.
(O excepție la această incompatibilitate la nivel de limbaj maşină este Java bytecode,
care reprezintă un limbaj maşină pentru o maşină virtuală. Aceste programe vor
rula nemodificate pe orice procesor care rulează Maşina Virtuală Java. MVJ este
scrisă în limbajul de asamblare al procesorului țintă. MVJ interceptează bytecodul
Java şi îl execută ca şi cum ar rula pe un hardware Java)
Datorită acestei incompatibilități în setul de instrucțiuni, sistemele de calcul sunt
adesea identificate prin tipul de procesor cu care sunt dotate. Setul de instrucțiuni
determină programele pe care sistemul le poate executa şi are un efect important
asupra performanței. Programele compilate pentru IBM PC (sau compatibil)
folosesc setul de instrucțiuni al unui procesor 80x86, unde x se înlocuieşte cu o cifră
ce corespunde versiunii de procesor: 2, 3, 4, 5 (Pentium). Aceste programe nu vor
rula pe Apple Macintosh sau IBM RS6000 din moment ce sistemele IBM execută
setul de instrucțiuni ale procesorului Motorola PowerPC. Chiar şi un program scris
pentru un procesor nu va rula întotdeauna pe sisteme diferite datorită diferențelor
între sistemele de operare şi convențiilor de intrare‐ieşire.
Software pentru generarea de programe în limbaj maşină sunt de regulă
compilatoarele şi asambloarele.
Un compilator este un program care transformă programul scris într‐un limbaj de
programare de nivel înalt în limbaj maşină. Compilatoarele pentru un limbaj de
programare vor avea partea „din față” (cea care recunoaşte construcțiile din
limbajul de programare de nivel înalt) identică, iar „partea din spate” (cea care
creează codul maşină) diferită pentru fiecare tip de sistem de calcul. Se poate ca
acelaşi program compilat cu compilatoare diferite pentru acelaşi sistem de calcul să
producă cod diferit.
În procesul de compilare al unui program, programul sursă, scris într‐un limbaj de
programare de nivel înalt, este transformat în cod în limbaj de asamblare iar mai
apoi codul în limbaj de asamblare este transformat în cod maşină de către asamblor.
Aceste traduceri au loc în faza de compilare respectiv de asamblare. Programul
obiect care rezultă poate fi link‐editat cu alte programe obiect în faza de link‐
editare. Programul link‐editat, stocat de regulă pe disc, este încărcat în memoria
principală în faza de încărcare a programului şi este executat de către procesor în
faza de execuție (run‐time).
Cu toate că majoritatea programelor se scriu în limbaje de nivel înalt, programatorii
pot scrie programe sau secvențe din unele programe, care trebuie să ruleze foarte
81

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
repede, în asamblare. În plus, s‐ar putea să nu existe compilatoare pentru anumite
procesoare speciale sau compilatoarele să nu poată fi folosite pentru a efectua
anumite operații speciale. În aceste cazuri, programatorul este nevoit să recurgă din
nou la limbajul de asamblare.
Limbajele de programare de nivel înalt ne permit să ignorăm arhitectura sistemului
de calcul țintă. Pe de altă parte, la nivel limbaj maşină, arhitectura este cel mai
important aspect de care trebuie ținut cont.
ARC – „A RISC Computer”
În continuare vom prezenta un model arhitectural bazat pe arhitectura SPARC
(Scalable Processor Architecture) dezvoltată de SUN la mijlocul anilor 60.
Arhitectura SPARC a devenit populară datorită naturii sale „deschise”: definiția
completă a arhitecturii SPARC a fost făcută publică în 1992. Noi, vom prezenta doar
o submulțime a SPARC, pe care o vom numi ARC (A RISC Computer).
Memoria ARC
ARC este o maşină pe 32 de biți cu memoria adresabilă la nivel de octet. Poate
manipula tipuri de date de 32 de biți, dar toate datele sunt stocate în memorie ca
octeți iar adresa unui cuvânt de 32 de biți eset adresa bitului care se află la adresa
cea mai mică. Memoria este împărțită în mai multe zone aşa cum prezentat harta
memoriei într‐o figură precedentă. Zonele memoriei sunt: zona rezervată sistemului
de operare, zona rezervată programelor utilizator, stiva sistem şi zona pentru
operații de intrare‐ieşire.
ARC‐ul are mai multe tipuri de date (octet, jumătate de cuvânt, cuvânt). Fiecare
întreg este stocat în memorie ca patru octeți în format big‐endian, aşa că octetul cel
mai semnificativ este la adresa cea mai mică.
Setul de instrucţiuni ARC
Procesorul ARC are:
• 32 de registre de 32 de biți pentru uz general, precum şi registrele PC şi IR.
• Registrul PSR (Processor Status Register) care conține informații despre
starea procesorului, inclusiv informații despre operațiile aritmetice. „Indicatorii
aritmetici” din PSR se numesc coduri condiționale. Acestea specifică dacă o
anumită operație aritmetică a generat valoarea zero (z), valoare negativă (n),
transport din UAL (c) şi depăşire (v). Bitul v este setat atunci când rezultatul
operației aritmetice este prea mare pentru a putea fi tratat de UAL.
• Toate instrucțiunile au dimensiunea de un cuvânt (32 de biți).
• ARC este o maşină de calcul de tip încărcare‐stocare: singurele operații de
acces la memorie permise sunt cele de încărcare a unei valori din memorie într‐
un registru şi stocarea unei valori dintr‐un registru într‐o locație de memorie.
Toate operațiile aritmetice operează asupra unor valori ce sunt conținute în
82

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
registre iar rezultatul este plasat tot într‐un registru. Arhitectura SPARC are
aproximativ 200 de instrucțiuni. Pentru ARC vom considera doar 15 – cele mai
importante. Acestea sunt prezentate în tabelul de mai jos împreună cu
mnemonicele asociate (numele care reprezintă instrucțiunea).
Mnemonică Înțeles
Memorie ld Încarcă un registru din memorie
st Stochează un registru în memorie
Logic sethi Încarcă cei mai semnificativi 22 de biți ai unui registru
andcc AND logic pe biți
orcc SAU logic pe biți
orncc NOR logic pe biți
srl Deplasare la dreapta (logic)
Aritmetic addcc Adunare
Control call Apel de subrutină
jmpl Salt şi legătură (return din apel de subrutină)
be Ramificare în caz de egalitate
bneg Ramificare dacă e negativ
bcs Ramificare dacă există transport
bvs Ramificare dacă apare depăşire
ba Ramificare întotdeauna
Instrucțiunile ld (load) şi st (store) transferă un cuvânt între memorie şi unul din
registrele ARC. Acestea sunt singurele instrucțiuni care pot accesa memoria în ARC.
Instrucțiunea sethi setează cei mai semnificativi 22 de biți ai unui registru cu o
constantă pe 22 de biți conținută în instrucțiune. Este folosită pentru a construi o
constantă pe 32 de biți într‐un registru, împreună cu o altă instrucțiune care setează
cei 10 biți mai puțin semnificativi ai registrului.
Instrucțiunile andcc, orcc, orncc efectuează operațiile AND, OR, NOR pe biți asupra
operanzilor lor. Unul din cei doi operanzi sursă trebuie să fie într‐un registru.
Rezultatul este stocat într‐un registru. Sufixul cc indică faptul că după terminarea
operației biții „cod condiție” din PSR sunt actualizați pentru a reflecta rezultatul
operației. Bitul z este setat dacă rezultatul este zero, bitul n este setat dacă cel mai
semnificativ bit al rezultatului este 1, iar c şi v sunt setați la zero.
Instrucțiunile call şi jmpl formează o pereche de instrucțiuni folosite la apelul şi
întoarcerea dintr‐o subrutină. Instrucțiunea jmpl este folosită şi pentru a transfera
controlul unei alte părți a programului.
Ultimele cinci instrucțiuni provoacă o ramificare în execuția programului. Aceste
instrucțiuni verifică anumiți biți din PSR şi execută ramificarea în funcție de
valoarea acestora. Aceste instrucțiuni sunt folosite pentru implementarea unor
instrucțiuni din cadrul limbajelor de nivel înalt cum sunt: goto, if‐then‐else, do‐
while.
83

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Formatul instrucţiunilor în limbaj de asamblare ARC
Fiecare limbaj de asamblare are propria sintaxă. Pentru ARC formatul va fi:
Operand Operand
Etichetă Mnemonică sursă destinaţie Comentariu
Avem patru câmpuri: o etichetă opțională, un câmp pentru opcod (codul operației),
unul sau mai multe câmpuri care specifică operanzii sursă şi destinație, un
comentariu (opțional). Limbajul face distincție între literele mari şi mici.
Arhitectura ARC conține 32 de registre etichetate %r0 ‐ %r31, fiecare având 32 de
biți. Există un registru de 32 de biți PSR (Processor State Register) care descrie
starea curentă a procesorului şi un registru de 32 de biți PC (Program Counter), care
ține evidența instrucțiunii care se execută. Figura de mai jos prezintă aceste registre.
Registrele %r14 şi %r15 sunt folosiți ca pointer stivă (%sp) şi registru link.
Operanzii instrucțiunilor în limbaj de asamblare sunt separați prin virgule iar
operandul destinație apare întotdeauna ultimul. Baza implicită pentru operațiile
aritmetice este baza 10. Dacă valorile sunt precedate de 0x sau se termină cu H
atunci se consideră a fi în baza 16. Instrucțiunea:
addcc %r1, 12, %r3
are ca efect adunarea valorii din registrul %r1 cu constanta 12 iar rezultatul este
plasat în registrul %r13.
Formatul instrucţiunilor ARC
Formatul instrucțiunilor defineşte modul în care câmpurile de biți ale
instrucțiunilor sunt create de către asamblor şi cum sunt interpretate de unitatea de
84

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
control a ARC. Arhitectura ARC are doar câteva formate de instrucțiuni şi anume
cinci:
Fiecare instrucțiune are o mnemonică cum ar fi ld şi un opcod. Câmpul de 5 biți rd
identifică registrul țintă sau sursă pentru operație.
Formatul datelor pentru ARC
ARC suportă 12 formate diferite pentru date aşa cum sunt prezentate în figura de
mai jos.
ARC nu face distincție între întregi cu semn sau fără semn. Aceştia sunt stocați şi
manipulați ca întregi în complement față de doi. Ceea ce variază este interpretarea
lor.
Descrierea instrucţiunilor ARC
În continuare referirea conținutului unei locații de memorie (pentru ld sau st) este
indicat prin "ld [x], %r1" ce are ca efect copierea conținutului locației x în registrul
%r1. O referință la adresa unei locații de memorie se specifică direct, fără paranteze
drepte "call sub_r", ceea ce va apela subrutina sub_r. Doar ld şi st pot accesa
memoria, prin urmare sunt singurele instrucțiuni la care se folosesc parantezele
drepte. Când utilizăm registre întotdeauna se accesează conținutul şi niciodată nu se
ia adresa acestora aşa că nu e nevoie să fie pus numele unui registru între paranteze
drepte.
85

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Instrucţiunea: ld
Descriere: încarcă un registru cu o valoare din memoria principală. Adresa de
memorie trebuie să fie la începutul unui cuvânt (să fie divizibilă cu 4). Adresa se
calculează prin adunarea conținutului registrului din câmpul rs1 cu conținutul
registrului din câmpul rs2 sau cu valoarea câmpului simm13.
Exemple: ld [x], %r1
ld [x], %r0, %r1
ld %r0+x, %r1
Înţeles: copiază conținutul locației de memorie x în registrul %r1.
Instrucţiunea: st
Descriere: stochează conținutul unui registru în memorie. Adresa de memorie
trebuie să fie divizibilă cu 4. Adresa se calculează prin adunarea conținutului
registrului din câmpul rs1 cu conținutul registrului din câmpul rs2 sau cu valoarea
câmpului simm13. Câmpul rd este folosit pentru registrul sursă.
Exemple: st %r1, [x]
Înţeles: Copiază conținutul registrului %r1 în locația de memorie x.
Instrucţiunea: sethi
86

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Descriere: setează cei mai semnificativi 22 de biți şi pune pe zero ceilalți 10 (mai
puțin semnificativi). Dacă operandul este zero şi registrul este %r0, atunci
instrucțiunea se comportă ca NOP (no operation) adică nu are loc nici o operație.
Exemple: sethi 0x304F15, %r1
Înţeles: setează cei 22 de biți mai semnificativi la valoarea indicată iar ceilalți 10 la
zero.
Instrucţiunea: andcc
Descriere: ŞI logic pe biți între operanzii sursă iar rezultatul este salvat în
operandul destinație. Codurile de condiție sunt setate conform rezultatului.
Exemple: andcc %r1, %r2, %r3
Înţeles: se efectuează operația ŞI logic între valorile din %r1 şi %r2 iar rezultatul
este salvat în %r3.
Instrucţiunea: orcc
Descriere: SAU logic pe biți între operanzii sursă iar rezultatul este salvat în
operandul destinație. Codurile de condiție sunt setate conform rezultatului.
Exemple: orcc %r1, 1, %r1
Înţeles: setează cel mai semnificativ bit al lui %r1 la 1.
Instrucţiunea: orncc
Descriere: NOR logic pe biți între operanzii sursă iar rezultatul este salvat în
operandul destinație. Codurile de condiție sunt setate conform rezultatului.
Exemple: orncc %r1, %r0, %r1
Înţeles: Complementează %r1.
Instrucţiunea: srl
Descriere: deplasează un registru la dreapta cu 0‐31 biți. Biții din partea dreaptă
vor avea valoarea 0.
Exemple: srl %r1, 3, %r2
Înţeles: deplasează %r1 la dreapta cu trei biți şi stochează rezultatul în %r2.
Instrucţiunea: addcc
Descriere: adună operanzii sursă şi stochează rezultatul în operandul destinație
folosind aritmetica în complement față de 2.
Exemple: addcc %r1, 5, %r1
Înţeles: Adună 5 la %r1.
Instrucţiunea: call
Descriere: apelează o subrutină şi stochează adresa instrucțiunii curente (unde este
stocat apelul) în %r15, ceea ce are ca efect o operație de „apel şi legătură”. În codul
asamblat, câmpul disp30 din formatul de apel va conține deplasamentul pe 30 de
biți din adresa instrucțiunii call.
87

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Exemple: call sub_r
Înţeles: Apelează o subrutină care începe la locația sub_r.
Instrucţiunea: jmpl
Descriere: salt şi link (întoarecere din subrutină). Salt la o nouă adresă şi stocarea
adresei instrucțiunii curente (unde este plasată instrucțiunea jmpl) în registrul
destinație.
Exemple: jmpl %r15 + 4, %r0
Înţeles: Întoarcere din subrutină. Valoarea registrului PC pentru instrucțiunea call a
fost salvat inițial în %r15 aşa că adresa de întoarcere ar trebui calculată din
instrucțiunea care urmează apelului, la %r15+4. Adresa curentă este eliminată în
%r0.
Instrucţiunea: be
Descriere: Dacă codul de condiție z este 1, atunci ramifică la adresa calculată prin
adunarea valorii 4 x disp22 din formatul instrucțiunii de ramificare la adresa
instrucțiunii curente. Dacă codul de condiție z este 0, atunci controlul este transferat
la instrucțiunea următoare.
Exemple: be etichetă
Înţeles: Ramifică la etichetă dacă codul de condiție z este 1.
Instrucţiunea: bneg
Descriere: Dacă codul de condiție n este 1, atunci ramifică execuția la adresa
calculată prin adunarea valorii 4 x disp22 din formatul instrucțiunii de ramificare la
adresa instrucțiunii curente. Dacă codul de condiție n este 0, atunci controlul este
transferat la instrucțiunea următoare.
Exemple: bneg etichetă
Înţeles: Ramifică la etichetă dacă codul de condiție n este 1.
Instrucţiunea: bcs
Descriere: Dacă codul de condiție c este 1, atunci ramifică execuția la adresa
calculată prin adunarea valorii 4 x disp22 din formatul instrucțiunii de ramificare la
adresa instrucțiunii curente. Dacă codul de condiție c este 0, atunci controlul este
transferat la instrucțiunea următoare.
Exemple: bcs etichetă
Înţeles: Ramifică execuția programului la etichetă dacă codul de condiție c este 1.
Instrucţiunea: bvs
Descriere: Dacă codul de condiție v este 1, atunci ramifică execuția la adresa
calculată prin adunarea valorii 4 x disp22 din formatul instrucțiunii de ramificare la
88

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
adresa instrucțiunii curente. Dacă codul de condiție v este 0, atunci controlul este
transferat la instrucțiunea următoare.
Exemple: bvs etichetă
Înţeles: Ramifică execuția programului la etichetă dacă codul de condiție v este 1.
Instrucţiunea: ba
Descriere: Ramifică execuția la adresa calculată prin adunarea valorii 4 x disp22
din formatul instrucțiunii de ramificare la adresa instrucțiunii curente.
Exemple: ba etichetă
Înţeles: Ramifică execuția programului la etichetă indiferent de valoare codurilor de
condiție.
Pseudo­operaţii
Pe lângă instrucțiunile ARC suportate de arhitectură, există şi pseudo‐operații care
nu reprezintă opcoduri. Acestea sunt instrucțiuni pentru asamblor pentru a efectua
unele acțiuni la asamblare. O listă cu pseudo‐operații şi exemple de utilizare a lor
este prezentată în lista de mai jos.
Spre deosebire de opcoduri care sunt specifice sistemului de calcul, tipul şi natura
pseudo‐operațiilor sunt specifice unui anumit asamblor, deoarece acestea sunt
executate de asamblor.
Exemple de programe în limbaj de asamblare
Procesul de scriere a unui program în limbaj de asamblare este similar cu procesul
de scriere a unui program într‐un limbaj de programare de nivel înalt, cu excepția
89

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
faptului că multe detalii ce sunt abstractizate în limbajele de nivel înalt, în limbajele
de asamblare trebuie scrise explicit.
Program: Adunarea a doi întregi (15+9)
Program: Suma unui tablou de întregi
Variaţii în arhitecturile sistemelor de calcul şi în modul de adresare
ARC este un calculator de tip încărcare/salvare. Programele scrise pentru astfel de
sisteme se execută de regulă mai repede, datorită reducerii traficului dintre
procesor şi memorie prin încărcarea operanzilor în procesor o singură dată şi prin
90

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
stocarea rezultatelor doar când calculul este încheiat. Mărirea dimensiunii memoriei
programului este un preț care merită plătit.
Dacă ARC‐ul poate face operații aritmetice şi logice doar cu operanzi care se află în
registre, trebuie ştiut faptul că unele sisteme de calcul aveau instrucțiunii aritmetice
care efectuau operațiile aritmetice folosind trei, două sau o adresă de memorie.
Să considerăm modul în care este evaluată expresia A = B*C + D de fiecare din cele
trei tipuri de instrucțiuni. În exemplele de mai jos atunci când ne referim la variabila
„A” va însemna operandul a cărui adresă este „A”. Pentru a efectua statisticile de
performanță pentru fragmentele de cod de mai jos vom face următoarele
presupuneri:
• Adresele şi cuvintele sunt de 16 biți
• Opcodurile sunt de 8 biți
• Operanzii şi opcodurile sunt mutate din şi în memorie câte un cuvânt.
Vom calcula atât dimensiunea programului, în octeți cât şi traficul de memorie
ținând cont de aceste valori.
Traficul de memorie are două componente: codul propriu‐zis, care trebuie extras
din memorie şi încărcat în procesor pentru a fi executat şi valorile – operanzii care
trebuie mutați în procesor pentru a fi efectuate calculele, iar rezultatul trebuie
mutat înapoi în memorie la încheierea calculelor. Astfel putem vedea
compromisurile între dimensiunea programelor şi traficul de memorie oferit de
diferitele clase de instrucțiuni.
Instrucţiuni cu trei adrese
Expresia A = B*C + D poate fi codificată astfel:
mult B, C, A
add D, A, A
ceea ce înmulțeşte B cu C şi salvează rezultatul în A (operațiile mult şi add sunt
generice – ele nu sunt instrucțiuni ARC) după care se adună D la A şi se stochează
rezultatul la adresa A. Dimensiunea programului este 2 x (1+2+2+2) = 14 octeți iar
traficul de memorie este 2 x (7 + (2 + 2 +2)) = 26 octeți (7 octeți pentru încărcarea
instrucțiunii şi 6 octeți pentru traficul de date).
Instrucţiuni cu două adrese
Expresia de mai sus poate fi codificată astfel:
load B, A
mult C, A
add D, A
Dimensiunea programului este acum 3 x (1 + 2 + 2) = 15 octeți. Traficul de memorie
este (5 + 4) + (5 + 6) + (5 + 6) = 31 octeți. La fiecare instrucțiune sunt 5 octeți pentru
91

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
încărcarea instrucțiunii. La prima instrucțiune mai sunt 4 octeți pentru variabile, iar
la ultimele două instrucțiuni sunt câte 6 octeți (cu 2 mai mult decât la prima) pentru
că ambii operanzi trebuie încărcați în CPU. Salvarea rezultatului din CPU în memorie
se face la fiecare din cele trei instrucțiuni ceea ce necesită 2 octeți.
Instrucţiuni cu o adresă sau instrucţiuni acumulator
O instrucțiuni cu o adresă foloseşte un singur registru al procesorului, numit
acumulator. Acumulatorul conține un operand aritmetic şi serveşte şi ca țintă
pentru rezultatul unei operații aritmetice. Acest format nu este obişnuit în ziua de
astăzi dar era folosit frecvent mai demult când procesoarele aveau registre puține şi
erau folosite pentru mai multe scopuri. Aceste registre au rolul de a stoca temporar
unul din operanzi şi rezultatul. Expresia de mai sus se poare exprima astfel:
load B
mult C
add D
store A
Fiecare instrucțiune are 1 + 2 = 3 octeți aşa că dimensiunea programului este 4 x 3 =
12 octeți. Traficul de memorie pentru fiecare instrucțiune este 3 + 2 = 5 octeți aşa că
traficul total de memorie este 4 x 5 = 20 de octeți.
Registre speciale
Pe lângă registrele generale, majoritatea arhitecturilor moderne includ şi alte
registre dedicate unor scopuri speciale. De exemplu:
• Registre pentru index de memorie: registrele SI (Source Index) şi DI
(Destination Index) de la Inter 80x86. Acestea sunt folosite pentru a indica
începutul sau sfârşitul unui tablou din memorie.
• Registre pentru virgulă mobilă: multe procesoare au registre speciale şi
instrucțiuni care se ocupă de numerele reprezentate în virgulă mobilă.
• Registre pentru tratarea timpului şi sincronizarea operațiilor.
• Registre pentru suportul sistemelor de operare.
• Registre care pot fi accesate doar prin „instrucțiuni privilegiate”.
Accesarea datelor în memorie – moduri de adresare
Până acum am văzut patru moduri de calculare a adresei unei valori din memorie:
1. o valoarea constantă, cunoscută la asamblare,
2. conținutul unui registru,
3. suma a două registre,
4. suma dintre un registru şi o constantă.
Tabelul de mai jos dă nume acestor moduri de adresare şi prezintă câteva moduri
suplimentare:
92

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Sintaxa din tabel diferă de cea a maşinii ARC. Notația M[x] presupune că memoria
este un tablou, M, a cărui index este dat de calculul adresei dintre parantezele
drepte. Fiecare mod de adresare are propria utilizare:
• Modul de adresare „Imediat” permite referirea unei constante care este
cunoscută la asamblare.
• Modul de adresare „Direct” este folosit pentru a accesa date a căror adresă
este cunoscută la asamblare.
• Modul de adresare „Indirect” este folosit pentru a accesa o variabilă pointer a
cărei adresă este cunoscută la compilare. Aceste mod nu este foarte folosit
întrucât instrucțiunea este prea complicată.
• Modul de adresare „Register indirect” este folosit atunci când adresa
operandului nu este cunoscută decât la execuție.
Link­editarea subrutinelor şi stivă
O subrutină, numită şi funcție sau procedură, este o secvență de instrucțiuni care
este invocată ca şi cum ar fi o singură instrucțiuni văzută de la un nivel superior.
Atunci când un program apelează o subrutină, controlul execuției este transferat de
la program la subrutină, care execută o secvență de instrucțiuni după care se
întoarce la instrucțiunea din program imediat următoare instrucțiunii de apel.
Există mai multe modalități de a transmite argumente la rutina apelată şi din rutina
apelată, modalități care se numesc convenţii de apel. Procesul de transmitere a
argumentelor între rutine se numeşte link‐editarea subrutinelor.
O convenție de apel este plasarea argumentelor în registre. Codul de mai jos încarcă
două argumente în registrele %r1 şi %r2, apelează subrutina add_1 şi salvează
rezultatul în registrul %r3 înainte de a se întoarce cu jmpl.
93

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Această metodă este rapidă şi simplă dar nu va funcționa dacă numărul de
argumente transmise între rutine depăşeşte numărul de registre libere sau dacă
apelurile de subrutine sunt imbricate (încuibate) pe mai multe niveluri.
O a doua convenție de apel este crearea de zone pentru legătura datelor. Adresa
zonei de legătură a datelor este transmisă într‐un registru predefinit rutinei apelate.
Codul de mai jos foloseşte această convenție:
Psedu‐operația .dwb din rutina apelantă stabileşte zona pentru legătura datelor care
are dimensiunea de 3 cuvinte la adresa x, x+4 şi x+8. Rutina apelantă încarcă cele
două argumente la x şi x+4, apelează subrutina add_2 din memorie de la adresa x+8
şi ia rezultatul transmis din add_2 de la locația de memorie x+8. Adresa zonei pentru
legătura datelor, x, este transmisă rutinei add_2 în registrul %r5.
Instrucțiunea sethi trebuie să aibă ca operand sursă o constantă astfel că asamblorul
recunoaşte construcția sethi şi îl înlocuieşte pe x cu adresa lui. Instrucțiunea srl ce
urmează mută adresa lui x în cei mai puțin semnificativi 22 de biți ai lui %r5, din
moment ce sethi plasează operandul în cei 22 de biți din stânga ai registrului țintă. O
alternativă pentru încărcarea adresei lui x în %r5 ar fi să folosim o locație de stocare
pentru adresa lui x şi să folosim instrucțiunea ld pentru a încărca adresa în %r5.
Subrutina add_2 citeşte cei doi operanzi din zona pentru legătura datelor de la
locațiile %r5 şi %r5 + 4, şi plasează rezultatul în zona pentru legătura datelor la
locația %r5 + 8 înainte de a se termina. Folosind zona pentru legătura datelor,
putem transmite şi întoarce din subrutine blocuri de orice dimensiune fără a copia
94

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
mai mult de un registru. Recursivitatea poate complica lucrurile pentru că o rutină
care se auto‐apelează va avea nevoie de mai multe zone pentru legătura datelor.
Zonele pentru legătura datelor au avantajul că dimensiunea lor poate fi nelimitată,
dar au şi dezavantajul că dimensiunea acestei zone trebuie să fie cunoscută în faza
de asamblare.
O a treia convenție de apel este folosirea stivei. Ideea este că rutina apelantă pune
toate argumentele (sau pointeri la argumente, dacă obiectele de date sunt mari) pe o
stivă de tip ultimul intrat‐primul ieşit. Rutina apelată scoate din stivă argumentele
transmise şi pune în stivă valorile pe care le întoarce. Rutina apelantă scoate valorile
întoarse din stivă şi îşi continuă execuția. Un registru al procesorului numit stack
pointer (pointer de stivă), conține adresa vârfului stivei. Multe sisteme de calcul au
instrucțiuni push şi pop care decrementează şi incrementează automat pointerul de
stivă pe măsură ce obiectele sunt plasate în stivă respectiv sunt scoase din stivă.
Un avantaj al folosirii stivei este că aceasta poate creşte şi descreşte după nevoi,
ceea ce duce la posibilitatea imbricării nelimitate a apelurilor de subrutine fără a fi
nevoie să se declare dimensiunea stivei la asamblare. Mai jos dăm un exemplu de
utilizare a stivei:
Registrul %r14 are rolul de pointer de stivă (%sp) care este inițializat de sistemul
de operare înainte de execuția rutinei apelante. Rutina apelantă plasează
argumentele (%r1 şi %r2) pe stivă decrementând pointerul de stivă (se mută %sp la
următorul cuvânt liber deasupra stivei) şi stocând fiecare argument pe noul vârf al
stivei. Subrutina add_3 este apelată, ceea ce va determina scoaterea argumentelor ei
din stivă, efectuarea operației de adunare, şi stocarea valorii calculate în vârful stivei
înainte de întoarcerea în rutina apelantă. Rutina apelantă scoate argumentul din
vârful stivei şi îşi continuă execuția.
Pentru fiecare convenție de apel, este folosită instrucțiunea call, care salvează PC‐ul
(Program Counter) curent în %r15. Când o subrutină se termină, trebuie să întoarcă
controlul la instrucțiunea care urmează apelului, instrucțiune care este la un cuvânt
(patru octeți) distanță de contorul program (PC) salvat. Astfel, instrucțiunea „jmpl
%r15 + 4, %r0” termină apelul. Dacă rutina apelată, apelează la rândul ei o altă
95

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
rutină, atunci valoarea lui PC salvată inițial în %r15 va fi suprascrisă aşa că
întoarcerea la rutina inițială nu va mai fi posibilă prin intermediul lui %r15. Pentru
a permite apeluri imbricate, valoarea curentă a registrului %r15 (care se numeşte
link register) trebuie salvată pe stivă, împreună cu orice alt registru care trebuie
restaurat după terminarea apelului.
Dacă se foloseşte o convenție de apel bazată pe registre, atunci link register trebuie
salvat în unul din registrele nefolosite înainte de apelul unei subrutine. Dacă este
folosită o zonă pentru legătura de date, atunci ar trebui rezervat spațiu pentru
register link. Dacă se foloseşte o schemă bazată pe stivă, atunci register link trebuie
salvat pe stivă. Pentru fiecare convenție de apel, register link şi variabilele locale din
rutina apelată trebuie să fie salvate înainte de a se face un alt apel, altfel, un apel
imbricat la aceeaşi rutină va determina suprascrierea variabilelor locale.
Cea mai folosită convenție de apel este cea bazată pe stivă. Când se apelează mai
multe rutine imbricate se creează un stack frame care conține argumentele
transmise rutinei apelate, adresa de întoarcere pentru rutina apelantă şi orice
variabile locale. În exemplul de mai jos dăm un exemplu de program scris într‐un
limbaj de programare de nivel înalt care conține apeluri imbricate:
Operațiile efectuate de program nu sunt importante, nici faptul că am folosit
limbajul C, ceea este important este modul în care sunt implementate apelurile de
subrutine.
Comportamentul stivei pentru acest program este prezentat în figura de mai jos:
96

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Programul principal apelează func_1 cu argumentele 1 şi 2, iar mai apoi apelează
func_2 cu argumentul 10 înainte de a‐şi încheia execuția. Funcția func_1 are două
variabile locale i şi j care sunt folosite pentru a calcula valoarea întoarsă j. Funcția
func_2 are două variabile locale m şi n care sunt folosite pentru a crea argumentele
ce se transmit lui func_1 înainte întoarcerea valorii m.
Pointerul de stivă (%r14 prin convenție la care ne referim prin %sp) este inițializat
înainte de pornirea programului, de obicei de sistemul de operare. Compilatorul
este responsabil pentru implementarea convenției de apel, aşa că va produce cod
pentru încărcarea parametrilor şi întoarcerea adreselor pe stivă, rezervând spațiu
pe stivă pentru variabilele locale, iar mai apoi reversând procesul la întoarcerea din
rutine.
La începutul execuției programului principal, pointerul de stivă indică elementul din
vârful stivei sistem (fig. a). Când funcția main apelează func_1 în linia 03 cu
argumentele 1 şi 2, acestea sunt puse în stivă (fig. b). Controlul este transferat
funcției func_1 printr‐o instrucțiune call (nu este prezentată), şi func_1 salvează pe
stivă adresa de întoarcere în %r15 ca rezultat al instrucțiunii call (fig. c). Pe stivă se
rezervă spațiu pentru variabilele locale i şi j ale lui func_1 (fig. d). În acest moment
avem un stack frame complet pentru funcția func_1, care este format din
argumentele transmise funcției func_1, adresa de întoarecere în rutina principală şi
variabilele locale pentru func_1.
Înainte ca func_1 să predea controlul rutinei apelante, eliberează spațiul din stivă
rezervat pentru variabilele ei locale, preia adresa de întoarcere din stivă, eliberează
97

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
spațiul din stivă rezervat argumentelor pe care le‐a primit, şi pune în stivă valoarea
de return (fig.. e). Controlul este întors la rutina apelantă prin instrucțiunea jmpl, şi
rutina apelantă este responsabilă pentru luarea valorii întoarse din stivă şi
decrementarea pointerului de stivă la poziția la care a fost înainte de apel (fig. f).
Rutina func_2 este mai apoi executată, şi procesul de construire a stack‐frame‐ului
reîncepe (fig. g). Din moment ce func_2 apelează func_1 înainte de a se termina, vor
fi stack‐frame atât pentru func_2 cât şi pentru func_1 în acelaşi timp (fig. h). În final
pointerul de stivă va fi la poziția inițială (fig. i‐k).
Intrare­ieşire în limbaj de asamblare
Vom trece în revistă modul în care un program în limbaj de asamblare poate
comunica cu exteriorul (activitățile de intrare‐ieşire). O modalitatea de tratare a
comunicației cu dispozitivele de intrare‐ieşire este folosirea unor instrucțiuni
speciale, şi cu o magistrală de intrare‐ieşire specială rezervată pentru acest scop. O
metodă alternativă de interacțiune cu dispozitivele de intrare‐ieşire este prin
folosirea memoriei asociată I/E, în care dispozitivele ocupă secțiuni din spațiul de
adresare unde nu avem memorie obişnuită. Dispozitivele sunt accesate ca şi cum ar
fi locații de memorie, aşa că nu e nevoie de tratarea dispozitivelor de intrare‐ieşire
cu instrucțiuni noi.
Ca un exemplu de memorie asociată I/E, să considerăm harta memoriei pentru ARC
din figura de mai jos:
Aici vedem două regiuni noi de memorie, pentru două module video şi pentru un
dispozitiv touchscreen. Un touchscreen poate fi de două tipuri: fotonic şi electric. O
ilustrare a versiunii fotonice este prezentată în figura de mai jos:
98

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
O matrice de raze acoperă ecranul atât pe verticală cât şi pe orizontală. Dacă raza
este întreruptă (prin atingere cu degetul) atunci poziția este determinată de razele
întrerupte.
Memoria reală ocupă spațiul de adresare cuprins între 2 22 şi 2 23‐1. (2 23‐4 este adresa
octetului din stânga a ultimului cuvânt în format big‐endian). Restul spațiului de
adresare este ocupat de alte componente. Spațiu de adresare cuprins între 0 şi 2 16‐1
conține programele programul inclus de pornire a sistemului şi rutinele grafice
elementare. Spațiul de adresare cuprins între 2 16 şi 2 19 ‐1 este folosit pentru două
module de memorie video.
Spațiul de adresare cuprins între 2 23 şi 2 24 ‐1 este folosit pentru dispozitivele de
intrare‐ieşire. Pentru acest sistem, coordonatele X şi Y care marchează poziția la
care un utilizator a făcut o selecție sunt actualizate automat în registre şi sunt
plasate în memorie. Registrele sunt accesate prin citirea din memorie a locațiilor la
care sunt localizate aceste registre. Locația „Screen flash” determină ecranul să
pâlpâie de fiecare dată când se scrie ceva.
Să presupunem că vrem să scriem un program care determină pâlpâirea ecranului
de fiecare dată când utilizatorul schimbă poziția. Schema logică de mai jos ilustrează
modul în care se poate face aceasta:
99

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Acesta este un exemplu de metodă programată de accesare a unui dispozitiv de
intrare‐ieşire.
Studiu de caz – ASI pentru Maşina Virtuală Java
Java este un limbaj de programare de nivel înalt dezvoltat de Sun Microsystems. Un
aspect esențial al Java este că codul binar Java este independent de platformă, ceea
ce înseamnă că acelaşi cod compilat va rula fără modificări pe orice sistem care
suportă Maşina Virtuală Java (MVJ). MVJ este modul în care Java realizează
independența de platformă: o specificare standard a MVJ este implementată cu
mulțimea de instrucțiuni native ale sistemului pe care rulează iar codul compilat
Java poate rula în orice mediu MVJ.
Programele scrise în limbaje cum sunt C, C++ sunt compilate direct în cod nativ ale
arhitecturii țintă şi acestea nu sunt portabile pe platforme diferite fără recompilarea
codului sursă. Limbajele interpretate, cum sunt Perl, Tcl, AppleScript sunt
independente de platformă dar se execută mult mai încet (de 100‐200 de ori mai
încet) decât un limbaj compilat. Programele Java sunt compilate într‐o formă
intermediară numită bytecode, care se execută mult mai încet decât un program
compilat în limbaj nativ dar, chiar şi cu acest inconvenient, faptul că este
independent de platformă îl plasează înaintea altor limbaje pentru multe tipuri de
aplicații.
În figura de mai jos dăm programul Java care adună numerele 15 şi 9 şi bytecode‐ul
în care a fost compilat. Bytecode‐ul este numit şi fişier class Java.
100

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
O modalitatea de îmbunătățire a vitezei de rulare a programelor Java este
reprezentat de compilatoarele „Just in time” (JIT). Acestea, în loc să interpreteze
bytecodul instrucțiune cu instrucțiune, profită de faptul că majoritatea timpului de
execuție a programelor este alocat unor bucle şi altor rutine iterative. De fiecare
când „Jitter”‐ul întâlneşte o linie de cod pentru prima dată, o compilează în cod nativ
şi o stochează în memorie pentru o utilizare ulterioară. La următoarele execuții ale
acelei instrucțiuni nu mai trebuie realizată compilarea din bytecod în cod nativ.
Concluzie
Am prezentat arhitectura setului de instrucțiuni pentru un sistemul ARC şi am
trecut în revistă unele proprietăți generale ale ASI. În proiectarea unui set de
instrucțiuni, trebuie păstrat un echilibru între performanța sistemului şi
caracteristicile tehnologiei în care este implementat procesorul. Interacțiunea între
procesor şi memorie este un punct important.
Când se face un acces la memorie, modul în care este calculată adresa este numit
modul de adresare a memoriei.
Am trecut în revistă mai multe componente ale sistemului de calcul care joacă un rol
important în execuția programelor. Am văzut că programele sunt secvențe de
instrucțiuni care fac parte din setul de instrucțiuni al procesorului.
101

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
6. Limbaje şi maşină
Introducere
În continuarea vom trece în revistă procesul de asamblare, link‐editare şi încărcare
a unui program. Vom prezenta legătura dintre limbajele de programare şi sistemul
de calcul.
Prima dată vom discuta despre compilare, procesul de traducere a programului
scris într‐un limbaj de programare de nivel înalt într‐un program, echivalent
funcțional, scris în limbaj de asamblare. După aceasta, vom discuta despre procesul
de asamblare adică, traducerea programului din asamblare într‐un program
echivalent funcțional în limbaj maşină. Vom prezenta link­editarea, procesul de
legare împreună a modulelor asamblate separat într‐un singur program şi
încărcarea, procesul de mutare a programului în memorie şi pregătirea lui pentru
execuție. Vom prezenta folosirea macro‐urilor în limbaj de asamblare, care pot fi
privite ca proceduri în limbaj de asamblare, cu excepția faptului că acestea sunt
plasate inline, în programul în limbaj de asamblare în fiecare loc în care sunt
apelate.
Procesul de compilare
Procesul de transformare a unui program din limbaj de asamblare în limbaj maşină
este foarte simplu pentru că există o corespondență unu‐la‐una între instrucțiunile
din limbaj de asamblare şi instrucțiunile binare din codul maşină. Limbajele de
programare de nivel înalt reprezintă o problemă mult mai complexă.
Paşii compilării
Să considerăm o instrucțiune simplă de atribuire:
A = B + 4;
Compilatorul trebuie să execute o serie de sarcini destul de complexe pentru a
converti această instrucțiune în una sau mai multe instrucțiuni în asamblare:
• Reducerea textului programului la simbolurile elementare ale limbajului, de
exemplu în identificatori cum sunt A şi B, notații cum ar fi valoare constantă 4 şi
delimitatori de program cum ar fi + şi =. Această parte a compilării se numeşte
analiză lexicală.
• Parsing‐ul (Analizarea/Separarea intrării în componente mai uşor de
procesat) simbolurilor pentru a recunoaşte structura programului. În
instrucțiunea de mai sus, parser‐ul trebuie să recunoască instrucțiunea ca fiind o
instrucțiune de atribuire de forma: Identificator „=” Expresie, unde Expresie
poate fi separată mai departe în forma: Identificator „+” Constantă. Această fază
de separare se mai numeşte analiză sintactică.
102

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
• Analiza numelor: asocierea numelor A şi B cu anumite variabile din program
şi asocierea lor mai departe cu locații de memorie particulare unde se vor localiza
variabilele la execuție.
• Analiza tipurilor: determinarea tipurilor tuturor unităților de date. În
exemplul de mai sus, variabilele A şi B şi constanta 4 vor fi recunoscute ca fiind
de tip int în unele limbaje. Analiza numelor şi a tipurilor se mai numeşte analiză
semantică: determinarea înțelesului componentelor program.
• Maparea de acțiune şi generarea de cod: asocierea instrucțiunilor
programului cu secvențele corespunzătoare din limbaj de asamblare. În
instrucțiunea de mai sus secvențele în limbaj de asamblare pot fi:
! Instructiunea de atribuire
ld [B], %r0, %r1 ! variabila B este incarcata in registru
add %r1, 4, %r2 ! calculeaza valoare expresiei
st %r2, %r0, [A] ! efectueaza atribuirea
• Există paşi suplimentari pe care compilatorul trebuie să‐i efectueze: alocarea
de variabile registrelor, urmărirea utilizării registrelor şi optimizarea
programului.
Specificaţiile asocierilor compilatorului
Atunci când se creează un compilator, trebuie incluse în el informații despre
arhitectura setului de instrucțiuni pentru care este creat. (ASI‐ul pe care se execută
compilatorul nu trebuie să fie identic cu ASI‐ul pentru care generează cod, proces
numit cross‐compilare). Această includere se mai numeşte specificare de asociere
pentru compilator. De exemplu, cel care scrie compilatorul trebuie să decidă cum să
asocieze variabilele şi constantele de tipuri diferite în resursele sistemului de calcul.
Aceasta ar putea fi o funcție atât a sistemului cât de calcul cât şi a limbajului de
programare de nivel înalt. În limbajul C, întregii (int) pot fi de 16 sau 32 de biți pe
când în Java întotdeauna tipul int are 32 de biți.
Cel care scrie compilatorul trebuie să țină cont de particularitățile şi limitările
sistemului de calcul atunci când asociază construcțiile din limbajul de programare
de nivel înalt la instrucțiuni sau secvențe de instrucțiuni în limbaj de asamblare. De
exemplu, setul de instrucțiuni ARC necesită ca toți operanzii aritmetici să fie
constante imediate sau variabile registru. De aceea, compilatorul trebuie să
genereze cod pentru încărcarea tuturor variabilelor în registre înainte de a se putea
orice instrucțiune aritmetică. Acesta este motivul pentru instrucțiunea:
ld [B], %r1
din exemplul de mai sus.
Noi vom prezenta asocierea construcțiilor din limbajele de nivel înalt în echivalentul
lor în limbaj de asamblare, ignorând detaliile ce țin de analiza sintactică şi
semantică.
103

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Modul în care compilatorul asociază cele trei clase de instrucţiuni în cod
în asamblare
Vom prezenta în detaliu asocierea celor trei clase de instrucțiuni – mişcarea datelor,
aritmetice şi controlul fluxului – din limbajele de programare de nivel înalt în limbaj
de asamblare. În discuția şi exemplele ce urmează vom folosi limbajul C. Cu toate că
limbajul este un limbaj de programare de nivel înalt, sintaxa şi semantica lui este
destul de aproape de conceptele din limbaj de asamblare.
În exemplele de până acum s‐a presupus că variabilele pot fi accesate direct prin
numele lor, nume ce este asociat unei locații de memorie ce este cunoscută la
asamblare. În exemplul precedent, A = B + 4, se presupune că variabilele A şi B au
adrese ce sunt cunoscute atunci când instrucțiunea este compilată. În C doar
variabilele globale statice, au adrese ce sunt cunoscute la compilare. Variabilele
declarate în funcții sau în blocuri ce nu sunt declarate explicit static sau global, sunt
create la intrarea în funcție sau în bloc şi dispar atunci când funcția sau blocul se
termină. Aceste variabile se numesc locale, sau automatice în C. În majoritatea
programelor variabilele locale sunt mult mai des folosite decât variabilele globale.
Având în vedere acest caracter efemer al variabilelor locale, o modalitate naturală
de a le implementa este o stivă de tip ultimul intrat‐primul ieşit. Variabilele stocate
în stivă se creează la apelul funcției şi dispar când funcția se termină. Dacă în
capitolul precedent am folosit pointerul de stivă %sp pentru a accesa stack frame‐ul,
aici vom folosi un al registru %fp (frame pointer) pentru a accesa stiva pe durata
execuției funcției. Motivul este că variabilele temporare pot fi puse şi scoase din
stivă în permanență pe durata execuției funcției, ceea ce duce la modificarea offset‐
ului dintre %sp şi elementele din stivă. Folosirea lui %fp va permite compilatorului
să folosească un offset constant între %fp şi valoarea stocată pe stivă, care rămâne
fixat pe durata de viață a frame‐ului stivei. Adresarea cu bază (based addresing) este
folosită pentru a accesa variabilele de pe stivă. De exemplu, o variabilă ARC
localizată la 12 octeți sub %fp poate fi încărcată în %r1 prin instrucțiunea
ld %fp, ‐12, %r1
sau, să folosească o notație obişnuită:
ld [%fp‐12], %r1
Folosirea adresării cu bază permite ca aritmetica adresei („adună conținutul lui %fo
la ‐12”) să fie efectuată într‐o singură instrucțiune. Adresarea cu bază este atât de
obişnuită încât toate seturile de instrucțiuni conțin acest mod de adresare. Unele
mulțimi de instrucțiuni conțin moduri de adresare mai complicate pentru a putea
accesa structuri de date complexe ce sunt stocate pe stivă.
104

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Variabilele ce sunt stocate pe stivă au adrese de memorie ce sunt cunoscute de abia
la execuție. Adresele lor de la momentul compilării sunt cunoscute ca offset‐uri de la
%fp. De abia la intrarea în funcție se ştie care este adresa de memorie exactă a
valorii. Astfel, cu toate că adresele variabilelor de pe stivă cum este [%fp ‐ 12] sunt
mult mai obişnuite decât adresele de variabile globale cum este A, vom presupune în
continuare că sunt folosite variabilele globale pentru că este mai uşor de înțeles
relația dintre numele variabilelor din limbajele de nivel înalt şi adresă aşa cum este
specificată în limbaj de asamblare.
În continuarea vom prezenta cele trei clase de instrucțiuni: mişcarea datelor,
aritmetice şi controlul execuției programelor.
Mişcarea datelor
Pe lângă variabilele scalare simple, majoritatea limbajelor de programare furnizează
diferite tipuri de structuri de date mai complexe, inclusiv structurile fixe (struct în
C) şi tablourile.
Un exemplu de structură este reprezentarea unui punct din spațiul tri‐dimensional,
care are trei coordonate întregi x, y, z. O astfel de structură se poate declara astfel:
struct point
{
int x:
int y;
int z;
};
O instanță a acestei structuri se defineşte astfel:
struct point pt;
Definind punctul pt, programatorul poate referi componentele individuale ale lui pt
prin notația pt.x, care se referă la componenta x a structurii. Compilatorul va pune în
memorie această structură ca trei locații de memorie consecutive.
Adresa de memorie a structurii este cea mai mică valoare sau adresa de bază a
structurii, aşa că componenta x va fi localizată la adresa pt, componenta y va fi
localizată la adresa pt+4 iar componenta z la adresa pt+8. Aşadar, componenta y a
structurii pt se încarcă în registrul %r1 prin instrucțiunea:
ld [pt + 4], %r1 ! %r1

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Această definiție va produce o colecție de 10 întregi indexați de la 0 la 9.
Componentele unei structuri trebuie numite explicit când se scrie programul, de ex.
pt.z. Referințe cum ar fi pt.i, unde i este o variabilă a cărei nume nu este determinat
până la execuție nu sunt permise. La tablouri, indexul poate fi calculat la execuție. De
exemplu, programatorul poate specifica un element al tabloului prin A[i], unde i este
o variabilă a cărei valoare este calculată la execuție şi care poate lua orice valoare
cuprinsă între 0 şi 9. Dacă în C indexul primului element al tabloului este
întotdeauna 0, în alte limbaje de programare există o flexibilitate mai mare. De
exemplu, în Pascal se poate declara un tablou astfel:
A: array [‐10..10] of integer
În cazul acesta calculul indecşilor la execuție este mai complicat. Expresia generală
pentru calculul adresa maşină a unui element al tabloului este dată de:
AdresăElement = BAZA + (INDEX ‐ START)*DIMENSIUNE
unde BAZA este adresa de început a tabloului, INDEX este indexul elementului dorit,
START este primul index pentru tablou iar SIZE este dimensiunea unui element
individual în octeți. Astfel, elementul 5 din tabloul declarat în Pascal de mai sus are
adresa A + (5 – (‐10))*4 = A +60. În limbajul de asamblare ARC, dacă presupunem că
BASE este în %r2, INDEX este în %r3, START este în %r4 şi presupunând că SIZE
este 4, codul pentru încărcarea unei valori a tabloului în memorie este:
ld %r3, %r4, ! %r6

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
registrelor”, şi pentru a decide când nu mai este nevoie de o anumită valoare dintr‐
un registru.
Controlul execuţiei programului
Majoritatea arhitecturilor de seturi de instrucțiuni folosesc ramificări condiționate
şi indicatorii aritmetici ai procesorului pentru a implementa structurilor pentru
controlul execuției programului. În continuare vom prezenta cele mai importante
instrucțiuni pentru controlul execuției.
Cea mai trivială instrucțiune este instrucțiunea goto, „goto Etichetă”, care este
implementată prin instrucțiunea de ramificare necondiționată ba (branch always).
Instrucțiunea if­else are în limbajul C sintaxa:
if (expr) instr1. else instr2.
Compilatorul va evalua expresia logică expr, şi va executa una din cele două
instrucțiuni în funcție de valoarea de adevăr a expresiei. Dacă presupunem că
expresia este %r1 == %r2 şi introducem instrucțiunea bne („branch if not equal”)
atunci codul pentru implementarea instrucțiunii if‐else este:
subcc %r1, %r2, %r0
bne Over
! codul instrucțiunii 1
ba End
Over: ! codul instrucțiunii 2
End:
Instrucțiunea while, are în limbajul C sintaxa:
while (expr) instr;
Se evaluează expresia şi dacă are valoarea „true” atunci se execută instrucțiunea,
după care se reevaluează condiția. Instrucțiunea se execută cât timp instrucțiunea
are valoarea „true”.
Cea mai eficientă reprezentare a acestei instrucțiuni în limbaj de asamblare are
codul pentru evaluarea expresiei după codul instrucțiunii.
Instrucțiunea:
while (%r1 == %r2) %r3 = %r3 + 1;
se poate implementa eficient în asamblare astfel:
ba Test
True: add %r3, 1, %r3
107

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Test: subcc %r1, %r2, %r0
Be True;
Instrucțiunea do­while are, în limbajul C, sintaxa:
do instrucțiune while (expresie)
se implementează în asamblare la fel ca şi instrucțiunea precedentă cu excepția
faptului că prima instrucțiune ba Test este eliminată.
Instrucțiunea for are, în limbajul C, sintaxa:
for (expr1; expr2; expr3) instrucțiune;
Definiția limbajului C precizează că această instrucțiune este echivalentă cu
secvența:
expr1;
while (expr2) {
instrucțiune;
expr3;
}
Instrucțiunea for se implementează în asamblare la fel ca şi instrucțiunea while cu o
singură modificare: se adaugă codul pentru expr1 şi expr3.
Procesul de asamblare
Procesul de traducere a programului din limbaj de asamblare în limbaj maşină este
numit proces de asamblare. Procesul de asamblare este unul direct şi simplu, din
moment ce există o corespondență unu‐la‐unu între instrucțiunile în asamblare şi
instrucțiunile maşină. Spre deosebire, la compilare o instrucțiune din limbajul de
programare de nivel înalt poate fi tradusă în limbaj de asamblare în mai multe
moduri echivalente din punct de vedere computațional.
Chiar dacă asamblarea se face direct, totuşi este grea şi supusă erorilor dacă este
făcută de o persoană. De fapt, asamblorul a fost primul software creat după invenția
calculatorului electronic digital.
Asambloarele au cel puțin următoarele funcții:
• Permit programatorului să specifice locațiile de la execuție ale datelor şi
programelor. (de cele mai multe ori programatorul nu specifică o locație de
pornire absolută pentru un program, deoarece programul va fi mutat, relocat de
către link‐editor sau de încărcător aşa cum vom vedea mai târziu).
• Furnizează mnemonici în limbaj de asamblare pentru toate instrucțiunile
maşină şi modurile de adresare şi traduc instrucțiunile valide din asamblare în
echivalentul lor binar din limbaj maşină.
108

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
• Oferă programatorului posibilitatea de a inițializa datele din memorie înainte
de execuția programului.
• Permit utilizarea de etichete simbolice pentru reprezentarea adreselor şi a
constantelor.
• Furnizează programatorului posibilitatea de a specifica adresa de pornire a
programului, dacă există una. (dacă modulul asamblat este o procedură sau
funcție atunci nu ar fi o adresă de pornire).
• Furnizează un anumit grad de aritmetică la momentul asamblării.
• Includ mecanisme ce permit variabilelor să fie definite într‐un program în
limbaj de asamblare şi să fie folosite într‐un alt program asamblat separat.
• Furnizează suport pentru expansiunea rutinelor macro, adică, rutine care pot
fi definite o singură dată şi instanțiate mai apoi de câte ori e nevoie.
Vom ilustra modul în care evoluează procesul de asamblare prin „asamblarea
manuală” a unui program simplu pentru ARC. Programul este cel de mai jos:
În procesul de asamblare a acestui program vom folosi formatele pentru instrucțiuni
din figura de mai jos:
109

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Figura prezintă codificarea instrucțiunilor pentru maşina ARC, adică specifică
limbajul binar țintă a unui calculator ARC pe care asamblorul trebuie să‐l genereze
din textul în limbaj de asamblare.
Asamblare şi asambloare în doi paşi
Majoritatea asambloarelor trec peste programul în limbaj de asamblare de două ori
şi de aceea se numesc asambloare în doi paşi. La primul pas se determină adresa
tuturor elementelor de date şi instrucțiunilor maşină şi se selectează instrucțiunile
maşină ce se vor produce pentru fiecare instrucțiune în asamblare (la acest pas nu
se generează codul maşină).
Adresele datelor şi instrucțiunilor sunt determinate prin folosirea unui analog la
nivel de asamblare pentru contorul program, numit contor de locaţie. Contorul de
locație ține evidența instrucțiunii curente sau a datelor pe măsură ce se efectuează
compilarea. De regulă este inițializat la zero la începutul primului pas şi este
incrementat cu dimensiunea fiecărei instrucțiuni. Pseudo‐operația .org determină
contorul de locație să fie setat la o valoare specificată de instrucțiunea .org. Dacă
asamblorul întâlneşte instrucțiunea
.org 1000
va seta contorul de locație la 1000, iar instrucțiunea următoare sau datele vor fi
asamblate la acea adresă. În timpul primului pas, asamblorul efectuează orice
aritmetică de la momentul asamblării şi inserează definițiile tuturor etichetelor şi
valorilor constante într‐o tabelă, numită tabela de simboluri.
Motivul principal pentru existența celui de‐al doilea pas este de a permite utilizarea
în program a simbolurilor, înainte de a fi definite, ceea ce se numeşte referenţiere
înainte (engl. forward referencing). După acest prim pas, asamblorul a identificat şi a
introdus în tabela de simboluri toate simbolurile, şi în timpul celui de‐al doilea pas
se va genera codul maşină, prin inserarea valorilor simbolurilor – valori care sunt
cunoscute al acest al doilea pas.
Acum vom asambla manual programul de mai sus. Când asamblorul întâlneşte
prima instrucțiune:
ld [x], %r1
foloseşte un proces „pattern matching” pentru a recunoaşte că e vorba de
instrucțiunea „load”. Mai departe se va identifica faptul că încărcarea se face la o
adresă specificată de o valoare constantă (aici x) într‐un registru (aici %r1). Aceasta
corespunde celui de‐al doilea format de instrucțiuni de memorie, astfel că găsim
câmpul op al acestei instrucțiuni (11). Destinația acestei instrucțiuni ld este câmpul
rd, care este 00001 pentru %r1 în acest caz. Câmpul op3 este 000000 pentru ld.
110

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Câmpul rs1 identifică registrul, %r0 în acest caz, care este adunat cu câmpul
simm13 pentru a forma adresa operandului sursă. Urmează bitul i. Bitul i este folosit
pentru a face distincția între primul format de instrucțiune de memorie (i=0) şi cel
de‐al doilea (i=1). De aceea bitul i este setat la valoarea 1. Câmpul simm13 specifică
adresa etichetei x, care apare la cinci cuvinte după prima instrucțiune. Din moment
ce prima instrucțiune apare la adresa 2048 şi din moment ce fiecare cuvânt este
format din patru octeți, adresa lui x este la 5 x 4 = 20 de octeți după începutul
programului. Adresa lui x va fi 2048 + 20 = 2068, care se reprezintă prin secvența de
13 biți: 010000010100. Această secvență intră în câmpul de 13 biți simm13.
Prin urmare prima linie a programului va fi asamblată astfel:
11 00001 000000 00000 1 0100000010100
op rd op3 rs1 i simm13
Următoarea instrucțiune are o formă asemănătoare, iar secvența de biți
corespunzătoare este:
11 00010 000000 00000 1 0100000011000
op rd op3 rs1 i simm13
Procesul de asamblare continuă până când toate cele 8 linii sunt asamblate:
ld [x], %r1 1100 0010 0000 0000 0010 1000 0001 0100
ld [y], %r2 1100 0100 0000 0000 0010 1000 0001 1000
addcc %r1,%r2,%r3 1000 0110 1000 0000 0100 0000 0000 0010
st %r3, [z] 1100 0110 0010 0000 0010 1000 0001 1100
jmpl %r15+4, %r0 1000 0001 1100 0011 1110 0000 0000 0100
15 0000 0000 0000 0000 0000 0000 0000 1111
9 0000 0000 0000 0000 0000 0000 0000 1001
0 0000 0000 0000 0000 0000 0000 0000 0000
Asamblorul citeşte instrucțiunile una câte una şi generează cod maşină pentru ele. O
problemă care poate să apară, aşa cum s‐a menționat, este referențierea înainte a
unor simboluri. În secvența de mai jos:
111

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
la întâlnirea instrucțiunii call, asamblorul nu ştie care este locația lui sub_r din
moment ce eticheta sub_r încă nu a fost întâlnită de asamblor. Aşa că, referința este
includă în tabela de simboluri şi este marcată ca fiind nerezolvată. Referința va fi
rezolvată doar mai târziu când este întâlnită în program.
Asamblare şi tabela de simboluri
Tabela de simboluri este creată la parcurgerea pentru prima dată a programului (la
un asamblor în doi paşi). Un simbol este ori o etichetă, ori un nume simbolic care se
referă la o valoare folosită în timpul procesului de asamblare.
Pentru a vedea cum operează un asamblor în doi paşi, să considerăm asamblarea
codului de mai jos:
Asamblorul întâlneşte instrucțiunea .org 2048. Aceasta va determina ca asamblorul
să seteze contorul de locație la valoarea 2048 şi asamblarea continuă de la acea
adresă. Prima instrucțiune este:
a_start .equ 3000
În tabela de simboluri se creează o poziție pentru simbolul a_start, care primeşte
valoarea 3000. (.equ nu generază cod aşa că nu primeşte o adresă la asamblare).
Prima instrucțiune maşină,
112
Crearea tabelei de
simboluri

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
ld [length], %r1
este asamblată la adresa specificată de contorul de locație, 2048. Contorul de locație
este incrementat cu dimensiunea unei instrucțiuni, adică 4 octeți, la 2052. Când este
întâlnit simbolul length, asamblorul încă nu a văzut definiția lui. În tabela de
simboluri se creează o poziție pentru length, care este primeşte inițial valoarea
„nedefinit” aşa cum se vede în figura de mai sus (a).
Asamblorul întâlneşte instrucțiunea:
ld [address], %r2
care este asamblată la adresa 2052 şi se introduce în tabela de simboluri simbolul
address a cărui valoare se setează din nou la „nedefinit”. Contorul de locații este
mărit cu 4 la 2056. Instrucțiunea andcc este asamblată la adresa 2056, iar contorul
de locație este mărit cu 4 octeți, la 2060. Următorul simbol care este întâlnit este
loop, care este introdus în tabela de simboluri cu valoarea 2060 – valoarea
contorului de locație. Următorul simbol întâlnit este done, simbol ce este introdus în
tabela de simboluri fără o valoare din moment ce nu este încă definit.
Primul pas al asamblării continuă şi simbolurile nerezolvate: length, address, şi done
primesc valorile 2092, 2096 respectiv 2088. Eticheta a este introdusă în tabela de
simboluri cu valoarea 3000. Eticheta done apare la locația 2088 deoarece sunt 10
instrucțiuni (40 de octeți) între începutul programului şi done. Adresele pentru
restul etichetelor sunt calculate într‐un mod similar. Dacă mai rămân etichete
nedefinite la sfârşitul primului pas, atunci înseamnă că există o eroare în program şi
asamblorul va semnala care este simbolul nedefinit şi va opri procesul de
asamblare.
După crearea tabelei de simboluri începe al doilea pas al asamblării. Programul este
parcurs încă o dată de la instrucțiunea .begin, dar de data asta se generează cod
obiect. Prima instrucțiune întâlnită ce determină generarea de cod este ld la locația
2048. Din tabela de simboluri se vede că porțiunea de adrese a instrucțiunii ld este
2092 pentru adresa lui length aşa că se generează cod de dimensiune egală cu un
cuvânt folosind formatul Memory aşa cum se vede în figura de mai jos.
113

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Al doilea pas continuă la fel până când se translatează tot codul.
Sarcinile finale ale asamblorului
După terminarea asamblării se adaugă la modulul asamblat informație suplimentară
ce va fi folosită de link‐editor şi asamblor.
• Numele modulului şi dimensiunea. Dacă modelul de execuție implică
segmente de memorie pentru cod, date şi stivă atunci trebuie precizate
dimensiunile şi identitățile diferitelor segmente.
• Adresa simbolului de start, dacă este definită în modul. Majoritatea
asambloarelor şi limbajelor de nivel înalt furnizează o etichetă rezervată specială
ce permit programatorului să specifice locul în care programul trebuie să înceapă
execuția. De exemplu, în C este funcția main(). Eticheta main este un semnal
pentru asamblor că execuția trebuie să înceapă în acel loc.
• Informație despre simbolurile globale şi externe. Link‐editorul va trebui să
ştie adresa simbolurilor globale definite în modul şi exportate de modul, şi va
trebui să ştie ce simboluri rămân nedefinite în modul deoarece acestea sunt
definite ca globale în alte module.
• Informație despre rutinele de bibliotecă care sunt referențiate de modul.
Unele biblioteci conțin funcționalitate ce apare de multe ori cum ar fi funcție
matematice sau alte funcții specializate.
• Valorile constantelor ce trebuie încărcate în memorie. Unele încărcătoare cer
ca inițializarea datelor să fie specificată separat de codul binar.
114

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
• Informație de relocare. Când link‐editorul este invocat majoritatea modulelor
ce trebuie link‐editate vor trebui relocate în momentul când modulele sunt
concatenate.
Localizarea programelor în memorie
Până acum am presupus că programele sunt localizate în memorie la o adresă ce
este specificată de pseudo‐operația .org. Aceasta s‐ar putea să fie în regulă pentru
programare de sisteme, atunci când programatorul are un motiv bine întemeiat
pentru ca programul să se afle la acea locație de memorie dar, de regulă,
programatorul nu este interesat de localizarea programului în memorie. Atunci când
programare asamblate sau compilate separat sunt legate, este dificil sau poate chiar
imposibil pentru un programator să ştie cu exactitate unde va fi localizat fiecare
modul după link‐editare. Din acest motiv majoritatea adreselor sunt specificate ca
fiind relocabile în memorie, cu excepția unor adrese particulare cum ar fi adresele
de intrare‐ieşire, care sunt fixate la locații de memorie absolute. Asamblorul este
responsabil pentru marcare simbolurilor ca fiind relocabile. Dacă un anumit simbol
este relocabil sau nu depinde atât de limbajul de asamblare cât şi de convențiile
sistemului de operare. Informația de relocare este inclusă în modulul asamblat
pentru a fi folosită de link‐editor sau de încărcător.
Link­editare şi încărcare
Majoritatea aplicațiilor vor fi formate dintr‐o serie de module compilate sau
asamblate separat. Aceste module pot fi generate de diferite limbaje de programare
sau pot fi prezente într‐un modul furnizat ca parte a mediului pentru dezvoltarea de
aplicații sau a sistemului de operare. Fiecare modul trebuie să furnizeze informația
pe care am prezentat‐o mai sus, pentru ca să poată fi legate împreună pentru
încărcare şi execuție.
Un link‐editor, este un program care combină programele asamblate separat
(numite module obiect) într‐un singur program, numit modul încărcabil. Link‐
editorul rezolvă referințele globale externe şi relochează adresele de memorie în
modulele separate. Modulul încărcabil poate fi încărcat în memorie de către
încărcător, care la rândul său poate modifica adresele dacă programul este încărcat
la o locație diferită de locația de încărcare folosită de link‐editor.
Tehnica DLL (Dynamic Link Library) din Windows, prezentă sub diferite forme şi în
alte sisteme de operare, amână link‐editarea unor componente până când este
nevoie de ele la execuție.
Link­editare
În procesul de combinare a modulelor asamblate sau compilate separat într‐un
modul încărcabil, link‐editorul trebuie să:
115

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
• Rezolve referințele la adrese care sunt externe modulelor pe măsură ce sunt
link‐editate.
• Relocheze fiecare modul prin combinarea lor cap‐la‐cap. În timpul acestui
proces de relocare multe adrese din modul trebuie să fie schimbate pentru a
reflecta noua lor locație.
• Specifice simbolul de pornire al modulului încărcabil.
• Dacă modulul de memorie include mai mult de un segment de memorie, link‐
editorul trebuie să specifice identitățile şi conținutul diferitelor segmente.
Rezolvarea referinţelor externe
Pentru rezolvarea referințelor externe link‐editorul trebuie să facă distincție între
numele simbolurilor locale (folosite în cadrul unui singur modul sursă) şi numele
simbolurilor globale (folosite în mai mult de un modul). Aceasta se realizează prin
folosirea pseudo‐operațiilor .global şi .extern în timpul asamblării. Pseudo‐operația
.global indică asamblorului să marcheze simbolul ca fiind disponibil altor module
obiect în timpul fazei de link‐editare. Pseudo‐operația .extern identifică o etichetă ce
este folosită într‐un modul dar este definită într‐altul. Astfel, .global este folosit în
modulul în care simbolul este definit şi .extern este folosit în fiecare modul care se
referă la simbol. Doar etichetele de adrese pot fi globale sau externe: nu ar avea sens
să marcăm un simbol .equ ca fiind global sau extern, din moment ce .equ este o
pseudo‐operație care este folosită doar în timpul procesului de asamblare, iar
procesul de asamblare este încheiat în momentul în care începe link‐editarea.
Toate etichetele referite dintr‐un program referite din alte programe, vor avea o
linie de forma:
.global simbol1, simbol2, …
Toate celelalte etichete sunt locale, ceea ce înseamnă că aceeaşi etichetă poate fi
folosită în mai mult de un modul sursă fără confuzie din moment ce etichetele locale
nu sunt folosite după ce procesul de asamblare se termină. Un modul ce se referă la
simboluri definite într‐un alt modul trebuie să declare acele simboluri folosind
forma:
.extern simbol1, simbol2, …
Un exemplu de utilizare e .global şi .extern este dat în figura de mai jos:
116

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Fiecare modul este asamblat separat în module obiect, fiecare cu propria tabelă de
simboluri, aşa cum se vede în figura de mai jos:
Tabelele de simboluri au un câmp suplimentar care indică dacă un simbol este
extern sau global. Programul main începe la locația 2048, şi fiecare instrucțiune are
patru octeți, aşa că x şi y sunt la locația 2046 şi 2068.. Simbolul sub este marcat ca
fiind extern ca rezultat al pseudo‐operației .extern. Ca parte a procesului de
asamblare asamblorul include informații antet în modul despre simbolurile ce sunt
globale şi externe aşa că acestea pot fi rezolvate în faza de link‐editare.
Relocare
În cele două programe de mai sus, atât main cât şi sub au aceeaşi adresă de pornire –
2048. Este evident că ele nu pot ocupa aceeaşi adresă de memorie. Dacă cele două
module sunt asamblate separat, asamblorul nu are cum să detecteze această
problemă. Pentru a rezolva problema, asamblorul marchează ca relocabile
simbolurile a căror adresă se poate schimba în timpul procesului de link‐editare, aşa
cum se vede în tabelele de mai sus. Ideea este că un program asamblat la adresa de
start 2048 poate fi încărcat la adresa 3000, atâta timp cât toate referințele la adrese
relocabile din program sunt mărite 2000‐2048 = 952. Relocarea se face de către
link‐editor aşa că adresele relocabile sunt modificate cu aceeaşi valoare cu care s‐a
modificat originea de încărcare. Adresele absolute sau non‐relocabile (cum ar fi
adresa cea mai mare posibilă pentru stivă 2 31 ‐4) rămân la fel indiferent de originea
la care se încărcă programul.
Asamblorul este responsabil pentru determinarea etichetelor relocabile atunci când
construieşte tabela de simboluri. Nu are sens ca o etichetă externă să fie relocabilă,
117

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
din moment ce eticheta este definită într‐un alt modul, aşa că în sub nu are nici un
simbol relocabil în tabela de simboluri pentru programul main, dar sub este marcat
ca relocabil în biblioteca de subrutine. Asamblorul trebuie să identifice cod în
modulul obiect ce trebuie să fie modificat ca rezultat al relocării. Numerele absolute,
cum ar fi constantele (marcate cu .equ, sau cele ce apar în locații de memorie, cum ar
fi conținutul lui x şi y, care este 105 şi 92) nu sunt relocabile. Locațiile de memorie
poziționate relativ la o instrucțiune .org, cum ar fi x şi y (nu conținutul lui x şi y!) de
obicei sunt relocabile. Referințele la locații fixe, cum ar fi rutinele grafice rezidente
permanent care sunt înglobate în hardware din fabricație, nu sunt relocabile. Toată
informația de care este nevoie pentru a reloca un modul este stocat într‐un dicționar
de relocare conținut în fişierul asamblat şi, astfel este disponibil link‐editorului.
Încărcare
Încărcătorul este un program care plasează modulul în memoria principală.
Conceptual, sarcina încărcătorului nu este dificilă. Trebuie să încarce diferitele
segmente de memorie cu valorile potrivite şi să inițializeze anumite registre, cum ar
fi %sp (stack pointer) şi %pc (program counter), la valori inițiale.
Dacă există un singur modul de încărcare ce se execută la un moment dat, atunci
acest model funcționează bine. Totuşi, în sistemele de operare moderne mai multe
programe sunt rezidente în memorie la un moment dat şi asamblorul sau link‐
editorul nu poate şti la ce adrese se vor găsi aceste programe. Încărcătorul trebuie
să relocheze aceste module la încărcare prin adăugarea unui offset codului relocabil
din modul. Acest tip de încărcător (loader) se numeşte încărcător cu relocare.
Încărcătorul cu relocare nu repetă doar sarcina link‐editorului. Link‐editorul
combină mai multe module obiect într‐un singur modul de încărcare, pe când
loader‐ul doar modifică adresele relocabile dintr‐un singur modul de încărcare
astfel ca mai multe programe să poată rezida în memorie simultan. Un loader cu
legare (linking loader) efectuează atât procesul de link‐editare cât şi procesul de
încărcare: rezolvă referințele externe, relochează modulele obiect şi le încarcă în
memorie.
Fişierul executabil legat conține informații în antet ce descriu unde trebuie încărcat,
adresa de start şi eventual informațiile de relocare, şi punctele de intrare pentru
rutinele care trebuie să fie disponibile extern.
DLL (Dynamic Link Librarie)
Conceptul de bibliotecă cu legare dinamică are numeroase trăsături atractive.
Rutinele folosite în mod obişnuit, cum ar fi cele pentru gestiunea memoriei sau
pachetele grafice trebuie să existe într‐un singur loc, biblioteca DLL. Aceasta duce la
programe de dimensiuni mai mici întrucât programele nu trebuie să aibă propria
copie a codului din DLL. Toate programele partajează acelaşi cod, chiar şi atunci
când rulează simultan.
118

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
DLL‐urile pot fi actualizate prin bug‐fix‐uri sau prin adăugări de funcții
suplimentare, şi programele ce le folosesc nu trebuie recompilate sau re‐legate.
Aceste trăsături pot fi în acelaşi timp şi dezavantaje, deoarece comportamentul
programelor se poate modifica într‐un mod neprevăzut (ca de exemplu epuizarea
memoriei din cauza faptului că DLL‐ul este prea mare). Biblioteca DLL trebuie să fie
prezentă întotdeauna şi trebuie să conțină versiunea pe care o cere fiecare program.
Mulți utilizatori Windows au văzut mesajul „A file missing from the dynamic
library”. Pentru a complica şi mai mult lucrurile, în implementarea Windows există
mai multe locuri în sistemul de fişiere unde sunt localizate DLL‐urile.
Un exemplu de programare
Să considerăm problema adunării a două numere pe 64 de biți folosind limbajul de
asamblare ARC. Putem stoca numerele pe 64 de biți în două cuvinte de memorie
distincte şi să adunăm separat cele două perechi de cuvinte. Dacă se generează
transport la adunarea celor două cuvinte mai puțin semnificative, atunci transportul
este adunat la cuvântul mai semnificativ al rezultatului.
În figura de mai jos avem o posibilă soluție la această problemă.
Operanzii pe 64 de biți A şi B sunt stocați în memorie în formatul big‐endian, în care
cei mai semnificativi 32 de biți sunt stocați la adresa de memorie mai mică.
Programul începe prin încărcarea cuvintelor lui A în %r1 (cuvântul mai semnificativ)
şi în %r2 (cuvântul mai puțin semnificativ). Cele două cuvinte ale lui B se încarcă în
%r3 şi %r4. Subrutina add_64 este apelată, care adună A cu B şi plasează cuvântul mai
semnificativ al rezultatului în registrul %r5 iar cuvântul mai puțin semnificativ în
%r6. Rezultatul de 64 de biți se stochează în C şi programul se termină.
Subrutina add_64 începe prin a aduna cele două cuvinte mai puțin semnificative.
Dacă nu se generează transport, atunci cuvintele mai semnificative sunt adunate şi
rutina se termină. Dacă se generează transport atunci acesta trebuie adunat la
cuvântul mai semnificativ al rezultatului. Dacă nu se generează transport la
adunarea cuvintelor mai semnificative, atunci transportul de la cuvântul mai puțin
semnificativ al rezultatului este doar adunat la cuvântul mai semnificativ al
rezultatului şi rutina se termină. Dacă, se generează transport la adunarea
cuvintelor mai semnificative, atunci când transportul de la cuvântul mai puțin
semnificativ este adunat la cuvântul mai semnificativ, starea finală a codurilor de
condiție vor arăta că nu avem transport care iese din cuvântul mai semnificativ, ceea
ce este greşit. Codul de condiție pentru transport este refăcut prin plasarea unui
număr mare în %r7 şi adunarea cu el însuşi.
119

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Macrouri
Dacă se foloseşte o convenție de apel bazată de stivă, atunci un anumit număr de
registre vor fi introduse şi scoase de pe stivă în mod frecvent în timpul apelurilor şi
întoarcerilor din subrutine. Pentru a pune pe stivă registrul %r15 al ARC, trebuie
prima dată să decrementăm pointerul de stivă (care este în %r14) iar după aceea să
copiem %r15 în locația de memoria indicată de %r14, aşa cum prezentăm în
secvența de mai jos:
addcc %r14, ‐4, %r14 ! decrementarea pointerului de stivă
st %r15, %r14 ! se pune %r15 pe stivă
O notație mai compactă pentru realizarea aceluiaşi efect este:
120

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
push %r15
Forma compactă atribuie o nouă etichetă (push) secvenței de instrucțiuni care
realizează comanda. Eticheta push este considerată un macro, iar procesul de
traducere a macro‐ului în echivalentul în limbaj de asamblare se numeşte macro‐
expansiune.
Un macro poate fi creat prin folosirea unei macro‐definiții, aşa cum se vede în figura
de mai jos. Macro‐ul începe cu pseudo‐operația .macro şi se termină cu pseudo‐
operația .endmacro.
Pe linia .macro primul simbol este numere macro‐urlui (push), iar restul simbolurilor
sunt argumentele liniei de comandă folosite în macro. Există un singur argument
pentru macro‐ul push, şi anume arg1. Aceasta corespunde lui %r15 în instrucțiunea
push %r15 sau lui %r1 în instrucțiunea push %r1. Argumentul este legat de arg1 în
timpul procesului de asamblare.
Pot fi folosiți şi parametri formali suplimentari, separați prin virgulă:
.macro nume arg1, arg2, arg3, …
iar macro‐ul este mai apoi apelat cu acelaşi număr de parametri actuali.
nume %r1, %r2, %r3, …
Corpul macro‐ului urmează după pseudo‐operația .macro. Orice comenzi pot urma,
inclusiv alte macro‐uri, sau chiar şi apeluri la acelaşi macro, ceea ce duce la o
dezvoltare recursivă la asamblare. Parametri care apar în linia .macro pot fi înlocui
orice text din corpul macro‐ului, aşa că aceşti parametri pot fi folosiți pentru
etichete, instrucțiuni sau operanzi.
În timpul macro‐expansiunii parametri formali sunt înlocuiți cu parametri actuali
folosind o substituție simplă textuală. Astfel, macro‐ul push poate fi apelat atât cu
argumente de memorie cât şi cu registre.
push %r1 sau push foo
Programatorul trebui să țină cont de această trăsătură a macro‐expansiunii atunci
când defineşte un macro.
Pentru macro‐expansiune recursivă este nevoie de pseudo‐operații suplimentare.
Pseduo‐operațiile .if şi .endif deschid şi închid o secvență de asamblare condițională.
121

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Dacă argumentul lui .if este true, atunci codul care urmează până la .endif este
asamblat. Dacă argumentul este false atunci codul dintre .if şi .endif este ignorat de
către asamblor. Operatorii condiționali pentru psedudo‐operația .if pot fi oricare din
mulțimea {, >=,

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
funcții, prin aceea că macrourile generează cod in‐line la asamblare, pe când
subrutinele sunt rulate la execuție.
Un link‐editor combină modulele asamblate separat într‐un singur modul ce poate fi
încărcat. Modulul este plasat în memorie de către loader şi începe execuția
programului. Loader‐ul poate face relocare dacă două sau mai multe module se
suprapun în memorie.
În practică detaliile asamblării, link‐editării şi încărcării sunt dependente de sistem
şi limbaj. Unele asambloare simple produc fişiere binare direct executabile, dar de
regulă un asamblor va produce informație suplimentară astfel ca modulele să poată
fi legate împreună de către linker. Unele sisteme oferă încărcătoare care efectuează
şi link‐editare. Unele încărcătoare pot încărca programul doar la adresa specificată
în fişierul binar, pe când altele, de obicei, încărcătoarele cu relocare pot reloca
programul la o adresă specificată la încărcare. Aceste procese sunt dependente de
sistemul de operare.
Înainte de apariția compilatoarelor, programele erau scrise direct în limbaj de
asamblare. În ziua de astăzi, limbajul de asamblare nu mai este folosit pentru a scrie
programe, întrucât compilatoarele pentru limbajele de nivel înalt produc un cod
foarte eficient. Cu toate acestea limbajele de asamblare sunt importante pentru a
înțelege aspecte de arhitectura calculatoarelor cum ar fi: link‐editarea programelor
compilate pentru convenții de apel.
123

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
7. Comunicaţii
Comunicația este procesul de transferare a informației de la o sursă la o destinație.
Sistemele de comunicație acoperă distanțele dintre calculatoare şi implică sistemul
public de telefonie, radio şi televiziune. Sistemele de comunicație pe arie largă au
devenit foarte complexe, transmițându‐se combinații de voce, date şi video prin
firele de comunicație, fibre optice, radio şi microunde. Rutele de comunicație trec
atât prin pământ cât şi prin apă, unde radio şi sateliți. Datele ce pornesc ca semnal
analogic de voce pot fi convertite în fluxuri de date digitale pentru o rutare eficientă
peste distanțe mari şi sunt convertite la destinație înapoi în semnal analog, fără ca
cei ce comunică să conştientizeze acest fapt.
În continuare ne vom concentra asupra comunicațiilor între entități localizate la
distanțe cuprinse între câțiva metri până la un kilometru (LAN – Local Area
Network) şi entități localizate la o distanță mult mai mare (WAN – Wide Area
Network), un exemplu tipic fiind chiar rețeaua Internet.
Modemuri
Oamenii comunică prin linii telefonice prin care semnalul sonor este convertit în
semnale electrice, ce sunt transmise la destinatar, unde sunt convertite înapoi în
sunet. Aceasta nu înseamnă că oamenii trebuie întotdeauna să vorbească şi să
asculte pentru a putea comunica prin liniile telefonice. Acest mediu de comunicație
poate transmite şi informația non‐auditivă ce este transformată într‐o formă
auditivă.
În figura de mai jos prezentăm o configurație în care două calculatoare comunică
prin linia telefonică prin utilizarea de modem‐uri (prescurtare de la modulator‐
demodulator).
Modem‐ul transformă semnalul electric de la calculator într‐o formă auditivă pentru
a fi transmis şi efectuează operația inversă la destinație. Modem‐urile sunt folosite
doar pe liniile de comunicație telefonice şi în alte sisteme cum ar fi CATV
(transmisia de date prin rețelele de cablu TV).
Comunicația prin modem pe liniile telefonice este efectuată într‐un mod serial, în
care biții au o codificare potrivită pentru mediul de transmisie. Există numeroase
scheme de modulare folosite în comunicație, ce reprezintă codificări ale datelor în
mediul de comunicație. În figura de mai jos sunt prezentate trei forme obişnuite de
modulare.
124

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
AM (Amplitude modulation) foloseşte puterea semnalului pentru a codifica
valorile 0 şi 1. AM este destinat unor implementări simple ce se creează ieftin.
Totuşi, din moment ce există informație în amplitudinea semnalului, tot ceea ce
modifică amplitudinea afectează semnalul. Pentru un radio AM, o serie de situații
afectează amplitudinea semnalului (trecerea pe sub un pod sau prin preajma liniile
de înaltă tensiune, fulgerele etc.)
FM (Frequency modulation) nu este atât de sensibil ca AM pentru că informația
este codificată în frecvența semnalului şi nu în amplitudinea lui. Semnalul FM pentru
radio este mult mai stabil şi nu se deteriorează în situațiile enumerate mai sus.
PM (Phase modulation) este folosit de regulă la modem‐uri. Aici patru faze
(despărțite de câte 90 de grade) dublează lățimea de bandă prin transmiterea a câte
doi biți o dată (ceea ce se numeşte dibit). Folosirea fazei oferă un grad de libertate
suplimentar față de frecvență şi este folosit atunci când numărul de frecvențe
disponibile este limitat.
PCM (Pulse code modulation) un semnal analog este eşantionat şi convertit în
formă binară. În figura de mai jos este prezentat procesul de conversie al semnalului
analog în secvență binară PCM.
125

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Semnalul original este eşantionat şi se produc valori la intervale discrete.
Eşantioanele sunt codificate în binar şi concatenate pentru a produce o secvență
PCM.
PCM reprezintă o abordare digitală şi are toate avantajele sistemelor informaționale
digitale. Prin folosirea de repeatere la intervale regulate semnalul poate fi recuperat
perfect. Prin micşorarea distanței dintre repeatere, se poate mări lățimea de bandă
în mod semnificativ. Totuşi semnalul analog, poate fi cel mult ghicit şi restaurat doar
aproximativ. Nu există o modalitate bună de a face semnalul analog perfect într‐un
mediu cu zgomot.
Medii de transmisie
Într‐un mediu închis, calculatoarele pot fi interconectate în diferite moduri. Pentru
sistemele aflate la distanță se poate folosit sistemul public de telefonie. Utilizatorii
se pot conecta la sistemul de telefonie cu modem‐uri ce convertesc biții în sunete.
Oamenii pot auzi frecvențe de până la 20KHz dar pot emite sunete de până la 4KHz,
ceea ce este aproximativ lățimea de bandă pe care o linie telefonică o transmite. Un
semnal analog (vocea) care este aproximată cu un semnal digital trebuie să fie
eşantionată cel puțin de două ori per ciclu (pentru a capta valorile mari şi mici), aşa
că o rată de eşantionare de 8 KHz este necesară pentru a digitiza o linie ce transmite
voce. La 8 biți/eşantion, se obține o rată de 8biți/ciclu x 8 KHz = 64 Kbit/s. Un
eşantion la fiecare 8 este folosit pentru administrarea liniei telefonice, aşa că rata
maximă posibilă este de 56Kbit/s.
O secvență binară transmisă este convertită în valori mari/mici, dar fluctuațiile sunt
atenuate şi distorsionate la frecvențe mari şi pe distanțe lungi. În figura de mai jos
este prezentată această problemă a eşantionării.
La receptor
Fluctuaţia ideală
Fluctuaţia transmisă
Secvența binară 01011001 este reprezentată printr‐o fluctuație ideală, care este
aproximată de fluctuația transmisă. Fluctuația ideală conține discontinuități, care
sunt dificil de produs la fluctuații reale. Frecvențele înalte sunt atenuate mai mult
decât frecvențele joase în majoritatea mediilor şi frecvențe diferite se propagă la
rate diferite, ceea ce duce la distorsiuni ale fluctuațiilor pe măsură ce se propagă.
Gradul de distorsiune variază cu mediul de transmisie.
126

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Linii deschise cu două fire
Cel mai simplu mediu de comunicație este o pereche de fire ce transportă semnalul
respectiv GND (ground). Firele emit radiații electromagnetice şi preiau zgomot în
cantități diferite pentru cele două linii, ceea ce distorsionează semnalul. Viteza şi
distanța la care se poate transmite semnalul sunt limitate (19.2 KHz respectiv 50m).
Linii torsadate în pereche
Dacă se răsucesc perechile de fire deschise atunci zgomotul extern va afecta ambele
fire la fel. În felul acesta poate creşte atât viteza cât şi distanța la care poate fi
transmis semnalul (1 Mbps respectiv 100m).
Cablu coaxial
Pentru viteze şi distanțe mai mari (10Mbps, sute de metri) firul de semnal este
plasat in interiorul lui GND în mod coaxial cu un izolator între ele. Ideea este de a
forma un scut pentru linia din centru care o protejează de interferențele externe şi
de pierderile de semnal datorate radiațiilor electromagnetice.
Fibră optică
Comunicația optică este imună la interferențe electromagnetice şi suportă o lățime
de bandă mult mai mare. La fiecare capăt e nevoie de o conversie optoelectronică,
ceea ce este disponibil până la câțiva Gbps (folosind diode laser). Fibra optică constă
dintr‐un miez optic, un înveliş optic şi un izolator de plastic.
Există mai multe tipuri de fibre optice cu capabilități şi performanțe diferite:
multimode stepped index fiber, multimode graded index fiber, single mode fible.
127

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Sateliţi
Sateliții de comunicație ce orbitează în jurul Pământului sunt folosiți atunci când
este nevoie de a transmite semnalul pe o distanță foarte mare cu costuri mai mici
decât liniile de comunicație terestre (mai ieftin şi decât fibrele optice).
În comunicația prin sateliți microundele sunt transmise de la sol la satelit, unde un
transponder ce acoperă o anumită bandă de frecvențe retransmite semnalul la o altă
zonă de pe Pământ aflată în aria de acoperire a satelitului.
Un satelit are o serie de transpondere. O arie de acoperire mai mică înseamnă că
semnalul transmis este mai puternic şi că antenele receptoare pot fi mai mici.
Aceasta este tipic la sateliții ce transmit semnal TV. Sateliții folosiți pentru
transmiterea semnalului TV sunt plasați pe orbite joase (aprox. 700 Km) aşa că este
nevoie de o zonă mai mică de colectare a semnalului, pe când sateliții plasați pe
orbite geosincrone (aprox. 23000 mile deasupra Pământului) unde forța
gravitațională a Pământului şi forța centrifugă sunt în echilibru, aşa că sateliții par
staționari deasupra Pământului, orbita lor fiind deasupra ecuatorului. Pentru aceşti
sateliți este nevoie de antene mult mai mari îndreptate înspre ecuator.
Pentru comunicație în ambele sensuri cu sateliții, există o întârziere tolerabilă.
Uplink‐ul este mai lent decât downlink‐ul. Aceasta se potriveşte cu modul de
operare al unui utilizator obişnuit al Internet‐ului, deoarece mai puțin de 10% din
traficul de Internet este transmis de la utilizator înspre afară şi peste 90% din trafic
este adus de utilizator din Internet. Viteza de comunicație este limitată de c (viteza
luminii în vid), care este aproximativ 300000km/s. pentru o distanță de 23000 de
mile întârzierea este de 100ms până la satelit şi încă 100ms înapoi şi în plus mai
apare şi întârzierea de procesare.
Microunde terestre
Legăturile terestre prin microunde sunt utile pe distanțe de până la 50Km atunci
când trebuie transmis semnalul în zone greu accesibile dar sunt afectate de
turbulențele meteorologice.
Radio
În rețelele radio celulare, o stație radio este plasată în mijlocul celulei, care de regulă
are diametrul mai mic de 20 de km. O bandă restricționată de frecvențe este folosită
în cadrul celulei, pentru comunicația între dispozitivele celulare şi stație. Celulele
învecinate folosesc o altă bandă de frecvențe, aşa că nu există confuzie la granițele
dintre celule atunci când un utilizator trece de la o celulă la alta în timp ce este în
mişcare. În aceste situații de regulă are loc o schimbare de frecvență.
128

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Arhitecturi de reţea: LAN
Un LAN (Local Area Network) este un mediu de comunicație care interconectează
calculatoare într‐o geografică limitată la cel mult câțiva kilometri. Un LAN permite
unui set de calculatoare şi alte dispozitive să partajeze resurse comune cum ar fi:
date, aplicații software, imprimante şi dispozitive de stocare.
Un LAN este format din hardware, software şi protocoale. Hardware‐ul constă din
cabluri şi circuite de interfață. Software‐ul de regulă este integrat în sistemul de
operare şi este responsabil pentru conectarea unui utilizator la rețea. Protocoalele
sunt mulțimi de reguli care guvernează formatul, sincronizarea, secvența şi
controlul erorilor. Protocoalele sunt importante pentru asigurarea faptului că datele
sunt împachetate pentru a fi trimise pe rețea şi sunt extrase din rețea în mod corect.
Datele sunt descompuse în elemente; fiecărui element i se adaugă un antet care
conține informații despre anumiți parametri cum ar fi destinația, sursa, biții de
protecție împotriva erorilor şi o marcă de timp. Datele sunt combinate cu antetul
pentru a forma pachete ce sunt trimise în rețea. Receptorul recurge la procesul
invers de extragere a datelor din pachete.
Procesul de comunicație prin rețea este de regulă efectuat într‐o ierarhie de paşi,
fiecare având propriul protocol. Paşii trebuie efectuați în ordine pentru transmisie şi
ordine inversă pentru recepție. Aceasta duce la noțiunea de stivă de protocoale, ceea
ce izolează protocolul folosit în cadrul ierarhiei.
Modelul OSI
Modelul OSI (Open System Interconnection) este un set de protocoale stabilite de
ISO (International Standard Organization) în încercarea de a defini şi a standardiza
comunicația de date. Modelul OSI a fost înlocuit de modelul Internet TCP/IP dar şi în
ziua de astăzi influențează comunicația prin rețea, în principal în industria
telecomunicațiilor.
În modelul OSI procesul de comunicație este împărțit în şapte niveluri: aplicație,
prezentare, sesiune, transport, rețea, legătură de date şi fizic aşa cum se vede în
figura de mai jos.
129

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Modulul OSI nu dă o singură definiție relativ la modul în care are loc efectiv procesul
de comunicație a datelor. Modelul OSI serveşte ca referință pentru modul în care
acest proces al trebuie împărțit şi ce protocoale ar trebuie folosite la fiecare nivel.
Conceptul este ca furnizorii de echipamente pot selecta un protocol pentru fiecare
nivel asigurând în acelaşi timp compatibilitate cu echipamente de la alți furnizori
care folosesc alte protocoale.
Nivelul cel mai de sus în modelul OSI este nivelul aplicaţie, care furnizează o
interfață ce permite aplicațiilor să comunice una cu alta prin rețea. Oferă suport de
nivel înalt pentru aplicații care interacționează prin rețea, cum ar fi servicii de baze
de date pentru programe ce accesează baze de date prin rețea, tratarea mesajelor
pentru programele de e‐mail şi manipularea fişierelor pentru programele de
transfer de fişiere.
Nivelul prezentare asigură că informația este prezentată aplicațiilor de comunicație
într‐un format comun. Aceasta e necesar deoarece sisteme diferite pot folosi intern
formate diferite de date. De exemplu, unele sisteme folosesc formatul intern big‐
endian pe când altele folosesc little‐endian. Funcția nivelului prezentare este de a
izola aplicația de aceste diferențe.
Nivelul sesiune stabileşte şi termină sesiunile de comunicație între procese. Nivelul
sesiune este responsabil pentru menținerea integrității comunicațiilor chiar şi
atunci când nivelurile de mai jos pierd date. De asemenea sincronizează schimbul şi
stabileşte puncte de referință pentru continuarea unui proces de comunicație
întrerupt.
Nivelul transport asigură transmisia sigură de la sursă la destinație. Alocă resurse de
comunicație astfel ca datele să fie transmise rapid şi eficient. Nivelul sesiune face
cereri nivelul transport, care ordonează cererile şi face compromisuri între viteză,
cost şi capacitate. De exemplu, transmisia poate fi împărțită în mai multe pachete,
care sunt transmise prin mai multe rețele pentru a obține un timp de comunicație
mai mic. Pachetele pot ajunge la destinație într‐o ordine aleatoare, iar nivelul
transport este responsabil ca nivelul sesiune să primească pachetele în aceeaşi
ordine în care au fost trimise. Nivelul transport furnizează corectarea de erori de la
sursă la destinație şi furnizează controlul fluxului (adică, asigură că vitezele
expeditorului şi receptorului sunt egale).
Nivelul reţea rutează datele prin sisteme intermediare şi subrețele. Spre deosebire
de nivelurile superioare, nivelul rețea ține cont de topologia de rețea, care
reprezintă conectivitatea dintre diferitele componente de rețea. Nivelul rețea
informează nivelul transport de starea conexiunilor potențiale şi existente din rețea
în ceea ce priveşte viteza, fiabilitatea şi disponibilitatea. Nivelul rețea este de regulă
implementat cu routere, care conectează diferite rețele ce folosesc acelaşi protocol
de transport.
Nivelul legătură de date gestionează conexiunile directe dintre componentele rețelei.
Acest nivel este împărțit în LLC (logical link control), care este independent de
topologia de rețea şi MAC (media acces control) care este specific topologiei. În
130

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
unele rețele conexiunile fizice dintre dispozitive nu sunt permanente, şi este
responsabilitatea nivelului legătură de date să informeze nivelul fizic când să
realizeze conexiunile. Acest nivel lucrează cu unități de date numite frame (pachete
izolate, sau colecții de pachete) ce conțin adrese, date şi informații de control.
Nivelul fizic asigură transmisia datelor brute de la sursă la destinație prin mediul de
comunicație fizic. Transmite şi repetă semnalele prin rețea. Nivelul fizic nu include
hardware‐ul propriu‐zis dar include metodele de accesare a hardware‐ului.
Topologii
Există trei topologii importante pentru rețele locale aşa cum se vede în figura de mai
jos:
Ce mai simplă este topologia bus (a). Componentele sunt conectate la o magistrală
sistem prin legarea lor la singurul cablu sau, în cazul rețelelor fără fir (wireless), prin
emiterea de semnale într‐un mediu comun. Avantajul acestui tip de topologie este că
fiecare componentă poate comunica direct cu orice altă componentă de pe
magistrală şi este relativ simplu să se adauge alte componente în rețea. Controlul
este distribuit componentelor, şi nu există o anumită componentă cu rol de
intermediar, ceea ce reduce costurile inițiale pentru acest tip de rețea. Dezavantajele
acestei topologii sunt: lungimea cablului de la magistrală la componentele rețelei;
pentru a adăuga o nouă componentă în rețea este necesară întreruperea magistralei,
ceea ce duce la întreruperea întregii rețele. Un exemplu de rețea bazată pe bus este
Ethernet.
Topologia inel (b) foloseşte un singur cablu, pentru care capetele sunt legate.
Pachetele sunt transmise prin inel şi trec prin fiecare componentă a rețelei până
când ajung la destinație. La destinație, pachetele sunt extrase din rețea şi nu mai
sunt transmise mai departe prin inel. Dacă pachetul ajunge înapoi la sistemul care l‐
a inițiat, atunci înseamnă că transmisia a eşuat, pachetul este oprit şi poate fi
încercată o nouă transmisie. Un exemplu de LAN cu topologie inel este IBM token
ring.
În topologia stea, fiecare componentă este conectată la un hub central, care are rolul
de intermediar pentru toate comunicațiile prin rețea. Într‐o configurație simplă hub‐
ul primeşte datele de la o componentă şi le trimite mai departe la toate celelalte
componente, lăsând în seama componentelor individuale să determine dacă datele
131

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
le sunt adresate. Într‐o configurație mai sofisticată, hub‐ul recepționează datele şi le
trimite doar destinatarului.
Un avantaj al topologiei stea este că majoritate serviciilor de rețea, modificările,
cablarea se face la hub‐ul central. Dezavantajul este că dacă se defectează hub‐ul
atunci toată rețeaua se opreşte. Un alt dezavantaj este că topologia stea necesită mai
mult cablu pentru a conecta componentele rețelei. Un exemplu de topologie stea
este ARCnet.
Transmisia datelor
Comunicația în cadrul unui calculator este sincronizată de un ceas, şi transmisia
biților este semnalată de voltaje joase/înalte ce sunt eşantionate la momentul
determinat de cea. Această schemă este simplă dar nu funcționează pe distanțe mai
mari, aşa cum este un LAN. Problema este că un şir lung de biți nu se poate
sincroniza cu exactitate atât cu ceasul sistemului emițător cât şi cu cel al
receptorului. Distanțele dintr‐un LAN sunt prea mari pentru a menține atât un ceas
global cât şi o viteză foarte mare. În rețele locale se foloseşte o sincronizare ce este
inclusă în datele ce se transmit.
La nivelul cel mai de jos al transmisiei se aplică această sincronizare. Al nivelul
următor fluxul de date este descompus în pachete şi cadre (engl. frame) ce sunt
transmise prin rețea într‐o ordine aleatoare. Nivelul legătură de date este
responsabil pentru descompunerea fluxului de date în pachete, transformarea
pachetelor în cadre şi injectarea cadrelor în rețea. Când recepționează cadre, nivelul
legătură de date extrage pachetele şi le asamblează într‐un format ce poate fi utilizat
de nivelul superior (nivelul rețea). Dimensiunea pachetelor de date este de regulă
câțiva KB şi necesită câteva microsecunde să fie transmise la viteze şi distanțe
obişnuite.
Ethernet este una din cele mai populare rețele bazate pe bus. Ethernet foloseşte
CSMA/CD (Carrier Sense Multiple Access with Collision Detection) pentru
transmisie. Cu această tehnologie, atunci când o componentă de rețea vrea să
transmită date, prima dată aşteaptă un carrier. Dacă există pe linie un carrier, care
este plasat de un dispozitiv ce transmite date, atunci nu va transmite nimic şi va
aştepta o anumită perioadă de timp (de regulă aleatoare). Perioada aleatoare este
importantă pentru a evita deadlock‐urile (situațiile fără ieşire) în care
componentele care încearcă să trimită date pe bus ascultă şi aşteaptă în mod
sincron. Dacă pe bus nu există trafic, atunci poate începe transmisia prin plasarea
unui carrier împreună cu datele. Sursă de asemenea monitorizează bus‐ul pentru
coliziuni, situație care apare atunci când două sau mai multe componente transmit
date simultan. O coliziune este detectată atunci când sunt prezenți mai mulți
carrieri. Coliziunile pot apare într‐o rețea ca rezultat al timpului finit necesar
semnalului pentru a traversa lungimea magistralei. Propagarea semnalului pe
magistrală este limitată de viteza luminii pe lungimea magistralei, lungime ce poate
fi până la 500 de metri pentru o rețea Ethernet tipică. Atunci când au loc coliziuni,
132

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
componentele ce transmit date vor aştepta un timp aleatoriu înainte de a
retransmite datele.
Datele sunt transmise în ambele direcții ale magistralei. Fiecare componentă „vede”
fiecare pachet de date, dar extrage doar pachetele ce le sunt adresate. După ce un
pachet este recepționat, la destinație se poate genera un mesaj de confirmare pentru
transmițător, de regulă la nivelul transport. Dacă transmițătorul nu primeşte
confirmarea după o perioadă de timp fixată (care trebuie să fie mai mare decât
întârzierea rețelei la un ciclu complet), atunci mesajul este retransmis.
Coliziunile apar rar în practică, aşa că latența dată de retransmisii nu este foarte
importantă. O degradare serioasă în performanța Ethernet nu are loc până când
traficul este sub limita de 35% din capacitatea rețelei.
Bridge, router, gateway
Pe măsură ce creşte dimensiune rețelelor acestea pot fi divizate în rețele mai mici
interconectate. Subrețelele mai mici operează independent una de alta şi pot folosi
protocoale şi topologii diferite.
Dacă toate subrețelele folosesc aceeaşi topologie şi aceleaşi protocoale, atunci
rețeaua poate fi extinsă folosind repeatere. Un repeater amplifică semnalul pe
rețea, semnal ce se atenuează pe măsură ce străbate rețeaua. Subrețelele nu sunt
independente în totalitate deoarece fiecare subrețea vede tot traficul de pe celelalte
subrețele. O rețea ce foloseşte doar repeatere nu se poate extinde foarte mult.
Repeaterele amplifică nu numai semnalul ci şi zgomotul de pe fir ceea ce va
determina în final dominarea semnalului de către zgomot dacă se folosesc prea
multe repeatere.
Un bridge nu numai că amplifică semnalul, acesta restaurează nivelurile individuale
ale semnalului la valorile logice 0 şi 1, ceea ce previne acumularea zgomotului.
Bridge‐urile au un anumit nivel de inteligență şi pot interpreta adresele destinație
ale pachetelor şi le pot transmite la rețeaua pentru care sunt adresate. Astfel,
traficul în rețea poate fi redus, din moment ce metoda alternativă ar fi trimiterea
pachetelor la fiecare subrețea (aşa cum se întâmplă în cazul folosirii repeaterelor).
Cu toate că bridge‐urile au un anumit nivel de inteligență în sensul că analizează
pachetele primite şi le rutează pe baza adresei de destinație, acestea nu țin cont de
protocol. Un router lucrează la un nivel mai înalt. Router‐ul conectează de regulă
rețele separate logic care folosesc acelaşi protocol de transport.
Un gateway translatează pachete până la nivelul aplicație din modelul OSI
(nivelurile 4 până la 7). Gateway‐urile conectează rețele diferite prin efectuarea
conversiilor de protocol, conversii în formatul mesajelor şi alte funcții de nivel înalt.
Erori de comunicaţie şi coduri corectoare de erori
Atunci când are loc o comunicație între sisteme de calcul sau chiar şi în cadrul unui
sistem de calcul există o anumită probabilitate ca datele să fie recepționate eronat
datorită zgomotului din canalul de comunicație. Reprezentările pentru date
133

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
considerate până acum utilizau simbolurile binare 0 şi 1. În realitate, simbolurile
binare au o formă fizică şi anume voltaje sau curent electric. Forma fizică este
supusă zgomotului introdus de mediul de comunicație, cum ar fi fenomene
atmosferice, raze gamma şi fluctuații ale curentului electric. Zgomotul poate cauza
erori, în care valorile 0 sunt transformate în 1 şi invers.
Presupunem că se transmite caracterul ASCII ‘b’ şi că în timpul transmisiei are loc o
eroare în urma căreia cel mai puțin semnificativ bit este inversat. Secvența binară
corectă pentru ‘b’ este 1100010. Secvența de biți recepționată este 1100011, ceea ce
corespunde caracterului ‘c’. Receptorul nu are cum să ştie că a avut loc o eroare doar
examinând secvența de biți recepționată. Problema este că fiecare din cele 128 de
secvențe de 7 biți reprezintă caractere ASCII valide şi dacă unul din cei 7 biți se
modifică secvența ce rezultă este tot un caracter ASCII valid.
Expeditorul poate trimite biți de verificare suplimentari împreună cu biții de date.
Receptorul poate examina aceşti biți şi în anumite condiții nu numai să detecteze
erori dar şi să le corecteze. În continuare vom prezenta două metode pentru a
realiza aceasta.
Definirea ratei de erori la nivel de bit
Există numeroase moduri în care pot apare erori în cadrul sistemelor iar erorile pot
lua diferite forme. Vom presupune că probabilitatea ca un bit recepționat să fie
eronat este independentă de probabilitatea ca biții învecinați să fie eronați. În acest
caz putem defini rata de erori la nivel de bit ca fiind probabilitatea ca un anumit bit
să fie eronat. Evident că acesta este un număr foarte mic, de regulă este mai mic de
10 ‐12 pentru fibra optică. Asta înseamnă că doar unul din 10 12 biți vor fi eronați. În
rețelele radio unul din 100 de pachete pot conține erori.
În cadrul unui sistem rata de erori este mai mică decât 10 ‐18. Un procesor de 500
MHz care prelucrează 32 de biți la fiecare ciclul de ceas va avea un număr de
erori/secundă egal cu 10 ‐18 erori/bit x 500 x 10 6 cuvinte/secundă x 32 biți/cuvânt =
1.6 x 10 ‐18 erori/secundă, adică aproximativ un bit eronat la doi ani de zile.
Pe de altă parte un flux de biți de la o linie de comunicație serială de un milion de
biți/secundă cu o rată de erori de 10 ‐10 , va avea un număr de erori egal cu 1 x 10 6 x
10 ‐10 sau 10 ‐4 erori/secundă adică, aproximativ 10 erori pe zi.
Detectarea şi corectarea erorilor
Una din cele mai simple şi mai vechi metode de detectare a erorilor foloseşte bitul
de paritate (s‐a folosit în cadrul sistemelor de telegraf).
134

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Bitul de
paritate
Poziţia bitului
Caracter ASCII pe 7
biţi
Caracter
Un bit de paritate se adaugă la fiecare caractere transmis astfel încât numărul de biți
egali cu 1 în fiecare caracter să fie par sau impar, în funcție de paritatea aleasă. În
exemplul nostru de transmitere a caracterului ASCII ‘b’, 1100010, presupunem că
dorim să folosim paritate pară şi atunci vom adăuga un bit 1 pentru a face par
numărul de biți egali cu 1, rezultând secvența de biți 11100010 pentru transmitere.
Bitul de paritate se poate adăuga la început sau la sfârşit în funcție de convenția
aleasă. Receptorul poate examina secvența de biți, şi dacă numărul de biți egali cu 1
este par, atunci poate considera că a recepționat caracterul fără erori. (Această
metodă nu mai este de nici un folos dacă probabilitatea ca doi biți să se modifice
este destul de mare. În acest caz trebuie folosite alte metode aşa cum vom vedea în
continuare).
Coduri Hamming
Dacă se adaugă biți suplimentari la date, atunci este posibil nu numai să detectăm
erori, dar şi să le corectăm. Unele din cele mai populare coduri corectoare de erori
se bazează pe munca lui Richard Hamming de la Bell Telephone Laboratories
(Lucent Technology).
Putem detecta un singur bit eronat într‐un cod ASCII prin adăugarea unui bit
redundant. Distanța Hamming defineşte distanța logică dintre două cuvinte valide,
ca măsură a numărului de cifre binare care diferă între cele două cuvinte. Dacă se
modifică un singur bit într‐un caracter ASCII, atunci secvența de biți ce rezultă este
un alt caracter ASCII. Distanța Hamming corespunzătoare pentru acest cod este 1.
Dacă recodificăm tabela ASCII astfel încât distanța Hamming să fie 2, atunci trebuie
modificați doi biți pentru a converti un caracter ASCII valid într‐altul. Astfel putem
detecta un singur bit eronat deoarece caracterul invalid va fi între două caractere
valide.
O modalitatea de a înregistra un caracter ASCII pentru o distanță Hamming de 2 este
de a atribui un bit de paritate, care ia valoarea 0 sau 1 pentru a face numărul de biți
egali cu 1 din codificarea caracterului par sau impar. Dacă folosim paritate pară,
atunci bitul de paritate pentru caracterul ‘a’ este 1 deoarece secvența de biți pentru
acest caracter conține 3 biți egali cu 1: 1100001. Bitul de paritate pentru caracterul
‘c’ este 0, ceea ce va duce la secvența de biți recodificată: 01100011. Dacă folosim
135

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
paritatea impară, atunci biții de paritate vor lua valoarea opusă: 0 pentru ‘a’ şi 1
pentru ‘c’.
Tabelul ASCII recodificat are acum 256 de poziții, din care jumătate (cele care au un
număr impar de biți egali cu 1) reprezintă caractere invalide. Dacă este recepționat
un caracter invalid, atunci receptorul ştie că a avut loc o eroare şi poate cere
retransmiterea caracterului.
Retransmiterea nu este întotdeauna practică iar pentru aceste cazuri ar fi util nu
numai să se poată detecta erorile dar să se şi corecteze. Folosirea bitului de paritate
va detecta eroarea dar nu va localiza poziția bitului eronat. Dacă este recepționată
secvența de biți 11100011 într‐un sistem care foloseşte paritate pară, atunci
eroarea este detectată pentru că paritatea cuvântului este impară. Nu există
suficientă informație pentru a determina doar cu ajutorul bitului de paritate care a
fost caracterul transmis (chiar şi bitul de paritate poate fi eronat).
Pentru a construi un cod corector de erori capabil să detecteze şi să corecteze
cuvinte ce conțin un singur bit eronat, trebuie să adăugăm mai multă redundanță
prin extinderea numărului de biți din cuvânt. De exemplu, să considerăm secvența
de biți pentru caracterul ‘a’ – 1100001. Dacă vrem să detectăm şi să corectăm un
singur bit eronat care poate să apară în orice poziție în cadrul cuvântului, atunci
trebuie să atribuim încă 7 secvențe de biți caracterului ‘a’ secvențe în care un singur
bit este modificat față de secvența binară corespunzătoare lui ‘a’: 0100001,
1000001, 1110001, 1101001, 1100101, 1100011, 1100000. Putem face acelaşi
lucru şi pentru celelalte caractere, dar trebuie să facem în aşa fel încât nici o
secvență de biți să nu fie comună la mai mult de un caracter ASCII; altfel nu vom
avea la dispoziție un mod de determinare neambiguu a secvenței binare originale.
O problemă cu folosirea redundanței în acest fel este că atribuim 8 secvențe de biți
fiecărui caracter: una pentru caracterul original şi încă şapte pentru secvențele de
biți învecinate eronate. Din moment ce avem 128 de caractere ASCII şi 8 secvențe
pentru fiecare caracter, înseamnă că putem recodifica 128/8 = 16 caractere dacă
folosim doar cei 7 biți pentru reprezentarea caracterelor.
Pentru a recodifica toate caracterele ASCII, trebuie să adăugăm biți de redundanță
suplimentari (numiți biţi de verificare). Acum trebuie să determinăm de câți biți
avem nevoie. Dacă cuvintele ce vrem să le recodificăm sunt de k biți şi folosim r biți
de verificare atunci are loc următoarea relație:
2 k x (k + r + 1)

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
numărul de secvențe binare din codul corector de erori. Pentru k = 7 vom obține r =
4 aşa că vom avea 11 biți în reprezentarea cuvintelor din codul corector de erori.
Acum vom vedea cum putem recodifica tabela ASCII într‐un cod pe 11 biți. Scopul
este de a atribui biții redundanți cuvântului original astfel încât orice bit eronat să
poată fi identificat. O modalitate de a face această atribuire este prezentată în figura
de mai jos:
Biţii de verificare Poziţiile
verificate
Fiecare din cei 11 biți are un index de la 1 la 11, iar reprezentarea binară pe 4 biți a
întregilor de la 1 la 11 este prezentată lângă fiecare index. Cu aceste atribuire,
fiecare din cele 11 linii sunt diferite (nu există două linii în care biții 1 să fie în
aceeaşi poziție).
Citind în jos fiecare din cele patru coloane, bitul 1 ne spune că poziția verificată
(care apare în coloana din dreapta) va fi inclusă într‐un grup care trebuie să formeze
paritate pară. De exemplu, bitul de verificare C8 acoperă un grup de 4 biți în pozițiile
8, 9, 10 şi 11, care trebuie să formeze paritate pară. Dacă această proprietate este
satisfăcută atunci când cuvântul de 11 biți este transmis, dar o eroare de transmisie
produce o paritatea impară la receptor, atunci receptorul va şti că este o eroare la
una din pozițiile 8, 9, 10 sau 11. Poziția exactă poate fi determinată prin examinarea
celorlalți biți de verificare, aşa cum vom vedea.
Fiecare bit din cuvântul codificat de 11 biți, care include biții de verificare, este
atribuit unei combinații unice a celor patru biți de verificare C1, C2, C4 şi C8.
Combinațiile sunt calculate ca reprezentare binară a poziției bitului ce este verificat,
începând de la poziția 1. C1 este astfel în poziția 1, C2 este în poziția 2, C4 în poziția
4 şi C8 în poziția 8. biții de verificare pot apare în orice poziții, dar de regulă apar în
poziții ce corespund puterilor lui 2 pentru a simplifica procesul de localizare a
erorilor. Acest cod se numeşte SEC (Single Error Correcting code).
Din moment ce poziția fiecărui bit egal cu 1 în fiecare din combinație de biți de
verificare este unică, putem localiza o eroare prin observarea unui bit de eroare
eronat. Dacă considerăm configurația din figura de mai jos:
137

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Poziţia bitului
Biţii de verificare
valorile biților de verificare sunt determinate în conformitatea cu tabelul precedent.
Bitul de verificare C1 = 0 creează paritate pară pentru grupul de biți {1, 3, 5, 7, 9,
11}. Membri acestui grup sunt luați din pozițiile care au valoarea 1 în coloana C1 din
tabel. Bitul de verificare C2 = 1 creează paritate pară pentru grupul de biți {2, 3, 6, 7,
10, 11}. Bitul de verificare C4 = 0 creează paritate pară pentru grupul de biți {4, 5, 6,
7}. Bitul de verificare C8 = 0 creează paritate pară pentru grupul de biți {8, 9, 10,
11}.
Ca o alternativă la căutarea într‐un tabel al biților de paritate, în general, bitul n al
cuvântului codificat este verificat de biții de verificare din pozițiile b1, b2, …, bj, astfel
încât b1 + b2 + … + bj = n. De exemplu, bitul 7 este verificat de biții din pozițiile 1, 2 şi
4 pentru că 1 + 2 + 4 = 7.
Acum să presupunem că receptorul primeşte secvența de biți 10010111001.
Presupunem că s‐a folosit codul SEC descris mai sus pentru caractere ASCII şi
întrebarea este ce caracter a fost trimis. Prima dată calculăm paritatea pentru
fiecare bit de verificare aşa cum se vede în figura de mai jos:
Poziţia biţilor
Biţii de verificare
Poziţia erorii
Paritate
impară
pară
impară
pară
Aşa cum se vede biții de verificare C1 şi C4 au paritate impară. Pentru a localiza
eroarea, adunăm pozițiile biților de verificare impari. Astfel, eroarea este în poziția
1+ 4 = 5. Cuvântul trimis este 10010101001. Dacă eliminăm biții de verificare,
obținem secvența 1000100, ceea ce corespunde caracterului ASCII ‘D’.
O modalitate de a privi SEC este: cuvintele valide sunt la o distanță suficient de mare
unul de altul astfel încât o singură eroare va plasa un cuvânt eronat mai aproape de
un anumit cuvânt valid față de orice alt cuvânt valid. De exemplu, putem considera
un cod SEC pentru doar două simboluri {000, 111}. Relația distanței Hamming
pentru toate secvențele de 3 biți sunt prezentate în figura de mai jos sub forma unui
cub:
138

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Coduri de
eronate
Cod
valid
Cod
valid
Schimbarea a trei biţi într-un
cod valid duce la o distanţă
Hamming de 3
Coduri
eronate
Pentru cuvinte de dimensiuni mai mare cubul are un corespondent numit hipercub.
Cele două cuvinte valide sunt plasate în vârfuri opuse ale cubului. Orice eroare de un
singur bit va localiza un cuvânt eronat pe un alt vârf al cubului. Fiecare cuvânt
eronat are un cuvânt valid cel mai apropiat, ceea ce face posibilă corectarea unui
singure erori.
Codifiare SECDED
Dacă considerăm acum că există două erori, atunci putem vedea că codul SEC
funcționează pentru dublă detectarea de erori (DDE) dar nu şi pentru dublă
corectare de erori (DCE). Aceasta se numeşte codificare SECDDE (engl. SECDED –
SEC double error detection). Din moment ce cuvintele valide sunt despărțite de o
distanță Hamming egală cu 3, două erori vor fi localiza un cuvânt eronat pe cub şi
astfel pot fi detectate două erori. Cuvântul valid original însă nu poate fi determinat
în mod neambiguu. Pentru a corecta două erori, trebuie întreținută o distanță
Hamming egală cu 5. În general trebuie întreținută o distanță Hamming egală cu p +
1 pentru a detecta p erori şi o distanță Hamming de 2p+1 pentru a corecta p erori.
Verificare verticală a redundanţei
Codul SEC este folosit pentru detectarea şi corectarea unui singur bit eronat. Biții
redundanți sunt adăugați la fiecare cuvânt, fi fiecare cuvânt rezultat este tratat
independent. Schema de recodificare se mai numeşte verificare orizontală sau
longitudinală a redundanţei deoarece lungimea cuvântului se extinde cu numărul de
biți redundanți.
O abordare alternativă este de a folosi verificare verticală a redundanţei în care o
sumă de verificare a cuvântului este adăugată la sfârşitul unui grup de cuvinte
transmise. În acest caz, paritatea este calculată coloană cu coloană, formând un
cuvânt ce conține suma de verificare, cuvânt ce este adăugat mesajului. Cuvântul cu
suma de verificare este calculat şi transmis de expeditor şi este recalculat şi
comparat cu cuvântul ce conține suma de verificare recepționată de către receptor.
Dacă se detectează o eroare, atunci receptorul trebuie să ceară retransmiterea
cuvântului din moment ce nu există suficientă redundanță pentru a identifica poziția
eronată.
139

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Verificare ciclică a redundanţei (Cyclic Redundancy Checking ­ CRC)
CRC este o schemă mai puternică de detectare şi corectare a erorilor care operează
în prezența unor burst errors, care încep şi se termină cu un bit eronat, cu zero sau
mai mulți biți intermediari eronați. Biții eronați de la capete sunt incluşi în burst
error. Dacă lungimea unui burst error este B, atunci trebuie să fie B sau mai mulți biți
corecți între mai multe burst errors.
CRC foloseşte coduri polinomiale, în care un cadru de date ce trebuie transmis este
împărțit cu un polinom iar restul împărțirii este adăugat cadrului de date ca o
secvență de verificare a cadrului (engl. Frame Check Sequence ‐ FCS), numită cifre
CRC. După recepționarea cadrului, receptorul face aceleaşi calcule, folosind acelaşi
polinom, şi dacă restul împărțirii este identic cu cel recepționat atunci nu există
erori detectabile. Pot exista erori nedetectabile, iar scopul la crearea unui cod CRC
este de a selecta un polinom care acoperă cele mai probabile erori pentru un anumit
model.
Abordarea este de a lua un mesaj de k biți ce trebuie transmis, M(x), la care se
adaugă n biți 0, unde n este gradul polinomului generator, G(x), cu k > n. Forma
extinsă a lui M(x) este împărțită la G(x) folosind aritmetică modulo 2 (în care
transportul şi împrumutul sunt ignorate), iar restul împărțirii R(x), care nu are mai
mult de n biți, formează cifrele CRC pentru M(x).
Ca exemplu, să considerăm că trebuie transmis cadrul:
M(x) = 1101011011
şi că polinomul generator este G(x) = x 4 + x + 1. Gradul lui G(x) este 4, aşa că
adăugăm 4 biți zero la M(x) pentru a forma deîmpărțitul operației.
Divizorul este 10011, ceea ce corespunde coeficienților din G(x) scris ca:
G(x) = 1 x x 4 + 0 x x 3 + 0 x x 2 + 1 x x 1 + 1 x 0 .
G(x) are gradul n = 4 şi există n + 1 = 5 coeficienți. Cifrele CRC sunt calculate aşa cum
este prezentat în figura de mai jos:
G(x), de grad
n = 4
SAU exclusiv pe biţi
(XOR), este la fel ca
şi adunarea şi
scăderea modulo-2
Cadrul transmis
Câtul este eliminat
la calculul CRC
original
n = 4 zerouri
R(x) este CRC
pentru M(x)
140

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Dacă în timpul transmisiei T(x) = M(x) + R(x) se alterează receptorul trebuie să poată
determina aceasta. Receptorul împarte cadrul primit G(x) şi toate burst errors care
nu îl includ pe G(x) ca factor vor fi interceptate pentru că restul va fi diferit de zero.
Atâta timp cât biții 1 din 10011 nu coincid cu pozițiile erorilor din cadrul
recepționat, toate erorile vor fi interceptate. Un cod polinomial de grad n va
intercepta toate burst errors de lungime mai mică sau egală cu n.
Polinoame care dau rezultate bune în ceea ce priveşte detectare erorilor sunt:
CRC­16 = x 16 + x 15 + x 2 + 1
CRC­CCITT = x 16 + x 12 + x 5 + 1
CRC­32 = x 32 + x 26 + x 23 + x 16 + x 12 + x 11 + x 10 + x 8 + x 7 + x 5 + x 4 + x 2 + x + 1
Arhitecturi de reţea: Internet
La începuturile erei informatice sistemele de calcul erau centralizate şi conțineau
toate resursele necesare. Datele erau transferate între sisteme de calcul diferite prin
diferite medii (cartele perforate, benzi magnetice, discuri magnetice).
Pe măsură ce a crescut numărul sistemelor de calcul iar costurile s‐au înclinat mai
mult dinspre hardware înspre servicii, a devenit rentabil din punct de vedere
economic conectarea directă a calculatoarelor astfel încât să fie posibilă partajarea
resurselor. Despre asta e vorba când vorbim despre rețele. Am prezentat deja
rețelele locale în contextul celor şapte niveluri din modelul OSI. În continuare vom
prezenta aspecte arhitecturale ale rețelelor de calculatoare în contextul modelului
Internet.
Modelul Internet
În sistemele de telecomunicații pot fi mai multe surse şi mai multe destinații. Un
exemplu pentru această formă de comunicație este o rețea telefonică. Pentru ca
fiecare telefon să poată fi apelat de la orice alt telefon trebuie să existe o cale, un
canal, între fiecare sursă şi destinație. Dacă există un milion de telefoane în locația A
şi un milion de telefoane în locația B atunci numărul de canale dintre locația A şi B
trebuie să fie un milion x un milion. Din fericire nu toți cei din locația A vor să
comunice cu toți cei din locația B aşa că un număr mult mai mic de canale este
suficient, canale ce sunt partajate. Pe de altă parte trebuie să fie cel puțin o linie de la
fiecare telefon din locația A la sediul central al companiei de telefoane şi trebuie să
fie suficiente linii între sediile centrale din A şi B pentru a putea gestiona numărul
maxim de conversații simultane.
Un număr mic de conexiuni fizice (în funcție de tipul de mediu de transmisie – fibră
optică sau fire tradiționale), este necesar pentru ca conecta locațiile A şi B deoarece
nu se va întâmpla niciodată ca simultan toți cei din locația A să apeleze pe cineva din
locația B. Capacitatea de transfer de informație a conexiunilor (numită lăţime de
bandă) este partajată de toți utilizatorii astfel că se realizează o reducere
141

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
substanțială a costurilor. Trebuie creat un mecanism de control care să permită
partajarea lățimii de bandă într‐un mod corespunzător.
Nivelurile în suita de protocoale TCP/IP
Un internet (cu i mic) este o colecție de rețele interconectate. Internet (cu i mare)
este probabil cel mai cunoscut internet, care foloseşte protocolul TCP/IP şi adrese
IP. Cele şapte niveluri din modelul OSI au fost simplificate într‐o oarecare măsură
pentru modelul Internet, model care are doar patru niveluri, aşa cum se vede în
figura de mai jos.
La nivelul cel mai de jos este nivelul Legătură format din subnivelurile MAC
(Medium Access Control) şi PHY (Fizic). Nivelul Legătură rezolvă „disputele” pentru
mediul de comunicație atunci când mai multe dispozitive încearcă să transmită,
gestionează gruparea logică a biților în cadre de date şi implementează protecția
împotriva erorilor.
Nivelul legătură este responsabil pentru transmiterea unui cadru de biți de la o
maşină la o alta maşină legată direct de ea. Aceasta funcționează bine între două
procese aflate pe maşini diferite care cooperează. Pentru ca mai multe procese să
partajeze acelaşi mediu de comunicație este nevoie de un protocol care să
coordoneze deplasare datelor de la un proces la altul. Aceasta este responsabilitatea
nivelului Reţea, care este implementat cu protocolul IP (Internet Protocol).
Nivelul Reţea se ocupă cu comunicația de la un punct la altul. Nivelul Transport se
ocupă cu comunicația end‐to‐end, în care pot fi mai multe puncte intermediare între
transmițător şi receptor. Nivelul Transport se ocupă cu retransmisia (în cazul
erorilor sau a pachetelor abandonate datorită congestionării mediului de
comunicație), secvențiere (pachetele pot recepționate într‐o ordine diferită de cea
de la transmisie), controlul fluxului, protecție împotriva erorilor (nivelul Legătură
nu face suficient în acest sens). În Internet nivelul Transport este implementat cu
protocolul TCP (Transmission Control Protocol). Combinația TCP/IP la nivelul Reţea
şi Transport este suita de protocoale dominante în Internet. La nivelul Legătură şi
Aplicaţie pot fi folosite orice alte protocoale. Pentru nivelul Transport şi Reţea există
şi alte tipuri de protocoale.
142

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
La nivelul Aplicaţie, un proces poate efectua schimb de date cu orice alt proces de
altundeva din Internet şi să trateze conexiunea ca şi cum ar fi un fişier pe sistemul
local, citind şi scriind octeți cu apeluri sistem obişnuite. De regulă aceste operații
sunt implementate prin socket‐uri, care sunt căi de comunicație spre rețea prin
sistemul de operare.
Adrese Internet
Fiecare interfață pe Internet are o adresă IP unică. Versiunea 4 a protocolului IP,
numită IPv4, este folosită încă pe scară largă dar este înlocuită de IPv6, care
foloseşte adrese de 4 ori mai mari decât IPv4 şi are o serie de îmbunătățiri şi
simplificări. Un exemplu de adresă IPv4 în forma cu puncte este dată mai jos:
165.230.140.67
Fiecare număr delimitat de caracterul punct este un număr întreg fără semn pe 8
biți din intervalul 0..255. Secvența binară corespunzătoare adresei de mai sus este:
10100101.11100110.10001100.01000011
Bitul cel mai din stânga (cel mai semnificativ) determină clasa de adresă. Figura de
mai jos prezintă cele cinci clase de adrese din IPv4.
Clasa A are 7 biți pentru identificare rețelei (ID) şi 24 de biți pentru ID host‐ului.
Astfel pot fi cel mult 2 7 rețele de clasă A fiecare din ele cu 2 24 host‐uri. O parte din
aceste adrese sunt rezervate, aşa că numărul de adrese ce pot fi atribuite host‐urilor
este mai mic decât numărul total de adrese posibile.
Adresele de clasă B folosesc 14 biți pentru identificatorul de rețea şi 16 biți pentru
identificatorul host‐urilor. Adresele de clasa C folosesc 21 de biți pentru ID‐ul rețelei
143

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
şi 8 biți pentru identificatorul de host. Adresele de clasă D sunt folosite pentru
grupuri multicast, la care un sistem care are adresă de clasă A, B sau C se poate
conecta şi va primi tot traficul de rețea ce este destinat grupului. Acesta este un
mecanism eficient pentru trimiterea aceloraşi pachete la mai multe sisteme, fără a
inunda rețeaua prin broadcast şi fără ca expeditorul să fie nevoit să țină evidența
tuturor sistemelor conectate. Adresele de clasă E sunt rezervate.
În momentul în care toate adresele IPv4 (adrese pe 32 de biți) disponibile vor fi
atribuite Internet‐ul nu va mai putea evolua aşa că este necesară adoptarea cât mai
curând a IPv6 ( acest protocol are adrese IP pe 128 de biți). În multe rețele se
folosesc protocoale ce permit partajarea adreselor IP; prin liniile dial‐up adresele IP
sunt atribuite dinamic doar pe durata sesiunii.
Porturi
Un port este mijlocul prin care un proces se deschide spre exterior. Un număr de
port identifică procesul sursă şi un alt număr de port identifică procesul destinație.
Un port identifică un punct de intrare în rețea pentru un proces. Porturile de la 0 la
1023 sunt porturi bine cunoscute pentru procese sever. De exemplu, portul telnet
este 23. Pe un sistem Unix, comanda:
%telnet fs.uoradea.ro 23
va conecta utilizatorul la sistemul fs.uoradea.ro. Dacă portul 23 nu este prezent în
linia de comanda se va considera implicit că este portul 23. Dacă 23 este înlocuit cu
alt port, de exemplu 13 (daytime), atunci se va ajunge la un alt serviciu, care are
comportament diferit.
Încapsulare
Datele din rețea sunt încapsulate pe măsură ce trec prin nivelurile de rețea aşa cum
se vede în figura de mai jos:
Datele utilizator sunt trimise în rețea folosind apeluri sistem pentru citire şi scriere
similare cu cele folosite la accesarea fişierelor. Nivelul Aplicaţie trimite datele
144

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
utilizator la nivelul Transport, unde sistemul de operare adaugă un antet TCP care
identifică porturile sursă şi destinație, formând un segment TCP. Segmentul TCP
este transmis la nivelul Reţea, unde segmentul TCP este reîmpachetat în datagrame
IP, fiecare cu un antet IP care identifică sistemele sursă şi destinație. Datagramele IP
sunt trimise la nivelul Legătură unde datagramele sunt încapsulate în segmente
(engl. frame) Ethernet (pentru acest exemplu). La destinație are loc procesul invers.
Un segment TCP poate fi descompus în mai multe datagrame IP, care sunt rutate
independent prin Internet. Fiecare datagramă conține adresele IP sursă şi destinație
(în antetul IP), porturile sursă şi destinație (în header‐ul TCP) şi protocolul de la
următorul nivel de încapsulare (în antetul IP – TCP este doar un protocol de nivel
transport folosit în Internet; mai există şi altele, de ex. UDP). Aceşti cinci parametri
identifică în mod unic fiecare datagramă IP în drumul ei prin Internet, ceea ce
permite trimiterea datagramei la procesul destinatar corect.
DNS (Domain Name System)
DNS este o bază de date distribuită care asociază nume de host şi adrese IP şi
furnizează informații pentru rutarea e‐mail. De exemplu adresa simbolică
www.uoradea.ro este asociată cu adresa IP 193.231.135.12. Mai multe nume pot fi
asociate cu aceeaşi adresă IP. DNS este responsabil pentru interacțiunea cu
programe care au nevoie de aceste asociere.
Fiecare domeniu (cum ar fi uoradea.ro) are propria bază de date cu informații şi
rulează un server pe care alte sisteme din Internet îl pot interoga. Accesul la DNS se
face printr‐un resolver, care este integrat în rutinele de bibliotecă, rutine ce sunt
link‐editate în programele ce accesează rețeaua.
NIC (Network Information Center) este organizația care gestionează domeniile toplevel
şi delegă autoritatea pentru domeniile din nivelul următor (nivelul 2). În cadrul
unei zone, un administrator local întreține baza de date pentru serverul de nume.
Trebuie să existe un server de nume primar, care îşi încarcă baza de date dintr‐un
fişier şi servere de nume secundare, care îşi iau informația de la serverul primar. Se
foloseşte un cache, astfel încât o interogare care provoacă contactarea altor servere
nu va mai necesita contactarea ulterioară a acelor servere.
World Wide Web
WWW este format din procese client (browserele Web) şi servere Web care rulează
http (HyperText Transfer Protocol) la nivelul Aplicaţie al Internet. Ceea ce trebuie
ştiu este că WWW != Internet. WWW este o aplicație creată pentru Internet.
În 1989, Tim Berners‐Lee de la CERN (laboratorul european pentru fizica
particulelor) a dezvoltat un Web bazat pe text, pentru schimbul de documente
tehnice printre colegi. În februarie 1993, NCSA (National Center for Supercomputing
Applications) din cadrul Universității Illinois a lansat o versiune grafică a
browserului Web Mosaic precum şi un server http, ambele gratuite şi de atunci
WWW a explodat şi a ajuns la ceea ce ştim astăzi.
145

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Bridge, router şi switch
Un hub este un punct de conexiune central pentru sisteme de calcul. Un hub se
numeşte bridge atunci când un sistem de calcul este un alt hub. Un hub doar copiază
pachetele de pe o interfață de rețea pe toate celelalte, aşa cum se în figura de mai jos
(a):
Hub‐urile şi bridge‐urile nu au multă inteligență, ele fiind capabile doar să izoleze
conexiunile la o singură rețea (dacă două pachete intră în coliziune într‐o rețea, ceea
ce este destul de normal dar de nedorit, semnalul de coliziune nu este propagat şi la
alte rețele), şi să limiteze trimiterea anumitor tipuri de trafic la alte interfețe.
Un ruter (engl. router) conectează o rețea la alta (fig. b) şi ia decizii în legătură cu
transmiterea pachetelor dincolo de limitele unei rețele. Un ruter are mai multe
interfețe de rețea şi trimite pachetele de la o interfață la alta. Pe interfețe diferite
protocoalele de rețea pot să difere.
Un ruter trimite pachetele pe baza protocolului, pe când un switch le trimite doar pe
baza adresei de destinație. Un switch este un hub de mare viteză care nu partajează
lățimea de bandă (fig. c). Un switch elimină conflictele de acces la mediul de
transmisie.
O îmbunătățire a switch‐ului este o rețea cu auto‐rutare în care se creează automat
conexiunile sursă‐destinație, pe baza adreselor din antetele pachetelor ce
traversează rețeaua. Un exemplu este un switch cu auto‐rutare cu 4 intrări şi 4 ieşiri.
Aceasta se poate realiza folosind algoritmul bubble­sort, în care pachetele cu cea mai
mică adresă sunt puse în partea de sus, prin interschimbarea pachetelor învecinate,
pachetele cu cea mai mare adresă ajungând în partea de jos. Pentru n canale, trebuie
făcute n(n­1)/2 comparații. Pentru n = 4 numărul de comparații ce trebuie făcute
este 6, ceea ce înseamnă că avem nevoie de 6 circuite de comparație. Switch‐ul
corespunzător este prezentat în figura de mai jos:
146

Universitatea din Oradea, Facultatea de Ştiinţe, sem I, 2009-2010
Departamentul de Matematică şi Informatică
Suport de curs pentru disciplina „Arhitectura sistemelor de calcul”
Specializarea: Informatică anul I Lector univ. dr. Horea Oros
Pachetele nesortate intră în partea stângă şi ies sortate în parte dreaptă după adresa
de desetinație.
Concluzii
Comunicația implică transferul informației între sisteme. Ca o regulă, datele sunt
transmise serial deoarece există o întotdeauna o întârziere la transferul de date prin
rețelele de mare viteză. Totuşi schemele de modulare permit codificarea mai multor
biți într‐o singură unitate de transfer. Alegerea schemei de modulare influențează
apariția erorilor la transferul de informație. Detecția şi corecția erorilor sunt
posibile prin redundanță, ceea ce presupune existența mai multor secvențe de biți
decât numărul maxim de secvențe de biți valide. Dacă o secvență de biți nu are un
singur cuvânt valid cel mai apropiat, atunci detectarea erorii este posibilă dar nu şi
corectarea. Dacă fiecare secvență de biți poate fi creată dintr‐o singură secvență de
biți validă atunci corectarea erorii este posibilă.
Rețelele LAN gestionează complexitatea folosind niveluri ce sunt bazate pe modelul
OSI. Rețelele locale sunt conectate la rețele WAN, în principal rețeaua Internet.
Rețeaua Internet se bazează pe suita de protocoale TCP/IP. Datele utilizator sunt
încapsulate la nivelurile Aplicaţie, Transport, Reţea şi Legătură şi sunt trimise prin
Internet şi decapsulate la destinație. În drumul lor înspre destinație, datele
traversează o serie de medii de transmisie, care diferă în lățime de bandă şi distanța
maximă la care se pot transfera datele.
147