compilarea Şi execuŢia aplicaŢiilor pe...

COMPILAREA ŞI EXECUŢIA APLICAŢIILOR PE ARHITECTURA MULTICORE ETEROGENĂ IBM-

CELL

COMPETENŢE GENERALE ŞI SPECIFICE

1. Arhitectura multicore IBM-CELL. Aplicaţii specifice.

2. Familiarizarea cu mediul CELL SDK: tools-uri de compilare / dezvoltare.

3. Tipuri diferite de executabile: standalone PPU program, standalone SPU program, (a)synchronous SPU thread called by PPU.

4. Implementarea, compilarea, depanarea şi execuţia programelor C/C++ pe arhitectura CELL.

Scopul acestui laborator este familiarizarea cu arhitectura multicore IBM-CELL şi are ca finalitate scrierea, compilarea si rularea unor programe simple. Continutul laboratorului va fi structurat in doua parti: prezentarea arhitecturii CELL BE, urmata apoi de aplicatii.

1. Descrierea arhitecturii Cell Broadband Engine

Fig. 1. Schema bloc a arhitecturii Cell Broadband Engine (ansamblu)

Prin intermediul magistralei de interconectare – Element Interconnect Bus (EIB), procesorul PPE si SPE-urile comunica in mod coerent intre ele, cu spatiul principal de stocare (main storage) si cu elementele I/O. Magistrala EIB are o structura bazata pe 4 inele (doua in sens orar si doua in sens anti-orar) pentru transferul datelor si o structura arborescenta pentru comenzi. Latimea de banda interna a magistralei EIB este de 96 bytes pe ciclu si suporta mai mult de 100 de cereri DMA in asteptare intre

Computer Science and Electrical Engineering DepartmentAdrian FLOREA

1

SPE-uri si spatiul principal de stocare (main storage). Accesul coerent la memorie dinspre EIB se face prin intermediul a doua interfete externe (vezi Figura 1):

• Controllerul de interfata cu memoria (Memory Interface Controller (MIC)) asigura interfata dintre magistrala EIB si spatiul principal de stocare (main storage). Suporta doua canale cu memoria de tip Rambus Extreme Data Rate (XDR) I/O (XIO) si accese la memorie pe fiecare canal de 1-8, 16, 32, 64, sau 128 bytes.

• Interfata cu Cell Broadband Engine (Cell Broadband Engine Interface (BEI)) asigura managementul transferurilor de date intre magistrala EIB si dispozitivele I/O. Asigura translatarea adreselor, procesarea comenzilor, interfatarea cu magistrala si pune la dispozitie un controller intern de intreruperi. Suporta doua canale de tip Rambus extern I/O. Unul dintre aceste canale suporta doar dispozitive I/O non-coerente cu memoria. Cel de-al doilea canal poate fi configurat sa suporte atat transferuri non-coerente cat si transferuri coerente cu memoria care extind la nivel logic magistrala EIB cu cu alte dispozitive externe compatibile, cum ar fi de exemplu un alt Cell Broadband Engine.

Fig. 2: Diagrama bloc a arhitecturii CELL Broadband Engine (detaliu)


2

Fig. 3: Schema bloc a procesorului PPE

Fig. 4: Schema bloc a procesorului SPE


3

Fig. 5: Topologia de date a magistralei de interconectare EIB

Dezvoltarea de aplicatii software scrise in limbajul C/C++ este sustinuta de catre un set bogat de extensii de limbaj care definesc tipurile de date din C/C++ pentru operatii SIMD si contin constructii C/C++ (comenzi sub forma de apeluri de functii) spre una sau mai multe instructiuni de asamblare. Aceste extensii de limbaj ofera programatorilor in C/C++ un control mai mare asupra performantelor ce pot fi obtinute din cod, fara a fi nevoie de programare in limbaj de asamblare. Dezvoltarea de software este sustinuta de existenta unor tools-uri de compilare / dezvoltare precum si a:

• Unui Software Development Kit complet bazat pe Linux,• Unui simulator de sistem (systemsim) si a• Unui set bogat de librarii de aplicatii, unelte de performanta si debugging.

1.1 Power Processor Element (PPE)

Fig. 6. Schema bloc a Power Processor Element (PPE)


4

