Operația de reduce (cunoscută în limbajele funcționale - Haskell, Racket - drept fold) reprezintă un tip de operație prin care elementele unei colecții sunt restrânse / acumulate într-un singur rezultat, printr-o singură operație aplicată între elementele unei colecții (+, *, min, max etc.)

Exemplu:

l = [1, 2, 3, 4, 5, 6]
op = +
rezultat = 1 + 2 + 3 + 4 + 5 + 6 = 21

În MPI, operația reduce este implementată în funcția MPI_Reduce, însă în cadrul laboratorului vom discuta cum poate fi implementată, de mână, această operație în MPI.

Aici aveți atașate slide-uri, care descriu în detaliu pașii de implementare ai operației reduce: slides

În concluzie, primul proces va avea valoarea finală.

Pseudocod:

for (pas = 2; pas <= nr_procese; pas *= 2)
	if (rank % pas == 0)
		primește de la procesul cu rank-ul [rank + (pas / 2)]
		adună
        else if (rank % (pas / 2) == 0)
                trimite la procesul cu rank-ul [rank - (pas / 2)]

Operația de scan este similară operației de reduce (acumularea elementelor unei colecții într-un singur rezultat). Diferența față de reduce este că ultimul proces din comunicator deține rezultatul final, practic scan reprezintă inversul lui reduce. În plus, fiecare proces are un rezultat parțial acumulat, în sensul că procesul 0 are valorea P0, procesul 1 are valoarea P0 + P1, procesul 2 are valoarea P0 + P1 + P2, etc.

Exemplu:

l = [1, 2, 3, 4, 5, 6]
op = +
rezultat = 1 + 2 + 3 + 4 + 5 + 6 = 21

Pași:
[1, 2, 3, 4, 5, 6]
[1, 3, 3, 4, 5, 6]
[1, 3, 6, 4, 5, 6]
[1, 3, 6, 10, 5, 6]
[1, 3, 6, 10, 15, 6]
[1, 3, 6, 10, 15, 21] -> rezultatul este 21

Aici aveți atașate slide-uri, care descriu în detaliu pașii de implementare ai operației scan: slides

Pseudocod:

for (pas = 1; pas < nr_procese; pas *= 2)
	if (rank + pas < nr_procese)
		trimite la procesul cu rank-ul [rank + pas]
        if (rank - pas >= 0)
                primește de la procesul cu rank-ul [rank - pas]
                adună 

Operația de broadcast este o operație prin care un proces trimite o valoare tuturor proceselor din cadrul comunicatorului. Această operație este reprezentată, în MPI, de MPI_Bcast (remember laboratorul 8).

Aici aveți atașate slide-uri, care descriu în detaliu pașii de implementare ai operației broadcast: slides

Pseudocod:

for (pas = 1; pas < nr_procese; pas *= 2)
	if (rank < pas and rank + pas < nr_procese)
		trimite la procesul cu rank-ul [rank + pas]
        else if (rank >= pas and rank < pas * 2)
                primește de la procesul cu rank-ul [rank - pas]

În domeniul de computer science, un pipeline reprezintă un concept folosit în proiectarea procesoarelor și al echipamentelor hardware prin care se crește numărul de instrucțiuni ce sunt executate într-o unitate de timp.

Acest concept poate fi extins în MPI, unde un proces produce rezultate intermediare, care sunt transmise către procesul următor, care procesează și prelucrează rezultatele primite, pe care le trimite mai departe, către procesul următor, totul repetându-se până la ultimul proces.

Slides cu explicații și exemple: slides

Un polinom, în matematică, reprezintă o ecuație de tipul: f(x) = x^2 + 2 * x + 1, unde x reprezintă variabila din ecuație.

În MPI, putem calcula un polinom folosind tehnica pipeline în felul următor: numărul de coeficienți va fi egal cu numărul de procese (care este egal cu numărul de pași din procesul de pipeline). În cazul exemplului de mai sus, o să avem 3 procese, fiecare proces corespunzând cu câte un coeficient din ecuație.

