MULTIPROCESOARE PE UN CHIP

• Comparatie SMT – CMP

• SMT
• Arhitectura Hirata
• Modelele Tullsen
• Hyperthreading Technology (Intel)
• CMP
• Hydra
• Piranha
• Arhitecturi tera-scalare
• Proiectul Teraflop (Intel)
• Proiectul Cell
 SMT vs. CMP

Dezvoltarea tehnologiei de fabricatie a circuitelor integrate => cresterea

densitatii de integrare => cresterea optiunilor de proiectare.

Paralelism: executia simultana de instructiuni in cadrul unui program

secvential. Ex: arhitecturile superscalare -> executie out-of-order si executie
speculativa a instructiunilor (cu tehnici de predictie dinamica).
=> cost mare pentru extragerea de paralelism dintr-un singur thread (marirea
suprafetei necesare pe chip, timpi crescuti de proiectare si verificare).

Alternative microarhitecturale cu thread-uri multiple de control: SMT

(„simultaneous multithreading”) si CMP („chip multiprocessors”).
 
SMT = thread-uri multiple independente trimit instructiuni la unitati
functionale superscalare intr-un singur ciclu => utilizare mai buna a resurselor
procesorului si toleranta superioara la intarzieri.
 
CMP = utilizeaza core-uri relativ simple de procesor single-thread, executand
thread-uri multiple in paralel. Daca o aplicatie nu poate fi descompusa in thread-uri,
CMP este subutilizat.
 Paralelism:

-paralelism la nivel de instructiuni (ILP “instruction-level of

parallelism”): procesoarele au hardware special pentru identificarea dinamica a
instructiunilor independente care pot fi lansate in acelasi ciclu (se utilizeaza un rezervor
de instructiuni si un mecanism de redenumire a registrelor pentru eliminarea
dependentelor false);

-paralelism la nivel de thread-uri (TLP “thread-level parallelism”):

executia in paralel a mai multor thread-uri.
 SMT

SMT: mai multe thread-uri intra in competitie si partajeaza resursele

disponibile ale procesorului in fiecare ciclu.

Executia unui program paralel: TLP si ILP (in mod interschimbabil).

Probleme de design hardware -> complexitatea arhitecturilor SMT :

-aria ocupata creste x4 cu complexitatea core-ului (complexitatea

crescand si timpul de proiectare);

-creste durata ciclului datorita logicii complexe;

-core-urile CPU sunt complexe, compuse din mai multe componente

strans interconectate => cresterea costului proiectarii si verificarii.
Cauze pentru resurse inactive: pierderea orizontala si pierderea verticala:
 Pierderile orizontale: lipsa paralelismului la nivel de instructiuni pentru
instructiuni apartinand unui singur proces.

Pierderea verticala: asteptarea pentru citirea dintr-o memorie indepartata cu

latenta mare => nu se mai lanseaza noi instructiuni (fenomen asemanator cu blocarea
procesorului).

Principiul de baza al SMT: intr-un ciclu de memorie instructiunile lansate nu

apartin neaparat aceluiasi thread. Astfel exista putin ILP pentru un thread, dar pentru ca
se lanseaza si instructiuni ale altor thread-uri => pierderea orizotala este diminuata. In
acelasi timp, executia simultana de thread-uri diferite => cresterea TLP.
Arhitectura Hirata
Instructiunile lansate sunt planificate dinamic de unitatile de planificare instructiuni.

Daca unitatile functionale sunt libere -> aceste instructiuni sunt trimise la unitatile
functionale pentru executie.

Logica de arbitrare implementeaza un mecanism de rotatie a prioritatilor.

Daca totusi instructiunile nu pot fi trimise imediat la unitatile functionale, atunci

acestea sunt memorate in statiile de asteptare (de adancime 1).

Fisierul de registre comun tuturor thread-urilor, dar impartit in bancuri

=> un banc: set privat de registre pentru fiecare thread.

Registrele de coada sunt utilizate pentru comunicatia intre thread-uri la nivelul

transferurilor intre registre.

Starea fiecarui thread, inclusiv registrele reprezinta un cadru de context. Schimbarea de

context se face rapid prin schimbarea legaturii logice intre un thread si cadrul context,
fara referinta la memorie => overhead scazut.
 Modelele Tullsen
Modele Tullsen (University of California, San Diego) pentru SMT
(complexitati hardware diferite) cu 10 unitati functionale, permitand lansarea a 8
instructiuni pe ciclu:

-multithreading de granulatie fina: in fiecare ciclu un singur thread lanseaza

