Tutorial Cell - Eclipse

Observatii:

  • Pentru a căuta fișiere sau directoare în Linux, în directorul rădăcină, se poate folosi comanda:
find / -name eclipse
  • Cerințe minime recomandate de sistem pentru a lucra în Cell - IDE:
    • Hardware: sistem x86 cu procesor 2GHz Pentium® 4 (sau echivalent), minimum 1 GB RAM, minimum 9 GB spațiu liber pe HDD. În cazul folosirii Full System Simulator, capacitatea minima a memoriei RAM trebuie sa fie dublul memoriei simulate. Pentru a simula un system cu 512MB de RAM, pe sistemul gazdă trebuie să existe cel puțin 1GB de RAM.

În continuare sunt prezentați pașii pentru crearea și rularea unui proiect Cell folosind Eclipse și mediul de lucru din imaginea de FC7 rulată prin VMware Server (1.0.5).

Cell/B.E. SDK 3.0: Crearea unui proiect SPU

Verificarea instalării Cell IDE:

  1. Mergeți în directorul în care a fost instalat Eclipse și porniți-l:
    /opt/cell/ide/eclipse/eclipse
    #Pe masinile din laborator dati
    /opt/cell/ide/eclipse/eclipse -vm /opt/jdk1.6.0_21_x86/bin
  2. Click pe meniul de sus Help→Software Updates→ Manage Configuration, expandati /home/student/eclipse (sau: /home/cell_IDE/eclipse SDK 3.0 respectiv /opt/cell/ide/eclipse) și verificați că există:
  • Eclipse C/C++ Development Tooling SDK 3.1.xxx
  • Eclipse Project SDK 3.3.xxx (sau Eclipse Project SDK 3.2.xxx pentru SDK 3.0 pe VMware Image)
  • IBM SDK for Multicore Acceleration IDE 3.1.xxx (sau IBM SDK for Multicore Acceleration IDE 3.0.xxx pentru SDK 3.0 pe [=VMware=] Image)

Crearea proiectului SPU:

1. Dupa deschiderea Eclipse, salvați workspaceul într-o locație dorită (de exemplu: /home/student/Desktop/workspace). Puteți copia ulterior întregul director, eliminând necesitatea efectuării pașilor următori de fiecare dată pentru crearea unui proiect. Treceți apoi pe perspectiva 'C/C++' din: Window > Open Perspective > Other (Fig. 1).

Invalid Link
Fig. 1. Schimbarea perspectivei

2. Alegeți C/C++ (Fig. 2) și dați click pe OK.

Invalid Link
Fig. 2. Selectarea perspectivei C/C++

3. Creați un nou proiect C mergând la: File → New → Project (Fig. 3).

Fig. 3. Crearea unui proiect nou pentru SPU

4. Acum ar trebui să vă aflați in New Project Wizard. Expandați subsecțiunea C si selectați Managed Make C Project. Un proiect Standard Make C/C++ necesita un makefile din partea programatorului, pe cand intr-un proiect Managed Make Project fisierul makefile este creat automat. Daca proiectul dvs are deja un makefile sau doriti sa creati propriul makefile, selectati Standard Make. Apasati pe Next pentru a continua (daca opțiunea Managed Make C Project nu este disponibilă, selectați C Project).

5. Pentru numele proiectului, completați SPU, apoi apăsați pe Next pentru a continua. La tipul proiectului selectati : Cell SPU Executable si apoi faceti click pe Finish. Pentru ca opțiunile de Cell să fie vizibile, trebuie să debifați “show project types and toolchains only if they are supported on the platform”.

6. În fereastra din stanga (view) numită C/C++ Projects, faceți dreapta-click pe proiectul SPU și selectați Properties (Fig. 4).

Invalid Link
Fig. 4. Setarea proprietatilor proiectului SPU

7. La acest pas veți adăuga directorele pentru compilatorul de SPU. Va trebui să adăugați directorul ce conține fișierul header profile.h la lista cu căi incluse a compilatorului (necesar și pentru a putea folosi uneltele de analiză dinamică a performanței). Faceți click pe C/C++ Build in meniul din stanga. In tabul Tool Settings, selectați Directories din subsectiunea SPU GNU 32 bit C Compiler with Debug Options. În cadrul secțiunii Include Paths din dreapta, faceți click pe butonul Add (Fig. 5).

