Scopul acestui concurs este familiarizarea cu API-ul pus la dispoziție de framework-ul LLVM. Folosind acest API trebuie să implementați o serie de pași de analiză/optimizare de bitcode LLVM. Tema este compusă din patru părți:

1. Analiză statică
2. Analiză dinamică/instrumentare
3. Optimizare
4. Concurs

• Deadline: Termenul limită până când se pot trimite rezolvări 13 ianuarie 2016, ora 19:59. Pentru mai multe detalii, consultaţi regulamentul aferent temelor de casă.
• Atenție: Deadline-ul este final - după 13 ianuarie 2016, ora 19:59 nu se vor mai putea trimite rezolvări.
• Colaborare: Rezolvarea este individuală.
• Punctare
  • 100p pentru implementarea completă şi corectă a primelor trei părți
  • Pentru cea de-a patra parte se va face un clasament în funcție de costul obținut de fiecare rezolvare individuală. Cel mai mic cost va fi cel care va câștiga concursul.
  • Concursul valorează 12.5 puncte din nota finală - poate fi folosit pentru a recupera punctajul pierdut în cursul anului.

• Rezolvarea cerințelor se va face folosind LLVM 3.6.2
• Setup-ul de testare este identic cu cel din mașina virutală. Vă recomandăm să folosiți mașina virtuală pentru rezolvare.

Premisa acestul concurs este că avem la dispoziție o arhitectură fictivă care execută instrucțiuni LLVM IR. Pentru a executa o instrucțiune LLVM IR pe procesorul fictiv este necesar un anumit număr de cicluri de ceas. Astfel, putem estima cât de costisitoare este execuția unei instrucțiuni.

Pentru aceasta fiecare pas va folosi un fișier de intrare care conține pe fiecare linie numele unei instrucțiuni LLVM IR și un cost/scor asociat. Exemplu:

br 10
add 7
sub 7
alloca 10
default 1

Token-ul special default este folosit pentru a asocia un cost implicit pentru instrucțiunile care nu sunt menționate explicit în fișier. Dacă linia cu token-ul default lipsește, costul implicit este 0.

Fiecare pas LLVM implementat trebuie să citească costurile asociate instrucțiunilor din fișierul cpl-score-file.txt. Pașii trebuie să poată permită folosirea unui alt fișier cu scoruri folosind argumentul -cpl-score-file. Exemplu:

# run the optimization pass with the default score file
opt -load=/path/to/libLLVMCpl.so -cpl-opt test.bc > out.bc
 
# run the analysis/instrumentation pass with a custom score file
opt -load=/path/to/libLLVMCpl.so -cpl-dynamic -cpl-score-file=my-custom-score-file.txt test.bc > out.bc

Pentru a rezolva această cerință va trebui să implementați un pas LLVM care, pe baza unui fișier de intrare precum cel de mai sus, să afișeze suma scorurilor tuturor instrucțiunilor din program.

Analiza trebuie să nu țină cont de instrucțiunile de control-flow întâlnite, de evaluarea unor condiții, de bucle etc. Cu alte cuvinte, tot ce trebuie să faceți este să iterați pe fiecare instrucțiune din fiecare funcție a programului, să îi contorizați scorul asociat iar la final să afișați scorul/costul total.

Pasul NU trebuie să analizeze conținutul funcțiilor implicite, al constructorilor sau al destructorilor.

Funcțiile implicite (intrinsics) sunt folosite intern de către LLVM. Aceste funcții pot fi identificate prin faptul că numele lor începe cu prefixul “llvm.*”. Se poate verifica ușor dacă o funcție este sau nu implicită folosind API-ul

Constructorii și destructorii sunt menținuți în câte un array global. Funcțiile din llvm.global_ctors vor fi apelate atunci când modulul LLVM este încărcat (înainte de începerea efectivă a execuției programului), în ordinea ascendentă a priorității asociate. Funcțiile din llvm.global_dtors sunt apelate atunci când modulul LLVM este descărcat (după terminarea efectivă a execuției programului), în ordinea descendentă a priorității. Pentru lucrul cu contructori, puteți folosi clasa CtorUtils

Scorul static ne poate da o idee despre cât de “costisitoare” este execuția unui program, însă nu reprezintă o estimare realistă pentru toate cazurile de execuție. In practică, o instrucțiune se poate executa de mai multe ori (de exemplu dacă face parte dintr-o buclă) sau niciodată (de exemplu dacă face parte dintr-o funcție neapelată). De asemenea căile de execuție depind de multe ori de setul de date de intrare al programului. Calculul static al scorului nu ia în considerare aceste cazuri.

Pentru a rezolva a doua parte a temei va trebui să implementați un pas LLVM care instrumentează un program astfel încât costul execuției acestuia să fie calculat la runtime. Codul original trebuie modficat astfel: în interiorul fiecărui basic block trebuie adăugat cod care adună scorul total al BasicBlock-ului curent. Scorul total al BasicBlock-ului este egal cu suma scorurilor instrucțiunilor din care acesta este compus.

Arhitectura pe care lucrăm are o particularitate: costul execuției instrucțiunilor br și switch (atât condiționale cât și necondiționale) este foarte ridicat. Pentru a rezolva a treia parte a temei, trebuie să creați un pas de optimizare care să micșoreze costul de execuție reducând numărul de instrucțiuni br executate (ex: mai puține bucle).

Evaluarea se va face folosind un set de benchmark-uri: costul de execuție pentru arhivarea/dezarhivarea unui anumit set de date, folosind utilitarele zip/unzip. Costul de execuție se calculează instrumentând varianta optimizată a programului de test folosind pass-ul implementat în partea a doua.

Regula este simplă: cine obține cel mai mic scor pentru benchmark-ul dat, câștigă. Pentru a micșora costul de execuție puteți implementa orice pași de optimizare doriți, pe care îi puteți apela în orice ordine. Atenție însă: nu aveți voie să folosiți pașii LLVM, nici direct (nu aveți voie să îi apelați), nici indirect (nu aveți voie să preluați cod - verificați ce înseamnă temă copiată). Aceeași regulă se aplică și pentru pașii de analiză.

Pentru implementarea pașilor LLVM, puteți urmării pașii de mai jos:

1. Descărcați arhiva de start în afara surselor LLVM și dezarhivați-o (Exemplu: zip concurs-arhiva.zip)
2. Creați un director de build și intrați în el (Exemplu: mkdir build; cd build)
3. Rulați cmake cu calea directorului unde ați dezarhivat arhiva (Exemplu: cmake ..)
4. Compilați pasul (Exemplu: make)
5. Dacă totul s-a compilat cu succes, ar trebui să se genereze biblioteca libLLVMCpl.so în directorul Cpl

• Arhiva de start
• Documentația LLVM
• Loop Unrolling:
  • Dragon Book: Capitolele 10.4.5, 9.6
  • Muchnik: Capitolul 18 (Secțiunea 18.4), Capitolul 14
• Testare: TODO