Profiling

Introducere

Analiza performantelor (profiling) reprezinta analiza comportamentului unui program pentru a determina partile din cadrul acestuia ce pot fi optimizate. Analiza dinamica se realizeaza in timpul rularii programului si poate fi implementata cu ajutorul interuperilor hardware, al contorilor hardware, al hookurilor din cadrul sistemelor de operare, etc. Analiza statica este realizata fara a rula programul si se bazeaza pe analiza codului sursa, a codului obiect sau a unei versiuni intermediare a acestuia.

Pentru Cell/B.E., setul de utilitare ce pot fi folosite pentru analiza performantelor este alcatuit din:

  • profiling: Cell Perfomance Counter (CPC), OProfile, Performance Debugging Tool (PDT)
  • autotuning: Feedback Directed Program Restructuring (FDPR-Pro)
  • vizualizare: PDT Trace Reader (PDTR), Visual Performance Analyzer (VPA).

Din perspectiva temporala, analiza performantelor in vederea optimizarii aplicatiilor are loc dupa faza de debugging. In figura de mai jos, este prezentata ordinea recomandata pentru optimizarea cu utilitarele puse la dispozitie pentru Cell/B.E..

Utilitare pentru profiling si auto-tuning

In continuare vor fi descrise cele patru utilitare pentru profiling si autotuning: CPC, OProfile, PDT si FDPR-Pro. Tabelul de mai jos prezinta o vedere de ansamblu asupra utilitarelor.

Utilitar Utilizeaza Returneaza
CPC Contori hardware Profil vizualizat cu VPA Counter Analyzer
OProfile Contori hardware & Cod sursa Profil vizualizat cu VPA Profile Analyzer
PDT Cod instrumentat Profil vizualizat cu VPA Trace Analyzer
FDPR-Pro Cod instrumentat & Workload reprezentativ Cod executabil optimizat & Profil vizualizat cu VPA Code Analyzer

Cell Performance Counters


CPC permite setarea si citirea contorilor de performanta pusi la dispozitie de procesorul Cell/BE. Prin intermediul CPC, programatorul are acces la numarul de evenimente care au avut loc intr-un anumit interval de timp. Evenimentele hardware care pot fi monitorizate sunt asociate cu: PPE, SPE-uri, interface bus, memorie, controler de I/O.

Contorizarea evenimentelor este posibila prin unitatea Performance Monitoring Unit (PMU) care pune la dispozitie 4 contori pe 32 biti care pot fi configurati si ca perechi de cate 2 contori pe 16 biti. Pe scurt, CPC permite citirea regulata a contorilor din PMU prin setarea perioadei de sampling. CPC poate opera in urmatoarele doua moduri:

  • workload in cadrul caruia este determinata performanta pentru un singur proces si
  • system-wide care intoarce performanta pentru toate procesele.

Rezultatele analizei cu CPC sunt grupate in 7 blocuri logice, PPU, PowerPC Processor Storage Subsystem (PPSS), SPU, Memory Flow Controller (MFC), Element Interconnection Bus (EIB), Memory Interface Controller (MIC) si CELL/B.E. Interface Unit (BEI), fiecare bloc logic avand semnale organizate in grupuri. PMU poate monitoriza oricate semnale din cadrul aceluiasi grup dar numai doua grupuri de semnale in acelasi timp.

Citirea periodica a contorilor este realizata printr-un mecanism hardware. Astfel, monitorizarea este eficienta deoarece reduce numarul de apeluri ale CPC in interiorul kernelului. Procedura este denumita hardware sampling iar pasii necesari pentru activarea ei sunt urmatorii:

  1. se specifica valorile initiale ale contorilor si intervalul de sampling
  2. se inregistreaza valorile contorilor in hardware trace buffer dupa fiecare interval
  3. se reseteaza contorii
  4. rezultatele masuratorilor sunt disponibile in hardware trace buffer.

Samplingul hardware poate fi utilizat in mai multe moduri:

  • count mode in care se inregistreaza valorile din contori petru fiecare interval
  • occurence in care se indica daca evenimentele de interes au avut loc sau nu in cadrul intervalelor
  • threshold (prag) care indica daca evenimentele de interes au avut loc intr-un numar de ori mai mare decat pragul specificat.