Invalid Link
Fig. 5. Adaugarea directoarelor pentru compilator

:!:Următorul pas nu il faceți momentan pe sistemele din laborator

8. Mergeți la File System, apoi selectati calea: /opt/ibm/systemsim-cell/include/callthru/spu. Apasati apoi de doua ori pe OK pentru a reveni la ecranul principal.

9. Urmează crearea unui nou fișier sursa C din meniul File → New → Source File (Fig. 6). Ca nume, scrieți spu.c, apoi apăsați pe Finish.

Invalid Link
Fig. 6. Crearea unui nou fisier sursa

10. Pasul urmator constă în editarea conținutului sursei. Faceți copy paste în fișierul spu.c, în fereastra de editare, la următoarea secvență de cod:

hello_spu.c
#include <stdio.h>
#include <profile.h>
 
int main(unsigned long long id){
   //prof_clear();
   //prof_start();
   printf("Hello Cell (0x%llx)\n", id);
   //prof_stop();
   return 0;
}

11. Salvați sursa (CTRL+S). Se va face automat build. Informațiile de output sunt afișate în fereastra (view-ul) Console, în partea inferioara a ecranului (Fig. 7). Resursele noi, cum ar fi fișierele binare și cele incluse în proiect, pot fi vazute în fereastra (view-ul) C/C++ Projects din partea stanga (Fig. 7).

Dacă build-ul automat nu funcționeaza (“nothing to build”), folosiți Project/Build All.

Invalid Link
Fig. 7. Vedere dupa salvarea sursei si build automat

12. Felicitari! In acest moment ati terminat crearea unui proiect SPU.

Cell/B.E. SDK 3.0: Crearea unui proiect PPU

Pasii din aceasta subsectiune 1.2 este recomandat sa fie urmati dupa urmarea tuturor pasilor prezentati in subsectiunea 1.1 din acest laborator. In acest moment ar trebui sa aveti deschis Eclipse si perspectiva C/C++ selectata (vedeti pasii 1 si 2 din sectiunea 1.1, Crearea unui proiect SPU). Pentru a crea un proiect PPU parcurgeti urmatorii pasi:

1. Primul pas consta in crearea unui proiect PPU executable care va folosi modulul Embed SPU tool asupra proiectului SPU construit la punctul 1.1. Creati un nou proiect C mergand in meniul File → New → Project (Fig. 3).

2. Acum ar trebui sa va aflati in New Project Wizard. Expandati subsectiunea C si selectati Managed Make C Project. Un proiect Standard Make C/C++ necesita un makefile din partea programatorului, pe cand intr-un proiect Managed Make Project fisierul makefile este creat automat. Daca proiectul dvs are deja un makefile sau doriti sa creati propriul makefile, selectati Standard Make. Apasati pe Next pentru a continua. (La fel ca la proiectul SPU, daca optiunile “Standard Make/Managed Make” nu exista, selectati “C Project”).

3. Pentru numele proiectului, completati PPU, apoi apasati pe Next pentru a continua. La tipul proiectului selectati : Cell PPU Executable si apoi faceti click pe Next.

4. In urmatoarea fereastra va aparea proiectul creat in subsectiunea 1.1 (numit SPU). Acesta trebuie bifat deoarece executabilul din proiectul SPU va fi inclus in proiectul PPU. Bifati casuta din dreptul SPU si apoi faceti click pe Finish (Fig. 8).

In versiunea de Eclipse din laborator, pentru a realiza aceasta setare trebuie ca in fereastra de “Select Configurations” care apare sa dati click pe “Advanced Settings”, si sa bifati “SPU” la “Project References”.

Invalid Link
Fig. 8. Includerea proiectului SPU in proiectul PPU

5. In fereastra din stanga (view) numita C/C++ Projects, faceti dreapta-click pe proiectul PPU si selectati Properties (Fig. 9).

Invalid Link
Fig. 9. Setarea proprietatilor proiectului PPU

