4.év Mérnoki Informatika BBTE Matematika és Informatika.

Az előadások a következő témára: "4.év Mérnoki Informatika BBTE Matematika és Informatika."— Előadás másolata:

1 4.év Mérnoki Informatika BBTE Matematika és Informatika

2 Molekuláris Dinamika szimuláció (MD) meg akarjuk határozni a rendszert alkotó atomok, molekulák helyét (x,y,z) minden időpontban x(t), y(t), z(t) Ehhez meg kell oldjam a mozgásegyenletet minden részecskére

3 A mozgásegyenlet általában a klasszikus Newton II. törvénye: f = ma ahol az f a részecskére ható összes erőt jelenti ez függ a részecske helyzetétől de a többi részecske helyzetétől is – csatoltak az egyenletek, muszály egyszerre megoldani őket. Numerikusan, lépésről lépésre oldjuk meg őket

4 Minden lépésben kiszámoljuk az összes erőt az összes részecskére (poziciókból, sebességektől) elmozdítjuk az összes részecskét egyszerre nullázzuk az erőket Ismételjük ezt a lépést

5 Futás közben megkapjuk a részecskék pozicióját (x(t0),x(t1),x(t2),x(t3), …) – ebből a mikroszkopikus adatból bármit ki tudunk számolni ami a rendszerre jellemző (makroszkópikus jellemzőket is) statisztikai számításokat végezhetünk  futás közben  utólagos feldolgozás közben

6 Az MD szimuláció megengedi hogy bármilyen mennyiséget kiszámoljunk, mert minden adat a rendelkezésünkre áll (hiszen minden egyes atom helyzetét tudjuk) A kísérletekben nem minden adat áll rendelkezésre (pl az egyedi atomok poziciója nem, csak átlagolt, makroszkopikus mennyiségek mérhetők)

7 MD – Kísérletek Azon mennyiségekkel amelyek mindkettőből kiszámolhatók(mérhetők), lehet ellenőrizni hogy mennyire jó a modell Ha ezek a mennyiségek egyeznek, akkor az MD betekintést nyújthat olyan részletekbe amit másképp nem tudnánk tanulmányozni, megérthetünk mechanizmusokat, stb.

8 MD léptetés egy adott időpillanatban ismerjük x(t), v(t) és a(t)-t és meg akarjuk őket határozni egy későbbi t+dt időpontban: x(t+dt ), v(t+dt ) és a(t+dt) mivel a differenciál egyenletet helyettesítettük egy véges diffrenciákkal dolgozó egyenlettel, veszítünk a pontosságból. A jó léptető algoritmusok azok amelyek gyorsak és minél pontosabbak.

9 MD léptetés – Leapfrog x i = x i-1 + v i-(1/2) Δt a i = f(x i ) v i+(1/2) = v i-(1/2) + a i Δt

10 MD léptetés – Leapfrog Ez a módszer O2 pontosságú, de nagyon stabil, időben reverzibilis (energiamegmaradás) pl. harmonikus mozgásra nem vezet be szisztematikus hibát:

11 MD léptetés – Velocity Verlet algoritmus v i+1/2 = v i + a i Δt/2 x i+1 = x i + v i+1/2 Δt a i+1 = 1/m*f(x i+1 ) v i+1 = v i+1/2 + a i+1 Δt/2 előnye, hogy adott úgy az x,a mint a v minden időpontban (ha a számolásokhoz kellett a sebesség, a leapfrog nem tartja meg ugyanabban az időpontban)

12 BD léptetés – Brownian Dynamics A Brownian Dynamics egy egyszerűbb rendszert ír le: ebben a rendszerben nagyon nagyok a súrlódási erők, ezért minden mozgás csak az erők miatt történik, ha megszűnik az erő, azonnal lefékezik a mozgást a súrlódási erők.

13 Robert Brown Brown-mozgás

14 f+f s = ma ahol a súrlódási erő: f s = -ηv a=0 (instant beáll a végső értékre) ηv = f ηdx/dt = f dx =1/η f dt (x = x + f dt, η=1) ez az egyenlet nem tartalmaz másodfokú differenciált, csak elsőfokút, egyszerűbb integrálni

15 Hogyan tudjuk felgyorsítani az MD szimulációs kódunkat? Több trükk is létezik hozzá Mielőtt optimizálnánk a kódot, jó megvizsgálni azt hogy melyik része az ami a legtöbb ideig fut, hol lehet a legtöbbet elérni a gyorsítással: profiling (gprof, cachegrind,valgrind) a gprof a legegyszerűbb, leggyorsabb

16 Általában a legtöbb időt a kölcsönhatási potenciál számolása veszi el. Ez az a rész ami a legtöbbször végrehajódik és itt minden nyereség számít. 1000 részecske 1,000,000 időlépés ~10 12 számítás egy futattás során és ez egy kis rendszer. A mai processzoroknak ez nem olyan sok művelet

