Show page

Differences

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

--- asc:teme:tema2 [2020/04/09 16:21]
emil.slusanschi [Punctaj]
+++ asc:teme:tema2 [2025/05/13 16:32] (current)
costin.carabas [Tema 2 - Implementarea în CUDA a arborelui Merkle și a algoritmului de consens Proof of Work din cadrul Bitcoin]
@@ Line 1: / Line 1: @@
-====== Tema 2 ======
+====== Tema 2 - Implementarea în CUDA a arborelui Merkle și a algoritmului de consens Proof of Work din cadrul Bitcoin ======
-    * **Deadline soft:** 19 aprilie 2020, ora 23:55. Primiți un bonus de 10% din punctajul obtinut pentru trimiterea temei cu 3 zile înaintea acestui termen, adică înainte de 16 aprilie 2020, ora 23:55.
-    * **Deadline hard:** 26 aprilie 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 26 aprilie 2020, ora 23:55.
+<note important>
+  * **Deadline soft:** **18 Mai 2025, ora 23:55** <del>**11 Mai 2025, ora 23:55**. Primiți un bonus de 10% din punctajul obținut pentru trimiterea temei înainte de **8 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 **18 Mai 2025, ora 23:55**</del>.
+  * **Deadline hard:** **18 Mai 2025, ora 23:55**.
+  * **Responsabili:** [[tudor.calafeteanu@upb.ro |Tudor Calafeteanu]], [[costin.carabas@gmail.com|Costin Carabaș]]
+</note>
+<note tip>
+  * Dată publicare: 27 Aprilie 2025
+</note>
 ===== Enunț =====