Samplingul poate fi controlat fin cu ajutorul PPU bookmarks care sunt accesibile in cadrul sistemului de fisiere la: /sys/devices/system/cpu/cpu*/pmu_bookmark. Operatiile permise pentru aceste bookmarkuri se refera la oprirea sau pornirea unui anumit contor. Executarea acestor operatii poate fi realizata atat din linie de comanda ca parametru al CPC cat si din cadrul aplicatiilor.
Datele de iesire oferite de CPC sunt disponibile in diferite formate: text, HTML, XML.

OProfile


OProfile este o aplicatie de profiling la nivel de sistem capabila sa monitorizeze performanta intregului cod rulat cu un overhead minim. Este compus din: kernel driver, daemon pentru colectarea rezultatelor si utilitare de post-profiling pentru conversia datelor in informatii.

Comparat cu CPC, ofera statistici mai complexe. In plus, OProfile asociaza evenimentele hardware cu codul care le genereaza. Intreg codul este analizat de OProfile: intreruperi hardware si software, module kernel, kernel, biblioteci partajate si aplicatii.

OProfile este folosit in urmatoarele situatii:

  1. pentru profilingul unei aplicatii si a bibliotecilor partajate
  2. determinarea comportamentul din punct de vedere al performantei al intregului sistem
  3. pentru analiza handlerelor de intreruperi
  4. examinarea efectelor hardware.

OProfile are in componenta mai multe subutilitare:

  • opcontrol care configureaza si controleaza sistemul de profiling si seteaza contoarele pentru evenimentele hardware ce urmeaza a fi monitorizate
  • opreport care genereaza profiluri formatate in functie de simboluri si nume de fisiere; la iesire poate intoarce fisiere text sau XML
  • opannotate: genereaza surse sau cod asamblare adnotate; adnotarile sunt efectuate pentru fiecare linie de cod; opannotate necesita compilare cu simboluri de debugging.

Ca dezavantaj, OProfile necesita acces exclusiv la contorii hardware din PMU, fapt care nu permite rularea simultana a OProfile si CPC spre exemplu.

Performance Debugging Tool (PDT)


PDT ofera o modalitate de a inregistra evenimentele semnificative in timpul executiei programului si a de a pastra ordinea secventiala a evenimentelor. Inregistrarea evenimentelor este efectuata in timp real, datele fiind colectate de la PPE si SPE-uri.

Profilingul este bazat pe instrumentarea codului care implementeaza functiile cheie generatoare de evenimente pe SPE si PPE si colectarea inregistrarilor de traceuri. PDT creeaza un trafic aditional intre SPE-uri si PPE deoarece datele sunt colectate in memoria PPE.

Tracingul este realizat la nivel aplicatie (user space) iar datele sunt colectate la fiecare rulare a aplicatiei. De regula sunt selectate numai acele evenimente de interes. Procesul de profiling poate fi controlat dinamic prin API-ul PDT. In timpul rularii aplicatiei datele sunt colectate intr-un fisier mapat in memoria PPE in care este pastrata ordinea evenimentelor. SPE-urile utilizeaza DMA pentru a scrie date in memoria PPE.

Principalul dezavantaj al PDT consta in generarea un trafic aditional considerabil si de aceea poate influenta negativ performanta aplicatiei monitorizare.

Instrumentarea este realizata pentru functii din urmatoarele biblioteci:

  • pe PPE: DaCS, ALF, libspe2 si libsync
  • pe SPE: DaCS, ALF, libsyncm, spu_mfcio si overlay manager.

In general, evenimentele sunt capturate de functii din SDK care au fost deja instrumentate pentru tracing, intre acestea fiind: activarea SPE-urilor, transferuri DMA, sincronizare, semnalizare etc.

Feedback Directed Program Restructuring (FDPR-Pro)


FDPR-Pro este mai mult decat un utilitar pentru profiling, este un utilitar pentru optimizarea automata a aplicatiilor. Optimizarile sunt efectuate pentru un volum mediu de date de intrare. Pe baza datelor de intrare, este generata o noua versiune a programului in vederea unei executii mai rapide si unei utilizari mai eficiente a memoriei (ex. in functie de proprietatile datelor de intrare, instructiunile unui program ar putea fi reordonate astfel incat portiunea de cod cea mai des accesata sa incapa in cache). Apelat cu flagul -O, FDPR-Pro incearca sa aplice urmatoarele optimizari: reordonarea codului, predictia branchurilor, alinierea codului, branch folding si eliminarea instructinilor NOOP redundante.

