„Processzoridő” változatai közötti eltérés

Tartalom törölve Tartalom hozzáadva

Sorban

A lap 2020. június 22., 11:58-kori változata

Processzoridő egyprocesszoros, többfeladatos rendszer esetén
Processzoridő a P1 program esetében

A processzoridő (vagy folyamatidő) az az idő, melyet 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 órajelként vagy másodpercben mérik. Gyakran hasznos a processzoridőt a processzor kapacitásának százalékában mérni, amelyet processzor kihasználtságának hívnak.

A proceszoridőnek és a processzor kihasználtságának két fő felhasználási területe van. Az első használat a rendszer teljes kihasználtságának meghatározása. Ha magas a processzorhasználat, a felhasználó késleltetést tapasztalhat. Az ilyen magas processzor kihasználtság alacsony feldolgozási teljesítményt jelez. Ilyenkor vagy nagyobb teljesítményű processzort kell beszerezni, vagy a felhasználói élményt csökkenteni, például alacsonyabb felbontásra váltással, illetve az animációk csökkentésével.

A második alkalmazás a többfeladatosság megjelenésével annak meghatározása, hogy a processzor hogyan osztja el a rendelkezésére álló időt a programok között. Magas processzor kihasználtság egy program esetében azt jelezheti, hogy nagyon igényes a feldolgozási teljesítményre, vagy azt, hogy hibásan működhet; például egy végtelen ciklusba lépett be. 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 többi program futtatá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

A processzoridő vagy processzor kihaszná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óak:

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, mely 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.
A készenléti 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. A készenléti 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 hypervizor megtagadta azt.^[1] Ez akkor fordulhat elő, ha a hardver több vendég operációs rendszert futtat, és a hypervizor úgy döntött, hogy az időtartamot egy másik rendszernek biztosítja.

Unix parancsok a processzoridőhöz

Unix top parancs

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

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

A POSIX clock() és getrusage() függvények felhasználhatóak arra, hogy a 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ő

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 összege.

Processzoridő és eltelt valós idő

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 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

Ha egy program párhuzamos feldolgozást használ, akkor a program teljes processzorideje meghaladja az eltelt valósidő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 az 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 a folyamat. 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.

További információk

Jegyzetek

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

További oldalak

Thimmannagari, Chandra. CPU Design: Answers to Frequently Asked Questions. Springer, 68. o. (2005. január 1.). ISBN 0-387-23799-2

Processor And CPU Time. The GNU C Library, 2014. február 9. (Hozzáférés: 2014. augusztus 5.)

clock - report CPU time used. The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition. (Hozzáférés: 2014. augusztus 5.)
getrusage - get information about resource utilization. The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition. (Hozzáférés: 2014. augusztus 5.)

Fordítá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 és a szerzői jogokat jelzi, nem szolgál a cikkben szereplő információk forrásmegjelöléseként.

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

[1]