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 [2025/05/15 19:01] (current)
emil.slusanschi [Tema 3]
@@ 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.
-    * **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.
+<note important>
+  * **Deadline soft:** **<del>18</del> 20 Mai 2025, ora 23:55**. Primiți un bonus de 10% din punctajul obținut pentru trimiterea temei înainte de **<del>16</del> 18 Mai 2025, 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 **<del>25</del> 27 Mai 2025, ora 23:55**.
+  * **Deadline hard:** **<del>25</del> 27 Mai 2025, ora 23:55**.
+  * **Responsabili:** [[vladspoiala@gmail.com |Vlad Spoiala]], [[emil.slusanschi@cs.pub.ro|Emil Slusanschi]], [[serban.ionescu0609@stud.acs.upb.ro | Serban Ionescu]], [[adumitrescu2708@stud.acs.upb.ro | Alexandra Dumitrescu]].
+</note>
+<note tip>
+  * Dată publicare: 7 mai 2025
+  * Dată actualizare enunț: 15 mai 2025
+</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ătorul calcul cu matrice:
+<code>
+C = B * At
+D = Ct * A
+i = 0
+while (i < N) {
+    y = Ct * x
+    x = C * y
+    i += 1
+}
+y = D * x
+</code>
+unde:
+  * $A$ si $B$ sunt matrice pătratice de dimensiune N x N cu elemente de tip double
+  * x si y sunt 2 vectori de dimensiune N x 1 cu elemente de tip double
+  * $A^t$ este transpusa lui $A$, $C^t$ este transpusa lui $C$
+  * $*$ este operația de înmulțire
-Această structură de date tip hashtable va avea următoarele caracteristici:
+Se dorește implementarea expresiei de mai sus folosind limbajele C/C++, în 3 moduri:
-  - va face maparea key -> value, (o singură valoare per key)
+  * **blas** - o variantă care folosește una sau mai multe funcții din [[https://www.netlib.org/lapack/explore-html/de/d6a/group__blas__top.html | BLAS Atlas]] pentru realizarea operațiilor de înmulțire și adunare.
-  - va putea stoca date de tip int32, mai mari strict ca 0, atât pentru chei, cât și pentru valori
+  * **neopt** - o variantă "de mână" fără îmbunătățiri.
-     * valid (key->value): 1234 -> 8965, 12334244 -> 8223965
+  * **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.
-     * 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).
+===== Rulare și testare =====
-Exemple de implementări:
+Pentru testarea temei vă este oferit un schelet de cod pe care trebuie să-l completați cu
-  * Linear probing: se calculează hash(key) și se dacă slotul nu e liber se încearcă succesiv hash(key) + 1… hash(key) + N
+implementările celor 3 variante menționate mai sus. Scheletul de cod este structurat astfel:
-  * 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
+  * **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__.
-  * Bucketized cuckoo - se folosește tehnica cuckoo, având buckets cu 2, 4, 8 sloturi fiecare.
+  * **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__.
-===== Schelet tema =====
+<note important>Puteți aduce orice modificare scheletului de cod exceptând fișierele menționate mai sus.</note>
-Se va completa scheletul pus la dispoziție (gpu_map.cu) având următoarele funcții ce trebuie implementate:
+Î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.
+<note tip>Rularea se va realiza astfel:
+<code>./tema3_<mod> input </code>
+unde:
+  * mod este unul din modurile **blas**, **neopt**, **opt_m**
+  * input este fișierul ce contine descrierea testelor.
+</note>
+Fișierul **input** este structurat astfel:
+  * pe prima linie se află numărul de teste.
+  * pe următoarele linii se regăsește descrierea fiecărui test:
+    * valoarea lui N.
+    * seed-ul folosit la generarea datelor.
+    * calea către fișierul de ieșire ce conține matricea rezultat.
+Rularea se va face pe partiția **haswell** folosind **sbatch**. Compilarea se va face folosind **gcc-8.5.0**.
+Pentru a vedea cat de incarcate sunt nodurile puteti folosi **scontrol**:
 <code>
-/* INIT HASH
+[vlad.spoiala@fep8 sol]$ for node in haswell-wn{29..40}; do echo -n $node; scontrol show node $node | grep CPU; done
- */
+haswell-wn29   CPUAlloc=20 CPUTot=32 CPULoad=13.62
-GpuHashTable::GpuHashTable(int size) { }
+haswell-wn30   CPUAlloc=18 CPUTot=32 CPULoad=4.19
+haswell-wn31   CPUAlloc=18 CPUTot=32 CPULoad=3.76
+haswell-wn32   CPUAlloc=18 CPUTot=32 CPULoad=3.79
+haswell-wn33   CPUAlloc=18 CPUTot=32 CPULoad=3.76
+haswell-wn34   CPUAlloc=18 CPUTot=32 CPULoad=3.79
+haswell-wn35   CPUAlloc=18 CPUTot=32 CPULoad=3.75
+haswell-wn36   CPUAlloc=18 CPUTot=32 CPULoad=3.88
+haswell-wn37   CPUAlloc=18 CPUTot=32 CPULoad=3.76
+haswell-wn38   CPUAlloc=18 CPUTot=32 CPULoad=3.87
+haswell-wn39   CPUAlloc=18 CPUTot=32 CPULoad=3.95
+haswell-wn40   CPUAlloc=18 CPUTot=32 CPULoad=3.47
+</code>
-/* DESTROY HASH
+Pentru a evita rularea pe nodurile incarcate puteti folosi optiunea **--exclude** din **sbatch**. De exemplu, pentru a nu rula pe nodurile 29 si 30 putem folosi **sbatch** in felul urmator:
- */
+<code>
-GpuHashTable::~GpuHashTable() { }
+[vlad.spoiala@fep8 sol]$ sbatch -p haswell --time 00:03:00 --exclude=haswell-wn[29-30] test_all_opt.sh
+Submitted batch job 471560
+</code>
-/* RESHAPE HASH
+Jobul ruleaza pe haswell-wn31:
- */
+<code>
-void GpuHashTable::reshape(int numBucketsReshape) { }
+[vlad.spoiala@fep8 sol]$ squeue -u vlad.spoiala
+             JOBID PARTITION     NAME     USER ST       TIME  NODES NODELIST(REASON)
+   haswell test_all vlad.spo  R       0:06      1 haswell-wn31
+</code>
-/* INSERT BATCH
+/* <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>
- */
-bool GpuHashTable::insertBatch(int *keys, int* values, int numKeys) { return false; }
-/* GET BATCH
- */
-int* GpuHashTable::getBatch(int* keys, int numKeys) { return NULL; }
-/* GET LOAD FACTOR
+Pentru variantele **blas**, **neopt** și **opt_m** nu vor fi utilizate flag-uri de optimizare pentru compilare (va fi utilizat -O0).
- * num elements / hash total slots elements
+<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>
-float GpuHashTable::loadFactor() {
-	return 0.f; // no larger than 1.0f = 100%
+*/
-}
+<note warning> Testele voastre de performanță trebuie realizate pe partiția **haswell** deoarece evaluarea temelor se va face pe această partiție. </note>
-#define HASH_INIT GpuHashTable GpuHashTable(1);
+Fisierul **input** contine 3 teste:
-#define HASH_RESERVE(size) GpuHashTable.reshape(size);
+<code>
+
+123 out1
+456 out2
+789 out3
+</code>
-#define HASH_BATCH_INSERT(keys, values, numKeys) GpuHashTable.insertBatch(keys, values, numKeys)
+În cazul fișierului **input** avem 3 teste pentru urmatoarele valori ale lui N: 200, 600, respectiv 1000. Seed-urile folosite la generarea datelor de intrare sunt 123, 456, respectiv 789. Fișierele de output sunt out1, out2, respectiv out3.
-#define HASH_BATCH_GET(keys, numKeys) GpuHashTable.getBatch(keys, numKeys)
-#define HASH_LOAD_FACTOR GpuHashTable.loadFactor()
+<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>
+Fișierul **input_valgrind** ce va fi folosit pentru rulările de valgrind contine un singur test:
+<code>
+123 out1
 </code>