instructiuni (impiedica pierderea verticala, dar nu si cea orizontala);

-lansare complet simultana: toate cele 8 thread-uri active pot intra in

competitie pentru fiecare slot de lansare. Se poate intampla ca toate cele 8 instructiuni
care se executa intr-un ciclu sa apartina aceluias thread;

-lansare singulara, lansare duala, lansare ordin patru: fiecare thread poate lansa
1, 2 sau 4 instructiuni per ciclu, rezultand numarul de thread-uri 8, 4 sau 2;

-conexiune limitata: fiecare context (thread) este direct conectat la o singura

instanta a fiecarui tip de unitate functionala (exemplu: daca exista 4 unitati intregi,
atunci o unitate de intregi poate primi instructiuni de la exact doua thread-uri) =>
flexibilitate redusa.
Performante:

Complexitatea hardware pentru modelul cu lansare complet simultana este foarte mare
(deci si costul). Performantele modelelor cu lansare de ordin 4 si chiar 2 sunt apropiate,
dar la un cost mai scazut.
 Asigurarea fluxului de instructiuni
Problema importanta: asigurarea ca in fiecare ciclu sa fie suficiente
instructiuni citite din memorie. Solutii:
-unitatea de fetch este divizata pentru citirea de instructiuni de la thread-uri
diferite;
-fetch selectiv: se aplica algoritmi pentru selectarea thread-urilor pentru care se vor
citi instructiuni. Algoritmi:
-BRCOUNT: prioritate maxima thread-ul cu probabilitate minima de
a se afla pe o secventa gresita (se numara instructiunile de salt „branch” => prioritate
maxima thread-ul cu numarul minim de instructiuni “branch”);
-MISSCOUNT: prioritate maxima thread-ul cu numarul minim de
evenimente lipsa in cache;
-ICOUNT: prioritate maxima thread-ul cu numarul minim de
instructiuni in banda de asamblare in segmente anterioare unitatilor functionale;
-IQPQSN: prioritate minima thread-ului care are instructiuni in coada
in ultimele pozitii (introduse recent) => cele mai bune rezultate cu ICOUNT.
-pre-executie: accelerarea thread-urilor prin generarea de noi thread-uri care
realizeaza diferite pre-executii (precitirea datelor si instructiunilor, prezicerea
ramificatiilor, etc.);
-tehnici de paralelizare a buclelor (restructurarea buclelor, fuziunea buclelor,
desfacerea buclelor etc);
-optimizari ale compilatoarelor;
 Analiza ariei ocupate in functie de numarul de thread-uri
 
Burns si Gaudiot -> cresterea liniara a capacitatilor de fetch, decodificare,
redenumire si a numarului de registre pentru redenumire (capacitatea de repartizare
instructiuni) => crestere quadratica a suprafetei ocupate pe chip. Rezultatele (functie de
numarul de thread-uri t):
 
Bloc functional Aria

Tabele de remapare (reg. arhitecturale->reg. fizice) O (t*log (t))

Registre INT and FP O (t)
Bloc fetch, reg. PC multiple si algoritm fetch icount O (t)
Bloc predictie ramificatii, stiva separata per bloc O (t)
Coada instructiuni (“out-of-order”) O (log (t))
Dtag, Itag O (log (t))
Routare O (log (t))
 
Factor cheie: tabelele de remapare (RAM multiport), -> aria creste quadratic cu
cresterea latimii repartizare instructiuni -> t*log2t (nu numai se adauga noi registre
pentru thread-uri noi, dar se memoreaza si bitii de adresa - termenul log).
La fel si fiserele de registre INT si FP, aria creste quadratic. Totusi, deoarece
numarul de biti de adresa este fix, aria creste liniar cu numarul de thread-uri.
 O implementare comerciala de SMT:

Intel’s Hyperthreading Technology

 
Hyperthreading Technology: un procesor fizic apare ca doua procesoare
logice (resursele fizice de executie sunt partajate, iar starea arhitecturala este dublata
pentru cele doua procesoare logice).

S.O. si programele utilizator planifica procese si thread-uri catre procesoarele

logice, ca si cum ar fi procesoare fizice multiple.

Scop al tehnologiei: minimizarea ariei chipului si costului implementarii.

Alt scop: cand un procesor este blocat, celalalt face progrese.

Organizarea (doua procesoare fizice, fiecare cu cate doua copii ale starii
arhitecturale => sistemul apare ca si cand ar avea 4 procesoare ):
 Implementarea tehnologiei : + 5% dim. chipului si cerinte maxime de putere
