Atop

1 Az ATOP figyelőrendszer

Az ATOP egy interaktív figyelőrendszer linux rendszerek számára, amely méri a terheltséget a rendszer és a folyamatok szintjén egyaránt.

1.1 Az ATOP telepítése

Az ATOP kizárólag Linux alapú rendszerek felhasználói számára elérhető ingyenes program, mely a következő címről tölthető le: http://www.atcomputing.nl/Tools/atop/

1.2 Az ATOP naplózási rendszere

Az adatokat speciálisan tömörített csak ATOP-pal megnyitható fájlokban tárolja 24 órás felbontásokban. Minden fájl 10 perces szakaszokban tartalmazza az adatokat. A szakaszok alapvetően két nagy részre oszthatóak. Az első rész (a továbbiakban Fejléc) tartalmazza az adott 10 percre vonatkozó globális információkat a rendszerről, míg a második rész a folyamatok szintjéről nyújt számunkra információt. A szakaszokat később részletezem.

1.3 Az ATOP használata

A log fájlok írása és olvasása: atop -w rawfile [-a] [-S] [ interval [ samples ]] atop -r [ rawfile ] [-b hh:mm ] [-e hh:mm ] [-g|-m|-d|-n|-u|-p|-s|-c|-v] [-C|-M|-D|-N|-A] [-f1x] [-Plabel[,label]...]

1. ábra Egy ATOP log fájl kinézete

Az éppen aktuális log fájlt az atop –r paranccsal érhetjük el. Az egyes mezők jelentését később részletezem. Amennyiben egy régebbi atop log fájl tartalmát szeretnénk megnézni, úgy azt az atop –r [fájlnév] paranccsal tehetjük. Ha adott időpontok közötti időszakot szeretnénk vizsgálni, úgy azt az atop -r [ fájlnév ] [-b hh:mm ] [-e hh:mm ] paranccsal tehetjük meg.

1.3.1 Interaktív parancsok

Ha futtatjuk az atop-ot, akkor a billentyűk segítségével irányíthatjuk a kimenetet. Általánosan elmondható, hogy a kisbetűk az aktív folyamatokról szolgáltatnak más jellegű információt, míg a nagybetűk aktív folyamatok listájának rendezési elvét módosítják. A látható mezőnevek magyarázatát az átláthatóság kedvéért egy-egy mondatban leírtam. Részletesen később mutatom be őket.

g - generikus kimenet (alapbeállítás)

Folyamatonként a következő mezőket mutatja: a folyamat azonosítója, az előző intervallum cpu-terheltsége rendszer- és felhasználói módban, ill. a folyamatok rezidens és virtuális memória növelése. Az ezt követő oszlopok a használt kerneltől függenek. Ha a ’cnt’ kernel patch telepítve van, az olvasási és írási műveletek számát, és a küldött és fogadott hálózati csomagokat is megjeleníti minden folyamat esetében. Amennyiben nincs telepítve, és a kernel nem támogatja a folyamatonkénti I/O statisztikákat, úgy a felhasználónevet, szálak számát, az állapotot és a kilépési kódot láthatjuk. Az utolsó oszlopok az állapotokat, a kiválasztott erőforrásigényt és a folyamat nevét tartalmazzák.

Csak azok a folyamatok jelennek meg, melyek hozzáférést kértek a rendszer valamely erőforrásához, vagy állapotuk megváltozott.

PID: a folyamat azonosítója

SYSCPU: rendszermód CPU használatba vétele

USRCPU: felhasználói mód CPU használatba vétele

VGROW: virtuális memória növekedése (az előző intervallumhoz képest) ha felszabadul negatív

RGROW: rezidens memória növekedése (az előző intervallumhoz képest) ha felszabadul negatív

USERNAME: felhasználó neve

THR: szálak száma

ST: azt mutatja meg, hogyha leállítódik az adott folyamat hogyan történik

EXC: exit kóddal

S: a leállító jel

CPU: a teljes CPU-kihasználtság

CMD: a folyamathoz tartozó utasítás

m - Memóriával összefüggő kimenet

Folyamatonként a következő mezők látszanak: folyamat azonosítója, kisebb és nagyobb memóriahibák, a virtuálisan megosztott szöveg mérete, a folyamat teljes virtuális memória mérete, a folyamat teljes rezidens memória mérete, az előző intervallum során történt virtuális és rezidens memóriaméret növekedés, memória kihasználtság százalékban és folyamatnév.

PID: a folyamat azonosítója

MINFLT: kisebb hibák

MAJFLT: lényeges hibák

VSTEXT: a virtuálisan megosztott szöveg mérete

VSIZE: (folyamat által) lefoglalt virtuális memória mérete

RSIZE: (folyamat által) lefoglalt rezidens memória

VGROW: virtuális memóriafoglalás növekedése

RGROW: rezidens memóriafoglalás növekedése

MEM: memória használata százalékban

CMD: a folyamathoz tartozó utasítás

d - Lemezekhez kapcsolódó információk megjelenítése

Folyamatonként a következő mezőket jeleníti meg: folyamat azonosítója, fizikális lemezolvasások, olvasások átlagos mérete (byte-ban), az olvasási műveletek teljes mérete, fizikális lemezreírások, írások átlagos mérete (byte-ban), az írási műveletek méretének összege, ill. a lemezek használata százalékban és a folyamatok neve. Ezek az információk csak akkor jeleníthetőek meg, ha a ’cnt’ kernel patch telepítve van.

n - Hálózattal kapcsolatos információk megjelenítése

Folyamatonként a következő mezők láthatóak: folyamat azonosítója, az érkezett TCP csomagok a csomagok átlagos méretével (byte-ban), a küldött TCP csomagok száma a csomagok átlagos méretével (byte-ban), az érkezett UDP csomagok száma, a csomagok átlagos méretével (byte-ban), a küldött UDP csomagok száma, a csomagok átlagos méretével (byte-ban), a hálózati leterheltség százalékban, ill. a folyamat neve.

Ezek az információk csak akkor jeleníthetőek meg, ha a ’cnt’ kernel patch telepítve van.

s - Ütemezési karakterisztikák megjelenítése

