Új hozzászólás Aktív témák

• #5587 joysefke veterán BeZol #5585

  Új Válasz 2017-04-28 15:06:51 #5587

  Új hozzászólás

  Összes hozzászólása itt Válaszok az összes hozzászólására itt Válaszok erre a hozzászólásra

  Privát üzenet küldése

  

  joysefke

  veterán

  válasz BeZol #5585 üzenetére

  Szoftveroldalról úgy néz ki a dolog, hogy egy futó program/alkalmazás a feladatkezelőben mint egy "processz" jelenik meg.

  1,
  Itt látod az (általad) elindított alkalmazásokat.

  Feladatkezelő -> Alkalmazások

  2,
  Megnézheted, hogy ez az alkalmazás milyen futó processzként van "számontartva"

  jobb klikk az alkalmazás nevén -> Go to Process (US Windowsom van, magyar winen nyilván magyarul valami hasonló)

  Infó:

  Egy processz legalább egy programszálból áll, de a processz több programszálat is kreálhat (többmagos processzorok kihasználása vagy egyszerűen a UI fennakadások elkerülése végett). Ez az alkalmazásfejlesztőre van bízva.

  Például ha van egy ablakos Windows programod, akkor célszerű lehet az ablaknak lenni egy fő szálnak, ami aszerint, hogy a felületen mit választasz ki (mit kell csinálni) dedikál munkát külön-külön dolgozó szálaknak, amelyek amikor végeznek, akkor az eredményt visszaadják a fő-szálnak, ami azt megjeleníti az alkalmazás ablakában. Ennek az az előnye, hogy a fő szál tulajdonképpen nincsen soha terhelés alatt, így az ablak mindig reszponzív tud(hat) maradni, akkor is ha az ablak igazából vár egy dolgozó szálra.

  Ha a dolgozó elkészült, akkor azt a programszál akár ki is léphet.

  3,

  programszálak megtekintése:
  Task manager-> View - Select columns (oszlopok kiválasztása) -> Threads (szálak )

  Itt megjeleneik egy oszlop, ami mutatja, hogy az alkalmazás mennyi szálat indított. Elég komoly számok fognak megjelenni Nekem ebben a pillanatban 1317 programszál van elindítva a Windowsban.

  Az hogy egy program indított kismillió szálat, még nem fogja azt jelenteni, hogy mindegyik egyszerre tud ezerrel tekerni, és egy sokmagos procit ki tudna maga az alkalmazás értelmesen használni.

  Infó:
  Programszálak vs "processzorszálak"

  Most tegyünk úgy, mintha nem létezne Hyperthreading (az csak bonyolítja a dolgokat, de valójában holt ugyanaz a koncepció) és egyetlen processzormag egyszerre egyetlen programszálat tudna végrehajtani.

  A program végrehajtása a programszálak (thread) végrehajtásával történik, tehát a programszál amelynek éppen dolga van, az valamelyik (az ütemező által kiválasztott) processzormagon fut, annak teljesítményét (órajelciklusok) és erőforrásait (regiszterek) osztatlanul élvezi. Tehát egyetlen programszál egyszerre egyetlen magon fog futni. Az elérhető legnagyobb CPU teljesítmény amit egyetlen programszál meg tud kapni (bármikor) az egyetlen mag teljesítménye. A programszálon múlik, hogy ezt a teljesítményt maximálisan kihasználja, de a korlát akkor is él: egy programszál nem fér egyszerre több CPU-teljesítményhez hozzá, mint a proci maximális egymagos teljesítménye.

  Ha a programozó azt szeretné (és hajlandó is érte tenni) hogy az alkalmazás több teljesítményhez férjen hozzá, mint egyetlen processzormag teljesítménye, akkor kénytelen az alkalmazásban több dolgozó-programszálat létrehozni, ezek a programszálak egyenként hozzá fognak férni (maximum) egy-egy processzormaghoz és annak teljesítményéhez. A probléma itt alapvetően a programozó vállán van, mert valahogyan az alkalmazás által megoldandó feladatot el kell tudnia több szál között osztania, hogy azok együtt tudjanak működni. Ez nem egyszerű...

  Az, hogy valamelyik alkalmazás (mondjuk Firefox) indított 80 szálat, még nem jelenti azt, hogy amikor tényleges CPU-intenzív munka van, akkor majd egynél több szál fog ezek közül érdemben tekerni. A legtöbb szál csak alszik és speciális feladata van.

  Infó:
  Az összes modern asztali oprendszer időosztásos ütemezéssel működik, az ütemezés teljes mértékben az oprendszer ütemezőjének a feladata/felelőssége.

  Általában több programszál van mint processzormag, ezek közül elég sok programszál gondolhatja azt, hogy őneki éppen dolga van és futni szeretne, tehát kell egy felsőbb hatalom, aki eldönti, hogy mikor ki futhat és végső soron felel azért, hogy a rendszer mindig reszponzív maradjon, akkor is, ha bármelyik program minden erőforrást magának akarna és felel a többé kevésbé igazságos erőforrás elosztásért.

  Ez az oprendszer ütemezője. Az összes modern desktop oprendszer időosztásos. Ez azt jelenti, hogy a processzormagok idejét az ütemező rövid időszeletekre (timeslice) osztja, ez mondjuk olyan 20ms lehet. Tehát egyetlen másodpercbe 50db időszeletet fér bele (egyetlen magon). Ha a te procid 8 magos, akkor egyetlen másodpercben 50x8= 200 időszeleted van, ennyivel tud az ütemező gazdálkodni. Az időszelet az ütemezés legkisebb egysége.

  Az ütemező a szálakat prioritás és egyéb szempontok szerint (melyik thread milyen régóta vár) rangsorolja és az éppen futni akaró threadek között ez alapján dönt, hogy melyik mikor kap 1-1 időszeletet. Ha egy egyprocesszormagos rendszeren 2db thread akar futni, akkor az ütemező pld. megcsinálhatja azt, hogy egyszer az egyik thread kapja meg a magot egy időszelet erejéig, másszor a másik kapja meg egy időszelet idejéig és így váltogatják egymást 20ms-ként. Te azt látod, hogy mindkét program/thread fut szépen, mert olyan gyorsan történik a váltás, hogy nem veszed észre, hogy az egyetlen processzormagon mindig csak egy thread fut, a másik pedig várakozik.

  Egy nyolcmagos processzoron ahol nyolcnál több szál akar futni ugyanez történik meg: az ütemező 20ms-ként dönt arról, hogy melyik futni akaró thread melyik processzormagot kapja meg. Azok a threadek amelyek alszanak, azok nyilván nem versengenek a processzorért.

  Ha van egy egyszálas programod (SuperPI) ami egyetlen threadből áll, és folyamatosan futni akar, neked meg van egy többmagos géped, a thread folyamatosan kéri hogy kapjon egy processzormagot (egy szál <-> egy mag egyidőben). Annak a threadnek egy időosztásos rendszerben _majdnem_ mindegy, hogy a thread folyamatosan ugyanazon a processzormagon fut, vagy 20ms-ként az ütemező ugráltatja egyik magról a másikra. Addig amíg folyamatosan kapja az időszeleteket, addig nem éri hátrány és képes lesz egy processzormag erejét fullosan kihasználni.

  Hogy miért szereti a Windows processzormagról processzormagra átdobálni a futó szálat akkor is, amikor igazából nem kéne, azt nem értem. hogy utána miért kell a Task Managerben CPU-magokra lebontott kihasználtságot mutatni, azt sem értem. Mert nagyon zavaró és megtévesztő az biztos...

  Az smt off viszont emlékeim szerint 10%-ot dobott rajta. Majd ezt az affinitásos dolgot rálövöm a wow-ra, hátha segít valamit,

  Érdemes lenne úgy csinálni, hogy megnézed valahol (nem tudom hol van dokumentálva, BIOS függő is lehet), hogy a processzor egyes fizikai magjai hogyan jelennek meg a BIOS-ban/ Windows taskmanagerben.

  Ha affinitással rendelsz hozzá a WoW-hoz vagy egyéb progihoz magokat, akkor érdemes lenne úgy csinálni, hogy az affinitásban az alkalmazás számára engedélyezett magok ugyanazon a CCX-en belül legyenek mind (4+0 leosztás). Memóriaintenzív kevés (de egynél több) szálas programokban ennek kéne legyen előnye egy 2+2 leosztáshoz képest.

  [ Szerkesztve ]

Új hozzászólás Aktív témák