Sziasztok.
A problémám a következő. Adott egy nagyon sok lépésből konvergáló iteráció (pár 10millió általában), ami lévén iteráció, nem tudom jól szálakra bontani, mivel n, re épül n+1 (n az iteráció száma), viszont van egy ötletem. Addig addig patkoltam a dolgot, hogy egy vektorba rendezéssel, valamint egy kisebb deriválási tétel következménnyel, n+1 már számolható, ha n-et n+1 legalább 3-lépéssel lemaradva számolja mögötte. És ez folytatható n+2 n+3....-al. Na a kérdésem a kövektező. C, vagy Cpp-ben van e arra megoldás, hogy ha van egy nagy tömb, erre eresztek threadszám pointert, akkor n+1 szál addig várakozik, amíg n szál odébb nem áll X-el (jelen eseteben 3-al)?
Előre is köszönöm.
UI:
Egy kis részletesebb magyarázat, mert többen is kérték. Az adat amin dolgozok, egy pár 100k elemszámú sorvektor. Egy metódus egyszerűen végig szalad, most tegyük fel úgy hogy, ha 3.elemre mutat egy p pointer akkor a 3. elem értéke p=(p-3)+(p-2)+(p-1)+p+(p+3)+(p+2)+(p+1). majd lép egyet a pointer, és ugyanezt ismétli eggyel odébb. Persze a képlet nem ez de ez a lényeg. Kicsit olyan mint egy mozgóátlag. Mivel a megfelelő sorba rakást követően (valamint egy közelítés a derivál szabályból) az eredményre nincs hatással csak a p +-3-as környezete, így elvileg. a következő szál már indulhat is, ha a pointer nagyobb elemszámra mutat mint 4, hiszen minden eredmény készen van, ami kell a számításhoz.
Hozzászólások
Adok egy UP-ot a délutános műszaknak.
------
3 fajta matematikus létezik. Aki tud számolni, és aki nem.
Erdekesen hangzik, de nem teljesen ertem, hogy mukodik most.
- Az n+1. iteracio eredmenyehez kell az n. iteracio eredmenye?
- "n+1 már számolható, ha n-et n+1 legalább 3-lépéssel lemaradva számolja mögötte" - Ezt lehetne kicsit reszletesebben? Mi az, hogy 3 lepessel lemaradva?
- "akkor n+1 szál addig várakozik, amíg n szál odébb nem áll X-el (jelen eseteben 3-al)?" - Ha mindig csak egy szal dolgozik, akkor nem nyersz vele semmit, ha tobb szall dolgozik felvaltva.
Vagy ugy kell erteni, hogy n. iteracio eredmenyebol lehet szamolni n+1., n+2. es n+3. iteracio eredmenyet is?
Én se értem igazán. Az n. lépés számolgatása közben van egy pont, amikor már elindulhat az n+1 szmámítása? (Mert ebben az esetben pthread_cond_init, pthread_cond_wait, pthread_cond_signal/pthread_cond_broadcast - talán ami neked kell. Minden szál úgy indul - az első X db kivételével(?), hogy ellenőriz valamilyen feltételt. Ha nincs rá beállítva semmi, akor megy tovább - és beállít az őt követő szálnak egy feltételt. Aztán amikor már eljutott odáig, amikor elindulhat a következő szál, akkor elengedi. Ha meg a a pthread_cond_init által beállított változó nem engedi, akkor úgy se fut tovább.)
Nem egészen értem a problémát, de a válaszhoz ez nem is kell: igen, van rá megoldás. Szinkronizációnak hívják, legegyszerűbb esetben közös változókon keresztül. Ahogy nézem itt minden szál csak előre halad, így nagyon komolyan szinkronizációs védelem nem kell, akár még mutex nélküli közös változós móka is bejátszik, hiszen a szál csak előre halad, sosem fog ugyanazzal foglalkozni mégegyszer.
Standard C++ tartalmaz ilyen elemeket, de platformos és platformfüggetlen libek is foglalkoznak a témával.
----
Hülye pelikán
Valoszinuleg nem kene egyebkent mutexeket hasznalni, lockmentes szerkezetekkel is meg lehet oldani egyszeru eseteket. Bar kicsit reszletesebb informacio kellene.
----------------------
while (!sleep) sheep++;
Értem, most is hamarabb kérdeztem, minthogy gondolkodtam volna. Közben eszembe is jutott egy ötlet, ami lehet hogy csúnya, de egyszerű. Pl Adott 2 közös változót, + az adatvektor. Egyik változó az hogy hány szál futott le eddig (nevezzük t_end nek), 2. hogy hol tart a legkisebb indítóazonosítójú szál (nevezzük p_end nek). Ezekből könnyen megoldható a gond, hisz a legkisebb még futó indításazonosítójú, az a t_end+1, ez a szál írja a másik közös változót, hogy hol áll az ő pointere a p_end. Azok a szálak amik nagyobb azonosítóval rendelkeznek, mint a t_end+1, azok rendre maximálisan t_end+2 p_end-3, t_end+3 p_end-6... ig futhatnak. Ha t_end+1 befejezi a futást, akkor t_end-en léptet egyet, és ezzel t_end+2-es azonosítójú lép elő t_end+1-re, majd indít egy szálat. Tényleg. Kell még egy változó, amibe azt írom hogy mi la legnagyobb indításazonosító, mert nem praktikus több ezer szálat indítanom néhány cpu-magra. Logikusnak tűnik?
------
3 fajta matematikus létezik. Aki tud számolni, és aki nem.