performante mult mai mari.

Starea arhitecturala: registrele, incluzand registrele de scop general, registrele

de control, registrele APIC si anumite registre de stari ale masinii.

Cele mai multe instructiuni se executa din TC (“Execution Trace Cache”). Se

utilizeaza doua seturi de pointeri de instructiune urmatoare. Procesoarele logice
concureaza pentru acces la TC in fiecare ciclu => accesul este permis alternativ. Daca
un procesor este blocat atunci celalalt procesor are acces complet.

Executia de instructiuni complexe (necesita secventa complexa de microcod)

se utilizeaza doi pointeri de microcod catre Microcod ROM, controland secvente
independente de microcod (accesul la Microcod ROM se face de asemenea alternativ).

Structurile de predictie a ramificatiilor sunt duplicate.

Logica de redenumire a registrelor utilizeaza un RAT („Register Alias Table”):

urmareste ultima versiune a fiecarui registru arhitectural => doua RAT-uri, unul pentru
fiecare procesor logic, operand in paralel.
 CMP

CMP => TLP prin rularea unor secvente complet separate de instructiuni pe
procesoare separate .

Avantaje:
-durata ciclului redusa datorita caracteristicelor naturale de cluster
(fiecare CPU este un mic cluster rapid de componente). S.O. aloca fiecarui CPU un
singur thread de control (nu necesita alocare dinamica de instructiuni), ceea ce
limiteaza exploatarea dinamica a ILP, dar permite ca fiecare CPU sa fie mic si rapid.

-utilizarea unui grup de procesoare mici, identice => costul de

proiectare si verificare este scazut;

-arhitectura CMP este mai putin sensibila la o slaba organizare de

date si gestiune a comunicatiilor, deoarece intarzierile in comunicatii sunt mici si rata
de transfer este mare.
 Utilizeaza core-uri relativ simple pentru thread singular, dar executa thread-uri
multiple in paralel pe core-uri multiple.
simplitatea proiectului;
frecventa mai mare a ceasului;
scaderea timpului consumat cu validarea proiectului.

Arhitectura de baza:
 8 procesoare mici superscalare cu unitate de lansare de dim. 2.
Core-urile:
-complet independente;
-strans integrate cu memoriile cache (accesul la cache intr-un singur ciclu).

CMP = platforma ideala pentru rularea de aplicatii multithread.

In multithreading speculativ: thread-urile speculative din aplicatie trebuie sa

fie identificate la momentul compilarii sau complet la momentul rularii (cu suport
hardware).

Pentru implementarea multithreading speculativ exista doua abordari generale:

-utilizarea de suport hardware: permite comunicarea intre procesoare la nivelul
memoriei si la nivelul registrelor;
-utilizarea de suport hardware minim: suport minim pentru executie
speculativa, iar comunicatia se face numai la nivelul memoriei.
 Implementare a arhitecturii CMP: Hydra

Hydra (Stanford University) integreaza 4 procesoare bazate MIPS, cache-urile L1 si

cache-ul L2 pe un chip.
 Procesoarele suporta instructiunile normale load/store, plus instructiunile speciale
„load locked” (LL) si „store conditional” (SC) pentru implementarea primitivelor de
sincronizare.
Procesoarele+cache-uri -> conectate la cache-ul L2 prin magistrala de scriere si
magistrala de citire, plus cateva magistrale de adrese si control (logic functioneaza ca
magistrale, magistralele virtuale sunt fizic conexiuni (wires) impartite in mai multe
segmente utilizand repetoare si buffere in banda de asamblare, pentru a impiedica
scaderea frecventei ceasului).

Magistrala de citire functioneaza ca o magistrala sistem de scop general,

pentru transferul datelor intre procesoare, cache-ul secundar si memoria externa
chipului ( transfera o linie de cache intr-o singura perioada de ceas).
Magistrala de scriere executa scrierile core-urilor in cache-ul L2.
-> protocol de coerenta cu invalidare pentru cache-urile L1 (scrierile sunt
transmise pe magistrala pentru invalidarea copiilor blocului in cache-urile L1);
-> consistenta memoriei (toate scrierile trebuie plasate pe magistrala pentru a fi
vizibile procesoarelor, in ordinea in care ele actualizeaza memoria partajata).

Arhitectura bazata pe magistrala suficienta pentru accesul la memoria cache

L2 a 4 - 8 procesoare. Pentru implementari cu mai multe procesoare sunt necesare
solutii cu mai multe magistrale, interconectari crossbar sau conexiuni ierarhice.
 Specularea la nivel de thread-uri.