Power Processor Element (PPE) este un procesor de uz general, dual-threaded, cu arhitectura RISC pe 64 de biti conforma cu arhitectura Power, avand setul de extensii Multimedia Vector/SIMD. Spre exemplu, programele scrise pentru procesorul Power 970, pot fi rulate pe Cell Broadband Engine nefiind necesare modificari. Procesorul PPE are doua unitati principale (vezi Figura 6):

• Power Processor Unit (PPU). • Power Processor Storage Subsystem (PPSS).Power Processor Element (PPE) este responsabil de controlul general asupra sistemului si

ruleaza (incarca) sistemele de operare pentru toate aplicatiile ce ruleaza pe Cell Broadband Engine. Power Processor Unit (PPU) se ocupa de controlul si executia instructiunilor. Acesta contine:

• setul complet de registri Power pe 64 biti, • 32 registri de vector pe 128 de biti, • un cache de instructiuni de nivel 1 (L1) de 32 KB, • un cache de date de nivel 1 (L1) de 32 KB, • o unitate de control de instructiuni, • o unitate pentru instructiuni Load / Store, • o unitate pentru numere intregi in virgula fixa, • o unitate pentru numere in virgula mobila, • o unitate pentru vectori, • o unitate de predictie de ramificatie, • o unitate de management a memoriei virtuale. Power Processor Unit (PPU) suporta executia simultana a doua threaduri si poate fi privit ca un

multiprocesor 2-way cu flux de date partajat (shared dataflow). Din punct de vedere software, acesta este vazut ca doua unitati de procesare independente.

Power Processor Storage Subsystem (PPSS) se ocupa cu cererile de acces la memorie venite din partea PPE si cererile externe pentru PPE venite din partea altor procesoare si dispozitive I/O. Acesta contine:

• un cache de nivel 2 (L2) unificat de date si instructiuni de 512 KB, • o serie de cozi (queues), • o unitate de interfata cu magistrala cu rol de arbitru de magistrala EIB. Memoria este vazuta ca vector liniar de bytes indexati de la 0 la 264 - 1. Fiecare byte este

identificat prin indexul sau, numit adresa, si contine o valoare. Se face cate un singur acces la memorie o data.

Cache-ul de nivel 2 (L2) si cache-urile dedicate translatarii adreselor folosesc tabele de management ale procesului de inlocuire a blocurilor din cache care permit controlul lor din software. Controlul software asupra cache-ului este util in special pentru programarea de timp real.

1.2 Synergistic Processor Elements (SPE-uri)

Fiecare dintre cele opt Synergistic Processor Elements (SPE-uri) este un procesor RISC pe 128 biti specializat in aplicatii SIMD (vectoriale) ce necesita calcul intens asupra unor seturi multiple de date. Conform Figurii 7, fiecare Synergistic Processor Element (SPE) contine doua unitati principale:

• Synergistic Processor Unit (SPU). • Memory Flow Controller (MFC).


5

Fig. 7. Schema bloc a Synergistic Processor Element (SPE)

Synergistic Processor Unit (SPU) controleaza si executa instructiunile. Contine:• un singur set de 128 registri, fiecare de 128 biti, • o memorie locala (local store - LS) unificata (instructiuni si date) de 256 KB, • o unitate de control a instructiunilor, • o unitate de Load / Store, • doua unitati pentru numere in virgula fixa, • o unitate pentru numere in virgula mobila si • o interfata DMA. Synergistic Processor Element (SPU) implementeaza un nou set de instructiuni SIMD, numit

SPU Instruction Set Architecture, care e specific pentru Broadband Processor Architecture. Fiecare Synergistic Processor Unit (SPU) este un procesor independent cu Program Counter propriu si este optimizat pentru rularea de threaduri SPE lansate de catre Power Processor Element (PPE). Instructiunile pentru Synergistic Processor Unit (SPU) sunt aduse din memoria locala (local store – LS) iar datele sunt aduse si salvate tot in memoria locala (local store – LS). Fiind proiectata pentru a fi accesata in primul de catre SPU-ul propriu, memoria locala (local store – LS) este neprotejata si netranslatata.