17 Ahhoz hogy megértsük azt hogy mi kerül sok időbe, meg kell érteni azt hogy egy program mikor processor bound és mikor memory bound processor bound: a futási sebességét az határozza meg hogy milyen gyorsan tud a processzor műveleteket végezni: mindig minden adat kéznél van

18 memory bound: a futási sebességét az határozza meg hogy mikor tud a processzor az adathoz hozzáférni, a műveleteket sokkal gyorsabban el tudná végezni de az adat nincs kéznél, keresgélni kell a memóriában utána Erre találták ki a cache-t, hogy lehetőleg ott legyen az adat azt elérni gyorsabb mint a memóriában keresgélni

19 A cache-nek különböző szintjei vannak, L1 level 1 cache a leggyorsabb és legkisebb, L2 nagyobb és lassúbb és így tovább végrehajtás közben a processzor prediktál: előrejelez

20 cache miss: ha az adat nincs benn a cache-ben akkor van egy cache miss azalatt az adatot keresgélik a memóriában nagyon nem mindegy hogy hogyan van megírva a szimuláció, a kompiler nem érti a számítások logikáját, ezért a programozó kell optimálisan megírja a kódot

21 cache miss kivédése: ha lehet erre kell koncentrálni, legyen helyben az adat, ha az adat betöltődött a cache-be akkor dolgozzunk vele amennyit csak lehet számítások csökkentése: ha nem rontjuk el vele a processor bound-ságot akkor ha lehet csökkentsük a számításokat

22 számítások csökkentése 1.lépés Newton III. törvénye felhasználhatjuk azt hogy a hatás és a ellenhatás ugyanakkora csak ellenkező előjelű – i és j részecskék között az erő f ij =-f ji ezt elég egyszer kiszámolni és mindkét részecskén tárolni. Ha a számítást végezzük rajtuk, már a cacheben vannak (ha jól tároljuk őket, azaz rendezve vannak)

23 számítások csökkentése 2.lépés Erők tabulálása mivel mindig ugyanazt a potenciált használjuk, ahelyett hogy behelyettesítsünk a képletbe minden egyes alkalommal egy r-et, előre kiszámolt r értékekre tabulálunk … sok apró lépésre felosztjuk a lehetséges r tartományt és egyer mindegyikre kiszámoljuk az f-et

24 számítások csökkentése 2.lépés Erők tabulálása jobb nem r hanem r 2 függvényében tárolni és jobb nem f-et hanem f/r-et tárolni nem mindig éri meg ezt a lépést megtenni, van amikor cache misshez vezet és olcsóbb lenne mindig újraszámolni (egyszerű képletek esetén)

25 számítások csökkentése 2.lépés Erők tabulálása dx = x i – x j dy = y i - y j dr 2 = dx*dx + dy*dy ezért érdemes dr 2 szerint tabulálni fx = f *dx/dr fy = f* dy/dr ezért érdemes f/r-et tárolni

26 számítások csökkentése 3.lépés Verlet szomszédsági lista Ez az a csel amivel nagyon nagyon fel lehet gyorsítani a programot. Egy olyan potenciálunk kell legyen ami levágható. Ha ez teljesül akkor elérhetjük azt hogy sokkal kevesebb számolást végezzünk N 2 ről Nlog(N)re lehet átmenni (futási idő függése a rendszer méretétől)

27 számítások csökkentése 3.lépés Verlet szomszédsági lista Ha mindenkit mindenkivel kölcsönhatásba léptetek, akkor N(N-1) számítást kell elvégezzek. Newton IIIal N(N-1)/2 –t. De igazán nem is kellene mindenkit mindenkivel állandóan kiszámoljak: megjegyezhetném kik vannak közel

28 számítások csökkentése 3.lépés Verlet szomszédsági lista Pl legyen egy 50x50-es doboz, 2000 részecske. Potenciál levágása: 4.0 távolságnál Mindenki mindenkivel: 2000*1999/2 ~ 10 6 Csak akik szomszédok: 2000*ρ*πr 2 ~80,000 ρ=2000/(50*50)= 0.8 ; r = 4.0

29 számítások csökkentése 3.lépés Verlet szomszédsági lista A listát kicsit nagyobbra kellene csinálni mint amekkora a potenciál levágási határa, azért hogy ne kelljen minden lépésben újraszámolni kik a szomszédok (akkor nem csináltunk semmit)

30 számítások csökkentése 3.lépés Verlet szomszédsági lista

31 Listaméret optimizálása: nagyobb lista – kevesebbszer kell újraépíteni de többet kell számolni kisebb lista - többször kell újraépíteni de kevesebbet kell számolni pl. 1.5x a levágási határ jó kompromisszum sok esetben(kolloid rendszereknél ezt használom)