Sunt trei faze distincte ale optimizarilor realizate cu fdprpro:

  1. faza de instrumentare in care se creeaza un executabil instrumentat insotit un fisier gol de profiling
  2. faza de antrenare in care programul primeste la intrare un workload reprezentativ iar in timpul rularii, fisierul de profiling este actualizat
  3. faza de optimizare in care compilatorul genereaza un nou executabil considerand datele colectate in fisierul de profiling.

FDPR-Pro are dezavantajul ca exista optimizari agresive (realizate cu flagul -O4 spre exemplu) care pot distruge semantica programului, acesta constituind motivul pentru care aplicatiile trebuie testate atent dupa optimizarea cu FDPR-Pro.

Un alt dezavantaj al FDPR-Pro consta in faptul ca un executabil instrumentat este de cateva ori mai lent decat programul original. De obicei datele folosite in etapa de antrenament sunt de dimensiuni mai mici decat cele reale pentru a nu creste timpul de executie. In acelasi timp datele trebuie sa fie reprezentative pentru worloadul acceptat in general de aplicatie.

Utilitare pentru vizualizare profiluri

In cadrul acestui laborator sunt descrise doua utilitare de vizualizare a rezultatelor monitorizarii aplicatiilor:

  1. PDTR care furnizeaza rapoarte pe baza rezultelor monitorizarii efectuate cu PDT
  2. VPA care prin intermediul subaplicatiilor sale (VPA Counter Analyzer, VPA Profile Analyzer, VPA Trace Analyzer si VPA Code Analyzer) este compatibil cu rezultatele furnizate de CPC, OProfile, PDT si FDPR-Pro.

PDT Trace Reader (PDTR)


PDTR este folosit pentru vizualizarea si procesarea rezultatelor returnate de PDT. Sumarul generat de PDTR include statistici legate de locking, DMA, mailboxuri si diverse evenimente. PDTR poate de asemenea genera rapoarte secventiale incluzand evenimente si parametri insotiti de stampile corespunzatoare de timp.

Visual Performance Analyzer (VPA)


VPA este un set de aplicatii vizuale integrate in Eclipse:

  • analizor de profiluri (ex. de la OProfile) cu ajutorul caruia pot fi identificate bottleneckurile de performanta (inhibitori) la nivel de proces, thread, modul, offset, instructiune sau linie de cod
  • analizor de cod (ex. de la FDPR-Pro) care faciliteaza determinarea hotspoturilor unui program (portiunile din cod cel mai des executate) si in plus ofera sugestii de optimizare
  • analizor de contori (ex. de la CPC) care permite identificarea si eliminarea bottleneckurilor de performanta prin examinarea valorilor contorilor hardware ai procesorului Cell/B.E., a metricilor de performanta calculate si a modelului Breakdown Cycle Per Instruction (CPI) in cadrul caruia este determinat numarul de cicli consumati pentru executia fiecarei etape din cadrul pipeline-ului.
  • analizor de traceuri (ex. de la PDT) cu care poate fi vizualizata executia programului si a evenimentelor care au avut loc ordonate in functie de timp
  • analizor de pipeline (ex. de la Sim-GX) care ofera informatii despre executia instructiunilor in cadrul pipelineului (intereseaza aici reducerea stallurilor din pipeline).

Exercitii

Pentru a putea rula exemplele din cadrul acestui laborator va trebui sa descarcati VPA de la http://www.alphaworks.ibm.com/tech/vpa/download si sa-l dezarhivati (tot aici sunt disponibile si instructiunile de instalare). Pentru a face sa mearga vpa-ul pe masinile de la laborator (si probabil si pe cele de acasa, aveti nevoie sa urmati pasii descrisi aici: http://www.alphaworks.ibm.com/tech/vpa/faq#05.

Fix vpa pentru Code Analyzer: “chcon -t texrel_shlib_t /opt/vpa/jre/bin/xawt/libmawt.so”. Aceasta comanda functioneaza daca vpa-ul este instalat in /opt/vpa.

Rulati programul vpa pe masina locala. Experimentele le veti face pe cell-1.grid.pub.ro iar analiza acestora pe masina locala.