6. In panelul din stanga selectati C/C++ Build. In grupul Active configuration de sus, puteti schimba configuratia curenta, ca de exemplu ppu-gnu32-debug si ppu-xl32-debug, sau puteti crea propria configuratie. In Tabul Tool Settings, puteti manipula compilatorul, linker-ul, assembler-ul si functia SPU embedded (acest lucru e valabil doar pentru proiectele PPU). Faceti click pe Manage (Fig. 10) pentru a vedea in detaliu aceste optiuni.

Invalid Link
Fig. 10. Alegerea optiunilor C/C++ build

7. Puteti redenumi, sterge sau crea configuratii noi. Selectati ppu-gnu32-debug apoi faceti click pe OK (Fig. 11).

Invalid Link
Fig. 11. Manipularea configuratiilor de proiect PPU

8. In acest pas se vor adauga bibliotecile pentru linker in PPU. In codul sursa PPU va fi inclus fisierul libspe2, astfel ca biblioteca spe2 va trebui adaugata la lista de biblioteci a linkerului. Mergeti in tabul Tool Settings, selectati optiunea Libraries din categoria PPU GNU 32-bit C Linker, apoi faceti click pe butonul de Add din sectiunea Libraries din partea dreapta (Fig. 12). Scrieti spe2 apoi apasati pe OK.

Invalid Link
Fig. 12. Adaugarea librariei spe2

9. Urmeaza adaugarea executabilului din proiectul SPU in proiectul PPU. Pentru a include executabilul din proiect SPU in proiectul PPU, acesta va trebui adaugat folosind &#8220;embed SPU input&#8221;. In categoria PPU GNU 32-bit Embed SPU, selectati optiunea Inputs. Faceti apoi click pe butonul de Add din sectiunea (panelul) Embed SPU Inputs din partea dreapta. Apasati apoi pe butonul Workspace, apoi selectati executabilul SPU, mergand in structura arborescenta la: SPU → spu-gnu-debug → SPU. Apasati apoi OK de doua ori pentru a reveni la fereastra de proprietati a proiectului PPU si inca o data OK pentru a parasi fereastra de proprietati (Fig. 13).

Invalid Link
Fig. 13. Adaugarea executabilului din proiectul SPU in proiectul PPU

10. Selectati PPU din panelul C/C++ Projects din partea stanga a ecranului. Urmeaza crearea unui nou fisier sursa C din meniul File → New → Source File (Fig. 6). Ca nume, scrieti ppu.c, apoi apasati pe Finish.

11. Pasul urmator consta in editarea continutului sursei. Faceti copy paste in fisierul ppu.c, in fereastra de editare, la urmatoarea secventa de cod:

ppu.c
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <libspe2.h>
#include <pthread.h>
 
extern spe_program_handle_t SPU;
 
#define SPU_THREADS 8
 