Aici aveți atașate slide-uri, care ilustrează pas cu pas: slides

Dându-se un vector cu n elemente în ordine aleatoare, dorim să-l sortăm prin metoda pipeline, folosind MPI. Pentru aceasta, vom folosi o rețea cu n + 1 noduri (1 master și n workeri).

Punctul final este momentul în care fiecare proces worker deține stocat unul din numerele din vectorul inițial, iar rank[i]→saved_value < rank[i + 1]→saved_value pentru orice i din [1, n).

Fiecare worker este inițializat la început cu o valoare (-1 sau depinde de restricții), va primi (n - rank) numere de la rank-ul anterior și va trimite mai departe rank-ului următor (n - rank - 1) numere.

Atunci când primește un număr, worker-ul îl va compara cu valoarea stocată:

• dacă nr < saved_value, atunci salvăm noua valoare și o trimitem pe cea veche procesului următor
• dacă nr >= saved_value, atunci o trimitem direct procesului următor

La final, fiecare worker va trimite către master valoarea lui, iar master-ul va construi vectorul rezultat. Urmăriți slide-urile pas cu pas: slides

Rank Sort este un algoritm de sortare a unui vector folosindu-se de rangul fiecărui element din vector. Rangul unui element presupune câte numere sunt mai mici decât el în vector.

Pași:

1. Se calculează rangul fiecărui element: pentru fiecare element din vector v[i], unde 0 ⇐ i < N (N - dimensiunea vectorului), se numără câte elemente din vector v[j], j != i sunt mai mici: v[j] < v[i], 0 ⇐ i, j < N, i != j.
2. Elementul de pe poziția “i” va fi pe poziția “rang” în noul vector sortat: q[rank] = v[i].

Pseudocod serial:

for i = 0 to N
    for j = 0 to N
	if v[i] > v[j]
		rank[i]++

for i = 0 to N
    results[rank[i]] = v[i]

Algoritmul “Parallel rank sort” are ca scop paralelizarea pasului 1. Rangul fiecărui element poate fi căutat în paralel, adică fiecare proces sau fir de execuție va realiza căutarea rangurilor pentru elementele din intervalul său: [start, end).

Complexitatea temporală a algoritmului este O(n^2), ceea ce face complexitatea în cazul paralelizării pasului 1 a lui să devină O(n^2 / p), p - numărul de procesoare / fire de execuție.

Aici aveți atașate slide-uri, care ilustrează pas cu pas: slides

Schelet laborator

1. Implementați operația de reduction, unde fiecare proces are o valoare proprie, prin care avem o colecție de valori (a nu se folosi MPI_Reduction)
2. Implementați operația de scan, unde fiecare proces are o valoare proprie, prin care avem o colecție de valori (a nu se folosi MPI_Scan)
3. Implementați operația de broadcast, prin care procesul 0 trimite o valoare tuturor proceselor (a nu se folosi MPI_Bcast)
4. Implementați operația de calcul polinomial folosind pipeline, pentru f(5), unde f(x) reprezintă ecuația polinomială (construită prin citirea din fișier existentă în scheletul de cod, unde aveți hint-uri legate de implementare). Pentru testare, există două fișiere de test pentru input (a1.txt și a2.txt) și puteți să vă folosiți de oricare dintre ele, cu precizia că numărul de procese trebuie să fie același cu numărul de coeficienți. Pentru ușurință în testare, puteți folosi regulile run1 și run2 din Makefile.
5. Implementați sortarea prin pipeline, folosind scheletul de laborator și explicațiile din laborator și slide-uri
6. Să se sorteze un vector folosindu-se algoritmul Rank Sort. Procesul master va genera vectorul și îl va popula cu elemente. Va trimite tot vectorul celorlalte procese. Fiecare proces este responsabil pentru calcularea pozițiilor unei anumite părți din vector. La final toate procesele trimit procesului master noile poziții calculate. Procesul master va aranja elementele conform noilor poziții primite.

Aici aveți atașate resurse suplimentare (slide-uri) legate de conceptele din cadrul acestui laborator, ce pot fi utile pentru testele practice.