wiki:SolarSim

Solar System Simulator

  • Membri echipei: Marius Ion - mion, Monica Tudora - mtudora
  • Descriere proiect: Simularea sistemului solar.

Activitate proiect

Completati ce veti face in fiecare etapa a proiectului

  • 12 Nov 2009 - 14 Ian 2010
    - Documentare:
     Problema nbody, si modelul matematic al sistemului solar.
     http://en.wikipedia.org/wiki/N-body_problem
     http://en.wikipedia.org/wiki/N-body_simulation
     http://en.wikipedia.org/wiki/Newton%27s_law_of_universal_gravitation
     http://en.wikipedia.org/wiki/Kepler%27s_laws_of_planetary_motion
    
    - Implementare seriala a algoritmului in C:
     La fiecare pas din simulare, se calculeaza interactiunile intre particule folosind legea atractiei gravitationale
     a lui Newton si apoi se modifica pozitiile si vitezele particulelor folosind ecuatiile miscarii ale lui Galilei.
     Este necesar un interval de timp mic intre pasii de simulare, pentru a mentine precizia simularii, deci un numar
     mare de pasi de simulare.
    
    - Implementare interfata grafica minimala in JAVA:
     Este necesara pentru a verifica daca orbitele obtinute ale planetelor sunt conforme cu realitatea. Am folosit ca
     date de start pozitia si viteza pamantului la periheliu. Precizia algoritmului serial este ok.
    
    - Paralelizarea algoritmului folosind instructiuni SSE
     Deoarece procesoarele pe care rulam sunt Intel Xeon, folosim Intel Compiler si SSE intrinsics. Pentru precizie
     float, operatiile cu vectori se executa de trei ori mai repede, iar pentru double, de doua ori. Asta din cauza ca
     registrele pentru SSE sunt de 128 de biti, si un vector float incape intr-un singur registru, iar un vector double
     incape in doua registre.
     http://www.intel.com/cd/software/products/asmo-na/eng/347603.htm
    
    - Prelucrarea datelor de intrare
     Pentru a vedea imbunatatiri de timp la algoritmul folosind OpenMP, avem nevoie de mai multe particule. Calculam
     un nou set de valori de intrare pornind de la datele extrase din Astronomer's Almanach(sursa-US Naval Observatory)
     Este nevoie sa convertim datele din elemente orbitale de tip kepler in coordonate carteziene. Documentare si apoi
     scrierea unui script in matlab care sa produca datele de intrare.
     http://en.wikipedia.org/wiki/Orbital_elements
     http://asa.usno.navy.mil/SecE/2008/Osculating_Elements_2008.txt
     http://www.mathworks.com/matlabcentral/fileexchange/13439-orbital-mechanics-library
    
    - Prima paralelizare a algoritmului folosind OpenMP 
     Am paralelizat fiecare bucla for cu #pragma omp parallel for. Rezultatele sunt mai proaste decat la alg serial.
    
    - A doua varianta de paralelizare a algoritmului
     Folosim paradigma bag of tasks. La inceput, master-ul calculeaza task-urile care sunt de forma unor perechi (i,j)
     si astfel se inlocuiesc cele doua bucle for i for j de la calculul acceleratiilor cu o singura bucla. Fiecare
     thread calculeaza local acceleratiile, iar apoi se face o operatie de reducere. Astfel sunt eliminate regiunile
     critice. Obtinem load balancing mai bun, dar performantele lasa de dorit comparativ cu varianta seriala. Incepem sa
     lucram si la interfata 3d folosind Java bindings for OpenGL (jogl).
    
    - A treia varianta de paralelizare a algoritmului
     Suspectam ca problema este ca la fiecare pas al simularii, se pornesc si se opresc threadurile de prea multe ori,
     asa ca modificam algoritmul astfel incat threadurile sa porneasca o singura data, la inceputul simularii, si sa se
     opreasca la final. Apare necesitatea unei bariere la sfarsitul fiecarui pas de simulare. Performantele tot nu sunt
     multumitoare. Incercam sa generam aleator un numar mare de particule. Se vede ca penalizarile nu mai sunt la fel de
     mari, dar pentru un numar mare de particule, trebuie crescut intervalul de timp DT intre doi pasi de simulare, iar
     metoda aleasa pierde semnificativ din precizie.
    
    - Concluzii
     Algoritmul se poate paraleliza folosind instructiuni vectoriale, dar overheadul introdus de management-ul threadurilor
     nu justifica folosirea OpenMP. Acest lucru se datoreaza faptului ca numarul de instructiuni pe care un thread openmp
     le executa in o iteratie a unei bucle este comparativ sau chiar mai mic decat numarul de operatii necesare management
     -ului threadului.
    
    - Methoda Sochacki
     Documentare si implementare in java a algoritmului pentru metoda Sochacki. Metoda integreaza ecuatiile diferentiale
     ale pozitiilor si vitezelor particulelor, obtinand polinoame de ordin arbitrar de mare. Am rulat teste pentru
     2body problem: sistemul soare-pamant. Am vazut ca polinoamele aproximeaza corect functia pe durata unei revolutii
     a pamantului in jurul soarelui.
    
    - TODO
     Regenerarea polinoamelor periodic pentru a mari intervalul de precizie a metodei Sochacki. Implementarea algoritmului
     in C si reluarea procesului de optimizare.
    
Last modified 12 years ago Last modified on Jan 17, 2010, 6:20:14 PM

Attachments (5)

Download all attachments as: .zip