32 számítások csökkentése 3.lépés Verlet szomszédsági lista Listaméret optimizálása: nagyobb lista – kevesebbszer kell újraépíteni de többet kell számolni kisebb lista - többször kell újraépíteni de kevesebbet kell számolni pl. 1.5x a levágási határ jó kompromisszum sok esetben(kolloid rendszereknél ezt használom)

33 számítások csökkentése 3.lépés Verlet szomszédsági lista Mikor építsem újra a listát? Egyik lehetőség az hogy egy fix időlépés után. Ez nem annyira jó megoldás mert nem garantálja hogy minden rendben van – és potenciálisan túl gyakran fogom csinálni

34 számítások csökkentése 3.lépés Verlet szomszédsági lista Mikor építsem újra a listát? A másik lehetőség az hogy minden részecske számolja azt hogy mennyit mozdult el az utolsó frissítés óta, és ha eleget mozdult egyetlen részecske ahhoz hogy átmehetett volna a külső körből a belsőbe, akkor triggerel és újraépítjük a listát ez az elmozdulás az utolsó lépés óta amúgy is ki van számolva a rendes léptetésnél

35 számítások csökkentése 3.lépés Verlet szomszédsági lista Mikor építsem újra a listát? A másik lehetőség az hogy minden részecske számolja azt hogy mennyit mozdult el az utolsó frissítés óta, és ha eleget mozdult egyetlen részecske ahhoz hogy átmehetett volna a külső körből a belsőbe, akkor triggerel és újraépítjük a listát ez az elmozdulás az utolsó lépés óta amúgy is ki van számolva a rendes léptetésnél

36 számítások csökkentése 4.lépés Verlet szomszédsági cellák Ahelyett hogy végigmenjek mind az N(N-1) lehetőségen a cellák újraépítésekor, minden részecskét hozzárendelek egy cellához. Ez könnyű, mert csak egy modulo osztás kell hozzá. Ezután a cellák segítségével kevesebb részecskével kell ellenőrizzek minden részecskét, hogy szomszédok-e

37 számítások csökkentése 4.lépés Verlet szomszédsági cellák a nagy kör nem lehet több mint 3 cellaméret

38 számítások csökkentése 4.lépés Verlet szomszédsági cellák Minden cella egy láncolt listában tárolhatja azt hogy melyik részecskék vannak a cellában. A listák feje egy kétdimenziós pointer-lista, a next item pointer pedig minden részecskének lehet egy belső változója Pinning site-oknál is lehet ezt alkalmazni, csak ott nem kell újraépíteni a listát, mivel a pinning siteok általában nem mozdulnak el

39 cache missek csökkentése 5.lépés Térkitöltő görbék alkalmazása A cache úgy prediktálja azt hogy milyen adatokra van szüksége a program futása közben, hogy amikor egy beolvasás történik, akkor nem egyetlen változót olvas be a memóriából, hanem a körülötte levő környezetet is beolvassa. Így ezek már a cache- ben lesznek egyetlen cache miss után

40 cache missek csökkentése 5.lépés Térkitöltő görbék alkalmazása Egy egyszerű példának vegyünk egy mátrix szorzást. Nem mindegy az hogy sor vagy oszlop formájában tároljuk el az információt: ha sort olvasunk (első mátrix), akkor kevesebb cache miss-ünk lesz, ha oszlopot akkor minden elemnél van egy cache miss

41 cache missek csökkentése 5.lépés Térkitöltő görbék alkalmazása Amikor egy elemet beolvas a memóriából, akkor beolvassa az előtte és utána levő elemeket is

42 cache missek csökkentése 5.lépés Térkitöltő görbék alkalmazása A mi esetünkben minden részecske tartalmaz adott infomációkat (x,z,y koordináta, töltés, stb.) és mindig a szomszédos részecskék közötti kölcsönhatásokat számoljuk. Jó lenne hogyha azok a részecskék amelyek szomszédosak térben, a memóriában is szomszédosak lennének. Erre jó a térkitöltő görbe. Segítségével olyan indexeket kaphatunk, amelyekkel sorbarendeyhetjük a részecskéket, úgy, hogy a térben szomszédos részecskék a memóriában is szomszédosak legyenek.

43 cache missek csökkentése 5.lépés Térkitöltő görbék alkalmazása Többfajta térkitöltő görbe létezik. Két gyakran használt görbe a Morton és a Hilbert görbék (ezek a görbék mind fraktálok). A Mortont lehet könnyebben kiterjeszteni 3D-re. A térkitöltő görbe végtelen rendben kitölti a tér minden pontját. Mivel véges számú részecskénk van, csak egy adott rendig kell elmenni ahhoz hogy minden részecskének külön indexe legyen.

44 cache missek csökkentése 5.lépés Térkitöltő görbék alkalmazása

45

46 a görbe mentén generálhatunk indexeket amik alapján rendezhetjük a vektorban a sorrendet