Pentru rularea utilitarelor de profiling prezentate mai sus, va veti conecta la cell-1.grid.pub.ro folosind contul personal de pe curs.cs.pub.ro.

Pentru exemplul descris in acest laborator vom folosi aplicatia FFT16M, o gasiti in /opt/cell/sdk/src/demos_source.tar (daca e dezarhivat in /opt/cell/sdk/src/demos/FFT16M). Acest program calculeaza transformata fourier folosind operatii SIMD pe un array de 16.772.216 elemente.

Modificari necesare

Stergeti directorul FFT16M daca acesta exista deja in home-ul vostru si copiati codul in directorul home:
rm -R ~/FFT16M

- Daca aveti drept de root pe masina pe care rulati:
cp -R /opt/cell/sdk/src/demos/FFT16M ~

- Daca nu aveti drept de root, lucrati in home-ul vostru si dati:
cp /opt/cell/sdk/src/demos_source.tar
tar -xvf demos_source.tar

Intrati in directorul nou creat si modificati urmatoarele fisiere:
~/FFT16M/ppu/Makefile
si respectiv
~/FFT16M/spu/Makefile

Mai jos sunt afisate fisierele Makefile cu modificarile necesare pentru rularea aplicatiilor de profiling.

Fisierul: ~/FFT16M/ppu/Makefile

#######################################################################
##     Target
#######################################################################
#
 
PROGRAM_ppu= fft
 
#######################################################################
##     Objects
#######################################################################
#
 
IMPORTS = ../spu/fft_spu.a -lspe2 -lpthread -lm -lnuma
#INSTALL_DIR= $(EXP_SDKBIN)/demos
#INSTALL_FILES= $(PROGRAM_ppu)
LDFLAGS_gcc = -Wl,-q
CFLAGS_gcc = -g
 
#######################################################################
##      buildutils/make.footer
#######################################################################
#
 
ifdef CELL_TOP
   include $(CELL_TOP)/buildutils/make.footer
else
   include ../../../../buildutils/make.footer
endif

Fisierul: ~/FFT16M/spu/Makefile

#######################################################################
##       Target
#######################################################################
#
 
PROGRAMS_spu:= fft_spu
LIBRARY_embed:= fft_spu.a
 
#######################################################################
##       Local Defines
#######################################################################
#
 
CFLAGS_gcc:= -g --param max-unroll-times=1 # needed to keep size of
program down
LDFLAGS_gcc = -Wl,-q -g
 
#######################################################################
##       buildutils/make.footer
#######################################################################
#
 
ifdef CELL_TOP
   include $(CELL_TOP)/buildutils/make.footer
else
   include ../../../../buildutils/make.footer
endif

Colectare date cu CPC

Dupa ce compilati noile surse, puteti sa incepeti sa folositi CPC pentru a contoriza numarul de evenimente aparute in cadrul aplicatiei.
Pentru a vedea o lista cu evenimentele ce pot fi monitorizate rulati:

cpc --list-events

Verificati ca cpc poate fi folosit pentru monitorizare:

cpc --events C ls -l

Comanda de mai jos va numara instructiunile PPU comise si L1 cache load miss-uri si va afisa rezultatul intr-un format XML in fft_cpc.pmf.

cd ~/FFT16M
cpc --events C,2100,2119 --xml fft_cpc.pmf ./ppu/fft 20 1

Un alt exemplu de rulare, in care se numara evenimentele efectuate la fiecare ciclu de ceas intr-un interval de timp dat, este dat mai jos. Cu ajutorul argumentului –interval specificam un interval de timp de 100,000,000 cicli de ceas:

cpc -e 2100,2101,2106,2109 -e 2103,2104,2111,2119 --interval 100000000 -X fft_cpc2.pmf ./ppu/fft 20 1

Vizualizare rezultate cu Counter Analyzer

Pentru a vizualiza rezultatele cu utilitarul Counter Analyzer din VPA copiati mai intai pe masina locala fisierul fft_cpc.pmf si efectuati urmatorii pasi:

  • Deschideti VPA si selectati Tools > Counter Analyzer
  • Selectati File > Open
  • Deschideti fisierul fft_cpc.pmf

Utilizare FDPR-Pro

Utilitarul FDPR-Pro va ofera, pe langa functia de optimizare, posibilitatea de a investiga performantele aplicatiei mapand rezultatele la codul sursa in combinatie cu Code Analyzer.
Initial trebuie sa utilizati FDPR-Pro pentru colectarea datelor:

  • Stergeti rezultatele vechi si creati un director temporar pentru fdprpro