Memory Flow Controller (MFC) contine un controller DMA pentru transferurile DMA. Programele care ruleaza pe SPU, pe PPE sau pe alt SPU, folosesc transferuri DMA controlate de MFC pentru mutarea datelor si instructiunilor intre memoria locala (local store –LS) a SPU-urilor si spatiul principal de stocare (main storage). Spatiul principal de stocare (main storage) este format din spatiul de adrese efective care include memoria principala (main memory), memoriile locale ale altor SPE-uri si registri mapati in memorie cum ar fi registrii I/O [MMIO]. Memory Flow Controller (MFC) interfateaza Synergistic Processor Unit (SPU) cu Element Interconnect Bus (EIB), implementeaza facilitatile de rezervare bandwidth pe magistrala si sincronizeaza operatiile dintre Synergistic Processor Unit (SPU) si celelalte procesoare din sistem.

Pentru transferurile DMA, Memory Flow Controller (MFC) foloseste cozi de comenzi DMA. Dupa ce o comanda DMA a fost transmisa catre Memory Flow Controller (MFC), Synergistic Processor Unit (SPU) poate continua executia instructiunilor in timp ce Memory Flow Controller (MFC) proceseaza comenzile DMA autonom si asincron. Executia de comenzi DMA de catre Memory Flow Controller (MFC) autonom fata de executia de instructiuni de catre Synergistic


6

Processor Unit (SPU) permite planificarea eficienta a transferurilor DMA pentru a acoperi latenta de memorie.

La fiecare transfer DMA se pot pot transmite maxim 16 KB. Totusi, doar SPU-ul asociat MFC-ului poate lansa lista de comenzi DMA. Acestea pot contine pana la 2048 transferuri DMA, fiecare de cate 16 KB. Informatia cu privire la translatarea adreselor de memorie virtuala este pusa la dispozitia MFC de catre sistemul de operare ce ruleaza pe PPE. Atributele sistemului de stocare (translatarea si protectia adreselor) sunt controlate prin tabelele de segmentare si paginare ale arhitecturii Power. Totusi exista software special pentru PPE care poate mapa adresele si memoriile locale (local store – LS) si anumite resurse MFC in spatiul de adrese din main-storage, permitand astfel PPE si altor SPU-uri din sistem sa acceseze aceste resurse.

SPE-urile ofera un mediu de operare determinist. Acestea nu au memorii cache, astfel ca nu exista cache miss-uri care sa le afecteze performanta. Regulile de planificare pe pipeline sunt simple, astfel ca performantele codului sunt usor de evaluat static. Desi memoria locala (local store – LS) este partajata intre operatiile DMA de citire (Load) si scriere (store), si de prefetch de instructiuni, operatiile DMA sunt cumulate si pot accesa memoria locala (LS) cel mult unul din 8 cicluri. La prefetch de instructiuni sunt aduse cel putin 17 instructiuni secventiale de pe ramura tinta. In acest mod, impactul operatiilor DMA asupra timpilor de operatii load and store si de executie a programelor este limitata din designul arhitecturii.

1.3 Ordinea octetilor si numerotarea bitilor

Setul de instructiuni pentru PPE reprezinta o versiune extinsa a setului de instructiuni Power. Extensiile sunt reprezentate de catre setul de instructiuni Multimedia Vector / SIMD plus cateva adaugari si schimbari aduse setului de instructiuni Power. Setul de instructiuni pentru SPE este asemanator cu setul de instructiuni Multimedia Extins Vector / SIMD al PPE. Desi PPE si SPE-urile executa instructiuni SIMD, seturile de instructiuni sunt diferite pentru fiecare dintre ele (PPE si SPE), iar programele scrise pentru PPE si SPE-uri trebuie compilate cu compilatoare diferite. Stocarea datelor si instructiunilor in Cell Broadband Engine respecta ordonarea big-endian. Acest tip de ordonare are urmatoarele caracteristici:

• Byte-ul cel mai semnificativ este stocat la cea mai mica adresa, iar cel mai putin semnificativ byte este stocat la cea mai mare adresa.

• Numerotarea bitilor intr-un byte incepe de la cel mai semnificativ bit (bitul 0) pana la cel mai putin semnificativ bit (bitul n). Acest lucru difera fata de alte procesoare care folosesc tot ordonarea big-endian. Aceste aspecte sunt reprezentate grafic in Figura 8.


7

Fig. 8. Ordonarea Big-endian a byte-ilor si numerotarea bitilor in arhitectura Cell BE

1.4 Vectorizarea SIMD