-===== Notare =====
-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.
+===== Punctaj =====
-Punctajul maxim este de 100 pct distribuite astfel:
+Punctajul este impărțit astfel:
+  * **10p** pentru implementarea corecta a variantei **blas**
+  * **10p** pentru implementarea corecta a variantei **neopt**
+  * **15p** pentru implementarea variantei **opt_m** dintre care:
+    * 10p dacă implementarea obține rezultate corecte și timpul de calcul pe partiția **haswell ** este mai mic de 12s pentru testul cu N = 1000
+    * 5p daca timpul de calcul pe partitia **haswell ** pentru testul cu N = 1000 este mai mic de 5s. Veti obtine un punctaj partial daca timpul de calcul este intre 5s si 9s.
+  * **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**
+  * **16p** 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**
+    * 5p 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 performantelor obținute
+  * **40p** pentru o analiză comparativă a performanței pentru cele 3 variante si respectiv a furnizarii prompturilor folosite (in format text, NU imagini, si intrebare si raspuns, ordonate succesiv) in interactiunea cu unelte de tip LLM (e.g. ChatGPT, CoPilot, Grok, Gemini, etc.). Indicati unealta folosita + versiunea acesteia. Trebuie sa se puna accent si pe modificarile de mână ale codurilor dezvoltate, nu doar pe explicarea unor coduri generate automat:
+    * 12p 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 200, 600 și 1000 pentru N) si pentru comentarea / explicarea acestor grafice in README.
+    * 12p pentru explicații oferite în README pentru versiunile **blas**, **neopt**, si **opt_m**. Aceste explicatii trebuiesc scrise de voi si nu copiate din unelte online.
+    * 12p pentru oferirea (succesiunii) de prompturi folosite pentru obtinerea versiunilor de cod **blas**, **neopt**, si **opt_m** precum si detalierea in README a motivelor pentru care a fost utilizata succesiunea aleasa spre o solutie eficienta a fiecarei variante de cod
+    * 4p pentru oferirea unei explicații în README privind motivul existentei buclei de dimensiune N pentru ultimele trei operatii cu matrice din enuntul problemei
-  * [ **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!
+Depunctări posibile:
-  * [ **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
+  * **blas**:
+    * 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**
+    * î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ă si prompturi LLM**
+    * graficele nu au legendă / unități de măsură sau nu sunt explicate/descrise corespunzator in readme (intre -2p si -5p)
+    * lipsesc parțial sau complet timpii de rulare (intre -1p si -5p)
+    * lipsesc parțial sau total comentariile din REAME cerute explicit in enunt (intre -1p si -10p)
+    * graficele nu conțin toate datele cerute în enunț (intre -2p si -5p)
+    * prompturi identice cu ale altor submisii (-45p)
+  * **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)
-Arhiva va cuprinde obligatoriu fișierele cu soluția și alte fișiere adiționale folosite, dar minim:
+===== Precizări încărcare / Moodle =====
- - gpu_hashtable.cu
- - gpu_hashtable.hpp
- - Makefile, dacă sunt necesare modificări
- - Readme, unde se explică:
-   * Cum s-a implementat soluția ? (3p)
-   * Cum se stochează hashtable în memoria GPU VRAM ? (3p)
-   * Output la performanțele obținute și discutie rezultate. (4p)
+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
+LLMprompts
+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, LLMprompts, 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 1200.
+  * **În compararea rezultatelor se va permite o eroare absolută de maxim $10^{-6}$.**
+  * În cazul variantei **opt_m** complexitatea trebuie să fie aceeași cu cea din varianta **neopt**.
+  * Formatul arhivei trebuie să fie **zip**.
+  * Punctajul maxim obtinut de tester este 50p. Restul de 50p vor fi atribuite prin corectarea manuala a documentatiilor voastre (README, cod, grafice, prompturi, etc.)
+<note important>Pentru a evita aglomerarea cozii se recomandă rularea de teste pentru valori ale lui N mai mici sau egale cu 1200. </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/2024/mod/forum/view.php?id=115671|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, atat partea de cod cat si cea de prompturi LLM. Orice tentativă de copiere va fi depunctată conform [[asc:regulament|regulamentului]].
+Rezultatele notării automate este orientativă și poate fi afectată de corectarea manuală, de detaliile oferite in readme si respectiv de succesiunea de prompturi oferite so a motivelor pentru care ati ales sa folositi aceaste prompturi (este recomandat sa face acest lucru in readme).
+</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]]
+*/
+<hidden>
+</hidden>