Processzoridő

A Wikipédiából, a szabad enciklopédiából
Ugrás a navigációhoz Ugrás a kereséshez
Processzoridő egy egyprocesszoros, többfeladatos rendszer esetén
  Processzoridő a P1 program esetében

A processzoridő (vagy folyamatidő) az az idő, amelyet a processzor (CPU) egy számítógépes program vagy az operációs rendszer utasításainak feldolgozására használ, szemben az eltelt idővel, amely magában foglalja például a bemeneti/kimeneti (I/O) műveletekre való várakozást vagy alacsony fogyasztású (üresjárat) üzemmódba lépést. A processzoridőt a rendszer által felismert legkisebb időegységben vagy másodpercben mérik. Gyakran hasznos a processzoridőt a processzor kapacitásának százalékában mérni, amit processzorkihasználtságnak hívnak. A processzoridőnek és a processzorkihasználtságnak két fő felhasználási területe van.

A processzoridő két funkcionálisan azonos algoritmus általános empirikus hatékonyságának számszerűsítésére szolgál. Például bármely rendezési algoritmus egy rendezetlen listát vesz fel és egy rendezett listát ad vissza, és ezt egy adott bemeneti lista alapján meghatározott számú lépésben teszi meg. A buborékrendezés és az összefésüléses rendezés azonban eltérő futási idővel rendelkezik, így az összefésüléses rendezés általában kevesebb lépésben végez. Bármelyik algoritmus működésének ismerete nélkül a buborékrendezés nagyobb processzorideje azt mutatja, hogy bizonyos bemeneti adatok esetén kevésbé hatékony, mint az összefésüléses rendezés.

Ez a fajta mérés különösen hasznos olyan algoritmusok összehasonlításakor, amelyek bonyolultsága nem triviális. Ebben az esetben a valós idő nem releváns, mivel a számítógép lassabban vagy gyorsabban hajthatja végre a programot a valós világ változóitól, például a processzor hőmérsékletétől, valamint az operációs rendszer egyéb változóitól, például a folyamat prioritásától függően.

A processzorkihasználtságot arra használják, hogy számszerűsítsék a processzor megosztását a számítógépes programok között. Egyetlen program magas processzorkihasználtsága azt jelezheti, hogy nagy feldolgozási teljesítményt igényel, vagy hibásan működik, például belépett egy végtelen ciklusba. A processzoridő lehetővé teszi az egy program által igényelt feldolgozási teljesítmény mérését, kiküszöbölve az interferenciákat, például a bevitelre váró időt vagy a program futásának felfüggesztését.

Ezzel szemben az eltelt valós idő (vagy egyszerűen valós idő) a számítógépes program indításától a befejezéséig eltelt, egy rendes óra által mért idő. Az eltelt valós idő tartalmazza a bemeneti/kimeneti időket, a többfeladatosság miatti késéseket és a program által okozott összes egyéb várakozást.

Felosztás[szerkesztés]

A processzoridő vagy processzorkihasználtság jelenthető az egyes szálak, az egyes folyamatok vagy a teljes rendszer számára. Ezen felül, attól függően, hogy pontosan mit végzett a processzor, a jelentett értékek feloszthatók:

  • A felhasználói idő az az időtartam, amelyben a processzor a felhasználói szintű programkódok végrehajtásával foglalkozik.
  • A rendszeridő az az időtartam, amelyben a processzor a kernelszintű programkódok végrehajtásával foglalkozik. Ha ez az érték egy szálhoz vagy folyamathoz tartozik, akkor azt adja meg, amely idő alatt a kernel a végrehajtó környezet nevében végez munkát; például miután egy szál kiadott egy rendszerhívást.
  • Az üresjárati idő (csak az egész rendszer számára) az az időtartam, amelyben a processzor nincs elfoglalva, vagy egyéb esetben az, hogy mennyi ideig futtatta a rendszer üresjárati folyamatát. Az üresjárati idő valójában a fel nem használt processzorkapacitást méri.
  • A lopott idő (csak az egész rendszer számára) egy virtualizált hardveren az az időtartam, amelyet az operációs rendszer a programkódok végrehajtásával szeretne tölteni, de a hypervisor megtagadta azt.[1] Ez akkor fordulhat elő, ha a hardver több vendég operációs rendszert futtat és a hypervisor úgy döntött, hogy az időtartamot egy másik rendszernek biztosítja.

Unix-parancsok a processzoridőhöz[szerkesztés]