Un vector este un operand pentru o instructiune si contine un set de elemente (date) grupate sub forma unui tablou (array) unidimensional. Elementele pot fi numere intregi sau in virgula mobila. Majoritatea instructiunilor SPU si din setul Multimedia Extins Vector / SIMD au ca operanzi vectori. Vectorii mai sunt numiti si operanzi SIMD sau operanzi impachetati.

Procesarea SIMD exploateaza paralelismul la nivel de date. Paralelismul la nivel de date se refera la faptul ca operatiile ce trebuie aplicate pentru a transforma un set de elemente grupate intr-un vector pot fi aplicate simultan asupra tuturor elementelor. Cu alte cuvinte, aceeasi instructiune poate fi aplicata simultan asupra mai multor elemente de date.

Suportul pentru operatii SIMD este omniprezent in arhitectura Cell Broadband Engine. In PPE, suportul este asigurat prin setul de instructiuni Multimedia Extins Vector / SIMD. In SPE-uri, suportul este asigurat de catre setul de instructiuni al SPU. Atat in PPE cat si in SPE-uri, registrii de vectori contin mai multe elemente de date sub forma unui singur vector. Registrii si caile de date care suporta operatiile SIMD sunt pe 128 biti. Aceasta inseamna ca patru cuvinte pe 32 biti pot fi incarcate intr-un singur registru si, pot fi adunate cu alte patru cuvinte dintr-un alt registru intr-o singura operatie. Acest exemplu este reprezentat grafic in Figura 9. Operatii similare pot fi efectuate cu operanzi vectori continand 16 bytes, 8 semicuvinte sau 2 dublucuvinte.


8

Fig.9. Patru operatii de adunare executate simultan

Pregatirea unui program pentru a fi folosit pe un procesor ce lucreaza cu vectori se numeste vectorizare (vectorization sau SIMDization). Acest proces poate fi facut manual de catre programator sau de catre un compilator capabil de auto-vectorizare.

In Figura 10 se poate vedea un alt exemplu de operatie SIMD – operatia de amestecare a octetilor (byte-shuffle). Selectia octetilor pentru operatia de amestecare din registrii sursa (VA si VB) se face pe baza informatiilor din vectorul de control din registrul VC, in care un 0 indica VA ca sursa iar un 1 indica VB ca sursa. Rezultatul operatiei de shuffle este salvat in registrul VT.

Fig. 10. Operatia de Byte-shuffle (amestecarea octetilor)

1.5 Tipurile de date vector

Modelul Multimedia Extins Vector / SIMD adauga un set de tipuri de date fundamentale, numite tipuri de vectori (vector types). Tipurile de vectori sunt afisate in Tabelul 1. Valorile reprezentate sunt in notatie zecimala (baza 10). Registrii de vectori sunt pe 128 biti si pot contine:

• 16 valori pe 8 biti, cu semn sau fara semn.• 8 valori pe 16 biti, cu semn sau fara semn.• 4 valori pe 32 biti, cu semn sau fara semn.• 4 valori de numere in virgula mobila IEEE-754 in simpla precizie.


9

Toate tipurile de vectori folosesc prefixul „vector" in fata tipului de date standard C (de exemplu: vector signed int sau vector unsigned short). Un tip de date vector reprezinta un vector cu atatea elemente de tip standard C, cat incap intr-un registru de 128 biti. Astfel, un vector signed int este un operand pe 128 de biti care contine patru elemente signed int pe 32 de biti. Un vector unsigned short este un operand pe 128 de biti care contine opt elemente unsigned short pe 16 biti.

Tabelul 1 – Tipurile de date din setul Multimedia Extins Vector / SIMDVector Data Types Semnificatie Domeniu de valorivector unsigned char 16 valori fara semn pe 8 biti 0…255vector signed char 16 valori cu semn pe 8 biti -128…127

vector bool char 16 valori fara semn pe 8 biti cu valoare booleana 0(false), 255 (true)

vector unsigned short 8 valori fara semn pe 16 biti 0…65535vector signed short 8 valori cu semn pe 16 biti -32768…32767vector bool short 8 valori booleene pe 16 biti 0(false), 65535 (true)vector unsigned int 4 valori fara semn pe 32 biti 0…232-1vector signed int 8 valori cu semn pe 16 biti -231…231-1vector bool int 4 valori booleene pe 32 biti 0 (false), 231-1 (true)vector float 4 valori fara semn pe 32 biti in virgula mobila IEEE-754 values