Suportul hardware pentru specularea la nivel de thread-uri -> elimina necesitatea

ca programatorii sa imparta explicit programul original (secvential) in thread-uri
independente.

Hydra utilizeaza specularea la nivel de thread-uri => paralelizarea unui program in

thread-uri. Secventa de instructiuni este impartita arbitrar intr-un grup de thread-uri
care pot fi rulate in paralel pe un multiprocesor.

Hardware-ul trebuie sa urmareasca toate dependentele interthread: cand un thread

ulterior genereaza o incalcare a dependentei prin citirea prea devreme de date,
hardware-ul trebuie sa asigure ca thread-ul prost speculat va fi reexecutat (sau cel putin
portiunea cu citirea incorecta, de data aceasta cu datele corecte).

Pentru a suporta specularea la nivel de thread-uri este necesar un hardware de

coerenta special care sa monitorizeze datele partajate de thread-uri.
 Cerintele de baza pentru un hardware de coerenta care sa implementeze
specularea la nivel de thread-uri:

1) transmiterea datelor intre thread-uri paralele: un sistem speculativ trebuie sa

fie capabil sa transmita datele partajate rapid si eficient, de la un thread anterior (mai
devreme) ruland pe un procesor la un thread ulterior ruland pe alt procesor (figura b).
2) mecanism de urmarire a citirilor si scrierilor in memoria de date partajate,
pentru a detecta cand o citire apare prea deveme (hazarduri RAW): daca o data este
citita de un thread ulterior si inscrisa de thread anterior, hardware-ul trebuie sa
consemneze ca citirea a gasit data incorecta (incalcare de dependenta) => thread-ul care
a incalcat dependenta trebuie reexecutat cu valorile corecte de date (figura b).
 3) mecanism pentru descarcarea sigura a starii speculative dupa incalcare.
Memoria speculativa: un mecanism care sa permita descarcarea schimbarilor
speculative in starea masinii dupa o incalcare (in acest timp nu se poate pierde nicio
stare permanenta a masinii - figura c).
4) retragerea scrierilor speculative in ordinea corecta (hazarduri WAW). O
data ce thread-urile speculative s-au incheiat cu succes starea lor trebuie adaugata la
starea permanenta a masinii in ordinea corecta din program, considerand secventierea
originala a thread-urilor => hardware-ul trebuie sa intarzie scrieri ale unor thread-uri
ulterioare care au loc de fapt inaintea scrierilor unor thread-uri anterioare (figura d).
 5) furnizarea redenumirii de memorie (hazarduri WAR). Figura e) indica un
thread anterior care citeste de la o adresa la care un thread ulterior a scris deja date.
Hardware-ul speculativ trebuie sa asigure ca thread-ul anterior nu poate vedea nicio
modificare facuta de un thread ulterior (aceste modificari nu s-au produs inca in
secventa originala) => complicat: fiecare procesor va rula eventual thread-uri generate
mai noi (exemplu thread i+2), care trebuie sa vada modificarile.
 In Hydra, coerenta speculativa a memoriei este asigurata de hardware, iar
coerenta la nivel de registre este asigurata de software.
Resursele hardware care asigura coerenta speculativa a memoriei:
1) bitii de tag suplimentari adaugati la fiecare linie de cache primar pentru a indica daca
vreo data din linie a fost citita sau scrisa speculativ;

2) set de buffere de scriere care pastreaza scrierile speculative pana cand pot fi
executate sigur in cache-ul L2 (garantat sa pastreze numai date nespeculative).
Fiecare thread speculativ are un astfel de buffer. Numai dupa incheierea executiei
thread-urilor bufferele sunt inscrise in L2 si scrierile raman permanente. Daca un thread
speculativ („Me”) citeste din cache-ul L1, se executa cautarea si in bufferele de scriere
ale thread-urilor, in caz de coincidenta se furnizeaza linia din buffer si se seteaza bitul
Modified al liniei (mai optim numai pentru thread-urile i-1 si i). Daca exista
coincidenta in bufferul thread-ului speculativ i+1, se seteaza bitul de preinvalidare al
liniei:
 O arhitectura scalabila bazata pe un CMP: Piranha
Schema bloc (Compaq ):
 -8 core-uri CPU Alpha, cu lansare o singura instructiune, executie in-order.

-core: cale de date in banda de asamblare de 500 MHz cu v.m., 8 segmente:

-fetch instructiune;
-citire registru;
-UAL1 – 5 (suporta instructiuni in v.m. si de inmultire);
-write-back.