A top parancs kiírja a processzoridőket a különböző folyamatokhoz Unix-szerű (GNU/Linux) operációs rendszer esetén

Unix top parancs[szerkesztés]

A Unix top parancs processzoridőt, prioritást, eltelt valós időt és egyéb információkat biztosít minden folyamatról, és valós időben frissíti azokat.

Unix time parancs[szerkesztés]

A Unix time parancs kiírja a processzoridőt és az eltelt valós időt egy Unix-folyamat esetében.

% gcc nextPrimeNumber.c -o nextPrimeNumber
% time ./nextPrimeNumber 30000007
Prime number greater than 30000007 is 30000023
0.327u 0.010s 0:01.15 28.6%     0+0k 0+0io 0pf+0w

Ez a folyamat összesen 0,337 másodperc processzoridőt vett igénybe, ebből 0,327 másodpercet töltött a felhasználói szinten, az utolsó 0,010 másodpercet pedig kernelszinten. Az eltelt valós idő 1,15 másodperc volt.

Az alábbiakban bemutatjuk a NextPrimeNumber alkalmazás forráskódját, amelyet a fenti példában használtunk.

/* nextPrimeNumber.c */
#include <stdio.h>
#include <stdlib.h>

int isPrimeNumber(unsigned long int n) {
    for (int i = 2; i <= (n >> 1); ++i)
        if (n % i == 0) return 0;
    return 1;
}

int main(int argc, char *argv[]) {
    unsigned long int argument = strtoul(argv[1], NULL, 10), n = argument;
    while (!isPrimeNumber(++n));

    printf("Prime number greater than %lu is %lu\n", argument, n);
    return 0;
}

POSIX clock() és getrusage() függvények[szerkesztés]

A POSIX clock() és getrusage() függvények felhasználhatók arra, hogy POSIX-környezetben bármilyen folyamat processzoridejét megkapjuk. Ha a folyamat többszálú, a processzoridő az összes szál processzoridejeinek az összege. A Linux 2.6.26-os kerneltől kezdve van egy RUSAGE_THREAD paraméter, amely csak a hívó szál erőforrás-felhasználási statisztikáját adja meg.

Teljes processzoridő[szerkesztés]

Egy többprocesszoros gépen egy számítógépes program két vagy több processzort használ a párhuzamos feldolgozáshoz. Ilyen esetekben a teljes processzoridő fogalmát kell használni, amely a számítógépes program által felhasznált összes processzor processzoridejeinek az összege.

Processzoridő és eltelt valós idő[szerkesztés]

Az eltelt valós idő mindig nagyobb vagy egyenlő a processzoridővel azon számítógépes programok esetében, amelyek csak egy processzort használnak feldolgozáshoz. Ha nincs várakozás a bemenetre/kimenetre vagy más erőforrásokra, akkor az eltelt valós idő és a processzoridő nagyon hasonló.

Processzoridő és eltelt valós idő párhuzamos feldolgozás esetén[szerkesztés]

Ha egy program párhuzamos feldolgozást használ, akkor a program teljes processzorideje meghaladja az eltelt valós időjét. A teljes processzoridő osztva a processzorok számával megegyezik az eltelt valós idővel, ha a terhelés egyenletesen oszlik meg az egyes processzorokon és nincs várakozás a bemenetre/kimenetre vagy más erőforrásokra.

Példa: Egy alkalmazás egy hatmagos processzoron három Unix-folyamatot hoz létre a felhasználói követelmények teljesítéséhez. Mindhárom folyamat létrehoz két-két szálat, így összesen hat szálon fut az alkalmazás. A számítás egyenletesen oszlik meg a hat független szálon. Ha nincs várakozás az erőforrásokra, akkor a teljes processzoridő várhatóan az eltelt valós idő hatszorosa.

Jegyzetek[szerkesztés]

  1. Ehrhardt, Christian: CPU time accounting. IBM, 2010. július 1. (Hozzáférés: 2014. augusztus 5.)

Fordítás[szerkesztés]

  • Ez a szócikk részben vagy egészben a CPU time című angol Wikipédia-szócikk ezen változatának fordításán alapul. Az eredeti cikk szerkesztőit annak laptörténete sorolja fel. Ez a jelzés csupán a megfogalmazás eredetét jelzi, nem szolgál a cikkben szereplő információk forrásmegjelöléseként.

További információk[szerkesztés]

Kapcsolódó szócikkek[szerkesztés]