vector pixel 8 valori pe 16 biti fara semn, fiecare valoare reprezentand un cod de culoare 1/5/5/5 pixel

1.6 Thread-uri si task-uri

Intr-un sistem de calcul pe care ruleaza sistemul de operare Linux, thread-ul principal al unui program este un thread Linux care ruleaza pe PPE. Thread-ul principal Linux al programului poate crea unul sau mai multe task-uri Linux pentru Cell Broadband Engine. Un task Linux pentru Cell Broadband Engine are unul sau mai multe thread-uri de Linux asociate cu acesta, care pot fi rulate fie pe PPE fie pe SPE. Un thread SPE este un thread de Linux care ruleaza pe SPE. Thread-urile software descrise in aceasta sectiune nu au legatura cu capacitatea de hardware multithreading a PPE.

Taxonomie DefinitieThread Linux Un fir de executie care ruleaza pe o platforma (S.O) LinuxThread PPE Un thread Linux care ruleaza pe un procesor PPE

Thread SPE

Un thread Linux care ruleaza pe un SPE. Poate fi oricare dintre firele:• care dispune de context SPE propriu incluzand un set de 128 de

registri fiecare pe 128 de biti, registru Program Counter si coada de comenzi MFC.

• care poate comunica cu alte unitati de executie (sau cu memoria adresata prin MFC).

Task Cell Broadband Engine Linux

Un proces (task) care ruleaza pe PPE si pe SPE:• Fiecare astfel de proces contine unul sau mai multe thread-uri Linux.• Toate thread-urile Linux ale unui task partajeaza resursele task-ului.


10

Un thread Linux poate interactiona direct cu un thread SPE prin memoria locala a SPE-ului (local store – LS) si indirect prin memoria de adrese efective (EA) sau prin interfata oferita de catre subrutinele din SPE Runtime Management library.

Sistemul de operare ofera mecanismul si politicile de rezervare a unui SPE disponibil. Acesta are si rolul de a prioritiza aplicatiile de Linux pentru sistemul Cell Broadband Engine si de a planifica executia pe SPE, independenta de thread-urile normale Linux. De asemenea, este responsabil si de incarcarea run-time-ului, transmiterea parametrilor catre programele SPE, notificarea in cazul evenimentelor si erorilor din SPE-uri si asigurarea suportului pentru debugger.

Fig. 11. Vedere generala asupra unui chip Cell Broadband Engine

2. Mediul de lucru

PPE ruleaza aplicatii si sisteme de operare, care pot include instructiuni din setul Multimedia Extins Vector/SIMD. PPE necesita un sistem de operare extins pentru a oferi suport pentru caracteristicilor hardware a arhitecturii Cell Broadband Engine, cum ar fi: multiprocesarea cu SPE-uri, accesul la functiile din setul Multimedia Extins Vector / SIMD pentru PPE, controllerul de intreruperi din arhitectura Cell Broadband Engine si restul de functionalitati particulare din arhitectura Cell Broadband Engine. In acest mediu de operare, PPE se ocupa cu alocarea de thread-uri si managementul resurselor intre SPE-uri. Kernelul Linux de pe SPE-uri controleaza rularea programelor pe SPU-uri.

Thread-urile SPE urmeaza modelul de thread M:N, ceea ce inseamna ca M thread-uri sunt distribuite la N elemente de procesare. In mod normal, thread-urile SPE ruleaza pana la terminare. Totusi, rularea acestora este controlata de catre prioritatile si politicile de planificare a thread-urilor. Cuanta de timp alocata pentru thread-urile SPE este in mod normal mai mare decat cea a thread-urilor PPE, doarece o schimbare de context pe SPE are un cost mai ridicat.


11

Kernel-ul Linux se ocupa cu managementul memoriei virtuale, inclusiv maparea fiecarei memorii locale (local store – LS) si fiecarei zone de tip problem state1 (PS) in spatiul de adrese efective. Kernelul controleaza atat maparea memoriei virtuale a resurselor MFC, cat si manipularea segment-fault-urilor si page-fault-urilor MFC. Sunt suportate si paginile mari (16 MB), care folosesc extensia Linux hugetlbfs.