-fiecare core CPU conectat direct la cache de instructiuni (iL1) si cache de date
(dL1) de 64 KB, organizare set asociativa de dim. 2, protocol MESI.

-ICS (Intra-Chip Switch): conecteaza cache-urile la alte module (crossbar);

-interfata unidirectionala (initiatorul furnizeaza datele)-> daca destinatia este
“ready” se trimte un “grant” si are loc transferul cu rata de un cuvant de 64 biti per
ciclu;
-fiecare port are doua cai independente de date de 64 biti;
-rata globala interna 32 GB/s.
 -cache L2 de 1 MB, intretesut, cu 8 module separate, fiecare cu controller, tag-uri
si memorie separate.

-o linie = 64 octeti, organizare set asociativa, de dim 8, cu algoritm “round-robin”

(“least-recently-loaded”) de inlocuire a blocurilor.

-controller de memorie (MC) la fiecare modul L2, interfatat direct la un banc cu

maxim 32 chipuri Rambus DRAM. Capacitati:
-2 GB (chipuri de 64 Mb) = 8x32x64/8;
-8 GB (chipuri de 256 Mb);
-32 GB (chipuri de 1Gb);
=>rata de transfer de 1.6 GB/s per canal (in total 12.8 GB/s).

-doua motoare de protocol HE (Home Engine) si RE (Remote Engine) conectate la

ICS (suporta memorie partajata pentru mai multe chipuri Piranha):
-HE exporta blocurile avand home local;
-RE importa blocurile avand home la distanta.
=> implementare: controllere microprogramate.
Un motor:
Interconectarea chipurilor Piranha:

-RT (Router);
-IQ (Input Queue);
-OQ (Output Queue);
-PS (Packet Switch).
=> largimea de banda: 32 GB/s (pentru fiecare chip).

Modulul SC (System Control): gestioneaza functiile diverse de intretinere (configurare

sistem, initializare, distribuirea intreruperilor, manipularea exceptiilor, monitorizarea
performantelor).
Piranha = un multiprocesor pe un chip fara capabilitati de I/E.
=> chip special Piranha de I/E:
 Exemplu de sistem Piranha cu chipuri de prelucrare si chipuri de I/E:

-max 1024 noduri (raport variabil noduri prelucare / noduri I/E);

-routerul suporta topologii arbitrare de retea si reconfigurare dinamica.
 Software compatibil binar cu software-ul Alpha (de sistem si de aplicatii)
=> aplicatiile utilizator fara modificari, S.O. modificari minime (Tru64 Unix).

Comparatie de performante: uniprocesor P1 500MHz, uniprocesor INO (in-

order) 1 GHz, uniprocesor OOO (out-of-order) 1 GHz si multiprocesor P8 (8 core-uri)
500 MHz, pentru doua aplicatii de baze de date OLTP (on-line-transaction-processing)
si DSS:
 Arhitecturi tera-scalare

Necesitatea arhitecturilor tera-scalare:

-impunerea procesoarelor duale in ultimii ani;
-tendinta de crestere a numarului de core-uri;
-tehnicile SMP permit integrarea unor PE-uri („Processing Engine”) mici pe
chip.

tendinta este de a integra zeci-sute de core-uri pe un chip, impreuna cu

controloare de memorie, punti de I/E si motoare grafice.

Conectarea: infrastructura formata din retea de interconectare pe chip, ierarhie de

memorie cache, memorie, I/E si interfete de sistem (Intel: „uncore” = toate elementele
care nu sunt motoare de calcul).

O posibila abordare: „tiled architecture” -> imparte pastila de siliciu intr-un numar
mare de blocuri („tiles”) (aproape) identice, interconectate printr-o retea scalabila,
eficienta energetic => simplifica layout-ul si permite o integrare rapida a diferitelor
blocuri.
 Arhitectura tera-scale integreaza un numar mare de core-uri de calcul de scop
general impreuna cu motoare de calcul de scop special (unitati de textura, unitati de
umbrire „shader units”, unitati cu functii fixe), elemente de platforma (memorie si
controloare de I/E) si interfata de sistem pentru conectarea unor procesoare multiple si
a altor periferice:
 Uncore-ul arhitecturii tera-scale consta din urmatoarele elemente:

-retea de interconectare scalabila de banda larga, latenta scazuta si eficienta de

putere pentru conectarea elementelor de calcul si de platforma;

-ierarhie de cache-uri care sa permita elementelor de calcul multiple sa