void *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;
   spe_context_ptr_t ctxs[SPU_THREADS];
   pthread_t threads[SPU_THREADS];
 
   /* Create several SPE-threads to execute '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], &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);
}

12. Salvati sursa (CTRL+S). Se va face automat build (daca acest lucru nu se intampla, folositi Project/Build All). Informatiile de output sunt afisate in fereastra (view-ul) Console, in partea inferioara a ecranului. Resursele noi, cum ar fi fisierele binare si cele incluse in proiect, pot fi vazute in fereastra (view-ul) C/C++ Projects din partea stanga.

13. Felicitari! In acest moment ati terminat crearea unui proiect PPU.

Cell/B.E. SDK 3.0: Crearea mediului de simulare pentru arhitectura Cell/B.E

Pașii din aceasta subsectiune 1.3 este recomandat să fie urmati dupa urmarea în ordine a tuturor pașilor prezentați în subsectiunile 1.1 si 1.2 din acest laborator. În acest moment ar trebui sa aveți deschis Eclipse și perspectiva C/C++ selectată (vedeți pașii 1 si 2 din secțiunea 1.1, Crearea unui proiect SPU) și cele doua proiecte PPU si SPU create și configurate. Pentru a testa programul, mai intai trebuie creat mediul de simulare pentru arhitectura Cell/B.E. Cell/B.E. IDE integrează simulatorul IBM full-system simulator pentru procesorul Cell/B.E. in Eclipse. Pentru a realiza acest task, parcurgeți următorii pasi:

1. In partea de jos a ecranului, selectați Cell Environments, faceți dreapta-click pe Local Cell Simulator și apoi faceți click pe Create (Fig. 14).

Invalid Link
Fig. 14. Inceperea procesului de creare a mediului de simulare

Obs: daca in partea de jos lipsesc taburi, le puteți aduce în felul urmator: din meniul ; meniul Window → Show View → Console; meniul Window → Show View → Properties; meniul Window → Show View → Other → Cell → Cell Environments → OK.

2. Urmează configurarea simulatorului. În acest moment ar trebui să vă aflați în fereastra de proprietăți a Local Cell Simulator, după primul pas de mai sus. Puteți modifica oricând configurația mediului simulatorului Cell/B.E. (atăta timp cât acesta nu rulează) dând dreapta-click pe Environment si selectand apoi Edit. Introduceți un nume pentru simulator (de exemplu: My Cell Simulator), apoi faceți click pe tabul Simulator (observați că în tabul Hardware puteți seta cantitatea de memorie RAM din simulator) (Fig. 15).

Invalid Link
Fig. 15. Configurarea simulatorului

3. În tabul Simulator bifati optiunea Show TCL console, apoi faceti click pe Finish (Fig. 15).

4. Urmează pornirea simulatorului. In tabul Cell Environments, apăsați pe semnul + din dreptul Local Cell Simulator (pentru a expanda continutul). Selectați apoi din lista aparută numele simulatorului introdus la pasul 2 (în cazul nostru: My Cell Simulator), apoi apăsați pe butonul Start the Environment din partea dreaptă (săgeata verde, cu forma de play) (Fig. 16). În acest moment va începe lansarea simulatorului (:!: poate dura pâna la câteva minute) (Fig. 16).

5. Felicitări! În acest moment ați terminat crearea mediului de simulare Cell/B.E.

Invalid Link
Fig. 16. Lansarea simulatorului Cell/B.E.

Rularea programului

După terminarea încarcarii simulatorului, acesta va intra în pauză (PAUSED MODE). Pentru a rula programul PPU, trebuie parcurși următorii pasi:

  1. Mai întâi din fereastra de Linux systemsim-cell se selectează (optional) Mode→Fast, apoi se apasă pe butonul Go.
  2. Dupa ce simulatorul va intra in RUNNING MODE, se merge în panelul C/C++ Projects din stanga și se face dreapta-click pe proiectul PP, apoi se face click pe Run As→Run… (există și un buton de culoare verde, în formă de play, în partea de sus sau se poate intră în meniul Run → Run).
  3. În meniul din partea stanga, se face dreapta-click pe optiunea C/C++ Cell Target Application apoi se da click pe New. Se selecteaza subopțiunea aparuta (PPU) și în partea dreaptă, în tabul Main, în zona C/C++ Application se face click pe butonul Search Project. Apoi se selectează PPU din listă și se apasă butonul OK.
  4. În cazul in care apare eroarea “The CPU is not supported by selected debugger” se merge apoi la tabul Debugger (in dreapta) si se selecteaza Cell BE gdbserver gdb/mi folosind drop-down box-ul din zona Debugger.
  5. Se apasa apoi butonul Apply (partea dreapta, jos), urmat apoi de Run.
  6. Se poate urmări outputul programului în fereastra Console din partea de jos a ecranului. Atenție :!: : tot în partea inferioară, folosind butonul Display Selected Console, se poate comuta între diferitele console din simulator (util și necesar pentru a vedea rezultatul unui program care și-a terminat rularea).

Linkuri utile

asc/cellcookbook/tutorial-eclipse.txt · Last modified: 2017/03/08 11:31 by emil.slusanschi
CC Attribution-Share Alike 3.0 Unported
www.chimeric.de Valid CSS Driven by DokuWiki do yourself a favour and use a real browser - get firefox!! Recent changes RSS feed Valid XHTML 1.0