3. Aplicaţii3.1. Problema 1

Se consideră un program independent (de sine stătător) de tip PPU (Cell PPU executable) care crează şi lansează în execuţie două fire. Fiecare fir de execuţie incrementează o variabilă transmisă ca parametru referinţă de 1000000 (106) ori. Firul principal (main()) aşteaptă încheierea execuţiei celor două fire, adună valorile rezultate şi afişează pe ecran suma.

Soluţie_1În directorul lab_cell copiază directorul b8a1a. Din directorul b8a1a se fac următoarele:

• (1) Se dă fişierul blat8_p1a.c (sau main.c)• (2) Se construieste fişierul Makefile astfel:

• (3) Se tastează comanda:export CELL_TOP=/opt/cell/sdk/

• (4) Se tastează comanda: make

• (5) Se ruleaza aplicatia, se modifica, recompileaza si se executa din nou

3.2. Problema 2

Problema 1 se modifică astfel încât firele de execuţie create să reprezinte (să încarce) un context SPU. Proiectul realizat va reprezenta un program de tip SPU apelat (integrat în) prin intermediul PPU (Cell SPU executable). Din contextul SPU se afişează un simplu mesaj “Hello from SPU!”. Fiecare fir de execuţie incrementează o variabilă transmisă ca parametru referinţă de 1000000 (106) ori. Firul principal (main()) aşteaptă încheierea execuţiei celor două fire, adună valorile rezultate şi afişează pe ecran suma.

1 PPE executa codul la trei niveluri diferite de privilegiu denumite “problem state”, stare supervizor si stare hipervizor. “Problem state” reprezinta modalitatea de executie normala de nivel utilizator (privilegiul cel mai redus).


12

Soluţie_2În directorul lab_cell copiază directorul b8a1b.

• (1) Se dă fişierul b8a1b.c (sau main.c)• (2) Se construieste fişierul Makefile astfel:

• (3) În directorul current se crează directorul spu.• (4) Se trece în directorul spu unde se copiază fişierul b8a1b_spu.c (sau spumain.c)• (5) Se construieste fişierul Makefile astfel:

• (3) Se tastează comanda:export CELL_TOP=/opt/cell/sdk/


• (5) Se revine în directorul părinte (b8a1b).


• (7) Se ruleaza aplicatia rezultată (b8a1b), se modifica, recompileaza si se executa din nou.


13

3.3. Problema 3 - Scrierea unui program multi-threaded pentru CBE (PPE si SPE)

Acest program CBE creaza threaduri SPE care vor afisa pe consola mesajul:

"Hello World! from Cell (#)\n",

unde # este spe_id-ul al threadului SPE care executa comanda de afisare.

Programul (thread-ul executat pe) SPE (spu/simple_spu.c) este incapsulat in executabilul PPE.

Executia programului consta in apelul executabilului PPE in prompterul de Linux din directorul specific PPE:

./simpleNu exista alte optiuni de comanda.

Pentru a scrie un program pentru CBE, sunt recomandati pasii descrisi mai jos (exemplul de cod este inclus in kitul SDK si poate fi gasit in /opt/cell/sdk/src/tutorial/simple).

Proiectul se numeste "simple". Ca diversitate, in acest exemplu, codul pentru PPE va fi scris in directorul proiectului, in locul subdirectorului ppu.

1. Creati un director numit "simple". 2. In directorul simple, creati un fisier cu numele "Makefile", in care scrieti urmatoarea secventa

de cod:3. ################4. # Subdirectories5. ################

6. DIRS := spu

7. ################8. # Target9. ################10. PROGRAM_ppu := simple

11. ################12. # Local Defines13. ################

14. IMPORTS := spu/lib_simple_spu.a -lspe2 -lpthread15.16. # imports the embedded simple_spu library17. # allows consolidation of spu program into ppe binary

18. ################19. # make.footer20. ################

21. # make.footer is in the top of the SDK22. ifdef CELL_TOP23. include $(CELL_TOP)/buildutils/make.footer24. else25. include ../../../../buildutils/make.footer26. Endif

27. In directorul simple, create fisierul "simple.c", in care scrieti urmatoarea secventa de cod: Computer Science and Electrical Engineering Department

Adrian FLOREA14

