Tema de casă #1 – Parallel “Game of Life”

Responsabil de temă: Florin Pop

Data publicării: 19.10.2007

Data ultimei modificări a enunţului: 19.10.2007
Termenul de predare: 08.11.2007

Obiective
După realizarea acestei teme de casă studentul va fi capabil să:

• proiecteze un algoritm paralel pornind de la un algoritm secvential pentru problema “Game of Life”.

• folseasca directivele OpenMP pentru a implementa algoritmul proiectat.

• estimeze marimile care masoara performanta algoritmului paralel proiectat.

Cunoştinţele necesare rezolvării acestei teme de casă:

• programare in C si OpenMP.

• lucrul cu matrici si caractere.

Enunţul problemei

1. Introducere. Regulile “jocului”

Pentru modelarea unor populatii de indivizi, matematicianul britanic J. H. CONWAY a introdus in anul 1970 regulile jocului
"Game of Life". Acesta nu este chiar un joc, deoarece nu este nevoie de interactiunea cu utilizatorul (este un “zero player
game”) fiind doar o evolutie, dupa anumite reguli, a unei colonii de organisme vii.

Jocul se desfasoara pe o suprafata dreptunghiulara impartita in celule (ca in figura de mai jos). Spunem ca o celula este
ocupata daca acolo se afla un organism viu, altfel spunem ca celula respectiva nu e ocupata. Celulele ocupate se
considera a fi in viata, celelalte fiind moarte. La fiecare noua generatie unele organisme pot muri altele pot deveni vii.

Regulile jocului sunt urmatoarele:

1. Vecinii unei celule sunt sunt cele 8 celule din jur cu care exista cel putin un punct de contact (pe orizontala, pe
verticala sau pe diagonala).
2. Daca o celula este vie, dar nu are nici un vecin viu, sau doar un singur vecin viu, atunci ea va muri de singurate
in generatia urmatoare.
3. Daca o celula este in viata si are patru sau mai multi vecini vii, atunci ea va muri "sufocata" in generatia
urmatoare.
4. O celula cu doi sau trei vecinii vii va trai si in generatia urmatoare.
5. O celula moarta va invia in generatia urmatoare doar daca are exact trei vecini vii in generatia curenta. Celelalte
celule moarte vor ramane moarte si in generatia urmatoare.
6. Toate nasterile si mortile au loc simultan - o celula care moare poate ajuta sa dea nastere la una noua (intr-o
celula vecina) in generatia urmatoare, dar nu poate preveni moartea unei celule vecine.
Numim configuratie modul in care sunt aranjate pe tabla de joc celulele vii si moarte intr-o generatie. Trecerea dintr-o
configuratie in alta se face conform regulilor de mai sus.

Figura 1. Tabla de joc pentru “Game of Life” ilustrand trei situatii posibile.

Vom considera ca fiecare celula are 8 vecini. Astfel celulele din prima linie se vor invecina in partea de sus cu celulele din
ultima linie, iar celulele din ultima linie se vor invecina in partea de jos cu cele din prima linie. Analog se petrec lucrurile cu
prima si ultima coloana. Celula din colt va avea ca vecini cele trei celule din jurul ei, cele doua din ultima linie (primele 2
coloane), cele doua din ultima coloana (primele 2 linii) si cea din coltul diagonal opus, de jos. Analog pentru celelate
colturi ale tablei de joc.

Pentru a implementa regulile de trecere de la o generatie la alta se vor folosi 2 zone de memorie. In prima se retine
configuratia initiala, iar in a doua configuratia finala. Daca folositi o singura zona de memorie riscati sa nu obtineti
rezultatele corecte.

2. Implementarea paralela a problemei

Simularea trecerii de la o generatie la alta se va face in paralel folosind conceptul de memorie partajata. Implementarea
se va face in OpenMP. Vom cosidera ca avem o tabla de joc de dimensiune n x m si un numar de procesoare ce pot lucra
in paralel p, cu restrictia p <= min(n,m).

Problema se poate rezolva prin descompunerea tablei de joc in regiuni, fiecare procesor primind o regiune a tablei.
Descompunerea se poate face ca in figura 2.

Descompunere orizontala Descompunere verticala

Figura 2. Metode de descompunere pentru paralelizare

Aplicatia voastra va simula un numar de iteratii ale jocului, folosind doar doua zone de memorie. La finalul unei
succesiuni de aplicare a regulilor se va inlocui generatia veche cu cea noua. Copierea unei zone de memorie in alta se
va face in paralel, folosind toate procesoarele.
 3. Cerintele temei

3.1. Analiza algoritmului paralel

Reaspundeti la urmatoarele intrebari:
a. Fara a considera ca avem un numar fix de procesoare, care dintre cele doua cazuri de descompunere
prezentate in figura 2 conduc catre o solutie eficienta? Demonstrati de ce.
b. Fiecare procesor va lucra pe o zona de date, in unul din cele doua cazuri expuse in figura 2 (cazul evidentiat
la punctul a). Ce informatie se va accesa in comun de catre procesoare? Cum este informatia transmisa intre
procesoare?
c. Este necesara sincronizarea procesoarelor? Daca da, cum se va face acest lucur? Daca nu, demonstrati.
d. Cat este timpul paralel de calcul, speed-up-ul si eficienta algoritmului paralel? Explicati modul de calcul.
Raspunsurile la intrebari se vor scrie in fisierul: analiza.txt.
3.2. Implementarea algoritmului
Implementati algoritmul de simulare pentru “Game of life” conform cu raspunsurile date la intrebarile din sectiunea
anterioara. Implementarea se va face in OpenMP. Numarul de procesoare va fi identificat de variabila de mediu
OMP_NUM_THREADS (nu setati manual in program numarul de procesoare).
Progamul va citi in paralel datele de intrare. Fiecare procesor va deschide fisierul de intrare, se va pozitiona in el si va
citi un numar de linii. Rezultatul va fi scris de master in fisierul de iesire.

4. Formatul datelor de intrare/ieşire

Programul va incarca configuratia initiala dintr-un fisier primit ca parametru al liniei de intrare. In fisierul text se afla o
matrice n x m care contine elementele maticii, codificate astfel: 0 = celula moarta, 1 = celula vie.

Rezultatul se va scrie intr-un fisier de iesire care are acelasi format cu cel de intrare.

Numarul de iteratii pentru care se va simula jocul este dat ca parametru al liniei de comanda. Un exemplu de executie
este:

./pgol <generations> <initial_board_file> <final_board_file>

Argumentele liniei de comanda au urmatoarea semnificatie:

• <generations>: numarul de generarii.

• <initial_board_file>: fisierul ce contine datele de intrare. Pe prima linie sunt 2 numere naturale, despartite printr-un
spatiu, ce reprezinta dimeniunea tablei. Liniile urmatoare contin configuratia initiala. Elementele unei linii pot fi 0 sau 1 si
sunt despartite printr-un spatiu.

• <final_board_file>: fisierul cu configuratia finala.

4. Detalii de implementare si compilare

● Celule populatie se vor memora in variabile de tip char.

● Modularizati cat mai mult posibil implementarea programului.

● compilarea temei se va face pe un sistem linux folosind Omni OpenMP Compiler (http://phase.hpcc.jp/Omni/).

● realizati un fisier makefile pentru compilarea temei.

Resurse (opţional)

• Conway’s Game of Life at Wikipedia, http://en.wikipedia.org/wiki/Conway's_Game_of_Life

• Life at Mathworld, http://mathworld.wolfram.com/Life.html
• LLNL OpenMP Tutorial, http://www.llnl.gov/computing/tutorials/openMP/