utilizeze si sa partajeze resursele de memorie de pe chip;

-arhitectura de memorie scalabila si de banda larga, care sa alimenteze cu date

numarul mare de elemente de calcul.
 Reteaua de interconectare
 
Cerinte:

-scalabilitate: multe zeci pana la cateva sute de noduri (agenti) -> crestere
subliniara a distantei medii in raport cu numarul de noduri;

-partitionabilitate: topologia arhitecturii partitionata dinamic pentru a permite

performanta si izolarea defectelelor;

-toleranta la defecte: degradare „eleganta” la defecte;

-validare si testare: furnizeaza suport pentru testare si validare -> se prefera

routarea „deadlock-free” fata de „deadlock-recovery”;

-regularitate: se obtine simetrie fizica;

-flexibilitate si proiectare prietenoasa: cu un efort minim de reproiectare sa se

satisfaca un segment larg de pe piata.
 Posibile solutii pentru implementarea retelei:
-mesh 3D implementat 2D;
-inel;
-tor / mesh 2D, impreuna cu variante ale acestora. Impachetare 2D a
unui mesh 3D pentru 64 de noduri:
 Solutii de toleranta la defecte
 
1) Noduri de rezerva: procesoare de rezerva dotate cu interfete de retea si
switche-uri -> la detectarea unor defecte in unele procesoare, procesoarele de rezerva
sunt activate dupa reconfigurarea retelei de interconectare, pastrandu-se insa topologia
initiala.
 2) Routare toleranta la defecte: la initializarea sistemului se ruleaza un
algoritm de identificare a defectelor si a topologiei => se determina locatia / identitatea
componentelor defecte (sunt marcate). De asemenea se marcheaza si alte regiuni daca
sunt sigure sau nu din p.d.v. al routarii „deadlock-free”.
3) Partitionare pentru izolarea performantelor: se pot realiza mai multe partitii pe chip,
fiecare cu cate o fractie din numarul total de unitati de calcul, unitati de scop special si
alte elemente de platforma, fiecare partitie fiind utilizata intr-o aplicatie precisa:
 Ierarhia de cache-uri si protocolul de coerenta
 
Ierarhia de cache-uri trebuie sa suporte eficient o gama larga de modele de
programare si de incarcare:
-incarcari multiprogramate: nu exista comunicare si partajare de date intre
procese ruland pe core-uri diferite;
-incarcari cu combinatii de sectiuni scalare si paralele: performantele sunt
limitate de performantele sectiunii scalare (legea Amdahl);
-incarcari puternic paralele, care pot fi de tipuri diferite:
-paralelism de thread-uri: thread-urile pot fi similare sau foarte
diferite, pot sau nu sa partajeze date. Exemple: prelucrarea tranzactiilor si aplicatiile
web;
-paralelism de date: un task similar este executat pe seturi diferite de
date, unde anumite date pot fi partajate intre taskuri. Exemple: media, analiza numerica
si data-mining;
-stream-uri: programele sunt structurate sub forma unor nuclee
(„kernels”) unde date de intrare sunt prelucrate si date de iesire sunt transferate la alte
nuclee. Exemple: media si aplicatii grafice.
 In procesoarele multicore cache-urile L1 sau L1 si L2 sunt private fiecarui
core, iar ultimul nivel este partajat. In CMP-urile cu putine core-uri ultimul nivel de
cache este implementat sub forma unui singur bloc UMA, dar pe masura ce creste
numarul de core-uri se opteaza pentru o distribuire fizica a cache-ului. Organizarile
cache-ului multicore, in functie de incarcari:
 Coerenta: protocoale bazate pe directoare (adaptate CMP-urilor).

Director:
-evidenta starilor copiilor liniilor la nivelul memoriilor cache;
-intrari corespunzatoare liniilor;
-intrare = camp de stare + camp pentru memorarea identitatilor cache-urilor
care au copii ale liniei (pointeri).

Stari:
-I (invalid): niciun cache nu contine copie a liniei;
-S (shared): anumite cache-uri pot avea copii ale blocului in starea Shared;
-X (exclusive): unul din cache-uri poate avea o copie a liniei intr-una din
starile Modified, Exclusive sau Shared.
 Informatia de identificare:
-harta completa de biti (un bit pentru fiecare cache);
-harta partiala de biti (un bit pentru un grup de cache-uri);
-set limitat de identitati de cache-uri cu un mecanism de gestionare a
depasirilor.
 Arhitectura de memorie
 