#include <stdlib.h>#include <stdio.h>#include <errno.h>#include <libspe2.h>#include <pthread.h>extern spe_program_handle_t simple_spu;#define MAX_SPU_THREADS 16void *ppu_pthread_function(void *arg){

spe_context_ptr_t ctx;unsigned int entry = SPE_DEFAULT_ENTRY;ctx = *((spe_context_ptr_t *)arg);if (spe_context_run(ctx, &entry, 0, NULL, NULL, NULL) < 0) {

perror ("Failed running context");exit(1);

}pthread_exit(NULL);

}int main(){

int i, spu_threads;spe_context_ptr_t ctxs[MAX_SPU_THREADS];pthread_t threads[MAX_SPU_THREADS];/** Determine the number of SPE threads to create. **/spu_threads = spe_cpu_info_get(SPE_COUNT_USABLE_SPES, -1);if (spu_threads > MAX_SPU_THREADS)

spu_threads = MAX_SPU_THREADS;/* Create several SPE-threads to execute 'simple_spu'.*/for(i=0; i<spu_threads; i++) {/* Create context */

if ((ctxs[i] = spe_context_create (0, NULL)) == NULL){perror ("Failed creating context");exit (1);

}/* Load program into context */if (spe_program_load (ctxs[i], &simple_spu)) {

perror ("Failed loading program");exit (1);

}/* Create thread for each SPE context */if (pthread_create (&threads[i], NULL, &ppu_pthread_function, &ctxs[i])) {

perror ("Failed creating thread");exit (1);

}}/* Wait for SPU-thread to complete execution. */for (i=0; i<spu_threads; i++) {

if (pthread_join (threads[i], NULL)) {perror("Failed pthread_join");exit (1);

}/* Destroy context */if (spe_context_destroy (ctxs[i]) != 0) {

perror("Failed destroying context");exit (1);

}}printf("\nThe program has successfully executed.\n");return 0;

}


15

28. Creati un director numit spu.29. In directorul spu, creati un fisier numit "Makefile", in care scrieti urmatoarea secventa de cod: 30. # Target31. PROGRAMS_spu := simple_spu32. LIBRARY_embed := lib_simple_spu.a

33. # include partea care face toata treaba pe baza definitiilor de mai sus

34. ifdef CELL_TOP35. include $(CELL_TOP)/buildutils/make.footer36. else37. include ../../../../buildutils/make.footer38. endif39. Tot in directorul spu, creati un fisier numit "simple_spu.c", in care scrieti urmatoarea secventa

de cod:

#include <stdio.h>int main(unsigned long long id){/* The first parameter of an spu program will always be the spe_id of the spe thread that issued it. */ printf("Hello World! from Cell (0x%llx)\n", id); return 0;}

40. Compilati programul folosind urmatoarea comanda in consola, in timp ce va aflati in directorul simple:

41. make

Multumiri

Doresc sa adresez multumiri colegului meu Conf. univ. dr. ing. Emil Slusanschi de la Universitatea “Politehnica” din Bucuresti, precum si colegilor mei Sef lucr. dr. ing. Ion Mironescu, Ing.drd. Ciprian Radu si Ing.drd. Horia Calborean – membrii ai centrului de cercetare in arhitecturi avansate de procdesare a informatiei (ACAPS – acaps.ulbsibiu.ro) din cadrul Universităţii „Lucian Blaga”, pentru sprijinul acordat, pentru materialele didactice şi sfaturile tehnice deosebit de utile.

BIBLIOGRAFIE

[Ungerer T., Schlingmann S.] Laboratory on CELL processor programming at University of Augsburg, Processor Architectures and System Software, University of Augsburg, Department of Computer Science.

[Tapus N., Slusanschi E.] Laboratorul 6 – Descrierea arhitecturii Cell Broadband Engine, Laboratorul Arhitectura Sistemelor de Calcul, Universitatea “Politehnica” din Bucuresti, Departmentul Calculatoare.

http://publib.boulder.ibm.com/infocenter/ieduasst/stgv1r0/topic/com.ibm.iea.cbe/cbe/1.0/Overview/L1T1H1_10_CellArchitecture.pdf


16



http://www.informatik.uni-augsburg.de/lehrstuehle/sik/mitarbeiter/schlingmann/

http://acaps.ulbsibiu.ro/

compilarea Şi execuŢia aplicaŢiilor pe...

Documents