-Se dă următoarea operație cu matrice:
+Implementarea în CUDA a arborelui Merkle și a algoritmului de consens Proof of Work din cadrul Bitcoin.
-$$ C =  B \times A^t  + A^2 \times B $$
+<note important>**Disclaimer**: Această temă a pornit de la algoritmul Bitcoin descris în [[https://bitcoin.org/bitcoin.pdf|whitepaper]], însă nu replică în totalitate algoritmul și structurile de date.</note>
-unde:
+===== Obiectivele temei =====
-  * $A$ si $B$ sunt matrice patratice de double de dimensiune N x N
-  * $A$ este o matrice superior triunghiulara
-  * $A^t$ este transpusa lui $A$
-  * $\times$ este operația de înmulțire
-  * $+$ este operatia de adunare
-  * $A^2$ este $A$ ridicat la patrat
-Se dorește implementarea operației de mai sus in C/C++ în 5 moduri:
+  * Utilizarea eficientă a limbajului CUDA pentru programarea GPU-urilor, învățat la laborator;
-  * **blas** - o variantă care folosește una sau mai multe functii din [[http://www.netlib.org/blas/ | BLAS Atlas]] pentru realizarea operatiilor de inmultire de matrice. Adunarea matricelor poate fi facuta "de mana". Aceasta implementare va tine cont de faptul ca A este o matrice superior triunghiulara.
+  * Înțelegerea conceptelor de bază ale blockchain-ului;
-  * **neopt** - o variantă "de mână" fără îmbunătățiri. Aceasta implementare va tine cont de faptul ca A este o matrice superior triunghiulara.
+  * Participarea la algoritmul de consens din perspectiva unui nod;
-  * **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.
-  * **opt_f** - o variantă îmbunătățită obținută prin compilarea codului de la varianta **neopt** cu flag-ul -O3
-  * **opt_f_extra** - o variantă îmbunătățită obținută prin compilarea codului de la varianta **neopt** cu flag-ul -O3 si alte [[https://gcc.gnu.org/onlinedocs/gcc-5.4.0/gcc/Optimize-Options.html|flag-uri de optimizare specifice]] ce nu sunt incluse in -O3. Se vor avea in vedere flag-uri care activeaza o singura optimizare, nu flag-uri care actioneaza asupra unui grup de optimizari.
-===== Rulare și testare =====
+===== Introducere =====
-Pentru testarea temei vă este oferit un schelet de cod pe care trebuie să-l completați cu
+Blockchain-ul este o tehnologie care a devenit cunoscută odată cu apariția criptomonedelor, precum Bitcoin-ul, Ethereum, etc. Este o bază de date descentralizată și distribuită a tranzacțiilor și datelor, care funcționează pe baza unui lanț de blocuri. Fiecare bloc conține un set de tranzacții și este legat de blocurile anterioare printr-un proces de criptare și verificare, cunoscut sub numele de "hashing", formând astfel o structură sigură, imutabilă și transparentă. Dacă cineva ar încerca să modifice un bloc, ar trebui să modifice toate blocurile următoare, lucru extrem de dificil datorită mecanismelor criptografice.
-implementarile pentru cele 4 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__.
-  * **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ă adaugați implementarea variantei **blas**.
-  * **solver_neopt.c** - în acest fișier trebuie să adaugați implementarea variantei **neopt**.
-  * **solver_opt.c** - în acest fișier trebuie să adaugați implementarea variantei **opt_m**.
-  * **Makefile** - Makefile folosit la compilarea cu gcc.
-  * **input** - fișierul de input care contine 3 teste pentru urmatoarele valori ale lui N: 400, 800, 1200
-  * **compare.c** - utilitar ce poate fi folosit pentru a compara doua fisiere rezultat. __Acest fișier va fi suprascris în timpul corectării și nu trebuie modificat__.
-<note important>Puteți aduce orice modificare scheletului de cod exceptând cele 3 fișiere menționate mai sus.</note>
+{{:asc:teme:blockchain.jpg?700|}}
-În urma rulării comenzii **make** cu oricare din cele 2 Makefile-uri vor rezulta 5 fișere binare, **tema2_blas**, **tema2_neopt**, **tema2_opt_m**, **tema2_opt_f** si **tema2_opt_f_extra** corespunzătoare celor 5 variante care trebuie implementate.
+**Descentralizare**: Datele sunt stocate și gestionate de o rețea descentralizată de noduri, eliminând astfel nevoia de o autoritate centrală.
-<note tip>Rularea se va realiza astfel:
+**Imutabilitate**: Datele înregistrate în blocurile blockchain-ului sunt imutabile și nu pot fi modificate sau șterse ulterior.
-<code>./tema2_<mod> input </code>
-unde:
+**Transparență**: Tranzacțiile și înregistrările sunt publice și transparente, iar oricine poate să le verifice.
-  * mod este unul din modurile **blas**, **neopt**, **opt_m**, **opt_f** sau **opt_f_extra**.
-  * input este fișierul ce contine descrierea testelor.
+**Securitate**: Criptografia și algoritmii de consens asigură securitatea și integritatea datelor stocate în blockchain.
+===== Algoritmul de consens =====
+Calculatoarele participante la consens se numesc noduri (sau mineri în cazul PoW). Aceste noduri nu se cunosc și nu au încredere unele în altele.
+Scopul unui mecanism de consens este de a aduce toate nodurile în acord, adică de a avea încredere unul în celălalt, într-un mediu în care nodurile nu au încredere unul în celălalt.
+  * Minerii (aceștia veți fi voi) efectuează lucrări de calcul în rezolvarea unei probleme matematice complexe. Demonstrarea rezolvării problemei aduce de la sine și încredere.
+  * Problema matematică poate deveni mai complexă, în funcție de numărul de participanți la consens.
+Minerul care a rezolvat primul problema, va propaga răspunsul în rețea, iar acest va fi validat de către ceilalți participanți la rețea. Astfel, problema are 2 proprietăți:
+  * Este greu de calculat răspunsul;
+  * Este ușor de verificat răspunsul.
+Minerul care a rezolvat primul problema va fi recompensat. În cazul vostru, veți primi punctaj 😁
+===== Structura unui bloc =====
+Un bloc este format din:
+. Hash-ul blocului anterior, care creează conexiunea cu blocurile anterioare și asigură continuitatea și securitatea lanțului;
+. Root hash-ul tranzacțiilor (Merkle root), adică hash-ul rezultat dintr-un arbore Merkle construit pe baza tranzacțiilor din bloc. Permite validarea rapidă a tranzacțiilor fără a le parcurge individual. Algoritmul este următorul:
+    a. Se face hash-ul fiecărei tranzacții individuale.
+    b. Se grupează hash-urile câte două și se calculează un nou hash pentru fiecare pereche.
+    c. Se repetă procesul de grupare și hashing până când rămâne un singur hash - Merkle root-ul.
+<note tip>
+Dacă există un număr impar de hash-uri într-un nivel, ultimul hash se dublează pentru a forma o pereche.
 </note>
-Fișierul **input** este structurat astfel:
+<spoiler Click pentru a vedea un exemplu de calcul Merkle root>
-  * pe prima linie numărul de teste.
+<code>
-  * pe următoarele linii descrierea fiecarui test:
+Nivel 0:
-    * valoarea lui N.
+Tx1: "VBJJJUBSYWLBPLUN" -- SHA256 --> "dad1020a77b640cad9a44b80e689f0b467e42e67e24a2bd23e10d10bc513dc20"
-    * seed-ul folosit la generarea datelor.
+Tx2: "UBXGGEAYZTXLXKAL" -- SHA256 --> "9a64594a9bee37f5378ffa87bcc44b1412eedd542e007200af4af598f5c14429"
-    * calea către fișierul de ieșire ce conține matricea rezultat.
+Tx3: "UILARBVQAAOWYDKV" -- SHA256 --> "5853c3fbf9099e07e1668e110f0c8f37a26e8706be1aa3b964593819c359bb5e"
+Tx4: "NAHPEHOTTNBOJQHR" -- SHA256 --> "43dab3e61ac812e9c0b7e299d4ea603884eb1023d39a0f0568f0e69bb04e36b6"
+Tx5: "VRKAKNASZPTJUVMQ" -- SHA256 --> "f80412748b9c56d59e9ca23d45f9dd28daab3e36fd110e2490dbeca485c0efaf"
-Rularea se va face pe coada **ibm-nehalem.q**. Compilarea se va face folosind **gcc-5.4.0** din modulul **compilers/gnu-5.4.0**. Pentru a incarca modulul pentru GCC trebuie sa dati pe una din masinile din coada ibm-nehalem.q urmatoarea comanda: <code> module load compilers/gnu-5.4.0 </code>
+Nivel 1:
+Tx12: "dad1020a77b640cad9a44b80e689f0b467e42e67e24a2bd23e10d10bc513dc209a64594a9bee37f5378ffa87bcc44b1412eedd542e007200af4af598f5c14429" -- SHA256 --> "e5f4ed1fb64870a7a3ee6bf9c31ba3e1eb1887d3afa5c92482896b060323cf80"
+Tx34: "5853c3fbf9099e07e1668e110f0c8f37a26e8706be1aa3b964593819c359bb5e43dab3e61ac812e9c0b7e299d4ea603884eb1023d39a0f0568f0e69bb04e36b6" -- SHA256 --> "06962284b21218613fdfb4146a775fc6586eff41c3834a15173ac83d53f2c40c"
+Tx55: "f80412748b9c56d59e9ca23d45f9dd28daab3e36fd110e2490dbeca485c0efaff80412748b9c56d59e9ca23d45f9dd28daab3e36fd110e2490dbeca485c0efaf" -- SHA256 --> "fbc56527df5f7b9d33e1af001c04a559c84d588cc4199038a2735467ab830f66"
-Pentru variantele **blas**, **neopt** si **opt_m** nu vor fi utilizate flag-uri de optimizare pentru compilare (va fi utilizat -O0).
+Nivel 2:
-Pentru linkarea cu BLAS Atlas se va folosi versiunea single-threaded **libsatlas.so.3.10** de pe masinile din coada ibm-nehalem.q
+Tx1234: "e5f4ed1fb64870a7a3ee6bf9c31ba3e1eb1887d3afa5c92482896b060323cf8006962284b21218613fdfb4146a775fc6586eff41c3834a15173ac83d53f2c40c" -- SHA256 --> "5e74a2c7bbb58a67ad0a816f42e3dc10a1c2c82778f83f5ad73d5ad5d2301036"
-disponibile in directorul <code>/usr/lib64/atlas</code>
+Tx5555: "fbc56527df5f7b9d33e1af001c04a559c84d588cc4199038a2735467ab830f66fbc56527df5f7b9d33e1af001c04a559c84d588cc4199038a2735467ab830f66" -- SHA256 --> "e2d8d4a8b90fa567df034d02b2a0ca30e7fbe1ac651cffbc2cd08282a8131bb7"
-Fișierele output referință le găsiți aici:
-<code> /export/asc/tema2/</code>
-===== Punctaj =====
+Nivel 3:
+Tx12345555 (Merkle root): "5e74a2c7bbb58a67ad0a816f42e3dc10a1c2c82778f83f5ad73d5ad5d2301036e2d8d4a8b90fa567df034d02b2a0ca30e7fbe1ac651cffbc2cd08282a8131bb7" -- SHA256 --> "a660484fcf1c3b54d470e172c0472e68eadadfc2c6078b98519703586fd5eaed"
+</code>
+</spoiler>
-Punctajul este impărțit astfel:
+. Nonce (Number used only once) - un număr întreg random, pozitiv, pe 32 biți, pe care minerii încearcă să îl găsească, astfel încât aplicarea funcției de hashing, cum ar fi SHA-256, asupra block-ului rezultat prin includerea nonce-ului la finalul blocului, să fie mai mic decât o dificultate threshold (un alt hash, ales în funcție de numărul de 0-uri consecutive din prefix). Munca medie necesară pentru găsirea nonce-ului este exponențială în funcție de numărul de biți zero necesari și poate fi verificată prin executarea unui singur hash. Nonce-ul trebuie să îl găsiți prin metoda trial-and-error, pornind de la 0 și incrementând la fiecare iterație, pana la valoarea maximă pe 32 biți, i.e. uint32_max.
-  * **15p** pentru implementarea variantei **blas** dintre care:
-    * 12p daca implementarea obtine rezultate corecte
-    * 3p pentru descrierea implementarii in README
-  * **15p** pentru implementarea variantei **neopt** dintre care:
-    * 12p daca implementarea obtine rezultate corecte
-    * 3p pentru descrierea implementarii in README
-  * **20p** pentru implementarea variantei **opt_m** dintre care:
-    * 15p daca implementarea obtine rezultate corecte si timpul de calcul este cu cel putin 30% mai mic decat cel al variantei **neopt** pentru testul cu N = 1200
-    * 5p pentru descrierea implementarii in README
-  * **20p** pentru implementarea variantei **opt_f_extra** dintre care:
-    * 10p daca implementarea obtine rezultate corecte si timpul de calcul este cu cel putin 5% mai mic decat cel al variantei **opt_f** pentru testul cu N = 1200
-    * 10p pentru explicatii legate de alegerea flag-urilor si impactul flag-urilor asupra performantei
-  * **30p** pentru o analiza comparativa a performantei pentru cele 5 variante:
-    * 15p pentru realizarea unor grafice relevante bazate pe rularea a cel putin 5 teste (5 valori diferite ale lui N: adica inca cel putin doua valori diferite de 400, 800 si 1200 pentru N)
-    * 15p pentru explicatii oferite in README
-  * **(Bonus)**
-    * 20p daca timpul de calcul al variantei **opt_m** pentru testul cu N = 1200 este cel mult 4 secunde sau
-    * 10p daca timpul de calcul al variantei **opt_m** pentru testul cu N = 1200 este intre 4 si 8 secunde
-    * Bonusurile se calculeaza doar pe coada ibm-nehalem.q
-<note important>Pentru a fi luată în considerare la punctaj, implementarea trebuie să producă rezultate corecte pe cele 3 teste din fisierul **input**.</note>
+<spoiler Click pentru a vedea un exemplu de generare a hash-ului unui bloc, în urma găsirii unui nonce valid>
+<code>
+Fie dificultatea aleasă 4, i.e. "0000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff".
-===== Precizări și recomandări =====
+Hash-ul blocului anterior: "000000000000000000034158a91c1876f5fc2add1e69641e908956ac9de45b93".
+Merkle root: "a660484fcf1c3b54d470e172c0472e68eadadfc2c6078b98519703586fd5eaed".
+Nonce-ul găsit: 2429400
+Hash-ul blocului rezultat: "000000000000000000034158a91c1876f5fc2add1e69641e908956ac9de45b93a660484fcf1c3b54d470e172c0472e68eadadfc2c6078b98519703586fd5eaed2429400" -- SHA256 --> "0000aea01a49077c7843be9428d087b1f3b02de9cdbd6f30464413ea0b1628b2" < "0000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff".
-<note warning>Timpul maxim pentru rularea celor 3 teste folosind oricare din cele 5 variante este de 2 minute. Această limită de timp se referă la rularea întregului program, nu doar la partea intensiv computațională.</note>
+</code>
+</spoiler>
-  * Pentru a simplifica implementarea puteți presupune că N este multiplu de 40 și că este mai mic sau egal cu 1600.
+Hash-ul blocului rezultat în urma găsirii unui nonce valid va deveni "hash-ul blocului anterior" pentru următorul bloc de tranzacții. De aici vine denumirea de blockchain: se creează un lanț de blocuri, iar fiecare bloc depinde de cel anterior.
-  * Î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**.
-Pentru a vedea ce optimizari sunt prezente in fiecare nivel de optimizare puteti folosi comanda:
-<code> gcc -Q -Olevel --help=optimizers </code>
-<note tip>Pentru a evita aglomerarea cozii se recomanda rularea de teste pentru valori ale lui N mai mici sau egale cu 1600.</note>
+<note tip>
+Nonce-ul valid găsit nu e unic. Pot exista mai multe nonce-uri care să genereze un hash al blocului mai mic decât dificultatea aleasă.
+</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>
+{{:asc:teme:merkle.png?300|}}
-<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**.
+{{:asc:teme:blockchain_paper.png?400|}}
+[1]
+===== Descrierea temei =====
+În cadrul acestei teme, veți participa ca nod într-un blockchain, unde procesarea tranzacțiilor se va face pe GPU. Veți lucra pe baza unui cod existent, în C, care simulează procesul de minare a blocurilor Bitcoin. În varianta inițială, algoritmul rulează în întregime serial, pe CPU. Scopul vostru este să eficientizați timpul de execuție, **paralelizând două funcții esențiale, calcularea Merkle root-ului și găsirea nonce-ului, folosind CUDA**, astfel încât să obțineți un speedup al acestor funcții, rulate pe GPU.
+===== Fișierul de intrare =====
+//miner.cpp// citește un fișier de forma //<TEST_NAME>.in//, ce conține:
+Pe primul rând, în această ordine:
+  * //number_of_transactions// – Numărul de tranzacții din fișier;
+  * //prev_block_hash// – Hash-ul blocului anterior;
+  * //difficulty_zeros// – Numărul de zerouri al dificultății;
+  * //max_nonce// – Numărul maxim de nonce-uri de verificat;
+  * //max_transactions_in_a_block// – Numărul maxim de tranzacții într-un bloc;
+  * //transaction_size// – Dimensiunea, în bytes, a fiecărei tranzacții, numărând și caracterul nul, de la finalul șirului de caractere.
+Urmează apoi, începând cu al doilea rând, tranzacțiile propriu-zise, în număr de //number_of_transactions//, fiecare pe câte un rând, de dimensiune //transaction_size//.
+<spoiler Click pentru a vedea un exemplu de fișier de input>
+<code>
+<test4.in>
+,000000000000000000034158a91c1876f5fc2add1e69641e908956ac9de45b93,4,99999999,10000,226
+NWLRBBMQBHCDARZOWKKYHIDDQSCDXRJMOWFRXSJYBLDBEFSARCBYNECDYGGXXPKLORELLNMPAPQFWKHOPKMCOQHNWNKUEWHSQMGBBUQCLJJIVSWMDKQTBXIXMVTRRBLJPTNSNFWZQFJMAFADRRWSOFSBCNUVQHFFBSAQXWPQCACEHCHZVFRKMLNOZJKPQPXRJXKITZYXACBHHKICQCOENDTOMFGDWDWFC
+GPXIQVKUYTDLCGDEWHTACIOHORDTQKVWCSGSPQOQMSBOAGUWNNYQXNZLGDGWPBTRWBLNSADEUGUUMOQCDRUBETOKYXHOACHWDVMXXRDRYXLMNDQTUKWAGMLEJUUKWCIBXUBUMENMEYATDRMYDIAJXLOGHIQFMZHLVIHJOUVSUYOYPAYULYEIMUOTEHZRIICFSKPGGKBBIPZZRZUCXAMLUDFYKGRUOWZGI
+OOOBPPLEQLWPHAPJNADQHDCNVWDTXJBMYPPPHAUXNSPUSGDHIIXQMBFJXJCVUDJSUYIBYEBMWSIQYOYGYXYMZEVYPZVJEGEBEOCFUFTSXDIXTIGSIEEHKCHZDFLILRJQFNXZTQRSVBSPKYHSENBPPKQTPDDBUOTBBQCWIVRFXJUJJDDNTGEIQVDGAIJVWCYAUBWEWPJVYGEHLJXEPBPIWUQZDZUBDUBZV
+...
+</code>
+</spoiler>
+===== Procesarea datelor =====
+  * Se citesc tranzacțiile și se grupează în blocuri. La fiecare //max_transactions_in_a_block// tranzacții, se face câte un bloc nou. Așadar, ultimul bloc minat conține un număr de tranzacții egal, sau mai mic decât această valoare.
+  * Pentru fiecare grup:
+    * Se construiește merkle root-ul tranzacțiilor.
+    * Se formează blocul prin concatenarea //prev_block_hash// și //merkle_root//.
+    * Se caută un nonce astfel încât hash-ul rezultat să aibă //difficulty_zeros// zerouri la început.
+  * Dacă nu se găsește un nonce valid până la //max_nonce//, blocul e invalidat.
+<note tip>
+În realitate, blocul include mai multe date, precum un timestamp Unix, ceea cea oferă nondeterminism hash-ului blocului. Dacă un nonce nu e găsit, la următoarea încercare, timestamp-ul va fi diferit, ceea ce face din nou căutarea unui nonce o opțiune validă. Pentru o testare ușoară, nu vom include un astfel de parametru în tema noastră. De asemenea, vom lucra cu fișiere de input care asigură existența a cel puțin un nonce.
 </note>
-<note warning> Sesiunile interactive deschise prin qlogin nu sunt permise pe coada ibm-nehalem.q. Va trebui sa utilizati qsub pentru a folosi aceasta coada. </note>
+===== Fișierul de ieșire =====
-===== Resurse =====
-  * {{:asc:resurse:cluster-cheat-sheet.pdf| Cluster cheat sheet}}
+Rezultatele se scriu în fișierul //<TEST_NAME>.out//, în următorul format, pentru fiecare bloc
-  * {{:asc:tema2:skel1.0.zip| Schelet de cod}}
+<code>
+BLOCK_ID,NONCE,BLOCK_HASH,TIME_FOR_MERKLE_ROOT_COMPUTATION,TIME_FOR_NONCE_COMPUTATION,TIME_SUM
+</code>
+, unde TIME_SUM = TIME_FOR_MERKLE_ROOT_COMPUTATION + TIME_FOR_NONCE_COMPUTATION
+După procesarea tuturor tranzacțiilor, se scriu pe ultimul rând timpii totali pentru fiecare din cele 3 coloane de timpi, adică pentru toate blocurile găsite. Timpii sunt aproximați la cinci zecimale.
+<code>
+TOTAL_TIME_FOR_MERKLE_ROOT_COMPUTATION,TOTAL_TIME_FOR_NONCE_COMPUTATION,TOTAL_TIME_SUM
+</code>
+<spoiler Click pentru a vedea un exemplu de fișier de ieșire>
+<code>
+,33865,0000517db16db1b0a4b3c2a1eee14ebc3c6beaae6420dc90a0643d23a03c167a,0.10294,0.14677,0.24970
+,4050,00007ddf6566d4687489b21cd2764bd286e6958dd7d365fbe30de7ca4b9bbb50,0.09830,0.01761,0.11592
+,166127,00002663dafd560b4a42eca2fba9ee2c4692318b271a40e087af715c238d879d,0.09814,0.65140,0.74954
+.....
+,158592,0000f5e98829b6fc7d24b890e621b5ca64a6c7c4e4d097a126eae066b54b8de0,0.07127,0.49897,0.57024
+.79865,2.10661,2.90526
+</code>
+</spoiler>
+===== Ce aveți de făcut =====
+  * Înțelegerea algoritmului pe CPU: Veți porni de la directorul //cpu_miner//, ce conține implementarea deja făcută serial, pe CPU. Acesta **nu** face parte din rezolvarea temei. Scopul codului este de a înțelege funcționalitatea pe CPU, ca apoi să optimizați căutarea nonce-ului si generarea Merkle root-ului pe GPU, folosind CUDA.
+  * Implementarea algoritmului pe GPU: Veți porni de la directorul //gpu_miner//, în care veți realiza implementarea în CUDA a logicii funcțiilor discutate anterior. Pentru a vă ajută, aveți deja implementate funcții ajutătoare în //utils.cu//. Vă recomandăm să va folosiți de ele în implementarea voastră.
+  * Lucrați **DOAR** în fișierul //utils.cu//. La încărcarea pe Moodle, veți încărca **DOAR** fișierul //utils.cu// și un fișier //README.md// cu descrierea temei și eventuale observații. Restul fișierelor vor fi ignorate, fiind suprascrise la testarea automată a temei!
+  * Aveți la dispoziție 4 fișiere de intrare pentru testare. Sunteți încurajați să vă creați propriile teste pentru a verifica corectitudinea și performanța implementării voastre.
+  * Compilarea și rularea temei se vor face **EXCLUSIV** pe coada //xl// (testarea automată va fi, de asemenea, făcută pe //xl//). Nu este nevoie să modificați nimic în //Makefile//, regulile sunt deja făcute. Tot ce trebuie să faceți este să apelați //make//, //make run// și //make clean//, ca la laborator:
+<code>
+To compile:  make
+To run:      make run TEST=<TEST_NAME> (example: make run TEST=test4)
+To clean:    make clean
+</code>
+===== Evaluarea performanței și notarea =====
+<note important>Tema va fi verificată automat, folosind infrastructura de testare, pe baza unei suite de teste private. </note>
+  * Arhiva temei va fi încărcată pentru testare și validare pe [[https://curs.upb.ro/2024/mod/assign/view.php?id=115685|Moodle]]. Aceasta va avea denumirea <NUME_STUDENT>_<PRENUME_STUDENT>_<GRUPA>_ASC_TEMA2.zip și va cuprinde obligatoriu fișierele:
+    * //utils.cu//
+    * //README.md//
+<note>
+Repository-ul pe care îl folosiți în procesul de implementare este necesar să fie privat.
+</note>
+<note tip>
+Vă recomandăm să folosiți template-ul de README de [[https://gitlab.cs.pub.ro/asc/asc-public/-/blob/master/assignments/README.example.md|aici]] (includerea unui link către un repo de git este opțională).
+</note>
+  * Punctajul maxim este de 100 pct, distribuite astfel:
+  * 10 pct EXPLICAȚII:
+    * Implementarea descrisă în README, alături de rezultate și o discuție asupra lor.
+    * Programul compilează, codul nu are disfuncționalități majore.
+  * 90 pct IMPLEMENTARE:
+    * Punctaj dat de vmchecker.
+  * Punctajul la testarea automată ([[https://curs.upb.ro/2024/mod/assign/view.php?id=115685|Moodle]]) se va acorda în funcție de performanța (durata de rulare) a celor două funcții modificate, pentru o suită de teste private, generate de noi, în felul urmator:
+    * Fiecare test (asociat unui fișier de intrare) va fi rulat de 5 ori.
+    * Se vor selecta timpii minimi obținuți pentru fiecare funcție, independent unul de altul (de exemplu, timpul minim pentru generarea Merkle root-ului poate proveni din a 3-a rulare, iar timpul minim pentru găsirea nonce-ului valid din a 4-a) și vor fi aproximați la 2 zecimale (exemplu: 0.044 se aproximeaza la 0.04, 0.045 la 0.05, si 0.046 la 0.05).
+    * Timpii rezultați vor fi comparați cu threshold-urile de timp aferente fiecărui test, pentru stabilirea punctajului.
+  * Pentru a testa local eficiența implementării, înainte de încărcarea pe [[https://curs.upb.ro/2024/mod/assign/view.php?id=115685|Moodle]] pentru testarea automată, vă puteți ajuta de următoarele treshold-uri de timp în cazul parametrilor predefiniți din testul 4 (//test4.in//):
+    * Pentru Merkle root (TOTAL_TIME_FOR_MERKLE_ROOT_COMPUTATION):
+        * Timp bun:   ≤  0.04s -> 45 pct
+        * Timp mediu: ≤   0.1s -> 30 pct
+        * Timp slab:  ≤   0.5s -> 15 pct
+        * Timp foarte slab (>0.5s) SAU Merkle root incorect: 0 pct
+    * Pentru căutarea Nonce-ului (TOTAL_TIME_FOR_NONCE_COMPUTATION):
+        * Timp bun:   ≤  0.01s -> 45 pct
+        * Timp mediu: ≤   0.1s -> 30 pct
+        * Timp slab:  ≤     1s -> 15 pct
+        * Timp foarte slab (>1s) SAU Nonce incorect: 0 pct
+===== Observații =====
+<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>
+===== Bonus =====
+  * Temele care obțin punctaj maxim pentru EXPLICAȚII și IMPLEMENTARE vor fi eligibile pentru un bonus de 10% din punctajul total.
+  * Bonusul se acordă pentru o implementare deosebit de eficientă.
+  * Acordarea bonusului rămâne la discreția evaluatorului, pe baza calității și inovației soluției.
+===== Resurse necesare realizării temei =====
+Pentru a clona [[https://gitlab.cs.pub.ro/asc/asc-public | repo-ul]] și a accesa resursele temei 2:
+<code bash>
+student@fep8:~$ git clone https://gitlab.cs.pub.ro/asc/asc-public.git
+student@fep8:~$ cd asc-public/assignments/2-cuda_proof_of_work
+</code>
+===== Suport, întrebări și clarificări =====
+Pentru întrebări sau nelămuriri legate de temă folosiți [[https://curs.upb.ro/2024/mod/forum/view.php?id=115670|forumul temei]].
+<note important>
+E recomandat ca orice întrebare 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>
+===== Bibliografie =====
+[1][[https://bitcoin.org/bitcoin.pdf|Bitcoin Whitepaper]]