cd ~/FFT16M/ppu
rm -f *.mprof *.nprof
mkdir sputmp
  • Introduceti codul de profiling in executabilul fft:
fdprpro ./ppu/fft -cell -spedir sputmp -a instr
  • Rulati fisierul executabil creat:
./ppu/fft.instr 20 1
  • Ar trebui sa gasiti urmatoarele fisiere:
~/FFT16M/ppu/fft.nprof # profil PPU
~/FFT16M/ppu/fft_spu.mprof # profil SPU

Vizualizare informatii generate de FDPR-Pro cu Code Analyzer

Copiati mai intai fisierele fft, fft.c, fft.nprof, fft_spu.mprof pe masina locala.
Pentru a putea vizualiza informatiile generate de FDPR-Pro efectuati urmatorii pasi:

  • Deschideti VPA si selectati Tools > Code Analyzer
  • Mergeti in File > Code Analyzer > Analyze Executable, si deschideti fisierul executabil fft orginal. Ar trebui sa vi se deschida doua taburi, unul pentru PPU, unul pentru SPU, ca in imaginea de mai jos:

  • Introduceti informatiile generate despre PPU mergand in File > Code Analyzer > Add Profile Info si selectati fft.nprof.

Attach:lab5-5.jpg

  • Dupa ce veti introduce informatiile despre PPU, instructiunile vor fi colorate in functie de frecventa executiei lor (rosu pentru cele mai frecvente)

Attach:lab5-6.jpg

  • Puteti asocia si codul sursa selectand simbolul dorit in Program Tree, click-dreapta > Open Source Code si deschizand fisierul sursa. Rezultatul ar trebui sa adauge codul sursa intr-un nou tab si sa arate frecventa executiei liniilor de cod.

Attach:lab5-7.jpg

  • Pentru informatii despre dispatch groups apasati pe butonul “Collect display information about dispatch groups”

Attach:lab5-8.jpg

  • Vizualizati informatiile de pipeline pentru fiecare dispatch group selectand tabul Dispatch Info in coltul din dreapta jos si apasand butonul “Link with table”

Attach:lab5-9.jpg

  • Code Analyzer ofera si posibilitatea de a inspecta informatiile SPU-Timing la nivel de pipeline. Selectati tabul SPU, selectati simbolul dorit in Program Tree, click-dreapta si apasati pe “Select Timing”

Attach:lab5-11.jpg

Attach:lab5-12.jpg

Monitorizare cu PDT

PDT ofera posibilitatea inregistrarii evenimentelor importante din timpul executiei programului, vizualizarea acestora se face cu utilitarul Trace Analyzer. Va trebui sa recompilati aplicatia fft utilizand urmatoarele configurari:

  • Modificati spu/Makefile ca mai jos:
#######################################################################
##     Target
#######################################################################
#
 
PROGRAMS_spu:= fft_spu
LIBRARY_embed:= fft_spu.a
 
#######################################################################
##     Local Defines
#######################################################################
#
 
CFLAGS_gcc:= -g --param max-unroll-times=1 -Wall -Dmain=_pdt_main
-Dexit=_pdt_exit -DMFCIO_TRACE -DLIBSYNC_TRACE
LDFLAGS_gcc   = -Wl,-q -g -L/usr/spu/lib/trace
INCLUDE         = -I/usr/spu/include/trace
IMPORTS         = -ltrace
 
#######################################################################
##     buildutils/make.footer
#######################################################################
#
 
ifdef CELL_TOP
   include $(CELL_TOP)/buildutils/make.footer
else
   include ../../../../buildutils/make.footer
endif
  • Recompilati aplicatia
cd ~/FFT16M
make
  • Setati fisierul de configurare doar pentru stagnarile (stalls) relevante:
  1. Copiati fisierul default de configurare in directorul fft:
cp /usr/share/pdt/config/pdt_cbe_configuration.xml ~/FFT16M.
  1. Deschideti pentru editare fisierul copiat
  2. Pe prima linie schimbati numele aplicatiei in fft (application_name=“fft”)
  3. Cautati in fisier <configuration name=“SPE”>. Sub acea linie veti gasi grupul MFCIO, setati tag-ul grupului pe active=“false”
  4. Stergeti grupul SPE_MFC si salvati.
  • Pregatiti mediul de lucru prin setarea urmatoarelor variabile