Cresterea numarului de core-uri (puterii de calcul) => cresterea ratei de transfer a
datelor (pentru majoritatea aplicatiilor).Solutii:
-transfer de I/E off-chip cu eficienta de putere si viteza mare;
-acces DRAM cu eficienta de putere si banda larga.

Solutii CMP:
-memorii mai eficiente;
-imbunatatirea gestiunii memoriei de pe chip.

Exemplu: DRAM incorporat permite cresterea densitatii de memorie on-chip in

comparatie cu SRAM. In plus, gestiunea eficienta a memoriei de pe chip prin evitarea
datelor duplicate in ierarhia de cache-uri => cresterea capacitatii de pe chip.

Integrarea DRAM (ex. GDDR) pe chip permite un control mai bun al canalului I/E
si astfel o rata mai mare, in comparatie cu conectarea la un conector DIMM de pe placa
de baza. Solutii recente: „3D stacked SRAM” cu rata mare (exemple: prototipul Intel
tera-scale si cercetarile IBM in domeniul circuitelor integrate 3D).
 Proiectul Intel chip multicore - Teraflop
=> septembrie 2006: chip cu 80 core-uri, la 4 GHz, arie de 10x8 core-uri, retea
mesh interna. Performante: 1.28 Tflops.

Core: router cu 5 porturi, motor de prelucrare (PE – „processing engine”), fisier de

registre cu 32 de intrari (6 porturi de citire si 4 porturi de scriere), 2 K memorie de date,
3 K memorie de instructiuni si doua unitati de v.m. Fiecare FPU este un multiplicator –
accumulator de v.m. simpla precizie (FMAC) cu o banda de asamblare avand 9
segmente si o rata de 2 Flops/ciclu.
PE implementeaza VLIW ISA, non-x86, avand instructiuni de 96 biti cu
maxim 8 operatii/ciclu. Latentele instructiunilor pentru diferite blocuri functionale din
PE sunt:
-unitatea de v.m. 9 cicluri;
-load/store: 2 cicluri;
-send/receive: 2 cicluri;
-jump/branch: 1 ciclu.
Reteaua mesh care conecteaza PE-urile: comunicatia bazata pe pachete.
 Pentru economie de energie, fiecare core este impartit in 21 de regiuni
separate, iar pe baza conditionarii ceasului, diferite blocuri functionale pot fi trecute in
stare inactiva in mod dinamic, in functie de incarcarea de lucru. Chiar si routerul poate
fi oprit sau pornit pentru adaptarea la trafic!

=> proiect de testare a solutiilor de organizare, distribuire a ceasului si fabricare a

chipurilor masiv multicore.
 Proiectul Cell

Proiectul Cell: lansat in anul 2000 de IBM, Sony si Toshiba => arhitectura
„Cell Broadband Engine Architecture” (tip multiprocesor pe cip heterogen). Prima
implementare: Cell BE („Cell Broadband Engine”). Suporta instructiuni scalare,
instructiuni SIMD si furnizeaza un mediu de executie cu fire multiple de inalta
performanta pentru toate aplicatiile.

Cell furnizeaza paralelism la toate nivelurile de abstractizare sistem:

-paralelism la nivel de fire de executie: proiect multi-core;
-paralelism la nivel de instructiuni: planificare statica;
-paralelism de date: instructiuni pentru date paralele.

Un element esential: SPU („synergistic processor unit”) -> suporta paralelism

la nivel de date (instructiuni cu paralelism de date). Avand unitati multiple SPU pe un
cip se obtine si paralelism la nivel de fire de executie.
Cell BE implementeaza un CMP („single cip multiprocessor”) cu noua procesoare
operand pe o memorie partajata coerenta. Functiile procesoarelor:
-PPE („Power processor element”) optimizat pe taskuri de control;
-SPE („synergisitic processor element”) optimizat pentru prelucrarea de date.

PPE realizat pe arhitectura IBM Power 64 biti cu extensie vectoriala pentru

prelucrari media pe 128 biti si memorie cache pe cip cu doua niveluri.

SPE-urile sunt procesoare independente ruland fiecare cate un fir de executie

independent, fiind optimizate pentru aplicatii de calcul intensiv. Fiecare SPE dispune
de o memorie locala (partajata) pentru acces eficient la instructiuni si date, dar avand si
acces complet la memoria partajata coerenta (inclusiv spatiul de I/E mapat in memorie).

Fiecare SPE consta din SPU si controller SMF („synergistic memory flow”).
Controllerul SMF transfera datele si realizeaza sincronizarea in paralel cu SPU,
implementand si interfata pentru magistrala interna de interconectare.
Structura SPU:

SPU implementeaza paralelism la nivel de date prin integrarea unitatilor de executie

scalare si SIMD. Nu exista suport separat pentru prelucrari scalare, acestea realizandu-
se prin unitatile vectoriale. Nu exista fisier separat de registre scalare: SPU memoreaza
scalarii in fisierul de registre unificate scalare/vectoriale de 128 biti cu 128 intrari.
Astfel, se simplifica routarea datelor si partajarea datelor intre date scalare si vectoriale.
 Executia operatiilor scalare se face utilizand caile largi de date SIMD („scalar
layering”). Pentru exemplificare se considera executia operatiilor SIMD pe un vector
de patru elemente de un cuvant fiecare. O instructiune SIMD se realizeaza prin executia
in paralel a aceleiasi operatii in paralel pe toate elementele vectorului (a).

Operatiile SIMD paralele nu se pot utiliza pentru elemente scalare aliniate arbitrar si
incarcate in registrele vectoriale (b). Este necesar ca datele sa fie aliniate la aceeasi
componenta.
In figura (c) este prezentata compilarea codului scalar pentru a fi executat pe unitatile
SIMD. Realizarea operatiei se bazeaza pe alinierea operandului in componenta cea mai
din stanga, dar un programator sau un compilator poate alinia operandul in orice
pozitie. Pe baza alinierii specificate de adresa scalarului se utilizeaza instructiuni de
rotatie pentru plasarea scalarului in pozitia corecta.
Figura (d) prezinta utilizarea secventei „read-modify-write” pentru memorarea unui
scalar prin intermediul interfetei de memorare pentru date de tip quad-word. Secventa
de operatii este generata de compilator. Inserarea unui scalar intr-un quad-word se face
prin utilizarea unei instructiuni „shuffle” pentru routarea datelor din doua registre de
intrare. Pentru implementarea secventei „read-modify-write” SPU suporta o
instructiune „generate controls for insertion”, care genereaza un cuvant de control care
comanda instructiunea shuffle de inserare a unui octet/halfword/word intr-o pozitie
specificata de adresa de memorie.
 Interconectarea procesoarelor Cell se face prin intermediul IOIF (I/O
interface) si BIF (broadband engine interface).

Configuratie cu un singur nod avand doua interfete IOIF:

Configuratie cu doua noduri cate o interfata IOIF si un port configurat BIF pentru
conectarea nodurilor:
Configuratie multinod utilizand un switch atasat la porturile configurate BIF:
 Procesoare Cell sunt utilizate in sisteme pentru jocuri, echipamente HDTV,
servere si supercomputere.

Supercalculator hibrid de la Los Alamos National Laboratory

(„Roadrunner”) pentru o gama larga de aplicatii stiintifice si comerciale. Se bazeaza pe
un numar de peste 16000 core-uri AMD Opteron si peste 16000 procesoare Cell/B.E.
Performantele sistemului depasesc 1.6 Pflops. Supercalculatorul necesita tehnologii
avansate de racire si gestiune a puterii. Aria ocupata este de 12000 ft 2 (aproximativ trei
terenuri de basket).

IBM BladeCenter QS21 proiectat pentru utilizarea in aplicatii HPC („high

performance computing”): prelucrarea de imagini si semnale, cercetare stiintifica,
supraveghere digitala video. Caracteristici ale sistemului:
-doua procesoare Cell/B.E. la 3.2 GHz (fiecare cu un core PPE si opt core-uri
SPE);
-512 KB memorie cache L2 pentru fiecare procesor Cell/B.E. si 256 KB de
memorie locala pentru fiecare SPE;
-memorie principala 2GB (1GB per procesor);
-S.O. Linux Red Hat.
 Sisteme de la Mercury Computer Systems pentru prelucrari de imagini si
reconstructie de imagini, inclusiv in domeniul medical. Exemplu: computer tomograf
cu aplicatie de reconstructie de imagini ruland pe un Mercury Dual Cell-Based Blade.
Alte sisteme Mercury in diferite domenii: EDA („electronic design automation”),
semiconductori, aerospatial, aparare, prelucrarea datelor seismice, prelucrare video.

Supercalculatorul de la University of Massachusetts realizat din 16 module

PS3 (Playstation 3 de la Sony) pentru studierea coliziunii dintre doua gauri negre.
Modulele au fost conectate impreuna cu un switch comercial, s-a instalat PowerPC
Linux si au fost dezvoltate aplicatii bazate pe OpenMPI (distributie MPI pentru
PowerPC Linux).