Show page

Differences

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

--- asc:teme:tema2 [2024/04/20 21:41]
tudor.calafeteanu [Evaluarea performanței]
+++ 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 - Implementarea CUDA a algoritmului de consens Proof of Work din cadrul Bitcoin ======
+====== Tema 2 - Implementarea în CUDA a arborelui Merkle și a algoritmului de consens Proof of Work din cadrul Bitcoin ======
 <note important>
-  * **Soft deadline:** **8 Mai 2024**. Primiți un bonus de 10% din punctajul obtinut pentru trimiterea temei înainte de **30 aprilie 2024, ora 23:55**.
+  * **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>.
-  * **Hard deadline:** **12 Mai 2024**. Veți primi o depunctare de 10% din punctajul maxim al temei pentru fiecare zi de întârziere.
+  * **Deadline hard:** **18 Mai 2025, ora 23:55**.
-  * **Responsabili:** [[tudor.calafeteanu@stud.acs.upb.ro |Tudor Calafeteanu]], [[costin.carabas@gmail.com|Costin Carabaș ]]
+  * **Responsabili:** [[tudor.calafeteanu@upb.ro |Tudor Calafeteanu]], [[costin.carabas@gmail.com|Costin Carabaș]]
 </note>
 <note tip>
-  * Dată publicare: 20 Aprilie 2024
+  * Dată publicare: 27 Aprilie 2025
-  * Dată actualizare: 20 Aprilie 2024
 </note>
 ===== Enunț =====
-Implementarea unui algoritm de consens distribuit Proof of Work pe blockchain folosind programare pe GPU în CUDA.
+Implementarea în CUDA a arborelui Merkle și a algoritmului de consens Proof of Work din cadrul Bitcoin.
-<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>
+<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>
+===== Obiectivele temei =====
+  * Utilizarea eficientă a limbajului CUDA pentru programarea GPU-urilor, învățat la laborator;
+  * Înțelegerea conceptelor de bază ale blockchain-ului;
+  * Participarea la algoritmul de consens din perspectiva unui nod;
 ===== Introducere =====
-Blockchain-ul este o tehnologie care a devenit cunoscută odată cu apariția criptomonedelor, precum Bitcoin-ul, Ethereum, etc. Este o formă de înregistrare descentralizată și distribuită a tranzacțiilor și datelor, care funcționează pe baza unui lanț de blocuri. Fiecare bloc înregistrează o serie de tranzacții și este legat de blocurile anterioare printr-un proces de criptare și verificare, cunoscut sub numele de "hashing".
+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.
 {{:asc:teme:blockchain.jpg?700|}}
@@ Line 32: / Line 37: @@
 **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.
-===== Obiectivele temei =====
-În cadrul acestei teme veți participa ca nod într-un blockchain, unde execuția tranzacțiilor se va face pe GPU.
-Obiectivele temei:
-  * Înțelegerea conceptelor de bază ale blockchain-ului;
-  * Înțelegerea algoritmului de consens distribuit;
-  * Participarea la algoritmul de consens din perspectiva unui nod;
-  * Programarea pe GPU și folosirea limbajului CUDA;
-===== 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.
@@ Line 55: / Line 51: @@
 Minerul care a rezolvat primul problema va fi recompensat. În cazul vostru, veți primi punctaj 😁
-==== Structura unui bloc ====
+===== Structura unui bloc =====
 Un bloc este format din:
-  * Hash-ul blocului anterior - o valoare predefinită;
-  * Root hash-ul tranzacțiilor - o valoare calculată de host, tranzactiile avand valori predefinite;
-  * 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 hash-ul block-ului rezultat 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). Acest număr trebuie să îl găsiți, prin metoda trial-and-error.
+. 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>
+<spoiler Click pentru a vedea un exemplu de calcul Merkle root>
+<code>
+Nivel 0:
+Tx1: "VBJJJUBSYWLBPLUN" -- SHA256 --> "dad1020a77b640cad9a44b80e689f0b467e42e67e24a2bd23e10d10bc513dc20"
+Tx2: "UBXGGEAYZTXLXKAL" -- SHA256 --> "9a64594a9bee37f5378ffa87bcc44b1412eedd542e007200af4af598f5c14429"
+Tx3: "UILARBVQAAOWYDKV" -- SHA256 --> "5853c3fbf9099e07e1668e110f0c8f37a26e8706be1aa3b964593819c359bb5e"
+Tx4: "NAHPEHOTTNBOJQHR" -- SHA256 --> "43dab3e61ac812e9c0b7e299d4ea603884eb1023d39a0f0568f0e69bb04e36b6"
+Tx5: "VRKAKNASZPTJUVMQ" -- SHA256 --> "f80412748b9c56d59e9ca23d45f9dd28daab3e36fd110e2490dbeca485c0efaf"
+Nivel 1:
+Tx12: "dad1020a77b640cad9a44b80e689f0b467e42e67e24a2bd23e10d10bc513dc209a64594a9bee37f5378ffa87bcc44b1412eedd542e007200af4af598f5c14429" -- SHA256 --> "e5f4ed1fb64870a7a3ee6bf9c31ba3e1eb1887d3afa5c92482896b060323cf80"
+Tx34: "5853c3fbf9099e07e1668e110f0c8f37a26e8706be1aa3b964593819c359bb5e43dab3e61ac812e9c0b7e299d4ea603884eb1023d39a0f0568f0e69bb04e36b6" -- SHA256 --> "06962284b21218613fdfb4146a775fc6586eff41c3834a15173ac83d53f2c40c"
+Tx55: "f80412748b9c56d59e9ca23d45f9dd28daab3e36fd110e2490dbeca485c0efaff80412748b9c56d59e9ca23d45f9dd28daab3e36fd110e2490dbeca485c0efaf" -- SHA256 --> "fbc56527df5f7b9d33e1af001c04a559c84d588cc4199038a2735467ab830f66"
+Nivel 2:
+Tx1234: "e5f4ed1fb64870a7a3ee6bf9c31ba3e1eb1887d3afa5c92482896b060323cf8006962284b21218613fdfb4146a775fc6586eff41c3834a15173ac83d53f2c40c" -- SHA256 --> "5e74a2c7bbb58a67ad0a816f42e3dc10a1c2c82778f83f5ad73d5ad5d2301036"
+Tx5555: "fbc56527df5f7b9d33e1af001c04a559c84d588cc4199038a2735467ab830f66fbc56527df5f7b9d33e1af001c04a559c84d588cc4199038a2735467ab830f66" -- SHA256 --> "e2d8d4a8b90fa567df034d02b2a0ca30e7fbe1ac651cffbc2cd08282a8131bb7"
+Nivel 3:
+Tx12345555 (Merkle root): "5e74a2c7bbb58a67ad0a816f42e3dc10a1c2c82778f83f5ad73d5ad5d2301036e2d8d4a8b90fa567df034d02b2a0ca30e7fbe1ac651cffbc2cd08282a8131bb7" -- SHA256 --> "a660484fcf1c3b54d470e172c0472e68eadadfc2c6078b98519703586fd5eaed"
+</code>
+</spoiler>
+. 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.
+<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".
+Hash-ul blocului anterior: "000000000000000000034158a91c1876f5fc2add1e69641e908956ac9de45b93".
+Merkle root: "a660484fcf1c3b54d470e172c0472e68eadadfc2c6078b98519703586fd5eaed".
+Nonce-ul găsit: 2429400
+Hash-ul blocului rezultat: "000000000000000000034158a91c1876f5fc2add1e69641e908956ac9de45b93a660484fcf1c3b54d470e172c0472e68eadadfc2c6078b98519703586fd5eaed2429400" -- SHA256 --> "0000aea01a49077c7843be9428d087b1f3b02de9cdbd6f30464413ea0b1628b2" < "0000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff".
+</code>
+</spoiler>
+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.
+<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>
 {{:asc:teme:merkle.png?300|}}
+{{:asc:teme:blockchain_paper.png?400|}}
+[1]
-Hash-ul rezultat al blocului se va folosi în continuare pentru crearea unui alt bloc. De aici vine denumirea de blockchain: se creează un lanț de blocuri, iar fiecare bloc depinde de cel anterior.
+===== 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.
-{{:asc:teme:block.png?400|}}
+===== Fișierul de intrare =====
+//miner.cpp// citește un fișier de forma //<TEST_NAME>.in//, ce conține:
-==== Rezolvarea problemei ====
+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.
-Problema de rezolvat este găsirea unei nonce care, atunci când se aplică o funcție hash, cum ar fi SHA-256, hash-ul începe cu un număr de zero biți. Munca medie necesară este exponențială în funcție de numărul de biți zero necesari și poate fi verificată prin executarea unui singur hash.
+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//.
-De exemplu, pornim de la “Hello world” și trebuie să găsim un nonce astfel încât hash-ul să înceapă cu un 0.
+<spoiler Click pentru a vedea un exemplu de fișier de input>
-Pentru nonce = 4, aplicând sha256(“Hello world4”) obținem un hash ce începe cu un 0:
+<code>
+<test4.in>
+,000000000000000000034158a91c1876f5fc2add1e69641e908956ac9de45b93,4,99999999,10000,226
+NWLRBBMQBHCDARZOWKKYHIDDQSCDXRJMOWFRXSJYBLDBEFSARCBYNECDYGGXXPKLORELLNMPAPQFWKHOPKMCOQHNWNKUEWHSQMGBBUQCLJJIVSWMDKQTBXIXMVTRRBLJPTNSNFWZQFJMAFADRRWSOFSBCNUVQHFFBSAQXWPQCACEHCHZVFRKMLNOZJKPQPXRJXKITZYXACBHHKICQCOENDTOMFGDWDWFC
+GPXIQVKUYTDLCGDEWHTACIOHORDTQKVWCSGSPQOQMSBOAGUWNNYQXNZLGDGWPBTRWBLNSADEUGUUMOQCDRUBETOKYXHOACHWDVMXXRDRYXLMNDQTUKWAGMLEJUUKWCIBXUBUMENMEYATDRMYDIAJXLOGHIQFMZHLVIHJOUVSUYOYPAYULYEIMUOTEHZRIICFSKPGGKBBIPZZRZUCXAMLUDFYKGRUOWZGI
+OOOBPPLEQLWPHAPJNADQHDCNVWDTXJBMYPPPHAUXNSPUSGDHIIXQMBFJXJCVUDJSUYIBYEBMWSIQYOYGYXYMZEVYPZVJEGEBEOCFUFTSXDIXTIGSIEEHKCHZDFLILRJQFNXZTQRSVBSPKYHSENBPPKQTPDDBUOTBBQCWIVRFXJUJJDDNTGEIQVDGAIJVWCYAUBWEWPJVYGEHLJXEPBPIWUQZDZUBDUBZV
+...
+</code>
+</spoiler>
-"//Hello world4//" -> **0**9b044fe014a500edc4358d55e4b59d595b7a2c9d01143ae37c577d1f68378e4
+===== Procesarea datelor =====
-Considerăm această problemă ca având **dificultatea = 1**.
+  * 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 o problemă cu **dificultatea = 3**, hash-ul rezultat va începe cu trei de 0: “**000**”.
+  * 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>
-===== Cerințe ale temei =====
+===== Fișierul de ieșire =====
+Rezultatele se scriu în fișierul //<TEST_NAME>.out//, în următorul format, pentru fiecare bloc
-==== Înțelegerea algoritmului de consens pe CPU ====
+<code>
+BLOCK_ID,NONCE,BLOCK_HASH,TIME_FOR_MERKLE_ROOT_COMPUTATION,TIME_FOR_NONCE_COMPUTATION,TIME_SUM
+</code>
-  * Veți porni de la directorul **cpu_miner**, ce conține implementarea deja făcută 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 pe GPU, folosind CUDA.
+, unde TIME_SUM = TIME_FOR_MERKLE_ROOT_COMPUTATION + TIME_FOR_NONCE_COMPUTATION
-  * Acesta conține 5 teste:
-    * 4 pentru a vă familiariza cu funcțiile folosite.
-    * al 5-lea este efectiv implementarea miner-ului pe CPU
-  * Căutarea nonce-ului din testul 5 ar trebui să dureze ~2s pe xl, pentru o dificultate de 5 leading 0s.
-  * Aceasta este o abordare simplistă a calculării unui block hash, cu complexitate redusă. Nu reflectă implementarea reală a algoritmilor de consens POW, având scop pur educativ.
-  * Pași pentru rulare:
-    * To compile:  make
-    * To run:      make run
-    * To clean:    make clean
-==== Implementarea algoritmului de consens pe GPU ====
+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.
-  * Veți porni de la directorul **gpu_miner**, în care veți realiza implementarea în CUDA a logicii din //cpu_miner//.
-  * Veți implementa funcția device //findNonce//, care va paraleliza căutarea nonce-ului, folosind CUDA Threads. Aceasta trebuie implementată astfel încât să caute prin toate numerele de la 1 la MAX_NONCE.
-  * Pentru a va ajută, aveți deja implementate funcții ajutătoare în //utils.cu//. Vă recomandăm să va folosiți de ele în implementarea voastră.
-  * Nonce-ul găsit, hash-ul block-ului, precum și timpul rulării kernel-ului, vor fi scrise într-un fișier //results.csv//, în urmă apelarii funcției //printResult// din //utils.cu//.
-  * Pași pentru rulare:
-    * To compile:  make
-    * To run:      make run
-    * To clean:    make clean
-==== Evaluarea performanței ====
+<code>
+TOTAL_TIME_FOR_MERKLE_ROOT_COMPUTATION,TOTAL_TIME_FOR_NONCE_COMPUTATION,TOTAL_TIME_SUM
+</code>
-  * Punctajul se va acorda în funcție de durata rulării kernel-ului //findNonce//. Pentru a testa eficiența implementării, în cazul valorilor predefinte în //utils// (previous block hash și cele 4 tranzacții, pentru o dificultate de 5 zero-uri), timpii rezultați sunt considerați:
+<spoiler Click pentru a vedea un exemplu de fișier de ieșire>
-    * 100% pct implementare: //t// < 1s.
+<code>
-    * 75% pct implementare:  //t// < 1.5s.
+,33865,0000517db16db1b0a4b3c2a1eee14ebc3c6beaae6420dc90a0643d23a03c167a,0.10294,0.14677,0.24970
-    * 50% pct implementare:  //t// < 2s (durata rulării pe CPU).
+,4050,00007ddf6566d4687489b21cd2764bd286e6958dd7d365fbe30de7ca4b9bbb50,0.09830,0.01761,0.11592
-    * 0% pct implementare:   //t// >= 2s.
+,166127,00002663dafd560b4a42eca2fba9ee2c4692318b271a40e087af715c238d879d,0.09814,0.65140,0.74954
-Unde //t// este timpul //minim// înregistrat în urma a 5 rulări succesive. Motivul pentru care rulăm de mai multe ori este că timpul poate fi diferit cu câteva zecimi de la o rulare la alta.
+.....
-<note important>Această abordare o vom folosi și în testarea noastră, folosind teste **private**, pentru a vă oferi punctajul. Pentru a testa tema cu testele private, folositi submisia pe [[https://curs.upb.ro/2023/mod/assign/view.php?id=166059|Moodle]].</note>
+,158592,0000f5e98829b6fc7d24b890e621b5ca64a6c7c4e4d097a126eae066b54b8de0,0.07127,0.49897,0.57024
+.79865,2.10661,2.90526
+</code>
+</spoiler>
-===== Observații =====
+===== Ce aveți de făcut =====
-  * Compilarea si rularea temei se vor face **EXCLUSIV** pe coada //xl//. Nu este nevoie să modificăț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.
-  * Veți modifica **DOAR** fișierul //gpu_miner.cu//. Celelate fișiere din directorul //gpu_miner// se vor suprascrie la testarea automată.
-  * Deși nonce-ul este un număr întreg, pozitiv, pe 32 biți, MAX_NONCE pe GPU este setat cu valoarea 1e8, în loc de UINT32_MAX (~4.29 * 1e9). Motivul este de a reduce timpul și de a nu întâmpină bottleneck-uri când sunt trimise multe job-uri, în același timp, de la mai mulți studenți, pe coada xl.
-<note warning>
+  * Î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.
-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ă.
+  * 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>
-===== Notare =====
+<note tip>
-Toate modificările vor fi aduse fișierului **gpu_miner.cu**. Acest fișier îl veți submite pentru a fi evaluat și notat.
+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:
+  * Punctajul maxim este de 100 pct, distribuite astfel:
- pct EXPLICAȚII
+  * 10 pct EXPLICAȚII:
-  * Implementare descrisă în README, alături de rezultate și o discuție asupra lor.
+    * Implementarea descrisă în README, alături de rezultate și o discuție asupra lor.
-  * Programul compilează, codul nu are disfuncționalități majore
+    * Programul compilează, codul nu are disfuncționalități majore.
-pct IMPLEMENTARE
-  * Punctaj dat de bench.py / vmchecker
-Arhiva temei va fi încărcată pe [[https://curs.upb.ro/2023/mod/assign/view.php?id=166059|Moodle]]. Aceasta va cuprinde obligatoriu:
+  * 90 pct IMPLEMENTARE:
-  * gpu_miner.cu
+    * Punctaj dat de vmchecker.
-  * README
+  * 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 =====
-Pentru a primi un punctaj bonus de maxim 10 pct, va trebui să schimbați realizarea Merkle Tree-ului din metoda secvențială, pe CPU, într-una paralelă, pe GPU.
-Cerințe:
+  * Temele care obțin punctaj maxim pentru EXPLICAȚII și IMPLEMENTARE vor fi eligibile pentru un bonus de 10% din punctajul total.
-  * Puteți observa că Merkle Tree-ul se poate realiza într-un mod paralel, față de cel secvențial implementat deja.
+  * Bonusul se acordă pentru o implementare deosebit de eficientă.
-  * Va trebui să vă creați un fișier de intrare //inputs.txt//, din care să citiți //n// tranzacții, //n// >= 1000. Este la latitudinea voastră dacă folosiți același previous block hash folosit deja în cod, sau citiți unul nou.
+  * Acordarea bonusului rămâne la discreția evaluatorului, pe baza calității și inovației soluției.
-  * Veți defini o altă funcție kernel //merkleTree//, care va realiza în mod paralel crearea top hash-ului, folosind CUDA Threads.
-  * Punctajul se va da pe o abordare corectă și eficient paralelă a generării top hash-ului, în care să arătați speedup-ul obținut de la trecerea secvențială pe CPU, la cea paralelă pe GPU. Timpul nu va fi luat în considerare, însă nu  trebuie să dureze rularea job-ului mai mult decât valoarea predefinită în RUN_TIME.
 ===== Resurse necesare realizării temei =====
@@ Line 161: / Line 263: @@
 <code bash>
-student@asc:~$ git clone https://gitlab.cs.pub.ro/asc/asc-public.git
+student@fep8:~$ git clone https://gitlab.cs.pub.ro/asc/asc-public.git
-student@asc:~$ cd asc-public/assignments/2-cuda_proof_of_work
+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/2023/mod/forum/view.php?id=166058|forumul temei]].
+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>
-Orice intrebare 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.
+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]]