export LD_LIBRARY_PATH=/usr/lib/trace
export PDT_KERNEL_MODULE=/usr/lib/modules/pdt.ko
export PDT_CONFIG_FILE=~/FFT16M/pdt_cbe_configuration.xml 
  • Rulati de cel putin trei ori aplicatia pentru a obtine data relevante.
cd ~/FFT16M/ppu
./fft 1 1 4 1 0

Trebuie sa desetati variabila LD_LIBRARY_PATH pentru a putea rula binarul original mai tarziu.

Generati un raport cu PDTR

Pentru a genera un raport text complet din fisierele rezultate, puteti utiliza PDTR pentru a produce fisiere .pep in format ASCII:

$ pdtr -trc <nume fisiere trace (fara extensie)>

Importati datele PDT in Trace Analyzer

Copiati fisierul .pex generat de PDT pe masina locala.
Utilitarul Trace Analyzer va permite vizualizarea etapelor de executie a unei aplicatii folosind datele generate de PDT.

  • In VPA selectati Tools > Trace Analyzer
  • Selectati File > Open File si deschideti fisier .pex generat anterior.

Colectare date cu OProfile

Pentru a putea controla si configura OProfile se foloseste comanda:

opcontrol
(:sourceend:)
 
Puteti sa vizualizati lista de evenimente ce pot fi monitorizate cu ajutorul comenzii:
<code text>
opcontrol --list-events

Pentru a specifica un eveniment pentru monitorizare folositi:

opcontrol --event=NUME_EVENIMENT:INTERVAL

Deoarece rularea OProfile necesita acces root, nu veti putea rula pe masinile cell disponibile. Un exemplu de rulare este prezentat mai jos. Informatiile generate de OProfile pot fi vizualizate in VPA in modul Profile Analyzer.
Exemplu:

[brutman@qdc167 sandbox]$ sudo opcontrol --init
[brutman@qdc167 sandbox]$ sudo opcontrol --no-vmlinux
[brutman@qdc167 sandbox]$ sudo opcontrol --event=SPU_CYCLES:100000
[brutman@qdc167 sandbox]$ sudo opcontrol --start
Forcing required option --separate=lib with SPU_CYCLES
Forcing required option --separate=cpu with SPU_CYCLES
Using 2.6+ OProfile kernel interface.
Using log file /var/lib/oprofile/oprofiled.log
Daemon started.
Profiler running.
[brutman@qdc167 sandbox]$ sudo opcontrol --reset
Signalling daemon... done
[brutman@qdc167 sandbox]$ ./FFT16M/ppu/fft 1 0
(output from fft workload snipped)
[brutman@qdc167 sandbox]$ sudo opcontrol --stop
Stopping profiling.
[brutman@qdc167 sandbox]$ sudo opcontrol --dump
[brutman@qdc167 sandbox]$ sudo opcontrol --deinit
Stopping profiling.
Killing daemon.
Unloading oprofile module
[brutman@qdc167 sandbox]$

Pentru a genera un raport bazat pe simboluri folositi opreport –symbols.

