Proc::ProcessTable

Thank you, however those appear to give processor information for the entire machine, or current script, not for the user as a whole.

Edit: I might actually use one of those first ones. Gave me an idea for an added feature to also limit or send an alert based on total processor usage. Thank you yet again!

That is why I used the variation "top -b -n 1", so I could grab it as a string. However, Proc::ProcessTable mentioned by the other poster seems to return similar, as a Perl module. I am currently looking into calculating processor and memory usage from it.

This code seems to work. I added CPU idle percentage, just because I think it's useful to know how little idle processor you have left, so you know when you need to upgrade a server, or if you should run an intense process.

sub userMemCPUpercNidle {
  my @usernames = @_;
  my ($usercpu, $usermem, $cpuidle); # return values
  foreach my $username (@usernames){
    my $top = `top -b -n 1 -u $username`; # gets top from the system
    
    $top =~ m/(\d+\.\d+)\%id/; # matches CPU idle time
    $cpuidle = $1;
    
    my @lines = split(/\n/, $top); # split each line into an array val
+ue
    my ($cpucol,$memcol);
    foreach my $line (@lines){
      if ($line =~ m/\%CPU/){ # checks if it's collumb headers
        my $colcount = 0;
        foreach my $col (split(' ', $line)){
          if ($col eq '%CPU') {
            $cpucol = $colcount; # number of col that is the CPU val f
+or process
          } elsif ($col eq '%MEM') {
            $memcol = $colcount; # number of col that is the mem val f
+or process
          }
        
          if (defined($cpucol) && defined($memcol)){
            last;
          } else {
            $colcount++;
          }
        }
      } else {
        if (!defined($cpucol) && !defined($memcol)){
          $linecount++;
        } else {
          my @values = split(/\s+/, $line);
          $usercpu += $values[$cpucol]; # add process cpu percent to t
+otal
          $usermem += $values[$memcol]; # add process memory percent t
+o total
        }
      }
    }
  }
  return $usermem, $usercpu, $cpuidle;
}
[download]

Edit: This code was mainly written just to get it working. I didn't try to optimize it or think about how to do it better, just thought how it might be possible and did it to get it working. After looking at it later I noticed at least one major mistake. I tried to add the capability to check multiple users when first writing it, but then forgot that I had while I was writing. Will update with the code I am working on.

I was thinking about doing this. However, this would mean that the process would stay active, and I don't want that. Should be simple enough to do. I considered doing a slight wait, maybe a second or less, but considering this is actually going to be used in a CGI, not a good idea.

You could use something similar to this to check if there are enough resources for a heavy task, and keep checking, with a maximum wait time...

Response: Yes, the process would stay active, but isn't that what's needed, at least until the script ends, or the process is terminated? My guess would be to fork this check. I'm uncertain why there aren't any hooks already into the Linux kernel to do this... perhaps there are, afterall, I come from the MS world :)



---

Demize

Following is fixed code. Should now return data for multiple passed users, and return it in a hash ref, so you can access it by using ${$hash}{users}{username}{cpu}, etc.

Code is a bit cleaned up, but there are many ways I can improve it. Any suggestions are appreciated.

sub userMemCPUpercNidle {
  my @usernames = @_;
  my $topcommand = "top -b -n 1 -u ";
  my $top; # top result
  my $countusers = 0;
  my $rethash;
  
  foreach my $username (@usernames){
    $topcommand .= $username;
    if ($countusers < $#usernames){ # if there are more users
      $topcommand .= ", ";
    }
    $top = `$topcommand`; # gets top from the system
    }
    $top =~ m/(\d+\.\d+)\%id/;    # matches CPU idle time
    $rethash = {'cpuidle' => $1};  # assigns cpu idle to hash
  
  $top =~ s/^.+?Swap[^\n]+\s+//s; # removes everything before the proc
+esses
      
  my @lines = split(/\n/, $top); # split each line into an array value
  my ($cpucol,$memcol,$usrcol);
  
  my $headers = shift(@lines);
  foreach my $col (split(' ', $headers)){ # determines which collumn e
+ach value is in
    if ($col eq 'USER') {
      $usrcol = $colcount; # number of col that is the USER val for pr
+ocess
    } elsif ($col eq '%CPU') {  
      $cpucol = $colcount; # number of col that is the CPU val for pro
+cess
    } elsif ($col eq '%MEM') {  
      $memcol = $colcount; # number of col that is the mem val for pro
+cess
    }

    if (defined($usrcol) && defined($cpucol) && defined($memcol)){
      last;
    } else {
      $colcount++;
    }
  }
  
  foreach my $line (@lines){
    if (defined($cpucol) && defined($memcol) && defined($usrcol)){
      my @values = split(' ', $line);
      ${$rethash}{users}{$values[$usrcol]}{cpu} += $values[$cpucol]; #
+ add process cpu percent to total
      ${$rethash}{users}{$values[$usrcol]}{mem} += $values[$memcol]; #
+ add process memory percent to total
    }
  }
  return $rethash;
}
[download]