Folyamatonként a következő mezők láthatóak: folyamat azonosítója, „futó” állapotban lévő szálak száma (R), „megszakíthatóan alvó” állapotban lévő szálak száma (S), „nem megszakíthatóan alvó” állapotban lévő szálak száma (D), ütemezési alapelv (normál időosztásos, valós idejű (round-robin, valós idejű fifo), finomsági (nice) érték, prioritás, aktuális processzor, állapot, kilépési kód, a kiválasztott erőforrás kihasználtsága százalékban ill. a folyamat neve.

TGID: Folyamat csoport azonosítója

NICE: Finomsági érték

PRIO: prioritás

RTPRIO: real-time prioritás

CURCPU: aktuálisan használt CPU

ST: azt mutatja meg, h ha leállítódik az adott folyamat hogyan történik

EXC kilépési kóddal

S: valamilyen jellel

CMD: a folyamathoz tartozó utasítás

v - A különféle folyamati karakterisztikákat mutatja

Folyamatonként a következő mezőket jeleníti meg: folyamat azonosítója, felhasználó neve és csoportja, indítás kezdetének dátuma és ideje, állapot (kilépési kód, amennyiben a folyamat végzett), a kiválasztott erőforrás terheltsége százalékban, ill. a folyamat neve.

PID: folyamat azonosítója

USERNAME: felhasználó neve

GROUP: csoport neve

STDATE: indítás dátuma

STTIME: indítás ideje

ST: azt mutatja meg, h ha leállítódik az adott folyamat hogyan történik

EXC kilépési kóddal

S: valamilyen jellel

CMD: a folyamathoz tartozó utasítás

c - A folyamat parancssorát mutatja

Folyamatonként a következő mezőket jeleníti meg: folyamat azonosítója, a kiválasztott erőforrás kihasználtsága százalékban ill. az utasítás és a hozzá tartozó argumentumok.

PID: folyamat azonosítója

COMMAND-LINE: a folyamathoz tartozó utasítás és az argumentumok

u - A folyamati aktivitást mutatja meg felhasználónként összesítve

Felhasználónként a következő mezők láthatóak: az előző intervallum során aktív vagy leállított folyamatok száma (vagy teljes időben az ’a’ utasítással kombinálva), összegezett cpu terheltség az előző intervallum során rendszer- és felhasználói módban, az aktív folyamatok aktuális virtuális és rezidens memória kihasználtsága (vagy a felhasználó összes folyamatáé, ha az ’a’ utasítással kombináljuk). Amennyiben telepítve van a ’cnt’ patch, úgy a lemezen végzett olvasási és írási műveletek összesített száma, és az érkezett és küldött hálózati csomag száma is látszanak. Amennyiben a patch nincs telepítve, úgy ezen értékek 0-k. Az utolsó oszlopok tartalmazzák a kiválasztott erőforrás (alapból cpu) terheltségét ill. a felhasználó nevét.

NPROCS: folyamatok száma

SYSCPU: rendszer CPU használatba vétele

USRCPU: felhasználói CPU használatba vétele

VSIZE: lefoglalt virtuális memória mérete

RSIZE: lefoglalt rezidens memória mérete

RDDISK: olvasási műveletek száma

WRDISK: írási műveletek száma

RNET: érkezett hálózati csomagok száma

SNET: küldött hálózati csomagok száma

USER: felhasználó neve

P - A folyamati aktivitást mutatja programonként (folyamat neve szerint) összegezve

Programonként a követező mezők jelenítődnek meg: az előző intervallum során aktív vagy leállított folyamatok száma (vagy összesen, ha az ’a’ utasítással kombináljuk), az előző intervallum alatti cpu-terheltség rendszer- és felhasználói módban egyaránt, az aktív folyamatok által felhasznált virtuális és rezidens memória lefoglaltsága (vagy az összes folyamaté, ha az ’a’ utasítással kombináljuk’) Amennyiben telepítve van a ’cnt’ patch, úgy a lemezen végzett olvasási és írási műveletek összesített száma, és az érkezett és küldött hálózati csomag száma is látszanak. Amennyiben a patch nincs telepítve, úgy ezen értékek 0-k. Az utolsó oszlopok tartalmazzák a kiválasztott erőforrás (alapból cpu) terheltségét ill. a felhasználó nevét.

C

CPU-kihasználtság szerint rendezi sorba az aktuális listát, és az utolsó oszlop ”CPU”-ra változik

M

A rezidens memória használata szerint rendezi sorba az aktuális listát. Az utolsó oszlop ”MEM”-re változik

D

A lemezhozzáférések szerint rendezi az aktuális listát. Az utolsó oszlop ”DSK”-ra változik

N

A küldött/fogadott hálózati csomagok szerint rendezi az aktuális listát. Az utolsó oszlop ”NET”-re változik

A

Az adott intervallum során leginkább terhelt rendszererőforrás szerint rendezi az aktuális listát. Az utolsó oszlop ”ACPU”-ra, ”AMEM”-re, ”ADSK”-ra, ”ANET”-re változik. (Az ’A’ betű az automatikus rendezési rendet jelenti). A legterheltebb erőforrás kiválasztása úgy történik, hogy megvizsgálja és összehasonlítja a súlyozott százalékos terheltségeket. Ez a beállítás marad érvényes mindaddig, míg egy másik rendezési elvet nem választunk. (A lemez és hálózati terheltség szerinti rendezés csak a ’cnt’ patch telepítése után válik lehetségessé)

1.3.2 Egyéb interaktív parancsok

?

Súgóinformáció kérése (a ’h’ betű lenyomásával szintén)

V

Verzióinformáció lekérése (verziószám és dátum)

x

Színek használata a kritikus erőforrások kiemelésére (kapcsoló)

z

A szüneteltető billentyű lefagyasztja az aktuális helyzetet, hogy megvizsgálhassuk a kimenetet a kijelzőn. Mialatt az atopot szüneteltetjük a felsorolt billentyűk segítségével különféle egyéb információkat jeleníttethetünk meg az aktuális folyamati listánkról. Amennyiben a szüneteltető billentyűt újra megnyomjuk, úgy az atop a következő mintával folytatja a működést.

i

Módosítja az intervallum időzítőjét (eredetileg 10 másodperc). Ha intervallumidőzítőnek 0-t adunk meg, abban az esetben kikapcsoljuk. Ezesetben új minta megjelenítése csak manuálisan a ’t’ lenyomásával lehetséges.

t

Új minta triggerelése manuálisan. Ezt akkor használjuk, ha a következő mintára azelőtt van szükségünk, mielőtt lejárna az időzítő, vagy ha nincs időzítő beállítva (ha az intervallum időzítő értékét 0-ra állítjuk). Ha korábbi fájl tartalmát vizsgáljuk, akkor hatására a következő mintát mutatja fájlból.

T

Ha korábbi log fájlok tartalmát nézzük, úgy ennek hatására az előző mintára ugrik a fájlból.

r

Minden számlálót lenulláz, hogy újra láthassuk a rendszer- és folyamati aktivitást a bootolás óta. Ha korábbi log fájlok tartalmát vizsgáljuk, úgy ezzel ugorhatunk vissza a fájl elejére.

U

Specifikál egy kereső sztringet, hogy a felhasználói neveket, mint reguláris kifejezést specifikálhassuk. Ettől fogva csak a kifejezéssel egyező (aktív) folyamatokat fogja megjeleníteni a program. A rendszer statisztikái továbbra is rendszer szélességűek. Ha lenyomjuk az ENTER billentyűt, mielőtt bármilyen nevet beírtunk volna, úgy ismét látszódni fog az összes aktív folyamat.

P

Specifikál egy kereső sztringet, hogy a folyamatok neveit, mint reguláris kifejezést specifikálhassunk. Ettől fogva csak a kifejezéssel egyező (aktív) folyamatokat fogja megjeleníteni a program. Ha lenyomjuk az ENTER billentyűt, mielőtt bármilyen nevet beírtunk volna, úgy ismét látszódni fog az összes aktív folyamat.

a

Az ’all/active’ billentyűt arra használhatjuk, hogy átkapcsolhassunk, hogy csak az előző intervallum során aktív folyamatokat vegye figyelembe a program a megjelenítéskor, vagy (mint eredetileg) az összeset.

f

Rögzíti a rendszererőforrások sorainak számát. Eredetileg csak azok az erőforrások jelenítődnek meg, melyek aktívak voltak az előző intervallum során. A billentyű megnyomásával tehát az inaktív erőforrásokat is megjeleníthetjük.

l

Limitálja a rendszerszintű sorok számát. Alapból minden cpu-nak, lemeznek és hálózati interfésznek van külön sora. Ezen sorok limitálása sok CPU-val, lemezzel és interfésszel rendelkező rendszerek esetén lehet különösen hasznos. Minden említett erőforráshoz interaktívan szabályozhatjuk a sorok számát. Ha a –l flag-et használjuk, úgy a CPU sorokat 0-ra, a lemezek sorainak maximális számát 5-re és a hálózati interfészek sorainak maximális számát 3-ra állítjuk. Ezen értékeket újra módosíthatjuk az interaktív módban.

k

Jelet küld egy aktív folyamatnak.

q

Kilépés a monitorozó programból.

^F

A következő oldal mutatása a folyamatok listájából.

^B

Az előző oldal mutatása a folyamatok listájából.

1.4 Kimenet leírása

1.4.1 A Fejlécben található információk magyarázata

PRC

Ez a sor tartalmazza a teljes felhasznált CPU időt rendszermódban (’sys’) és felhasználói módban (’user’), az adott időben lévő folyamatokat összesen (’#proc’), a zombi folyamatokat (’zombie’) és az intervallum során befejeződött folyamatokat (’#exit’). Amelyik ’?’-t mutat, ott a folyamat nincs a nyilvántartásban.

CPU - CPU-kihasználtság

Legalább egy sor látszódik a CPU-k teljes kihasználtságának együttes mutatására. Többprocesszoros rendszer esetén minden különálló processzor (’cpu’ kis betűkkel) számára külön sor van, aktivitás szerint sorba rendezve. Alapból az inaktív processzorok nem jelenítődnek meg. A per-cpu összesítő sor utolsó mezője mutatja a processzorok számát. Minden sor százalékban tartalmazza az aktív folyamatok kernel módban töltött cpu idejét (’sys’), a felhasználói módban töltött cpu idejét (’user’), a megszakítások kezelésével töltött cpu idejét (’irq’), a kihasználatlan cpu időt, mialatt egy folyamat sem várakozott lemez I/O műveletre (’idle’) és a kihasználatlan cpu időt, mialatt legalább egy folyamat várakozott lemez I/O műveletre (’wait’). Az összesítő per-cpu sor esetén az utolsó oszlop mutatja a cpu-k számát, ill. a várakozási százalékát (’w’) a cpu-nak. A per-cpu összesítés sorainak száma korlátozható. Virtuális gépek esetében a második ’CPU’ jelzésű sor az első sor kiegészítése. A második sor tartalmazza a lopási százalékot (’steal’) az első sor kategóriáin kívül ('sys', 'user', 'irq', 'idle' and 'wait'). Ezenfelül az átlagos lopási százalék processzoronként (’stl/cpu’) is látszik. Egyprocesszoros rendszer esetén ez megegyezik a teljes lopási százalékkal.

CPL - CPU-betöltési információ

Ez a sor becslést ad arra vonatkozóan, hogy mennyi a futásra alkalmas folyamatok száma, vagy, hogy hányan várakoznak lemez I/O műveletek elvégzésére. Ez a becslés 1 ('avg1'), 5 ('avg5') és 15 ('avg15') percenként képes átlagolni. Ezenfelül mutatja a kontextus váltások (’csw’) számát és a kiszolgált megszakításokat (’intr’) is.

MEM - Memória leterheltség

Ez a sor tartalmazza a fizikai memóriát összességében (’tot’), az aktuálisan szabad memória méretet (’free’), a lapozó cache által használt memóriát (’cache’), a fájlrendszer metaadatai által lefoglalt memóriát (’buff’) és kernel memória-lefoglalásaihoz lefoglalt memória méretét (’slab’ – mindig 0 a 2.4-es kernelhez)

SWP - Swap használat

Ez a sor tartalmazza a lemezen található összes swap területet (’tot’) és a szabad swap méretet (’free’). Ezenfelül a megbízott virtuális memória mérete (’vmcom’) és a megbízott terület maximális korlátja (’vmlim’, ami eredetileg a swap méret és a memória 50%-a) is látható. A megbízott terület a folyamatok saját memóriaterülete amely az összes memóriafoglalásához van lefoglalva a virtuális memóriában.

PAG - Lapozási frekvencia

Ez a sor tartalmazza az átvizsgált lapok számát (’scan’), és az esetek számát, mikor a kernel vissza próbálta nyerni a lapokat valamilyen sürgős kéréshez (’stall’). Továbbá mutatja a memórialapok számát, melyeket a rendszer olvasott a swap területről (’swin’) ill. azokat is, melyeket a rendszer a swap területre írt (’swout’).

DSK - Lemez felhasználás

Aktív lemezenként egy sort tartalmaz lemezaktivitás szerint rendezve. Minden sor tartalmazza a lemez nevét (pl. hda vagy sda), az elfoglaltságot százalékban, azt a részét az időnek, mikor a lemez kéréseket kezelt (’busy’), a kiszolgált olvasási kérések számát (’read’), a kiszolgált írási kérések számát, és a keresési, késleltetési és adatátviteli kérésekhez szükséges átlagos időt milliszekundumban (’avio’)

A lemezeket megjelenítő sorok számát lekorlátozhatjuk.

NET - Hálózati kihasználtság (TCP/IP)

Egy sor mutatja a szállítási réteg (TCP és UDP) aktivitását, egy sor az IP réteget, és egy-egy sor az aktív interfészeket. A szállítási réteghez számlálók látszódnak: az érkezett TCP szeletek számára azokat is beleértve, melyek hibásan érkeztek (’tcpi’), a küldött TCP szelet számára kihagyva azokat, melyek csak újraküldött oktetteket (octets) tartalmaznak, az érkezett UDP datagramok száma (’udpi’), az átküldött UDP datagramok száma (’udpo’). Ezen számlálók az IPv4-hez és IPv6-hoz köthetőek. Az IP rétegnél a következő számlálók láthatóak: az interfészeken keresztül érkezett IP datagramok száma a hibásakat is beleértve (’ipi’), a helyi felső réteg protokolljai által felajánlott IP datagramok száma (’ipo’), más interfészek felé átirányított (forwardolt) IP datagramok száma (’ipfrw’), a helyi felső rétegű protokollok felé kézbesített IP datagramok száma (’deliv’). Ezen számlálók az IPv4-hez és IPv6-hoz köthetőek. Minden aktív interfész számára van egy-egy sor az interfészek aktivitása szerint sorba rendezve. Mindegyik sor első oszlopa tartalmazza az interfész nevét és százalékos terheltségét. Félduplex esetben a százalékos terheltséget az alapján számolja ki, hogy összehasonlítja az interfész sebességét, és a küldött/fogadott bitek számát másodpercenként.; full-duplex esetben az interfész sebességét hasonlítja össze a küldött és fogadott bitek közül a nagyobbal. Amennyiben az interfész sebessége nem határozható meg (pl. visszacsatolt interfész esetén), akkor ’---’ látszik a kihasználtsági százalék helyett. Ezenfelül az érkezett csomagok száma (’pcki’), a küldött csomagok (’pcko’), a másodpercenként küldött effektív bitek összege (’si’) és a másodpercenként fogadott effektív bitek összege (’so’) látszik. A hálózati interfészek sorainak száma korlátozható.

1.4.2 A folyamatleíró részekben található információk magyarázata

A következőkben a rendszerszintű információk, a folyamatok látszanak aszerint, hogy melyik erőforrás használata változott az előző intervallum során. Ezek a folyamatok cpu időt, kibocsátott lemez és hálózati kéréseket használhatnak. Egy folyamat akkor is látszik, ha ki lett téve a lapozó fájlokba, vagyis hiányzik a memóriából (amennyiben a folyamat alvó állapotban van). Folyamatonként a következő mezők látszódhatnak alfabetikus sorrendben. Az aktuális kimenet az interaktív parancsoktól függ.

CMD

A folyamat neve. A nevet határolhatják relációjelek (’<név>’), ami azt jelzi, hogy a folyamat az előző intervallum során befejezte a futást. A fejléc ’CMD’ rövidítése mögött az aktuális oldalszám és az összes folyamatlistát tartalmazó oldal száma látszik.

COMMAND-LINE

A folyamathoz tartozó teljes parancs (az argumentumokat is beleértve), amely korlátozva van a képernyő által megengedett sorhossz szerint. A sort határolhatják relációjelek (’<sor>’), ami azt jelzi, hogy a folyamat az előző intervallum során befejezte a futást. A fejléc ’COMMAND-LINE’ rövidítése mögött az aktuális oldalszám és az összes folyamatlistát tartalmazó oldal száma látszik.

CPU

A százalékos lefoglaltsága a rendszerszintű erőforrásnak a folyamat által felhasznált és rendelkezésre álló kapacitása szerint.

DSK

A lemez százalékos lefoglaltsága az összes folyamat szerint (vagyis az összes folyamat által az előző intervallum során végrehajtott lemezhozzáférések száma). Ez az információ csak akkor látszódik, ha a ’cnt’ kernel patch telepítve van.

EXC

A leállított folyamat kilépő kódja (az ’ST’ oszlop második helyén E) vagy a végzetes jel száma (az ’ST’ oszlop második helyén S vagy C)

GROUP

A valós elsődleges csoport identitása a futó folyamat alatt.

MAJFLT

A folyamat által okozott lapozó hibák száma.

MEM

A rendszerszintű erőforrás százalékos lefoglaltsága a folyamat által felhasznált és a rendelkezésre álló kapacitása szerint.

MINFLT

A folyamat által végrehajtott lap visszakérések száma.

NET

A rendszerszintű erőforrás százalékos lefoglaltsága a folyamat által felhasznált és rendelkezésre álló kapacitása szerint. (vagyis az összes folyamat előző intervallum során továbbított hálózati csomagjainak száma) Ez az információ csak akkor érhető el, ha a ’cnt’ kernel patch telepítve van.

NPROCS

Az aktív és leállított folyamatok összessége felhasználó vagy program szerint.

PID

Folyamatazonosító. Ha egy folyamat az utolsó intervallum során indult és fejeződött be, úgy ’?’-et látunk, mert a folyamatleíró nem tartozik folyamatnyilvántartó rekordhoz. Azonban, ha az ’acct’ kernel patch telepítve van, úgy az érték megfelelően jelenítődik meg.

POLI

Ütemező: ’norma’ (akkor normális, ha SCHED_OTHER) egy időosztásos folyamatot azonosít, ’fifo’ (SCHED_FIFO) és ’rr’ (round-rubin, SCHED_RR) pedig egy valós idejű folyamatot azonosít.

PPID

Szülőfolyamat-azonosító. Ha a folyamat az előző intervallum során kezdődött és fejeződött be, úgy az értéke 0 lesz, mivel a szülő folyamat nem lesz benne az alapvető folyamatleíró rekordban. Azonban, ha az ’acct’ kernel patch telepítve van, úgy az érték látszódni fog.

PRI

A folyamat prioritása 0 (legmagasabb prioritás) és 139 (legalacsonyabb prioritás) között van. A 0 és 99 közötti prioritásokat a valós idejű folyamatok használják, míg 100 és 139 közötti prioritásokat az időosztásos folyamatok.

RAWRS

A folyamat által küldött/fogadott alap (raw) datagramok száma. Ez az információ csak akkor látszódik, ha a ’cnt’ kernel patch telepítve van. Ha a folyamat az előző intervallum során végzett, úgy nem jelenik meg érték, mivel a hálózati számláló nincs regisztrálva az alapvető folyamat nyilvántartó rekordban. Azonban, ha az ’acct’ kernel patch telepítve van, úgy az érték látszódni fog.

RDDSK

Ha a ’cnt’ kernel patch telepítve van: a fizikai olvasási hozzáférések száma a lemezen (a lemez cache-ben olvasás nem számít bele)

RGROW

Az előző intervallum során a folyamat által megnövelt összes rezidens memória. A rezdiens memória megnövekedésének oka lehet pl. hogy egy olyan memórialapot kívánunk használni, ami korábban nem volt létrehozva/betöltve. Megjegyzés: az értéke lehet akár negatív is, pl. mikor a folyamat dinamikusan lefoglalt memóriaterületet szabadít fel. Ha egy folyamat az előző intervallum során fejeződött be, úgy nem látszik érték, mert a rezidens memória lefoglaltsága nem része az alapvető folyamat nyilvántartó rekordnak. Azonban, ha az ’acct’ kernel patch telepítve van, úgy az érték látszódni fog.

RNET

A TCP és UDP csomagok száma, melyeket a folyamat fogadott. Ez az információ csak akkor látszik, ha a ’cnt’ kernel patch telepítve van. Ha a folyamat az előző intervallum során végzett, úgy nem jelenik meg érték, mivel a hálózati számláló nincs regisztrálva az alapvető folyamat nyilvántartó rekordban. Azonban, ha az ’acct’ kernel patch telepítve van, úgy az érték látszódni fog.

RSIZE

A teljes rezidens memóriahasználat folyamat (vagy felhasználó) szerint. Ha egy folyamat az előző intervallum során fejeződött be, úgy nem látszik érték, mert a rezidens memória lefoglaltság nem része az alapvető folyamat nyilvántartó rekordnak. Azonban, ha az ’acct’ kernel patch telepítve van, úgy az érték látszódni fog.

RTPR

Valós idejű prioritás, amennyiben a POSIX standard. Az érték 0 időosztásos folyatok esetén (ütemezés ’norm’), vagy 1 (legkisebb) és 99 (legnagyobb) közötti érték valós idejű folyamatok esetén (’rr’ vagy ’fifo’ ütemezés).

S

A folyamat aktuális állapota. ’R’ a futók esetén (éppen futó, vagy a futási sorban lévő), ’S’ a megszakíthatóan alvók esetén (eseményre vár), ’D’ a nem megszakíthatóan alvóknál, ’Z’ a zombiknál (arra vár, hogy szinkronizáltatható legyen a szülőfolyamattal), ’T’ a megállítottaknál (felfüggesztett vagy megjelölt), ’W’ a swapelteknél és ’E’ (kilépő) az előző intervallumok során befejezettek esetén.

SNET

A folyamat által továbbított TCP és UDP csomagok száma. Ez az információ csak akkor látszik, ha a ’cnt’ kernel patch telepítve van. Ha a folyamat az előző intervallum során végzett, úgy nem jelenik meg érték, mivel a hálózati számláló nincs regisztrálva az alapvető folyamat nyilvántartó rekordban. Azonban, ha az ’acct’ kernel patch telepítve van, úgy az érték látszódni fog.

ST

A folyamat státusza. Az első hely azt jelzi, hogy az előző intervallum során indult-e el (az ’N’ új folyamatot jelent). A második hely jelenti, hogy az előző intervallum során befejeződött-e. Az E érték kilépést jelent. A kilépő kód az ’EXC’ oszlopban jelenítődik meg. Az S érték jelentése, hogy a folyamat nem önszántából állt le, hanem valamilyen jel hatására, a jel száma az ’EXC’ oszlopban látható. A C érték jelentése, hogy a folyamat nem önszántából állt le, hanem valamilyen jel hatására, létrehozva egy belső helyet a saját könyvtárában; a jel száma az ’EXC’ oszlopban .

STDATE

A folyamat kezdő dátuma

STTIME

A folyamat kezdetének ideje.

SYSCPU

Az adott folyamat CPU fogyasztása a rendszermódban (kernel mód), általában rendszerhívások kezelése esetén.

TCPRCV

A folyamat által fogadott kérések száma TCP socketeken keresztül, és az átlagos méretük átvitelenként byte-ban. Ez az információ csak telepített ’cnt’ kernel patch esetén látszik. Ha a folyamat az előző intervallum során végzett, úgy nem jelenik meg érték, mivel a hálózati számláló nincs regisztrálva az alapvető folyamatnyilvántartó rekordban. Azonban, ha az ’acct’ kernel patch telepítve van, úgy az érték látszódni fog.

TCPSND

A folyamat által TCP socketként küldött kérések száma, és az átvitelenkénti átlagos méret byte-ban. Ez az információ csak akkor látszik, ha a ’cnt’ kernel patch telepítve van. Ha a folyamat az előző intervallum során végzett, úgy nem jelenik meg érték, mivel a hálózati számláló nincs regisztrálva az alapvető folyamatnyilvántartó rekordban. Azonban, ha az ’acct’ kernel patch telepítve van, úgy az érték látszódni fog.

THR

A folyamaton belüli szálak száma. Minden összefüggő szál egy szálcsoportként jelenik meg, az atopban egy sorként reprezentálva. 2.4.-es Linux rendszereknél könnyen eldönthető, hogy az adott szálak ugyanazon szál csoporthoz tartoznak-e. Minden szálat külön sorban jelenít meg az atop.

TRUN

Futó (R) állapotban lévő folyamaton belüli szálak száma.

TSLPI

Megszakíthatóan alvó (S) állapotban lévő folyamaton belüli szálak száma.

TSLPU

Nem megszakíthatóan alvó (D) állapotban lévő folyamaton belüli szálak száma.

UDPRCV

A folyamat által fogadott UDP datagramok száma, és az átvitelenkénti átlagos méret byte-ban. Ez az információ csak akkor látható, ha a ’cnt’ kernel patch telepítve van. Ha a folyamat az előző intervallum során végzett, úgy nem jelenik meg érték, mivel a hálózati számláló nincs regisztrálva az alapvető folyamat nyilvántartó rekordban. Azonban, ha az ’acct’ kernel patch telepítve van, úgy az érték látszódni fog.

UDPSND

A folyamat által küldött UDP datagramok száma, és az átvitelenkénti átlagos méret byte-ban. Ez az információ csak akkor látható, ha a ’cnt’ kernel patch telepítve van. Ha a folyamat az előző intervallum során végzett, úgy nem jelenik meg érték, mivel a hálózati számláló nincs regisztrálva az alapvető folyamat nyilvántartó rekordban. Azonban, ha az ’acct’ kernel patch telepítve van, úgy az érték látszódni fog.

USERNAME

A valós felhasználó azonosítása a futó folyamat alatt.

USRCPU

A folyamat CPU-használati ideje felhasználói módban.

VGROW

Az előző intervallum során a folyamat által megnövelt összes virtuális memória.

A virtuális memória megnövekedésének oka lehet pl. egy malloc() végrehajtása vagy egy megosztott memóriaterület csatlakoztatása. Megjegyzés: az értéke lehet akár negatív is, pl. free() végrehajtásakor vagy megosztott memória leválasztásakor. Ha egy folyamat az előző intervallum során fejeződött be, úgy nem látszik érték, mert a virtuális memória lefoglaltság nem része az alapvető folyamat nyilvántartó rekordnak. Azonban, ha az ’acct’ kernel patch telepítve van, úgy az érték látszódni fog.

VSIZE

A teljes virtuális memóriahasználat folyamat (vagy felhasználó) szerint. Ha egy folyamat az előző intervallum során fejeződött be, úgy nem látszik érték, mert a virtuális memória lefoglaltság nem része az alapvető folyamat nyilvántartó rekordnak. Azonban, ha az ’acct’ kernel patch telepítve van, úgy az érték látszódni fog.

VSTEXT

A folyamat megosztott szövege által használt virtuális memória mérete.

WRDSK

Amennyiben a ’cnt’ kernel patch telepítve van: a lemezen végrehajtott fizikális írási hozzáférések (a lemez cache-be írás nem számít bele). Általában az alkalmazás folyamatok a cache-be továbbítják adataikat, míg a fizikális írási hozzáférést valamilyen kernel démon végzi el, mint pl. pdflush. Megjegyzés: az olvasási és írási hozzáférések nem különítődnek el az általános nyilvántartó rekordban. Ez azt jelenti, hogy csak egy értéket kapnak az olvasások és írások abban az esetben, ha a folyamat az előző intervallum során végzett. Azonban, ha az ’acct’ kernel patch telepítve van, akkor megfelelően elkülönítve jelennek meg az értékek. Ha a ’cnt’ kernel patch nincs telepítve, de a kernel karbantartja az alapvető I/O statisztikákat (>=2.6.20): a lemezre fizikálisan írt adatmennyiség (a lemez cache-be írás nem számít bele). Ez a számláló azon alkalmazási folyamatok karbantartását szolgálja, melyek adataikat a cache-be írják (és a lemezre fizikálisan csak később íródnak az adatok).

WRDSK_CANCEL

Ha a ’cnt’ kernel patch nincs telepítve, de a kernel karbantartja az alapvető I/O statisztikákat (>=2.6.20): az írási átvitel egy olyan folyamathoz lett feljegyezve, ami időközben le lett állítva. Pl. ha egy folyamat új adatot ír egy fájlba, és ez az adat újra el lesz mozdítva, mielőtt a cache buffer átkerült volna a lemezre. Az eredeti folyamat WRDSK-ként látja az írt adatot, míg a folyamat, amely újra elmozdítja a fájlt WRDSK_CANCEL-ként látja a cache-ből lemezre még át nem helyezett adatot.

1.5 A log fájlok tartalmának felhasználása

1.5.1 A log fájlok átalakítása szöveges állománnyá

Ahhoz, hogy a log fájlok tartalmát fel tudjuk használni, ahhoz első lépésként megfelelően kezelhető formátumba kell átalakítani őket. Miután az atop a log fájlokat speciálisan tömörített formában használja, így a következő utasítással a log fájlokat szöveges állománnyá alakíthatjuk:

atop –r log_neve –f > log_neve.log

1.5.2 A log fájlok feltöltése adatbázisba

Miután a log fájlok hatalmas mennyiségű adatot tartalmaznak, így szükséges egy megfelelő adatbázis-kezelő program használata, a választás a Microsoft SQL Server 2008-ra esett. Az adatokkal való munkához a MathWorks MATLAB termékét választottam. Első lépésként készítettem két rutint, amely a szerkeszthető log fájlokat betöltötte az SQL Server-be. A rutinok a LogRead ill. LogReadH nevet kapták: Működési alapelvük, hogy soronként olvassák be a fájl tartalmát, majd a megfelelő értelmezés és adatkonvertálás után feltöltik az adatokat a megfelelő táblába.

A LogReadH felelős a Fejléc, míg a LogRead a folyamatlista adatainak kezeléséért.

A felhasznált egyéb saját készítésű rutinok:

K2M: A GByte-ban és Kbyte-ban megadott adatokat Mbyte-ra alakítja

Pl.: K2M(’1.1G’) = ’1100M’

cutM: levágja az M betűt a sztring végéről

Pl.: cutM(’1100M’) = ’1100’

min2sec: az ’XmYs’ alakú időt másodpercbe váltja

Pl.: min2sec(’1m2s’) = ’62s’

cutS: levágja az S betűt a sztring

Pl.: cutS(’62s’) = ’62’

1.5.2.1 A Szerver nevének és a Dátumnak a kiolvasása:

D = fgetl(fp);%Az elsı fıfejléc beolvasása
disp(D(1:50))
SERVER = strtrim(D(7:15))
DATENUM = Date2Num(D(27:46));
DATENUMSTRING = D(27:46);
DATENUMSTRING = regexprep(DATENUMSTRING, '/', '-');

1.5.2.2 A LogReadH rutin

A létrehozott táblázatok és a hozzájuk kapcsolódó MATLAB forrás részletek:

HPRC

A fejléc legelső sorának adatai.

DATUM: smalldatetime, not null A bejegyzés dátuma

SERVER: char(15), not null A szerver neve

A többi attribútum elnevezése megegyezik az eredetivel:

SYS: numeric(10,2), not null

USR: numeric(10,2), not null

THR: int, not null

ZOMBIE: int, not null

EXITT: int, not null

Pl.:

DATUM SERVER SYS USR THR ZOMBIE EXITT
2009-01-13 19:21:00 kuka 3.67 24.99 155 1 594

A sor(ok)hoz tartozó MATLAB forráskód:

%PRC | sys 17h20m | user 65h35m | #thr 163 | #zombie 0 | #exit 0 |
D = fgetl(fp);
E{1,1} = DATENUMSTRING;
E{1,2} = SERVER;
E{1,3} = str2num(cutS(Min2Sec(strtrim(D(10:18)))));
E{1,4} = str2num(cutS(Min2Sec(strtrim(D(25:33)))));
E{1,5} = str2num(strtrim(D(40:48)));
E{1,6} = str2num(strtrim(D(58:63)));
E{1,7} = str2num(strtrim(D(71:78)));
colnames = {'DATUM' 'SERVER' 'SYS' 'USR' 'THR' 'ZOMBIE' 'EXITT'};
colvalues={E{1,1} E{1,2} E{1,3} E{1,4} E{1,5} E{1,6} E{1,7}};
insert(conn, 'HPRC', colnames, colvalues);

HCPU

A Fejléc CPU-val kapcsolatos adatai

DATUM: smalldatetime, not null A bejegyzés dátuma

SERVER: char(15), not null A szerver neve

A többi attribútum elnevezése megegyezik az eredetivel:

NAME: char(7), not null

SYS: numeric(4,0), not null

USR: numeric(4,0), not null

IRQ: numeric(4,0), not null

IDLE: numeric(4,0), not null

WAIT: numeric(4,0), not null

Pl.:

DATUM SERVER NAME SYS USR IRQ IDLE WAIT
2009-01-13 23:21:00 morgo cpu000 0 0 0 100 0

A sor(ok)hoz tartozó MATLAB forráskód:

% cpu | sys 0% | user 2% | irq 0% | idle 96% | cpu000 w 1% |
% cpu | sys 0% | user 1% | irq 0% | idle 97% | cpu002 w 2% |
% cpu | sys 0% | user 1% | irq 0% | idle 97% | cpu003 w 2% |
% cpu | sys 0% | user 1% | irq 0% | idle 98% | cpu001 w 1% |
D = fgetl(fp);
E{1,1} = DATENUMSTRING;
E{1,2} = SERVER;
E{1,3} = str2num(strtrim(D(11:16)));
E{1,4} = str2num(strtrim(D(26:31)));
E{1,5} = str2num(strtrim(D(40:46)));
E{1,6} = str2num(strtrim(D(56:61)));
E{1,7} = strtrim(D(65:72));
E{1,8} = str2num(strtrim(D(74:76)));
colnames = {'DATUM' 'SERVER' 'NAME' 'SYS' 'USR' 'IRQ' 'IDLE' 'WAIT'};
colvalues={E{1,1} E{1,2} E{1,7} E{1,3} E{1,4} E{1,5} E{1,6} E{1,8}};
insert(conn, 'HCPU', colnames, colvalues);

HMEM

A Fejléc memóriával kapcsolatos adatai.

DATUM: smalldatetime, not null A bejegyzés dátuma

SERVER: char(15), not null A szerver neve

A többi attribútum elnevezése megegyezik az eredetivel:

TOT: numeric(10,3), not null

FREE: numeric(10,3), not null

CACHE: numeric(10,3), not null

BUFF: numeric(10,3), not null

SLAB: numeric(10,3), not null

Pl.:

DATUM SERVER TOT FREE CACHE BUFF SLAB
2009-01-25 19:01:00 morgo 2000.000 691.500 1100.000 47.600 102.200

A sorhoz tartozó MATLAB forráskód:

% MEM | tot 2.0G | free 35.2M | cache 1.1G | buff 22.6M | slab 79.1M |
D = fgetl(fp);
E{1,1} = DATENUMSTRING;
E{1,2} = SERVER;
E{1,3} = str2num(cutM(K2M(strtrim(D(10:17)))));
E{1,4} = str2num(cutM(K2M(strtrim(D(25:32)))));
E{1,5} = str2num(cutM(K2M(strtrim(D(41:47)))));
E{1,6} = str2num(cutM(K2M(strtrim(D(55:62)))));
E{1,7} = str2num(cutM(K2M(strtrim(D(70:77)))));
colnames = {'DATUM' 'SERVER' 'TOT' 'FREE' 'CACHE' 'BUFF' 'SLAB'};
colvalues={E{1,1} E{1,2} E{1,3} E{1,4} E{1,5} E{1,6} E{1,7}};
insert(conn, 'HMEM', colnames, colvalues);

HSWP

A Fejléc Swap-pel kapcsolatos adatai.

DATUM: smalldatetime, not null A bejegyzés dátuma

SERVER: char(15), not null A szerver neve

A többi attribútum elnevezése megegyezik az eredetivel:

TOT: numeric(10,2), not null

FREE: numeric(10,2), not null

VCOM: numeric(10,2), not null

VMLIM: numeric(10,2), not null

Pl.:

DATUM SERVER TOT FREE VCOM VMLIM
2009-01-25 19:01:00 morgo 8000.00 8000.00 55.80 9000.00

A sorhoz tartozó MATLAB forráskód:

% SWP | tot 8.2G | free 8.2G | | vmcom 2.3G | vmlim 9.2G |
D = fgetl(fp);
E{1,1} = DATENUMSTRING;
E{1,2} = SERVER;
E{1,3} = str2num(cutM(K2M(strtrim(D(10:17))))); %TOT
E{1,4} = str2num(cutM(K2M(strtrim(D(25:32))))); %FREE
E{1,5} = str2num(cutM(K2M(strtrim(D(56:62))))); %VCOM
E{1,6} = str2num(cutM(K2M(strtrim(D(71:77))))); %VMLIM
colnames = {'DATUM' 'SERVER' 'TOT' 'FREE' 'VCOM' 'VMLIM'};
colvalues={E{1,1} E{1,2} E{1,3} E{1,4} E{1,5} E{1,6}};
insert(conn, 'HSWP', colnames, colvalues);

HPAG

A Fejléc lapozással kapcsolatos adatai

DATUM: smalldatetime, not null A bejegyzés dátuma

SERVER: char(15), not null A szerver neve

A többi attribútum elnevezése megegyezik az eredetivel:

SCAN: numeric(12,0), not null

STALL: int, not null

SWIN: int, not null

SWOUT: int , not null

Pl.:

DATUM SERVER TOT FREE VCOM VMLIM
2009-01-25 19:01:00 morgo 8000.00 8000.00 55.80 9000.00

A sorhoz tartozó MATLAB forráskód:

% PAG | scan 9350e5 | stall 5706 | | swin 2046 | swout 1940 |
D = fgetl(fp);
E{1,1} = DATENUMSTRING;
E{1,2} = SERVER;
E{1,3} = str2num(strtrim(D(11:18)));
E{1,4} = str2num(strtrim(D(26:33)));
E{1,5} = str2num(strtrim(D(55:63)));
E{1,6} = str2num(strtrim(D(71:78)));
colnames = {'DATUM' 'SERVER' 'SCAN' 'STALL' 'SWIN' 'SWOUT'};
colvalues={E{1,1} E{1,2} E{1,3} E{1,4} E{1,5} E{1,6}};
insert(conn, 'HPAG', colnames, colvalues);

HDSK

A Fejléc lemezekkel kapcsolatos adatai.

DATUM: smalldatetime, not null A bejegyzés dátuma

SERVER: char(15), not null A szerver neve

A többi attribútum elnevezése megegyezik az eredetivel:

NAME: char(10), not null

BUSY: char(10), not null

READD: numeric(15,0), not null A READ-nek felel meg

WRITE: numeric(15,0), not null

AVIO: int, not null

Pl.:

DATUM SERVER NAME BUSY READD WRITE AVIO
2009-01-13 19:11:00 morgo sda 0 3 391 5

A sor(ok)hoz tartozó MATLAB forráskód:

if (strcmp(SERVER,'morgo')==1) DSKNUM=2;
end
if (strcmp(SERVER,'mostoha')==1) DSKNUM=5;
end
if (strcmp(SERVER,'kuka')==1) DSKNUM=4;
end
% DSK | sda | busy 5% | read 62182e3 | write 7701e4 | avio 2 ms |
% DSK | sdb | busy 1% | read 28280e3 | write 8291e3 | avio 3 ms |
% DSK | sdc | busy 1% | read 24140e3 | write 4695e3 | avio 2 ms |
% DSK | hdc | busy 0% | read 0 | write 0 | avio 0 ms |
for i=1:DSKNUM
D = fgetl(fp);
E{1,1} = DATENUMSTRING;
E{1,2} = SERVER;
E{1,3} = strtrim(D(6:18));%NAME
E{1,4} = str2num(strtrim(D(25:31)));%BUSY
E{1,5} = str2num(strtrim(D(40:48)));%READ
E{1,6} = str2num(strtrim(D(56:63)));%WRITE
E{1,7} = str2num(strtrim(D(70:75)));%AVIO
colnames = {'DATUM' 'SERVER' 'NAME' 'BUSY' 'READD' 'WRITE' 'AVIO'};
colvalues={E{1,1} E{1,2} E{1,3} E{1,4} E{1,5} E{1,6} E{1,7}};
insert(conn, 'HDSK', colnames, colvalues);

HNETTRANS

A Fejléc hálózati részének TRANS sorával kapcsolatos adatok.

DATUM: smalldatetime, not null A bejegyzés dátuma

SERVER: char(15), not null A szerver neve

A többi attribútum elnevezése megegyezik az eredetivel:

TCPI: numeric(18,0), not null

TCPO: numeric(18,0), not null

UDPI: numeric(18,0), not null

UDPO: numeric(18,0), not null

Pl.:

DATUM SERVER TCPI TCPO UDPI UDPO
2009-01-25 19:21:00 morgo 1473 1539 134 134

A sorhoz tartozó MATLAB forráskód:

% NET | transport | tcpi 12447e5 | tcpo 19902e5 | udpi 95011e3 | udpo 94627e3 |
D = fgetl(fp);
E{1,1} = DATENUMSTRING;
E{1,2} = SERVER;
E{1,3} = str2num(strtrim(D(25:33)));%TCPI
E{1,4} = str2num(strtrim(D(40:48)));%TCPO
E{1,5} = str2num(strtrim(D(55:63)));%UDPI
E{1,6} = str2num(strtrim(D(70:78)));%UDPO
colnames = {'DATUM' 'SERVER' 'TCPI' 'TCPO' 'UDPI' 'UDPO'};
colvalues={E{1,1} E{1,2} E{1,3} E{1,4} E{1,5} E{1,6}};
insert(conn, 'HNETTRANS', colnames, colvalues);

HNETNET

A Fejléc hálózati részének NET sorával kapcsolatos adatai.

DATUM: smalldatetime, not null A bejegyzés dátuma

SERVER: char(15), not null A szerver neve

A többi attribútum elnevezése megegyezik az eredetivel:

IPI: numeric(18,0), not null

IPO: numeric(18,0), not null

IPFRW: numeric(18,0), not null

DELIV: numeric(18,0), not null

Pl:

DATUM SERVER IPI IPO IPFRW DELIV
2009-01-25 19:21:00 morgo 1701 1695 0 1690

A sorhoz tartozó MATLAB forráskód:

% NET | network | ipi 134233e4 | ipo 208606e4 | ipfrw 0 | deliv 1342e6 |
D = fgetl(fp);
E{1,1} = DATENUMSTRING;
E{1,2} = SERVER;
E{1,3} = str2num(strtrim(D(24:33)));%IPI
E{1,4} = str2num(strtrim(D(39:48)));%IPO
E{1,5} = str2num(strtrim(D(56:63)));%IPFRW
E{1,6} = str2num(strtrim(D(71:78)));%DELIV
colnames = {'DATUM' 'SERVER' 'IPI' 'IPO' 'IPFRW' 'DELIV'};
colvalues={E{1,1} E{1,2} E{1,3} E{1,4} E{1,5} E{1,6}};
insert(conn, 'HNETNET', colnames, colvalues);

HNETDEV

A Fejléc hálózati részének hálózati interfészekkel kapcsolatos adatai

DATUM: smalldatetime, not null A bejegyzés dátuma

SERVER: char(15), not null A szerver neve

A többi attribútum elnevezése megegyezik az eredetivel:

NAME: char(10), not null

PCKI: numeric(18,0), not null

PCKO: numeric(18,0), not null

INN: numeric(10,5), not null

OUT: numeric(10,5), not null

Pl.:

DATUM SERVER NAME PCKI PCKO INN OUT
2009-01-25 19:11:00 morgo eth0 2932 1857 0.00700 0.00300

A sor(ok)hoz tartozó MATLAB forráskód:

% NET | dev eth0 | pcki 11612e5 | pcko 18884e5 | in 253 Kbps | out 2 Mbps |
% NET | dev lo | pcki 19994e4 | pcko 19994e4 | in 942 Kbps | out 942 Kbps |
% NET | dev sit0 | pcki 0 | pcko 0 | in 0 Kbps | out 0 Kbps |
for i=1:3
D = fgetl(fp);
E{1,1} = DATENUMSTRING;
E{1,2} = SERVER;
E{1,3} = strtrim(D(11:18));%NAME
E{1,4} = str2num(strtrim(D(25:33)));%PCKI
E{1,5} = str2num(strtrim(D(40:48)));%PCKO
E{1,6} = str2num(cutM(K2M(strtrim(D(53:59)))));%IN
E{1,7} = str2num(cutM(K2M(strtrim(D(69:74)))));%OUT

1.5.2.3 A LogRead rutin

A létrehozott táblázatok és a hozzájuk kapcsolódó MATLAB forrás részletek:

A táblázatok attribútumai a következők:

DATUM: datetime, not null A bejegyzés dátuma

A többi attribútum elnevezése megegyezik az eredetivel:

PID: numeric(5,0), not null

SYSCPU: int, not null

USRCPU: int, not null

VGROW: int, not null

RGROW: int, not null

USERNAME: char(15), not null

THR: smallint, not null

ST: char(4), null

EXC: char(4), null

S: char(3), null

CPU: numeric(3,0), not null

CMD: char(30), not null

Pl.:

DATUM PID SYSCPU USRCPU VGROW RGROW USERNAME THR ST EXC S CPU CMD
2009-01-13 19:01:02.000 3936 2507 2884 81 12 gdm 4 -- - S 0 milter-greylis

A sor(ok)hoz tartozó MATLAB forráskód:

E{DN,1} = DATENUMSTRING;
if strcmp((strtrim(D(1:5))),'?')==1 E{DN,2}=str2num(strtrim('99999'));
else E{DN,2} = str2num(strtrim(D(1:5)));
end
E{DN,3} = str2num(cutS(Min2Sec(strtrim(D(7:14)))));
E{DN,4} = str2num(cutS(Min2Sec(strtrim(D(15:22)))));
E{DN,5} = str2num(cutM(K2M(strtrim(D(23:28)))));
E{DN,6} = str2num(cutM(K2M(strtrim(D(30:35)))));
E{DN,7} = strtrim(D(37:46));
E{DN,8} = str2num(strtrim(D(47:48)));
E{DN,9} = strtrim(D(51:52));
E{DN,10} = strtrim(D(55:57));
E{DN,11} = strtrim(D(58:61));
E{DN,12} = str2num(strtrim(regexprep( D(61:64),'%',  )));
E{DN,13} = D(66:oszlop);
colnames = {'DATUM' 'PID' 'SYSCPU' 'USRCPU' 'VGROW' 'RGROW' 'USERNAME' 'THR' 'ST' 'EXC' 'S' 'CPU' 'CMD'};
colvalues={E{DN,1} E{DN,2} E{DN,3} E{DN,4} E{DN,5} E{DN,6} E{DN,7} E{DN,8} E{DN,9} E{DN,10} E{DN,11} E{DN,12} E{DN,13}};
insert(conn, server_name, colnames, colvalues);

1.5.3 Az adatbázis felhasználása az adatelemzéshez

Pl. ha az aggregált CPU terheltséget szeretnénk megvizsgálni

Létrehozunk egy SQL_aggrCPU(DATE1.DATE2,SERVER) rutint

Az aggregált CPU használatot rajzolja ki a DATE1 és DATE2 dátumok közötti időben a SERVER kiszolgálón.

A dátumok formátuma a következő kell legyen: yyyy-mm-dd HH:MM:SS

A függvény eredménye SQL_aggrCPU('2009-02-01 00:00:00','2009-02-12 00:00:00','kuka') függvényhívás esetén: