Show page

Differences

This shows you the differences between two versions of the page.

--- asc:teme:tema3 [2020/04/20 14:04]
grigore.lupescu [Resurse]
+++ asc:teme:tema3 [2024/05/10 12:49] (current)
emil.slusanschi
@@ Line 1: / Line 1: @@
 ====== Tema 3 ======
-    * **Deadline soft:** 10 mai 2020, ora 23:55. Primiți un bonus de 10% din punctajul obtinut pentru trimiterea temei înainte de 7 mai 2020 2020, ora 23:55.
+<note important>
-    * **Deadline hard:** 17 mai 2020, ora 23:55. Veți primi o depunctare de 10% din punctajul maxim al temei pentru fiecare zi de întârziere, până la maxim 7 zile, adică până pe 17 mai 2020 2020, ora 23:55.
+    * **Deadline soft:** 22 mai 2024, ora 23:55.
+    * Primiți un bonus de 10% din punctajul obținut pentru trimiterea temei înainte de 20 mai 2024, ora 23:55.
+    * **Deadline hard:** 26 mai 2024, ora 23:55.
+    * Veți primi o depunctare de 10% din punctajul maxim al temei pentru fiecare zi de întârziere (după 22 mai), până la maxim 4 zile, adică până pe 26 mai 2024, ora 23:55.
+    * **Responsabili:** [[vladspoiala@gmail.com |Vlad Spoiala]], [[emil.slusanschi@cs.pub.ro|Emil Slusanschi]], [[alexandrut030@gmail.com | Alexandru Tudor]].
+</note>
+<note tip>
+  * Dată publicare: 10 mai 2024
+  * Dată actualizare enunț: 09 mai 2024
+</note>
 ===== Enunț =====
-Se va implementa o structură de date tip hashtable folosind CUDA, având ca target GPU Tesla K40 (hp-sl.q).
-<note important> Tema se poate dezvolta pe orice sistem cu suport CUDA, dar punctarea se face exclusiv pe coada hp-sl.q </note>
+Se dă următoarea operație cu matrice:
-Această structură de date tip hashtable va avea următoarele caracteristici:
+$$ C =  (A^t \times B + B \times A) \times B^t $$
-  - va face maparea key -> value, (o singură valoare per key)
-  - va putea stoca date de tip int32, mai mari strict ca 0, atât pentru chei, cât și pentru valori
-     * valid (key->value): 1234 -> 8965, 12334244 -> 8223965
-     * invalid (key->value): 0 -> 9779, -12334244 -> 83965, 7868 -> -977, “jknjjk” -> 78
-  - va stoca datele în VRAM și va putea să își reajusteze dimensiunea cât să poată acomoda numărul de perechi key->value, având un   *
-  - loadFactor decent (sloturi ocupate / sloturi disponibile)
-  - va rezolva intern coliziunile (exemplu: prin resize, folosind multe funcții de hash etc.). Funcțiile hash vor fi pentru cazurile generale (ex. cele de tip ax % b, a si b prime). Exemplu de funcție hash neacceptată: h(x) = x % limit, atunci când cheile sunt tot timpul în ordine crescătoare pe intervale și unice (nu tratează cazul general)
-  - va face update la valoarea unei chei -> operația de insert nu va conține niciodată 2 chei identice, însă operații succesive de insert nu au restricții (se va face update de valoare)
-  - va putea întoarce corect, într-un timp rapid, valoarea corespunzătoare unei chei
-  - va întoarce încărcarea (memoria efectiv folosită / memoria alocată) via funcția load_factor
-  - implementare greșită sau neclară poate duce la o depunctare suplimentară
-Implementarea temei are design la liber, cât timp testele trec și soluția este una rezonabilă, neavând ca scop trecerea testelor (ex. <<așa nu>> comportamentul tabelei hash e strict modelat pe teste, când se face resize etc).
+unde:
+  * $A$ si $B$ sunt matrice pătratice de dimensiune N x N, cu elemente de tip double
+  * **$A$ este o matrice superior triunghiulară**
+  * $A^t$ este transpusa lui $A$ și $B^t$ este transpusa lui $B$
+  * $\times$ este operația de înmulțire
+  * $+$ este operația de adunare
-Exemple de implementări:
+Se dorește implementarea expresiei de mai sus folosind limbajele C/C++, în 3 moduri:
-  * Linear probing: se calculează hash(key) și se dacă slotul nu e liber se încearcă succesiv hash(key) + 1… hash(key) + N
+  * **blas** - o variantă care folosește una sau mai multe funcții din [[http://www.netlib.org/blas/ | BLAS Atlas]] pentru realizarea operațiilor de înmulțire și adunare.
-  * Cuckoo based: se folosesc 2-3 funcții hash și se caută un slot liber, alternativ se face evict la key2-value2 din acel slot, se inserează nouă pereche key-value, iar key2-value2 se caută să se insereze folosind o altă funcție hash din cele disponibile
+  * **neopt** - o variantă "de mână" fără îmbunătățiri.
-  * Bucketized cuckoo - se folosește tehnica cuckoo, având buckets cu 2, 4, 8 sloturi fiecare.
+  * **opt_m** - o variantă îmbunătățită a versiunii **neopt**. Îmbunătățirea are în vedere **exclusiv** modificarea codului pentru a obține performanțe mai bune.
-===== Schelet tema =====
+<note important> Fiecare din cele 3 implementări de mai sus va ține cont de faptul că **A este o matrice superior triunghiulară**. </note>
-Se va completa scheletul pus la dispoziție (gpu_map.cu) având următoarele funcții ce trebuie implementate:
+===== Rulare și testare =====
-<code>
+Pentru testarea temei vă este oferit un schelet de cod pe care trebuie să-l completați cu
-/* INIT HASH
+implementările celor 3 variante menționate mai sus. Scheletul de cod este structurat astfel:
- */
+  * **main.c** - conține funcția main, precum și alte funcții folosite pentru citirea fișierului cu descrierea testelor, scrierea matricei rezultat într-un fișier, generarea datelor de intrare și rularea unui test. __Acest fișier va fi suprascris în timpul corectării și nu trebuie modificat__.
-GpuHashTable::GpuHashTable(int size) { }
+  * **utils.h** - fișier header. __Acest fișier va fi suprascris în timpul corectării și nu trebuie modificat__.
+  * **solver_blas.c** - în acest fișier trebuie să adăugați implementarea variantei **blas**.
+  * **solver_neopt.c** - în acest fișier trebuie să adăugați implementarea variantei **neopt**.
+  * **solver_opt.c** - în acest fișier trebuie să adăugați implementarea variantei **opt_m**.
+  * **Makefile** - Makefile folosit la compilarea cu gcc. __Acest fișier va fi suprascris în timpul corectării și nu trebuie modificat__.
+  * **compare.c** - utilitar ce poate fi folosit pentru a compara două fisiere rezultat. __Acest fișier va fi suprascris în timpul corectării și nu trebuie modificat__.
-/* DESTROY HASH
+<note important>Puteți aduce orice modificare scheletului de cod exceptând cele 3 fișiere menționate mai sus.</note>
- */
-GpuHashTable::~GpuHashTable() { }
-/* RESHAPE HASH
+În urma rulării comenzii **make** vor rezulta 3 fișere binare, **tema3_blas**, **tema3_neopt** și **tema3_opt_m** corespunzătoare celor 3 variante care trebuie implementate.
- */
-void GpuHashTable::reshape(int numBucketsReshape) { }
-/* INSERT BATCH
+<note tip>Rularea se va realiza astfel:
- */
+<code>./tema3_<mod> input </code>
-bool GpuHashTable::insertBatch(int *keys, int* values, int numKeys) { return false; }
-/* GET BATCH
+unde:
- */
+  * mod este unul din modurile **blas**, **neopt**, **opt_m**
-int* GpuHashTable::getBatch(int* keys, int numKeys) { return NULL; }
+  * input este fișierul ce contine descrierea testelor.
+</note>
-/* GET LOAD FACTOR
+Fișierul **input** este structurat astfel:
- * num elements / hash total slots elements
+  * pe prima linie se află numărul de teste.
- */
+  * pe următoarele linii se regăsește descrierea fiecărui test:
-float GpuHashTable::loadFactor() {
+    * valoarea lui N.
-	return 0.f; // no larger than 1.0f = 100%
+    * seed-ul folosit la generarea datelor.
-}
+    * calea către fișierul de ieșire ce conține matricea rezultat.
-#define HASH_INIT GpuHashTable GpuHashTable(1);
+Rularea se va face pe partiția **haswell** folosind **sbatch**. Compilarea se va face folosind **gcc-8.5.0**.
-#define HASH_RESERVE(size) GpuHashTable.reshape(size);
-#define HASH_BATCH_INSERT(keys, values, numKeys) GpuHashTable.insertBatch(keys, values, numKeys)
+/* <note warning> Sesiunile interactive deschise prin **srun** nu sunt permise pe partitia xl. Va trebui să utilizați **sbatch** pentru a folosi aceasta partitie. </note>
-#define HASH_BATCH_GET(keys, numKeys) GpuHashTable.getBatch(keys, numKeys)
-#define HASH_LOAD_FACTOR GpuHashTable.loadFactor()
+Pentru variantele **blas**, **neopt** și **opt_m** nu vor fi utilizate flag-uri de optimizare pentru compilare (va fi utilizat -O0).
+<note warning>//__**TODO**__//
+Pentru linkarea cu BLAS Atlas se va folosi versiunea single-threaded **libsatlas.so.3.10** disponibilă în directorul <code>/usr/lib64/atlas</code> de pe mașinile din partiția nehalem. </note>
+*/
+<note warning> Testele voastre de performanță trebuie realizate pe partiția **haswell** deoarece evaluarea temelor se va face pe această partiție. </note>
+Fisierul **input** contine 3 teste:
+<code>
+123 out1
+456 out2
+789 out3
 </code>
-===== Notare =====
+În cazul fișierului **input** avem 3 teste pentru urmatoarele valori ale lui N: 400, 800, respectiv 1200. Seed-urile folosite la generarea datelor de intrare sunt 123, 456, respectiv 789. Fișierele de output sunt out1, out2, respectiv out3.
-Se pot adăuga alte fișiere care să fie incluse în program, însă nu se vor altera fișierele puse la dispoziție, exceptie fiind Makefile, gpu_hashtable.cu si gpu_hashtable.hpp.
+<note important> Pentru a fi luată în considerare la punctaj, implementarea trebuie să producă rezultate corecte pe toate cele 3 teste din fișierul **input**. </note>
-Punctajul maxim este de 100 pct distribuite astfel:
+Fișierul **input_valgrind** ce va fi folosit pentru rulările de valgrind contine un singur test:
+<code>
+
+123 out1
+</code>
-  * [ **90 pct** ] Punctaj dat de bench.py, performanța trebuie să fie similară și în alte configurații. A nu se optimiza soluția pentru trecerea testelor!
+===== Punctaj =====
-  * [ **10 pct** ] Implementare descrisă în README, alături de rezultate și o discuție asupra lor. Programul compilează, codul nu are disfuncționalități majore
-Arhiva va cuprinde obligatoriu fișierele cu soluția și alte fișiere adiționale folosite, dar minim:
+Punctajul este impărțit astfel:
- - gpu_hashtable.cu
+  * **15p** pentru implementarea variantei **blas** dintre care:
- - gpu_hashtable.hpp
+    * 12p dacă implementarea obține rezultate corecte
- - Makefile, dacă sunt necesare modificări
+    * 3p pentru descrierea implementării în README
- - Readme, unde se explică:
+  * **15p** pentru implementarea variantei **neopt** dintre care:
-   * Cum s-a implementat soluția ? (3p)
+    * 12p dacă implementarea obține rezultate corecte
-   * Cum se stochează hashtable în memoria GPU VRAM ? (3p)
+    * 3p pentru descrierea implementării în README
-   * Output la performanțele obținute și discutie rezultate. (4p)
+  * **20p** pentru implementarea variantei **opt_m** dintre care:
+    * 15p dacă implementarea obține rezultate corecte și timpul de calcul pe partiția **haswell ** este mai mic de 10s pentru testul cu N = 1200
+    * 5p pentru descrierea implementării în README
+  * **9p** dacă cele 3 implementări nu prezintă probleme de acces la memorie
+    * Pentru a rezolva acest subpunct va trebui să folosiți **valgrind** cu opțiunile **--tool=memcheck --leak-check=full**
+    * Veți include 3 fișiere, **neopt.memory**, **blas.memory** si **opt_m.memory**, cu output-urile rulării valgrind pentru fiecare din cele 3 variante având ca input fișierul **input_valgrind**
+  * **17p** pentru analiza celor 3 implementări folosind **cachegrind**
+    * 6p pentru includerea în arhivă a 3 fisiere, **neopt.cache**, **blas.cache** si **opt_m.cache** reprezentând output-urile rulării **valgrind** cu optiunile **--tool=cachegrind --branch-sim=yes --cache-sim=yes** pe partiția **haswell** având ca input fișierul **input_valgrind**
+    * 6p pentru explicații oferite despre valorile obținute (I refs, D refs, Branches etc.)
+    * 5p pentru explicații oferite despre efectul optmizărilor făcute de mână în varianta **opt_m** asupra valorilor obținute
+  * **24p** pentru o analiză comparativă a performanței pentru cele 3 variante:
+    * 15p pentru realizarea unor grafice relevante bazate pe rularea a cel puțin 5 teste (5 valori diferite ale lui N: adică încă cel puțin două valori diferite de 400, 800 și 1200 pentru N)
+    * 9p pentru explicații oferite în README
+  * **(Bonus)**
+    * Veți primi un bonus de maxim 10p dacă timpul de calcul pentru varianta opt_m este mai mic de 7s pentru testul cu N = 1200
+    * Consultați main.c pentru mai multe detalii
+    * Bonusul se calculează doar pe partiția **haswell**
+Depunctări posibile:
+  * **neopt**
+    * nu se ține cont de faptul că A este matrice superior triunghiulară (între -3p si -6p)
+  * **blas**:
+    * nu se ține cont de faptul că A este matrice superior triunghiulară (intre -3p si -6p)
+    * unul sau mai multe calcule sunt realizate de mână, fără a folosi funcții din BLAS (intre -3p si -15p)
+    * a fost inclus codul BLAS (fisiere .so, .h., .c și altele) în arhiva temei (-15p)
+  * **opt_m**
+    * nu se ține cont de faptul că A este matrice superior triunghiulară (intre -3p si -6p)
+    * înmulțirea matricelor se realizează cu o complexitate diferită decât în cazul variantei neopt (ex. Strassen vs înmulțire normală de matrice) (-15p)
+    * timpul de calcul este mai mare decât timpul maxim permis - -15p
+  * **analiza comparativă**
+    * graficele nu au legendă / unități de măsură (intre -2p si -5p)
+    * lipsesc parțial sau complet timpii de rulare (intre -1p si -5p)
+    * graficele nu conțin toate datele cerute în enunț (intre -2p si -5p)
+  * **generale**:
+    * print-uri de debug în cod (intre -1p si -10p)
+    * blocuri de cod comentate sau nefolosite (-1p)
+    * warning-uri la compilare (intre -1p si -3p)
+    * cod înghesuit/ilizibil (intre -1p si -3p)
+    * implementare excesivă de funcții în headere (-1p)
+    * folosirea de constante hardcodate (-1p)
+    * publicarea temei pe GitHub (-100p)
+===== Precizări încărcare / Moodle =====
+Arhiva temei va fi încărcată pe [[https://curs.upb.ro/2023/mod/assign/view.php?id=172248|Moodle]].
+Structura arhivei va fi următoarea:
+<code>
+src
+  solver_blas.c
+  solver_neopt.c
+  solver_opt.c
+  ...
+cache
+  blas.cache
+  neopt.cache
+  opt_m.cache
+memory
+  opt_m.memory
+  neopt.memory
+  blas.memory
+README
+grafice
+  ...
+</code>
+La încărcarea pe Moodle vor fi verificate următoarele:
+  * corectitudinea rezultatelor pentru cele 3 implementări
+  * lipsa problemelor de acces la memorie pentru cele 3 implementări
+  * prezența unor fișiere .memory valide
+  * prezența unor fișiere .cache valide
+  * timpii limita pentru **opt_m** si bonus
+Celelalte aspecte ale temei (README, grafice) vor fi verificate ulterior.
 ===== Precizări și recomandări =====
-<note> În cazul în care job-urile vă rămân "agățate", va recomandam să utilizați de pe fep.grid.pub.ro, comanda <code> qstat </code> pentru a vedea câte job-uri aveți pornite, și apoi să utilizați comanda <code>qdel -f <id-sesiune> </code> unde <id-sesiune> sunt primele cifre din stânga, rezultate după comanda **qstat**.
+/*
+Reply Vlad 2021: added  valgrind pt memory checks
+Pentru asistentii care propun tema 2 din 2021!!!
+Adaugati ca si la alte teme (vedeti tema1) o lista cu cateva depunctari comune (e.g. memleaks).
+E.g. Vor fi depuntari intre -0.0 (warning) si -1.0 in functie de gravitate, pentru urmatoarele probleme:
+* memleaks
+* cod comentat
+* etc
+Sau, ca sa nu fie on the negative bias, puteti spune la precizari:
+Verificati codul vostru nu numai pentru corectitudine ci si pt memleaks (dati link catre vreun tool). De asemenea, este foarte important si aspectul codului, si in acest sens este bine sa aveti comentarii sugestive, organizare consistenta, etc.
+*/
+/*
+<note warning>Timpul maxim pentru rularea celor 3 teste din fișierul **input** pe partiția **haswell** folosind oricare din cele 3 variante este de 2 minute. Această limită de timp se referă la rularea întregului program, nu doar la partea intensiv computațională.</note>
+*/
+/*
+<note> Pentru a avea mai multe detalii despre sursa problemelor de acces la memorie semnalate de tool-ul memcheck din valgrind puteți folosi flag-ul de compilare -g pentru includerea simbolurilor de debug. </note>
+*/
+  * Pentru a simplifica implementarea puteți presupune că N este multiplu de 40 și că este mai mic sau egal cu 1600.
+  * **În compararea rezultatelor se va permite o eroare absolută de maxim $10^{-3}$.**
+  * În cazul variantei **opt_m** complexitatea trebuie să fie aceeași cu cea din varianta **neopt**.
+  * Formatul arhivei trebuie să fie **zip**.
+<note important>Pentru a evita aglomerarea cozii se recomandă rularea de teste pentru valori ale lui N mai mici sau egale cu 1600. </note>
+<note> Se recomandă ștergerea fișierelor coredump în cazul rulărilor care se termină cu eroare pentru a evita problemele cu spațiul de stocare.</note>
+<note> În cazul în care job-urile vă rămân "agățate", va recomandam să utilizați de pe fep.grid.pub.ro, comanda <code> squeue </code> pentru a vedea câte job-uri aveți pornite, și apoi să utilizați comanda <code>scancel <job_id> </code> pentru a opri un job.
 </note>
-<note warning> Sesiunile interactive deschise prin qlogin nu sunt permise pe coada hp-sl.q. Va trebui sa utilizati qsub pentru a folosi aceasta coada. </note>
-===== Resurse =====
+<note important>
-  * {{:asc:resurse:cluster-cheat-sheet.pdf| Cluster cheat sheet}}
+**Pentru întrebări sau nelămuriri legate de temă folosiți [[https://curs.upb.ro/2023/mod/forum/view.php?id=172599|forumul temei]].
-  * {{:asc:teme:tema3:skl.zip| Schelet de cod}}
+**
+Orice întrebare e recomandat să conțină o descriere cât mai clară a eventualei probleme. Întrebări de forma: "Nu merge X. De ce?" fără o descriere mai amănunțită vor primi un răspuns mai greu.
+**ATENȚIE** să nu postați imagini cu părți din soluția voastră pe forumul pus la dispoziție sau orice alt canal public de comunicație. Dacă veți face acest lucru, vă asumați răspunderea dacă veți primi copiat pe temă.
+</note>
+<note warning>
+Temele vor fi testate împotriva plagiatului. Orice tentativă de copiere va fi depunctată conform [[asc:regulament|regulamentului]].
+Rezultatele notării automate este orientativă și poate fi afectată de corectarea manuală.
+</note>
+===== Resurse necesare realizării temei =====
+Pentru a clona [[https://gitlab.cs.pub.ro/asc/asc-public | repo-ul]] și a accesa resursele temei 3:
+<code bash>
+student@asc:~$ git clone https://gitlab.cs.pub.ro/asc/asc-public.git
+student@asc:~$ cd asc-public/assignments/3-optimizari
+</code>
+Pentru a valida corectitudinea rezultatelor puteti folosi fisierele output referinta din directorul **references**.
+/*
+[[https://infrastructure.pages.upb.ro/wiki/docs/grid | Ghid pentru folosirea gridului instituțional]]
+*/