You are on page 1of 6

Tema de casa 1 ­ Paralel “Game of Life” 

 
Data publicarii: 17 noiembrie 2013 
Data ultimei modificari a enuntului: 17 noiembrie 2013 
Termenul de predare: 8 decembrie 2013 ora 23:59 
Autor: Grigoras Marius ­ Viorel (grigoras.marius.viorel@gmail.com) 
 
1. Obiective: 
 
Dupa realizarea acestei teme de casa, studentul va fi capabil sa: 
● proiecteze un algoritm paralel pornind de la un algoritm secvential pentru problema 
“Game of Life” 
● foloseasca directivele OpenMP pentru a implementa algoritmul proiectat 
 
Cunostintele necesare rezolvarii acestei teme de casa: 
● programare in C si OpenMP 
● lucrul cu matrici si caractere 
 
 
2. Enuntul problemei: 
 
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 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 2 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. 
 
 
3. 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. 
 
 
4. Cerintele temei 
 
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). 
Programul 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. 
 
 
5. Formatul datelor de intrare/iesire 
 
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. 
 
6. Detalii de implementare, compilare si corectare/testare 
 
● Celule populatiei se vor memora in variabile de tip char (puteti folosi si bitSet­uri, 
matricea poate fi m*n, deci nu e sigur ca va fi multiplu de 8) 
● Modularizati cat mai mult posibil implementarea programului. 
● compilarea temei se va face pe un sistem linux (Ubuntu) folosindOpenMP 
● realizati un fisier makefile pentru compilarea temei cu 2 target­uri: 
○ clean ­ va sterge fisierele temp si obiect 
○ build ­ va forma executabilul pgol 
● deadline­ul este hard (orice intarziere va avea ca rezultat notarea cu 0p a temei) 
● trimiterea temelor se va face la adresa grigoras.marius.viorel@gmail.com cu 
urmatoarele cerinte: 
○ sursele (cod, readme + makefile) vor fi puse direct intr­o arhiva .zip 
○ subiectul e­mailui va fi: [APD][TEMA1][GRUPA]NumePrenume . Un exemplu 
[APD][TEMA1][E214B]PopescuIon 
● tema are un checker cu 9 teste publice ­ fiecare test va valora 1p ­ in total 9p din 10p 
disponibile 
○ daca numarul de linii sau numarul de coloane este mai mic decat 3, atunci 
configuratia este invalida si va trebui sa printati in fisierul output: “configuratie 
invalida\n” si sa returnati 0 (success) 
○ pentru a rula checker­ul e de ajuns sa va puneti fisierele din tema direct in folderul 
checker si sa executati ./checker.sh 
○ checker­ul este disponibil la adresa [4] (click pe Fisier (partea stanga) ­> 
descarcati). 
● 1p va fi pentru implementare (voi tine cont de regulile de aici [1] ­ bineinteles, unde se 
aplica). Eu voi acorda/corecta tema doar pentru acest punct, restul de 9p sunt “acordate” 
de checker pentru functionalitate (Atentie! cine va implementa tema serial va primi 0 
puncte) 
● Atentie mare la temele copiate ­ toate vor fi verificate cu [3] ­ cine este prins, nu va intra in 
examen. Tema este destul de usoara si elementele originale sunt greu de distins, deci nu 
colaborati! Atentie si la codul care este public pe internet sau din alte surse ­ tema va fi 
verificata si pentru cod luat de pe internet. 
● tips and tricks care va pot ajuta pentru codul C [2]  
 
 
[1] http://ocw.cs.pub.ro/courses/so/teme/general 
[2] http://ocw.cs.pub.ro/courses/so/laboratoare/resurse/c_tips 
[3] http://theory.stanford.edu/~aiken/moss/ 
[4] https://drive.google.com/file/d/0BwBusujwKYrTemFFOXN5cGZqRkU/edit?usp=sharing 
 
Resurse optionale: 
● 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/