[brutman@qdc167 sandbox]$ opreport --symbols
CPU: ppc64 Cell Broadband Engine, speed 3200 MHz (estimated)
Counted SPU_CYCLES events (SPU Processor Cycles) with a unit mask of 0x00 (Count cycles                       [mandatory]) count 100000
Samples on CPU 0
Samples on CPU 1
Samples on CPU 2
Samples on CPU 3
Samples on CPU 4
Samples on CPU 5
Samples on CPU 6
Samples on CPU 7
samples %         samples %         samples %         samples %         samples  %       samples %       samples   %        samples  %        image name symbol name
398029   44.0202 398028    44.0201 391874    43.9982 390029    44.0115 390027    44.0113 390028  44.0114 390027    44.0113  390028   44.0114  fft_spu    _exit
394862   43.6699 394729    43.6552 388813    43.6545 386899    43.6584 386750    43.6415 386880  43.6562 386718    43.6379  386781   43.6450  fft_spu    main
71511     7.9088 71506      7.9082 70454      7.9103 70020      7.9012 70022      7.9014 70023    7.9015 70022      7.9014  70017      7.9008 fft_spu    process8192_816
29430     3.2548 29594      3.2730 29233      3.2822 29013      3.2739 29210      3.2961 29069    3.2802 29199      3.2949  29192      3.2941 fft_spu    process8192_0
6633      0.7336 6580       0.7277 6581       0.7389 6525       0.7363 6529       0.7367 6527     0.7365 6557       0.7399  6442       0.7269 fft_spu    stage1
2881      0.3186 2902       0.3209 2859       0.3210 2868       0.3236 2816       0.3178 2830     0.3193 2832       0.3196  2890       0.3261 fft_spu    _transpose_matrix4x4
289       0.0320 288        0.0319 285        0.0320 281        0.0317 284        0.0320 286      0.0323 282        0.0318  285        0.0322 fft_spu    stage3
265       0.0293 270        0.0299 263        0.0295 261        0.0295 262        0.0296 262      0.0296 263        0.0297  261        0.0295 fft_spu    stage2
122       0.0135 125        0.0138 122        0.0137 123        0.0139 121        0.0137 120      0.0135 118        0.0133  121        0.0137 fft_spu    _sind2
119       0.0132 124        0.0137 122        0.0137 117        0.0132 117        0.0132 123      0.0139 122        0.0138  123        0.0139 fft_spu    _cosd2
41        0.0045 40         0.0044 42         0.0047 48         0.0054 42         0.0047 44       0.0050 48         0.0054  39         0.0044 fft_spu    __divdf3
7        7.7e-04 3         3.3e-04 6         6.7e-04 5         5.6e-04 7         7.9e-04 2       2.3e-04 5         5.6e-04  8        9.0e-04  fft_spu    __pack_d
4        4.4e-04 4         4.4e-04 2         2.2e-04 5         5.6e-04 5         5.6e-04 2       2.3e-04 3         3.4e-04  3        3.4e-04  fft_spu    __do_global_dtors_aux
4        4.4e-04 4         4.4e-04 4         4.5e-04 3         3.4e-04 5         5.6e-04 1       1.1e-04 1         1.1e-04  7        7.9e-04  fft_spu    __unpack_d
[brutman@qdc167 sandbox]$

Pentru a genera un raport bazat pe fisiere folositi opreport –long-filenames.

[brutman@qdc167 sandbox]$ opreport --long-filenames
CPU: ppc64 Cell Broadband Engine, speed 3200 MHz (estimated)
Counted SPU_CYCLES events (SPU Processor Cycles) with a unit mask of 0x00 (Count cycles                         [mandatory]) count 100000
Samples on CPU 0
Samples on CPU 1
Samples on CPU 2
Samples on CPU 3
Samples on CPU 4
Samples on CPU 5
Samples on CPU 6
Samples on CPU 7
            cpu:0|            cpu:1|            cpu:2|            cpu:3|            cpu:4|            cpu:5|            cpu:6|            cpu:7|
  samples|       %| samples|      %|  samples|      %|  samples|      %|  samples|      %|  samples|      %|  samples|      %|  samples|      %|
------------------------------------------------------------------------------------------------------------------------------------------------
   904197 100.000    904197 100.000    890660 100.000    886197 100.000    886197 100.000    886197 100.000    886197 100.000    886197 100.000
    /home/brutman/sandbox/FFT16M/ppu/fft
[brutman@qdc167 sandbox]$

Concluzii

Analiza performantelor reprezinta este o componenta esentiala in procesul de optimizare a unei aplicatii pentru a folosi la maxim puterea de calcul pusa la dispozitie de arhitectura Cell/B.E.. Acest laborator a prezentat un set de utilitare pentru analiza performantelor aplicatiilor pentru Cell/B.E.:

  • CPC (bazat pe citirea contorilor de performanta oferiti de Cell/BE)
  • OProfile (analiza detaliata a codului si a legaturii cu evenimentele hardware)
  • PDT (analiza bazata pe instrumentarea functiilor din anumite librarii)
  • FDPR-Pro (analiza si optimizare automata a aplicatiilor)
  • PDTR si VPA (instrumente pentru vizualizarea fisierelor rezultate in urma profilingului).

Linkuri utile

asc/cellcookbook/profiler.txt · Last modified: 2017/03/08 11:29 by emil.slusanschi
CC Attribution-Share Alike 4.0 International
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