GTop(3)

NAME
GTop - Perl interface to libgtop

SYNOPSIS
 use GTop ();
 my $gtop = GTop->new;

DESCRIPTION
Perl interface to libgtop:

 http://ftp.gnome.org/pub/gnome/sources/libgtop/

CLASSES

  GTop::Cpu
    my $cpu = $gtop->cpu;

flags
        my $flags = $cpu->flags;

total
        my $total = $cpu->total;

user
        my $user = $cpu->user;

nice
        my $nice = $cpu->nice;

sys
        my $sys = $cpu->sys;

idle
        my $idle = $cpu->idle;

frequency
        my $frequency = $cpu->frequency;

  GTop::Fsusage
    my $fsusage = $gtop->fsusage($disk);

flags
        my $flags = $fsusage->flags;

blocks
        my $blocks = $fsusage->blocks;

bfree
        my $bfree = $fsusage->bfree;

bavail
        my $bavail = $fsusage->bavail;

files
        my $files = $fsusage->files;

ffree
        my $ffree = $fsusage->ffree;

  GTop::Loadavg
    my $loadavg = $gtop->loadavg;

flags
        my $flags = $loadavg->flags;

nr_running
        my $nr_running = $loadavg->nr_running;

nr_tasks
        my $nr_tasks = $loadavg->nr_tasks;

last_pid
        my $last_pid = $loadavg->last_pid;

  GTop::Mem
    my $mem = $gtop->mem;

flags
        my $flags = $mem->flags;

total
        my $total = $mem->total;

used
        my $used = $mem->used;

free
        my $free = $mem->free;

shared
        my $shared = $mem->shared;

buffer
        my $buffer = $mem->buffer;

cached
        my $cached = $mem->cached;

user
        my $user = $mem->user;

locked
        my $locked = $mem->locked;

  GTop::Mountlist
    my $mountlist = $gtop->mountlist($all_fs);

flags
        my $flags = $mountlist->flags;

number
        my $number = $mountlist->number;

total
        my $total = $mountlist->total;

size
        my $size = $mountlist->size;

  GTop::Netload
    my $netload = $gtop->netload($interface);

flags
        my $flags = $netload->flags;

if_flags
        my $if_flags = $netload->if_flags;

mtu
        my $mtu = $netload->mtu;

subnet
        my $subnet = $netload->subnet;

address
        my $address = $netload->address;

packets_in
        my $packets_in = $netload->packets_in;

packets_out
        my $packets_out = $netload->packets_out;

packets_total
        my $packets_total = $netload->packets_total;

bytes_in
        my $bytes_in = $netload->bytes_in;

bytes_out
        my $bytes_out = $netload->bytes_out;

bytes_total
        my $bytes_total = $netload->bytes_total;

errors_in
        my $errors_in = $netload->errors_in;

errors_out
        my $errors_out = $netload->errors_out;

errors_total
        my $errors_total = $netload->errors_total;

collisions
        my $collisions = $netload->collisions;

  GTop::ProcArgs
    my $proc_args = $gtop->proc_args($pid);

flags
        my $flags = $proc_args->flags;

size
        my $size = $proc_args->size;

  GTop::ProcMap
    my $proc_map = $gtop->proc_map($pid);

flags
        my $flags = $proc_map->flags;

number
        my $number = $proc_map->number;

total
        my $total = $proc_map->total;

size
        my $size = $proc_map->size;

  GTop::ProcMem
    my $proc_mem = $gtop->proc_mem($pid);

flags
        my $flags = $proc_mem->flags;

size
        my $size = $proc_mem->size;

vsize
        my $vsize = $proc_mem->vsize;

resident
        my $resident = $proc_mem->resident;

share
        my $share = $proc_mem->share;

rss
        my $rss = $proc_mem->rss;

rss_rlim
        my $rss_rlim = $proc_mem->rss_rlim;

  GTop::ProcSegment
    my $proc_segment = $gtop->proc_segment($pid);

flags
        my $flags = $proc_segment->flags;

text_rss
        my $text_rss = $proc_segment->text_rss;

shlib_rss
        my $shlib_rss = $proc_segment->shlib_rss;

data_rss
        my $data_rss = $proc_segment->data_rss;

stack_rss
        my $stack_rss = $proc_segment->stack_rss;

dirty_size
        my $dirty_size = $proc_segment->dirty_size;

start_code
        my $start_code = $proc_segment->start_code;

end_code
        my $end_code = $proc_segment->end_code;

start_stack
        my $start_stack = $proc_segment->start_stack;

  GTop::ProcState
    my $proc_state = $gtop->proc_state($pid);

flags
        my $flags = $proc_state->flags;

  GTop::ProcTime
    my $proc_time = $gtop->proc_time($pid);

flags
        my $flags = $proc_time->flags;

start_time
        my $start_time = $proc_time->start_time;

rtime
        my $rtime = $proc_time->rtime;

utime
        my $utime = $proc_time->utime;

stime
        my $stime = $proc_time->stime;

cutime
        my $cutime = $proc_time->cutime;

cstime
        my $cstime = $proc_time->cstime;

timeout
        my $timeout = $proc_time->timeout;

it_real_value
        my $it_real_value = $proc_time->it_real_value;

frequency
        my $frequency = $proc_time->frequency;

  GTop::ProcUid
    my $proc_uid = $gtop->proc_uid($pid);

flags
        my $flags = $proc_uid->flags;

uid
        my $uid = $proc_uid->uid;

euid
        my $euid = $proc_uid->euid;

gid
        my $gid = $proc_uid->gid;

egid
        my $egid = $proc_uid->egid;

pid
        my $pid = $proc_uid->pid;

ppid
        my $ppid = $proc_uid->ppid;

pgrp
        my $pgrp = $proc_uid->pgrp;

session
        my $session = $proc_uid->session;

tty
        my $tty = $proc_uid->tty;

tpgid
        my $tpgid = $proc_uid->tpgid;

priority
        my $priority = $proc_uid->priority;

nice
        my $nice = $proc_uid->nice;

  GTop::Proclist
    my $proclist = $gtop->proclist;

flags
        my $flags = $proclist->flags;

number
        my $number = $proclist->number;

total
        my $total = $proclist->total;

size
        my $size = $proclist->size;

  GTop::Swap
    my $swap = $gtop->swap;

flags
        my $flags = $swap->flags;

total
        my $total = $swap->total;

used
        my $used = $swap->used;

free
        my $free = $swap->free;

pagein
        my $pagein = $swap->pagein;

pageout
        my $pageout = $swap->pageout;

  GTop::Uptime
    my $uptime = $gtop->uptime;

flags
        my $flags = $uptime->flags;

AUTHOR
Currently maintained by Malcolm J Harwood <mjh@cpan.org>.

Previously maintained by Stas Bekman <stas@stason.org>.

Doug MacEachern wrote the original version.