project.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "01edd1d6",
   "metadata": {},
   "source": [
    "# Naučno izračunavanje \n",
    "Nastavnik: dr. Nina Radojičić Matić  \n",
    "Asistent: Anđelka Zečević  \n",
    "Marko Spasić 1014/2020  \n",
    "Projekat: https://github.com/spaske00/matf-ni-mi201014  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4fa0238e",
   "metadata": {},
   "source": [
    "## Kmeans (naive)\n",
    "\n",
    "```pseudo\n",
    "KMeans\n",
    "Ulaz: Skup tačaka X=[x0, x1, x2...Xn], xi iz R^m\n",
    "Izlaz: Indeksi: I=[j0, j1, j2,...jn] gde je ji indeks klastera kome xi pripada\n",
    "\n",
    "1. Nasumično odaberi C=[C0, C1, ...Ck] tacaka iz X kao centroide klastera\n",
    "2. Svakoj tacki iz X dodeli indeks najblizeg centroida C\n",
    "3. Azuriraj centroide Ci=avg(sve tacke iz X kojima je najblizi centroid Ci)\n",
    "4. Ponavljaj 2-4 M iteracija ili uslova konvergencije\n",
    "\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88d618d9",
   "metadata": {},
   "source": [
    "## 1.1 Tehnike optimizacije programa naučnog izračunavanja pisanih na niskom nivou u C++ jeziku na primeru KMeans algoritma\n",
    "\n",
    "Rad na primeru algoritma KMeans demonstrira dole navedene tehnike efikasnog izračunavanja. Performanse implementacije sklearn biblioteke se koriste kao referentna vrednost. \n",
    "\n",
    "Rad sa brojevima u pokretnom zarezu:\n",
    "- efikasne IO operacije\n",
    "- parsiranje brojeva u pokrentom zarezu\n",
    "- čuvanje i pristup u radnoj memoriji\n",
    "- aritmetičke operacije (šta kompajler može da optimizuje)\n",
    "\n",
    "Podela posla i paralelzacija:\n",
    "- sekvencijalna implementacija\n",
    "- paralelna implementacija sa aktivnim čekanjem\n",
    "- paralelna implementacija sa tokom izvršavanja (taskflow)\n",
    "\n",
    "Budući rad:\n",
    "- implementirati i testirati OpenMP verziju paralelizma\n",
    "- implementirati i testirati OpenCL verziju paralelizma\n",
    "- "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59e4d7c6",
   "metadata": {},
   "source": [
    "## 1.2 IO operacije\n",
    "\n",
    "Standarna biblioteka C++ za čitanje i pisanje datoteka definiše hijerarhiju klasa poznatu kao tokovi (strimovi). \n",
    "<img src='attachments/std-io-complete-inheritance.jpg'/>\n",
    "\n",
    "Kod koji u datoteku data.csv 3 vrednosti u pokrentom zarezu razdvojene karakterom `,`:\n",
    "[godbolt](https://godbolt.org/z/8TPP1zeeW)\n",
    "```c++\n",
    "void write_to_csv(float x, float y, float z) {\n",
    "    std::ofstream out(\"data.csv\");\n",
    "    out << x << ',' << y << ',' << z << '\\n';\n",
    "}\n",
    "```\n",
    "Kompajler u ovom slučaju tretira izraz ``out << x << ',' << y << ',' << z << '\\n';`` kao 6 poziva overlodovanoj funkciji operator<< za upis vrednosti u strim. Sa optimizacijama ``-O2`` g++-11 generiše sledeći asembler kod za x64 arhitekturu: [godbolt](https://godbolt.org/z/8TPP1zeeW)\n",
    "\n",
    "Za velike skupove podataka gde je potrebno upisati/pročitati vrednosti u pokretnom zarezu reda 10^6 i više, sve dodatne opepracije značajno doprinose brzini izvršavanje IO operacija. Za poredjenje:\n",
    "[godbolt](https://godbolt.org/z/vahYdx7er)\n",
    "```c++\n",
    "#include<cstdio>\n",
    "\n",
    "void write_to_csv(float a, float b, float c) {\n",
    "    FILE* f = fopen(\"data.csv\", \"w\");\n",
    "    fprintf(f, \"%f, %f, %f\", a, b, c);\n",
    "}\n",
    "``` \n",
    "Generiše: [godbolt](https://godbolt.org/z/vahYdx7er)\n",
    "\n",
    "\n",
    "U ovom projektu je korišćena biblioteka [fast_io](https://github.com/tearosccebe/fast_io), koja je po benčmarkovima daleko efikasnija od standarne biblioteke C++ za rad sa ulazom i izlazom. \n",
    "\n",
    "### Platform \tLinux \tGCC 11.0.0 \tglibc + libstdc++\n",
    "\t\t\t\n",
    "|Method|Output time|Input time|Comment|\n",
    "|---|---|---|---|\n",
    "|stdio.h(fprintf/fscanf)|0.532792935s|0.591907111s||\n",
    "|fstream with rdbuf.sputc trick|0.318896068s|0.429406415s||\n",
    "|**fast_io::i/obuf_file**|0.050300857s|0.065372395s||\n",
    "|**fast_io::i/obuf_file_mutex**|0.05290654s|0.083040518s|thread safe|\n",
    "|c_locale_i/obuf_file (\"C\")|0.051939052s|0.065820056s|imbued with locale, locale \"C\"|\n",
    "|c_locale_i/obuf_file local|0.162406082s|Meaningless|imbued with locale, locale \"\"|\n",
    "|std::to_chars+obuf_file| \t0.115453587s| \tMeaningless \t|\n",
    "|fmt::format_int+obuf_file| \t0.1183587s| \tMeaningless \t|\n",
    "|fmt::format_int+ofstream| \t0.195914384s| \tMeaningless| \t\n",
    "|fmt::format+ofstream| \t0.633590975s| \tMeaningless| \tfmt makes things slower|\n",
    "|fmt::print| \t0.495270371s| \tMeaningless| \tfmt makes things slower|\n",
    "|boost::iostreams| \t0.400906063s| \t0.444717051s| \tUsing boost iostreams does not make your code faster|\n",
    "|**fast_io::c_file_unlocked**| \t0.060076723s| \t0.073299716s| \tI hacked glibc's FILE* implementation|\n",
    "|**fast_io::c_file**| \t0.092490191s| \t0.104545535s| \tThread Safe. I hacked glibc's FILE* implementation|\n",
    "|**fast_io::filebuf_file**| \t0.052251608s| \t0.06655806s| \tI hacked libstdc++'s streambuf/filebuf implementation|\n",
    "*Tabela preuzta sa: https://github.com/tearosccebe/fast_io/blob/master/readme.md*"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f22983b8",
   "metadata": {},
   "source": [
    "## 1.3 Parsiranje brojeva u pokretnom zarezu\n",
    "\n",
    "Parsiranje brojeva u pokrentom zarezu je jedna od fundamentalnih operacija prilikom rada sa podacima. Zbog čestog korišćenja od izuzetne je važnosti da bude efikasna. Razvojem modernih arhitektura procesora na ovom polju je došlo do značajnog napretka radom profesora Daniel Lemire u radu [Number Parsing at a Gigabyte per Second](https://arxiv.org/pdf/2101.11408.pdf). \n",
    "\n",
    "|nstructions|mispredictions|cycles|instructions/cycle|\n",
    "|---|---|---|---|\n",
    "|netlib|740|4.1|330|2.2|\n",
    "|double-conversion|1100|1.7|380|3.0|\n",
    "|strtod|1100|0.7|370|3.0|\n",
    "|abseil|600|0.5|160|3.8|\n",
    "|ourparser|280|0.01|66|4.2|\n",
    "||juststring)|215|0.00|46|4.7|\n",
    "*tabela 10: https://arxiv.org/pdf/2101.11408.pdf*\n",
    "\n",
    "U kombinaciji sa fast_io, i minimizovanjem broja alokacija, IO operacije nad csv datotekama su do 2x brže od numpy loadtxt i savetxt funkcija.\n",
    "\n",
    "Razlike su veće na manjim skupovima podataka ( < 32000) do x6 puta, dok na većim podacima se razlike svode do 1.5x.\n",
    "\n",
    "Biblioteka je jednostavna za korišćenje.\n",
    "\n",
    "```c++\n",
    "for (u64 i = 0; i < result.m_num_of_values; ++i) {\n",
    "    assert(file_it != csv_file.end());\n",
    "    auto from_chars_result = fast_float::from_chars(file_it, csv_file.cend(), result.m_data[i]);\n",
    "    file_it = std::next(from_chars_result.ptr);\n",
    "}\n",
    "```\n",
    "Prva dva parametra funkcije fast_float::from_chars su pokzivači na trenutu poziciju u baferu i kraj bafera.\n",
    "Treći parametar je referenca na promenljivu u kojoj će parsirana vrednost biti sačuvana. \n",
    "Povratna vrednost funkcije je resultat koji ima pokazivač na mesto na kom se parsiranje završilo .ptr i indikator bool da li je parsiranje bilo uspešno.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "639941bb",
   "metadata": {},
   "source": [
    "## 1.4 Čuvanje i pristup podacima u radnoj memoriji\n",
    "\n",
    "Moderne ahitekture procesora koriste **keš memoriju** kako bi ubrzle pristup podacima iz glavne memorije. Brzine keš memorije i uticaj na performanse variraju u zavisnosti od mikroarhitekture i proizvođača procesora. Na slici je ugrubo prikazan odnos brzine pristupa podataku u zavisnosti od toga koliko je `udaljen` od registra. Gde je pristup podacima u registirma momentalan, L1 kešu nešto sporiji itd.\n",
    "\n",
    "<img src='attachments/cache.png'/>\n",
    "\n",
    "Drugi element modernih arhitektura procesora je **prefetch** sistem. Ukoliko program ima predvidive obrasce pristupa memoriji (npr arr[i], arr[i+1], arr[i+2]) prefetch sistem ima mogućnost da predvidi koja će sledeća memorijska lokacija biti potrebna i da keš liniju na kojoj se nalazi učita u keš unapred. Tako da kada se tom podatku pristupi, on se već nalazi u keš memoriji i procesor neće morati da čeka dok ti podaci ne stignu iz glavne memorije.\n",
    "\n",
    "Treći element važan element modernih arhitektura procesora je **branch-prediction**. U bilom delu koda koji se u malom vremnskom periodu često ponavlja procesora pokušava da predvidi da li će uslov u nekoj cmp i jmp instrukciji biti tačan. Ukoliko je f(i) u velikoj većini slučejva tačno (90%) performanse ovog dela koda će biti približno onima kao da grana ne postoji, samo evaluacija funkcije f.\n",
    "```c++\n",
    "for (int i = 0; i < n; ++i) {\n",
    "      if (f(i)) {\n",
    "          // do something\n",
    "      }\n",
    "}\n",
    "```\n",
    "\n",
    "Ova tri sistema procesora najbolje su iskorišćena ukoliko su podaci poredjani u memoriji kontinualno, onim redom kojim im se pristupa, bez mnogo nepredvidivih skokova i obrađuju se tako da nema ili ima minimalan broj grananja tokom obrade podataka koji su lako predvidivi od strane **branch-prediction** sistema.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd39c4de",
   "metadata": {},
   "source": [
    "## 1.5 Aritmetičke operacije (šta kompajler može da optimizuje)\n",
    "\n",
    "Kada se radi sa kodom koji je aritmetički intezivan obavezno je posmatrati šta je kranji izlaz asebmlera iz kompajlera i meriti različite implementacije. Neretko se dešava da kompajleri (u zavisnosti od vendora) umeju da generišu očigledno neefikasan kod za najjednostavnije moguće operacije. U [primeru](https://godbolt.org/z/vcs9q1zaW) možemo videti da clang generiše lošiji kod za jednostavnu inicijalizaciju matrica 4x4. Takodje, kod koji kompajler generiše može se promeniti iz ne tako očiglednih razloga, na primer promena promenljive Identity u static iz lokalne potpuno menja način na koji komajler generiše operacije inicijalizacije u petlji.\n",
    "\n",
    "Osnovno pravilo je **čitati asembler i meriti različite implementacije**."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad5cf53c",
   "metadata": {},
   "source": [
    "## 1.6 Podela posla i paralelzacija\n",
    "\n",
    "Paralelizm i podela posla se mogu ugrubo definisati na paralelisam zasnovan na zadacima (task based) i paralelisam zasnovan na podacima (data-based). \n",
    "\n",
    "Primer paralelizma zasnovanog na zadacima je kada se u programu različite odgovornosti i sistemi tog programa podele u niti. Na primer, u programu za obradu teksta postoji po jedna nit za: renderovanje, čitanje fajl sistema, pisanje fajl sistema i bojenje teksta na osnovu neke sintakse. Ovakav način podele može program učiniti responzivnijim u slučaju da nekoj od niti treba duže vreme da nešto završi ili dođe do greške, ostatak program bi trebalo da radi. Međutim, ovakav način paralelizacije se obično skalira samo dok je broj niti hardvera manji od broja zadataka. Povećanjem broja niti hardvera preko broja zadataka, ne skalira se efikasnost samog izvršavanja.\n",
    "\n",
    "Kod paralelizma podataka ista funkcija se izvršava nad podskupovima podataka. Na primer, ukoliko je potrebno pronaći neki element u nizu i na raspolaganju je m niti, moguće je podeliti skup na n/m blokova i pustiti po jednu nit da isti zadatak obavlja nad svojim blokom. Ovakav pristup je podložan sklairanju povećavanjem broja niti hardvera. Što više niti hardvera, to manje posla za svaku nit. Teorijski u skupu od N elemenata i N niti, bilo bi moguće pronaći bilo koji element u vremenskoj složenosti O(1).\n",
    "\n",
    "<img src='attachments/parallelism.png'/>\n",
    "\n",
    "\n",
    "Još jedna ideja iz sveta paralelnog izračunavanja koja će nam biti od koristi je Amdalov zakon koji kaže da je ubrzanje koje se dobije proporcionalno procentu programa koji je moguće paralelizovati. Na primer ako je moguće paralelizovati samo deo koda koji ukupnom izvršavanju programa doprionsi sa 10%, onda ubrzanje ne možete biti veće od tih 10%.\n",
    "<img src='attachments/law.png'/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8f448eb",
   "metadata": {},
   "source": [
    "# 2. Primena na KMeans\n",
    "\n",
    "Za učitavnje .csv fajlova u memoriju koristi se fast_io bibliotek, a za parsiranje brojeva u pokretnom zarezu fast_float biblioteka. U ovoj implementaciji apstrakcija nad skupom tačaka predstavljena je klasom Points koja u pozadini čuva jedan kontinualni niz brojeva u pokretnom zarezu u koji se smeštaju podaci učitani sa diska.\n",
    "\n",
    "```c++\n",
    "template<typename T>\n",
    "Points<T> Points<T>::load_from_csv(const CSVInfo &info) {\n",
    "    Points <T> result(info.num_of_rows, info.num_of_cols);\n",
    "    fast_io::native_file_loader csv_file(info.filepath);\n",
    "    auto file_it = csv_file.cbegin();\n",
    "    for (u64 i = 0; i < result.m_num_of_values; ++i) {\n",
    "        auto from_chars_result = fast_float::from_chars(file_it, csv_file.cend(), result.m_data[i]);\n",
    "        file_it = std::next(from_chars_result.ptr);\n",
    "    }\n",
    "    return result;\n",
    "}\n",
    "```\n",
    "Iz CSV fajla se prvo izvuče informacija o broju kolona i redova. Na osnovu toga alocira se dovoljno veliki prostor da sačuva sve vrednosti. \n",
    "fast_io::native_file_loader je fast_io implementacija memorijski mapiranog fajla. Funkcija fast_float::from_chars parsira broj u pokretnom zarezu i upisuje ga u treći parametar. Povratna vrednost je struktura koja sadrži indikator da li je parsiranje uspelo i pokazivač na kranji karakter parsirane vrednosti u nizu karatera fajla.\n",
    "\n",
    "Ovako specifično implementirano rešenje pokazalo se i do 2x brže na većim datotekama (>1GB) i do 3x brže na manjim (<100MB) od numpy.loadtxt funkcije.\n",
    "\n",
    "Važno je napomenuti, da je ovo specifična implementacija za specifičan slučaj, sa specifičnom postavkom memorije u specifične svhre. Dok je numpy biblioteka opšte namena, koja ima daleko više slučajeva korišćenja i operacija koje izvodi."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af2b8b69",
   "metadata": {},
   "source": [
    "## 2.2 Sekvencijalna implementacija\n",
    "Kod sekvencijalna implementacija algoritam se izvršava u jednoj niti, redom, kako je navedeno u algoritmu sa početka sveske. Iz sekvencijalne implementacije je uočljivo kako se algoritam može paralelizovati. Posmatrajući petlju koja prolazi kroz svaku tačku, može se uočiti da obrada i-te tačke ne zavisi od obrade bilo koje druge tačke u skupu ulaznih tačaka. Stoga se algoritam može paralelizovati po podacima, tako što bi svaka nit mogla da obrađuje jedan blok tačaka.\n",
    "```c++\n",
    "// N broj tacaka\n",
    "// K broj klastera\n",
    "// Ponavljaj M iteracija:\n",
    "for (u64 i = 0; i < N; ++i) {\n",
    "    const vec_ref<T> ith_point = input_points[i];\n",
    "    T distance_from_closest_centroid = std::numeric_limits<T>::max();\n",
    "    u64 index_of_closest_centroid = 0;\n",
    "    for (u64 k = 0; k < K; ++k) {\n",
    "        assert(k < m_output_centroid_coords.num_of_points());\n",
    "        const T distance_from_kth_centroid = L2(ith_point, m_output_centroid_coords[k]);\n",
    "        if (distance_from_kth_centroid < distance_from_closest_centroid) {\n",
    "            distance_from_closest_centroid = distance_from_kth_centroid;\n",
    "            index_of_closest_centroid = k;\n",
    "        }\n",
    "    }\n",
    "    m_output_closets_centroid_indices[i] = index_of_closest_centroid;\n",
    "}\n",
    "\n",
    "for (u64 i = 0; i < N; ++i) {\n",
    "    const auto cluster_index = m_output_closets_centroid_indices[i];\n",
    "    sum_of_all_points_in_cluster[cluster_index] += input_points[i];\n",
    "    num_of_points_in_cluster[cluster_index] += 1;\n",
    "}\n",
    "\n",
    "for (u64 k = 0; k < K; ++k) {\n",
    "    const T count = static_cast<T>(std::max(1ul, num_of_points_in_cluster[k]));\n",
    "    m_output_centroid_coords[k].copy_assign(sum_of_all_points_in_cluster[k]);\n",
    "    m_output_centroid_coords[k] /= count;\n",
    "}\n",
    "\n",
    "```\n",
    "\n",
    "## 2.3 Paralelna implementacija (atomic naivna sinhronizacija)\n",
    "Kod Paralelne implementacije skup od N ulaznih tačaka podeljen je u blokove veličine N/broj_niti.\n",
    "Svaka nit obradjuje jedan od ovih blokova. Kada završi obradu inkrementira brojač m_num_of_threads_that_finished_cluster_update_for_this_iteration. Kada sve niti završe obradu, glavna nit, objednjuje rezultate. \n",
    "\n",
    "\n",
    "```c++\n",
    "for (u64 iteration = 0; iteration < M; ++iteration) {\n",
    "    sum_of_all_points_in_cluster.fill(T{});\n",
    "    std::fill(range(num_of_points_in_cluster), 0);\n",
    "    // start parallel cluster update\n",
    "    // TODO: give this thread clusters to update also\n",
    "    m_num_of_threads_that_finished_cluster_update_for_this_iteration.store(0, std::memory_order_relaxed);\n",
    "    m_current_iteration.store(iteration, std::memory_order_release);\n",
    "    // TODO: this doesn't need to be an atomic store/read because of cv mutex lk\n",
    "    update_rows(params.start, params.end);\n",
    "    while (m_num_of_threads_that_finished_cluster_update_for_this_iteration.load(std::memory_order_acquire)\n",
    "           != (m_num_of_threads - 1)) {\n",
    "        // wait for all the threads to finish work\n",
    "    }\n",
    "    // update centroids\n",
    "    for (u64 i = 0; i < N; ++i) {\n",
    "        const auto cluster_index = m_output_closets_centroid_indices[i];\n",
    "        sum_of_all_points_in_cluster[cluster_index] += input_points[i];\n",
    "        num_of_points_in_cluster[cluster_index] += 1;\n",
    "    }\n",
    "    for (u64 k = 0; k < K; ++k) {\n",
    "        const T count = static_cast<T>(std::max(1ul, num_of_points_in_cluster[k]));\n",
    "        m_output_centroid_coords[k].copy_assign(sum_of_all_points_in_cluster[k]);\n",
    "        m_output_centroid_coords[k] /= count;\n",
    "    }\n",
    "}\n",
    "\n",
    "template<typename T>\n",
    "void KMeans<T>::update_rows(u64 start, u64 end) {\n",
    "    const auto K = m_params.num_of_clusters;\n",
    "    auto &input_points = *m_input_points;\n",
    "    for (u64 i = start; i < end; ++i) {\n",
    "        const vec_ref<T> ith_point = input_points[i];\n",
    "        T distance_from_closest_centroid = std::numeric_limits<T>::max();\n",
    "        u64 index_of_closest_centroid = 0;\n",
    "        for (u64 k = 0; k < K; ++k) {\n",
    "            assert(k < m_output_centroid_coords.num_of_points());\n",
    "            const T distance_from_kth_centroid = L2(ith_point, m_output_centroid_coords[k]);\n",
    "            if (distance_from_kth_centroid < distance_from_closest_centroid) {\n",
    "                distance_from_closest_centroid = distance_from_kth_centroid;\n",
    "                index_of_closest_centroid = k;\n",
    "            }\n",
    "        }\n",
    "        m_output_closets_centroid_indices[i] = index_of_closest_centroid;\n",
    "    }\n",
    "}\n",
    "\n",
    "template<typename T>\n",
    "void KMeans<T>::worker_thread(u64 thread_index) {\n",
    "    const auto params = \n",
    "        WorkerThreadChunkParams::compute(thread_index,m_input_points->num_of_points(),m_num_of_threads, 16);\n",
    "    for (u64 iteration = 0; iteration < m_params.num_of_iterations; ++iteration) {\n",
    "        while (m_current_iteration.load(std::memory_order_acquire) != iteration) {\n",
    "            // wait for the next iteration\n",
    "        }\n",
    "        update_rows(params.start, params.end);\n",
    "        m_num_of_threads_that_finished_cluster_update_for_this_iteration.fetch_add(1,\n",
    "                                                                                   std::memory_order_release);\n",
    "    }\n",
    "}\n",
    "```\n",
    "\n",
    "## 2.4 Paralelna implementacija korišćenjem taskflow biblioteke\n",
    "\n",
    "Paralelan kod često prati određene obrasce. Neki od tih obrazaca se mogu modelovati tokom obrade podataka.\n",
    "Na primer, zadaci mogu da formiraju graf zavisnosti. U grafu na slici, zadatak A je zadatak od kojeg počinje izvršavanje. Nakon što se završi zadatak A, mogu se izvršiti zadaci B i C. Da bi počelo izvršavanje zadatka E, moraju se završiti A i B, a da bi počelo izvršavanje zadatka D, moraju se izvršiti zadaci C i B.\n",
    "<img src='attachments/taskflow.png'/>\n",
    "\n",
    "Zadaci B i C su međusobno nezavisni i mogu se izvršiti paralelno, isto tako i E i D. Izraziti sve ovo preko primitiva za paralelno programiranje (atomične promenljive, condition promenljive, muteksi, semafori...) je sklono greškama i ume da oduzme mnogo vremena. Srećom, postoji biblioteka visokog kvaliteta [taskflow](https://taskflow.github.io/taskflow/index.html) koja modeluje baš ovakav način izračunavanja. Kod koji pomoću objekata taskflow biblioteke opisuje prethodno izračunavanje dat je u prilogu:\n",
    "```c++\n",
    "tf::Taskflow taskflow;\n",
    "\n",
    "tf::Task A = taskflow.emplace([] () {}).name(\"A\");\n",
    "tf::Task B = taskflow.emplace([] () {}).name(\"B\");\n",
    "tf::Task C = taskflow.emplace([] () {}).name(\"C\");\n",
    "tf::Task D = taskflow.emplace([] () {}).name(\"D\");\n",
    "tf::Task E = taskflow.emplace([] () {}).name(\"E\");\n",
    "A.precede(B, C, E);\n",
    "C.precede(D);\n",
    "B.precede(D, E);\n",
    "\n",
    "// dump the graph to a DOT file through std::cout\n",
    "taskflow.dump(std::cout);\n",
    "```\n",
    "\n",
    "Ova biblioteka ima i raznih drugih primitiva za opisivanje različitih paralelnih izračunavanja. Jedna od njih je paralelna for petlja koja se odlično mapira na problem kmeans algoritma za obradu ulaznih tačaka. Tako da umesto ručne sinhronizacije, možemo paralelni kmeans opisati na sledeći način.\n",
    "\n",
    "```c++\n",
    "auto clean_up = taskflow.emplace([&] {\n",
    "    sum_of_all_points_in_cluster.fill(T{});\n",
    "    std::fill(range(num_of_points_in_cluster), 0);\n",
    "});\n",
    "auto compute_centroids = taskflow.for_each_index((u64)0, N, (u64)1, [&](u64 i) {\n",
    "    const vec_ref<T> ith_point = input_points[i];\n",
    "    T distance_from_closest_centroid = std::numeric_limits<T>::max();\n",
    "    u64 index_of_closest_centroid = 0;\n",
    "    for (u64 k = 0; k < K; ++k) {\n",
    "        assert(k < m_output_centroid_coords.num_of_points());\n",
    "        const T distance_from_kth_centroid = L2(ith_point, m_output_centroid_coords[k]);\n",
    "        if (distance_from_kth_centroid < distance_from_closest_centroid) {\n",
    "            distance_from_closest_centroid = distance_from_kth_centroid;\n",
    "            index_of_closest_centroid = k;\n",
    "        }\n",
    "    }\n",
    "    m_output_closets_centroid_indices[i] = index_of_closest_centroid;\n",
    "});\n",
    "\n",
    "auto update_clusters = taskflow.emplace([&]{\n",
    "    for (u64 i = 0; i < N; ++i) {\n",
    "        const auto cluster_index = m_output_closets_centroid_indices[i];\n",
    "        sum_of_all_points_in_cluster[cluster_index] += input_points[i];\n",
    "        num_of_points_in_cluster[cluster_index] += 1;\n",
    "    }\n",
    "\n",
    "    for (u64 k = 0; k < K; ++k) {\n",
    "        const T count = static_cast<T>(std::max(1ul, num_of_points_in_cluster[k]));\n",
    "        m_output_centroid_coords[k].copy_assign(sum_of_all_points_in_cluster[k]);\n",
    "        m_output_centroid_coords[k] /= count;\n",
    "    }\n",
    "});\n",
    "auto iterate_while = taskflow.emplace([m=0ull, M]() mutable {\n",
    "    return (m++ < M) ? 0 : 1;\n",
    "});\n",
    "\n",
    "init.precede(clean_up);\n",
    "clean_up.precede(compute_centroids);\n",
    "iterate_while.precede(clean_up).succeed(update_clusters);\n",
    "executor.run(taskflow);\n",
    "\n",
    "```\n",
    "\n",
    "Biblioteka ima mali ili zanemariv overhead u ovom slučaju, a značjano skraćuje napisani kod i mogućnost grešaka prilikom sinhronizacije."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92e88c27",
   "metadata": {},
   "source": [
    "## 3. Benchmarks\n",
    "U daljem delu sveske slede merenja pokretanja. Sva merenja su normalizovana na vremen koje je potrebno numpy i sklearn.KMeans biblioteci da obavi isti posao. \n",
    "Kako bi se merilo vreme izvršavanja glavnog dela algoritma uvedena su sledeća ograničenja parametara.\n",
    "\n",
    "```python\n",
    "sklearn.KMeans(\n",
    "    n_init = 1 # broj ponovnih pokretanja KMeans algoritma\n",
    "    init = 'random'\n",
    "    tol = 0.0 # tolerancija za zaustavljanje konvergencije kako bi se izvrsio zadati broj iteracija\n",
    "    algorithm='full'\n",
    ")\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d1f35d4c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "88d48d7d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>file</th>\n",
       "      <th>type</th>\n",
       "      <th>num_of_samples</th>\n",
       "      <th>num_of_features</th>\n",
       "      <th>num_of_iterations</th>\n",
       "      <th>num_of_clusters</th>\n",
       "      <th>num_of_threads</th>\n",
       "      <th>load_csv</th>\n",
       "      <th>fit</th>\n",
       "      <th>save_to_csv</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>10_nsamples_32000_ncenters_8_nfeatures_8.csv</td>\n",
       "      <td>cpp_sequential</td>\n",
       "      <td>32000</td>\n",
       "      <td>8</td>\n",
       "      <td>1</td>\n",
       "      <td>8</td>\n",
       "      <td>1</td>\n",
       "      <td>0.016568</td>\n",
       "      <td>0.001115</td>\n",
       "      <td>0.000346</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>11_nsamples_32000_ncenters_8_nfeatures_16.csv</td>\n",
       "      <td>cpp_sequential</td>\n",
       "      <td>32000</td>\n",
       "      <td>16</td>\n",
       "      <td>1</td>\n",
       "      <td>8</td>\n",
       "      <td>1</td>\n",
       "      <td>0.033070</td>\n",
       "      <td>0.002206</td>\n",
       "      <td>0.000378</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>12_nsamples_32000_ncenters_8_nfeatures_32.csv</td>\n",
       "      <td>cpp_sequential</td>\n",
       "      <td>32000</td>\n",
       "      <td>32</td>\n",
       "      <td>1</td>\n",
       "      <td>8</td>\n",
       "      <td>1</td>\n",
       "      <td>0.056047</td>\n",
       "      <td>0.003388</td>\n",
       "      <td>0.000302</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>13_nsamples_32000_ncenters_8_nfeatures_64.csv</td>\n",
       "      <td>cpp_sequential</td>\n",
       "      <td>32000</td>\n",
       "      <td>64</td>\n",
       "      <td>1</td>\n",
       "      <td>8</td>\n",
       "      <td>1</td>\n",
       "      <td>0.108250</td>\n",
       "      <td>0.008068</td>\n",
       "      <td>0.000340</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>14_nsamples_32000_ncenters_8_nfeatures_128.csv</td>\n",
       "      <td>cpp_sequential</td>\n",
       "      <td>32000</td>\n",
       "      <td>128</td>\n",
       "      <td>1</td>\n",
       "      <td>8</td>\n",
       "      <td>1</td>\n",
       "      <td>0.209074</td>\n",
       "      <td>0.019711</td>\n",
       "      <td>0.000347</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                             file            type  \\\n",
       "0    10_nsamples_32000_ncenters_8_nfeatures_8.csv  cpp_sequential   \n",
       "1   11_nsamples_32000_ncenters_8_nfeatures_16.csv  cpp_sequential   \n",
       "2   12_nsamples_32000_ncenters_8_nfeatures_32.csv  cpp_sequential   \n",
       "3   13_nsamples_32000_ncenters_8_nfeatures_64.csv  cpp_sequential   \n",
       "4  14_nsamples_32000_ncenters_8_nfeatures_128.csv  cpp_sequential   \n",
       "\n",
       "   num_of_samples  num_of_features  num_of_iterations  num_of_clusters  \\\n",
       "0           32000                8                  1                8   \n",
       "1           32000               16                  1                8   \n",
       "2           32000               32                  1                8   \n",
       "3           32000               64                  1                8   \n",
       "4           32000              128                  1                8   \n",
       "\n",
       "   num_of_threads  load_csv       fit  save_to_csv  \n",
       "0               1  0.016568  0.001115     0.000346  \n",
       "1               1  0.033070  0.002206     0.000378  \n",
       "2               1  0.056047  0.003388     0.000302  \n",
       "3               1  0.108250  0.008068     0.000340  \n",
       "4               1  0.209074  0.019711     0.000347  "
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bmrk = pd.read_csv('data/benchmarks/final.csv')\n",
    "bmrk.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "340ddfad",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "num_of_samples:  [   32000   128000  1000000 10000000      512     1024     2048     4096]\n",
      "num_of_features:  [   8   16   32   64  128  256  512 1024    2    3]\n",
      "num_of_clusters:  [ 8 32 64]\n",
      "num_of_theads:  [ 1 16]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "    \n",
    "unique_num_of_samples = bmrk['num_of_samples'].unique()\n",
    "unique_num_of_features = bmrk['num_of_features'].unique()\n",
    "unique_num_of_clusters = bmrk['num_of_clusters'].unique()\n",
    "unique_num_of_threads = bmrk['num_of_threads'].unique()\n",
    "\n",
    "print('num_of_samples: ', unique_num_of_samples)\n",
    "print('num_of_features: ', unique_num_of_features)\n",
    "print('num_of_clusters: ', unique_num_of_clusters)\n",
    "print('num_of_theads: ', unique_num_of_threads)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "0781e76e",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "               type  load_csv  save_to_csv       fit\n",
      "240  cpp_sequential  0.011798     0.000393  0.010085\n",
      "270    taskflow_cpu  0.019372     0.000566  0.004233\n",
      "300    cpp_parallel  0.014416     0.000367  0.002044\n",
      "330  python_sklearn  0.206476     0.002617  0.087592 \n",
      "\n",
      "\n",
      "Params:\n",
      "        num_of_samples: 32000\n",
      "        num_of_features: 8\n",
      "        num_of_iteartions: 1\n",
      "        num_of_clusters: 64\n",
      "    \n",
      "(0, 'cpp_sequential')\n",
      "(1, 'taskflow_cpu')\n",
      "(2, 'cpp_parallel')\n",
      "(3, 'python_sklearn')\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "               type  load_csv  save_to_csv       fit\n",
      "248  cpp_sequential  0.032548     0.001147  0.023062\n",
      "278    taskflow_cpu  0.054067     0.001244  0.011096\n",
      "308    cpp_parallel  0.047924     0.001345  0.006851\n",
      "338  python_sklearn  0.821966     0.001060  0.087698 \n",
      "\n",
      "\n",
      "Params:\n",
      "        num_of_samples: 128000\n",
      "        num_of_features: 8\n",
      "        num_of_iteartions: 1\n",
      "        num_of_clusters: 64\n",
      "    \n",
      "(0, 'cpp_sequential')\n",
      "(1, 'taskflow_cpu')\n",
      "(2, 'cpp_parallel')\n",
      "(3, 'python_sklearn')\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "               type  load_csv  save_to_csv       fit\n",
      "256  cpp_sequential  0.213095     0.008023  0.185489\n",
      "286    taskflow_cpu  0.287218     0.011267  0.062394\n",
      "316    cpp_parallel  0.250999     0.007813  0.036517\n",
      "346  python_sklearn  6.358569     0.000802  0.236046 \n",
      "\n",
      "\n",
      "Params:\n",
      "        num_of_samples: 1000000\n",
      "        num_of_features: 8\n",
      "        num_of_iteartions: 1\n",
      "        num_of_clusters: 64\n",
      "    \n",
      "(0, 'cpp_sequential')\n",
      "(1, 'taskflow_cpu')\n",
      "(2, 'cpp_parallel')\n",
      "(3, 'python_sklearn')\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "def histogram_parts(bmrk, num_of_samples, num_of_features, num_of_clusters, num_of_iterations):\n",
    "    bmrk = bmrk.loc[((bmrk['num_of_samples'] == num_of_samples) \n",
    "                & (bmrk['num_of_features'] == num_of_features) \n",
    "                & (bmrk['num_of_iterations'] == num_of_iterations)\n",
    "                & (bmrk['num_of_clusters'] == num_of_clusters))]\n",
    "    if bmrk.empty:\n",
    "        return\n",
    "    print(bmrk.loc[:, ['type', 'load_csv', 'save_to_csv', 'fit']], '\\n')\n",
    "    print(f'''\n",
    "Params:\n",
    "        num_of_samples: {num_of_samples}\n",
    "        num_of_features: {num_of_features}\n",
    "        num_of_iteartions: {num_of_iterations}\n",
    "        num_of_clusters: {num_of_clusters}\n",
    "    ''')\n",
    "    \n",
    "    labels = bmrk['type'].unique()\n",
    "    load_times = bmrk['load_csv']\n",
    "    X = np.arange(len(labels))\n",
    "    print('\\n'.join(map(str, list(zip(X, labels)))))\n",
    "    width = 0.5\n",
    "    fig, ax = plt.subplots(2,2, figsize=(12, 8))\n",
    "\n",
    "    bar = ax[0,0].bar(X, load_times, width, label='load_csv')\n",
    "    ax[0,0].set_ylabel('Times in seconds')\n",
    "    ax[0,0].set_title('load_csv')\n",
    "    ax[0,0].set_xticks(X)\n",
    "    \n",
    "    save_times = bmrk['save_to_csv']\n",
    "    bar = ax[0,1].bar(X, save_times, width, label='save_to_csv')\n",
    "    ax[0,1].set_ylabel('Times in seconds')\n",
    "    ax[0,1].set_title('save_to_csv')\n",
    "    ax[0,1].set_xticks(X)\n",
    "    \n",
    "    fit_times = bmrk['fit']\n",
    "    bar = ax[1,0].bar(X, fit_times, width, label='fit')\n",
    "    ax[1,0].set_ylabel('Times in seconds')\n",
    "    ax[1,0].set_title('fit')\n",
    "    ax[1,0].set_xticks(X)\n",
    "    \n",
    "    total = load_times + save_times + fit_times\n",
    "\n",
    "    bar = ax[1,1].bar(X, total, width, label='total')\n",
    "    ax[1,1].set_ylabel('Times in seconds')\n",
    "    ax[1,1].set_title('total')\n",
    "    ax[1,1].set_xticks(X)\n",
    "    \n",
    "    fig.tight_layout()\n",
    "    plt.show()\n",
    "    \n",
    "\n",
    "num_of_features = 8\n",
    "num_of_clusters = 64\n",
    "num_of_iterations = 1\n",
    "for sample_size in sorted(unique_num_of_samples):\n",
    "    histogram_parts(bmrk, sample_size, num_of_features, num_of_clusters, num_of_iterations)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "672597d6",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "               type  load_csv  save_to_csv       fit\n",
      "246  cpp_sequential  0.438030     0.000373  0.740468\n",
      "276    taskflow_cpu  0.906010     0.000381  0.116255\n",
      "306    cpp_parallel  0.671074     0.000377  0.070355\n",
      "336  python_sklearn  5.803740     0.025126  0.182780 \n",
      "\n",
      "\n",
      "Params:\n",
      "        num_of_samples: 32000\n",
      "        num_of_features: 512\n",
      "        num_of_iteartions: 1\n",
      "        num_of_clusters: 64\n",
      "    \n",
      "(0, 'cpp_sequential')\n",
      "(1, 'taskflow_cpu')\n",
      "(2, 'cpp_parallel')\n",
      "(3, 'python_sklearn')\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "               type   load_csv  save_to_csv       fit\n",
      "254  cpp_sequential   1.749600     0.001120  2.866973\n",
      "284    taskflow_cpu   2.107763     0.002291  0.446845\n",
      "314    cpp_parallel   1.671447     0.001171  0.235411\n",
      "344  python_sklearn  23.369380     0.020527  0.411303 \n",
      "\n",
      "\n",
      "Params:\n",
      "        num_of_samples: 128000\n",
      "        num_of_features: 512\n",
      "        num_of_iteartions: 1\n",
      "        num_of_clusters: 64\n",
      "    \n",
      "(0, 'cpp_sequential')\n",
      "(1, 'taskflow_cpu')\n",
      "(2, 'cpp_parallel')\n",
      "(3, 'python_sklearn')\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "num_of_features = 512\n",
    "num_of_clusters = 64\n",
    "num_of_iterations = 1\n",
    "for sample_size in sorted(unique_num_of_samples):\n",
    "    histogram_parts(bmrk, sample_size, num_of_features, num_of_clusters, num_of_iterations)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "cd291102",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cpp_sequential  fit total: 48.229728808\n",
      "taskflow_cpu  fit total: 10.04261846\n",
      "cpp_parallel  fit total: 5.364536943000001\n",
      "python_sklearn  fit total: 23.050163507461548\n"
     ]
    }
   ],
   "source": [
    "unique_types = bmrk['type'].unique()\n",
    "for t in unique_types:\n",
    "    print(t, ' fit total:', bmrk.loc[bmrk['type'] == t]['fit'].sum())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "37a2772e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cpp_sequential  fit total: 83.455679259\n",
      "taskflow_cpu  fit total: 87.840001154\n",
      "cpp_parallel  fit total: 96.60086525400001\n",
      "python_sklearn  fit total: 1095.5325756072998\n"
     ]
    }
   ],
   "source": [
    "for t in unique_types:\n",
    "    print(t, ' fit total:', bmrk.loc[bmrk['type'] == t]['load_csv'].sum())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "4ff1b5f7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cpp_sequential  fit total: 0.5101963389999999\n",
      "taskflow_cpu  fit total: 0.552872668\n",
      "cpp_parallel  fit total: 0.51711731\n",
      "python_sklearn  fit total: 0.3501093387603716\n"
     ]
    }
   ],
   "source": [
    "for t in unique_types:\n",
    "    print(t, ' fit total:', bmrk.loc[bmrk['type'] == t]['save_to_csv'].sum())"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}