home *** CD-ROM | disk | FTP | other *** search
/ PC World 2005 June / PCWorld_2005-06_cd.bin / software / vyzkuste / firewally / firewally.exe / framework-2.3.exe / PerfLib.pm < prev    next >
Text File  |  2002-07-08  |  13KB  |  539 lines
  1. package Win32::PerfLib;
  2.  
  3. use strict;
  4. use Carp;
  5. use vars qw($VERSION @ISA @EXPORT @EXPORT_OK $AUTOLOAD);
  6.  
  7. require Exporter;
  8. require DynaLoader;
  9. require AutoLoader;
  10.  
  11. @ISA = qw(Exporter DynaLoader);
  12.  
  13. @EXPORT = qw(
  14.          PERF_100NSEC_MULTI_TIMER
  15.          PERF_100NSEC_MULTI_TIMER_INV
  16.          PERF_100NSEC_TIMER
  17.          PERF_100NSEC_TIMER_INV
  18.          PERF_AVERAGE_BASE
  19.          PERF_AVERAGE_BULK
  20.          PERF_AVERAGE_TIMER
  21.          PERF_COUNTER_BASE
  22.          PERF_COUNTER_BULK_COUNT
  23.          PERF_COUNTER_COUNTER
  24.          PERF_COUNTER_DELTA
  25.          PERF_COUNTER_ELAPSED
  26.          PERF_COUNTER_FRACTION
  27.          PERF_COUNTER_HISTOGRAM
  28.          PERF_COUNTER_HISTOGRAM_TYPE
  29.          PERF_COUNTER_LARGE_DELTA
  30.          PERF_COUNTER_LARGE_QUEUELEN_TYPE
  31.          PERF_COUNTER_LARGE_RAWCOUNT
  32.          PERF_COUNTER_LARGE_RAWCOUNT_HEX
  33.          PERF_COUNTER_MULTI_BASE
  34.          PERF_COUNTER_MULTI_TIMER
  35.          PERF_COUNTER_MULTI_TIMER_INV
  36.          PERF_COUNTER_NODATA
  37.          PERF_COUNTER_QUEUELEN
  38.          PERF_COUNTER_QUEUELEN_TYPE
  39.          PERF_COUNTER_RATE
  40.          PERF_COUNTER_RAWCOUNT
  41.          PERF_COUNTER_RAWCOUNT_HEX
  42.          PERF_COUNTER_TEXT
  43.          PERF_COUNTER_TIMER
  44.          PERF_COUNTER_TIMER_INV
  45.          PERF_COUNTER_VALUE
  46.          PERF_DATA_REVISION
  47.          PERF_DATA_VERSION
  48.          PERF_DELTA_BASE
  49.          PERF_DELTA_COUNTER
  50.          PERF_DETAIL_ADVANCED
  51.          PERF_DETAIL_EXPERT
  52.          PERF_DETAIL_NOVICE
  53.          PERF_DETAIL_WIZARD
  54.          PERF_DISPLAY_NOSHOW
  55.          PERF_DISPLAY_NO_SUFFIX
  56.          PERF_DISPLAY_PERCENT
  57.          PERF_DISPLAY_PER_SEC
  58.          PERF_DISPLAY_SECONDS
  59.          PERF_ELAPSED_TIME
  60.          PERF_INVERSE_COUNTER
  61.          PERF_MULTI_COUNTER
  62.          PERF_NO_INSTANCES
  63.          PERF_NO_UNIQUE_ID
  64.          PERF_NUMBER_DECIMAL
  65.          PERF_NUMBER_DEC_1000
  66.          PERF_NUMBER_HEX
  67.          PERF_OBJECT_TIMER
  68.          PERF_RAW_BASE
  69.          PERF_RAW_FRACTION
  70.          PERF_SAMPLE_BASE
  71.          PERF_SAMPLE_COUNTER
  72.          PERF_SAMPLE_FRACTION
  73.          PERF_SIZE_DWORD
  74.          PERF_SIZE_LARGE
  75.          PERF_SIZE_VARIABLE_LEN
  76.          PERF_SIZE_ZERO
  77.          PERF_TEXT_ASCII
  78.          PERF_TEXT_UNICODE
  79.          PERF_TIMER_100NS
  80.          PERF_TIMER_TICK
  81.          PERF_TYPE_COUNTER
  82.          PERF_TYPE_NUMBER
  83.          PERF_TYPE_TEXT
  84.          PERF_TYPE_ZERO
  85.         );
  86.  
  87. $VERSION = '0.05';
  88.  
  89. sub AUTOLOAD {
  90.    
  91.     my $constname;
  92.     ($constname = $AUTOLOAD) =~ s/.*:://;
  93.     local $! = 0;
  94.     my $val = constant($constname);
  95.     if ($! != 0) {
  96.     if ($! =~ /Invalid/) {
  97.         $AutoLoader::AUTOLOAD = $AUTOLOAD;
  98.         goto &AutoLoader::AUTOLOAD;
  99.     }
  100.     else {
  101.         croak "Your vendor has not defined Win32::PerfLib macro $constname";
  102.     }
  103.     }
  104.     eval "sub $AUTOLOAD { $val }";
  105.     goto &$AUTOLOAD;
  106. }
  107.  
  108. bootstrap Win32::PerfLib $VERSION;
  109.  
  110. # Preloaded methods go here.
  111.  
  112. sub new
  113. {
  114.     my $proto = shift;
  115.     my $class = ref($proto) || $proto;
  116.     my $comp = shift;
  117.     my $handle;
  118.     my $self = {};
  119.     if(PerfLibOpen($comp,$handle))
  120.     {
  121.     $self->{handle} = $handle;
  122.     bless $self, $class;
  123.     return $self;
  124.     }
  125.     else
  126.     {
  127.     return undef;
  128.     }
  129.     
  130. }
  131.  
  132. sub Close
  133. {
  134.     my $self = shift;
  135.     return PerfLibClose($self->{handle});
  136. }
  137.  
  138. sub DESTROY
  139. {
  140.     my $self = shift;
  141.     if(!PerfLibClose($self->{handle}))
  142.     {
  143.     croak "Error closing handle!\n";
  144.     }
  145. }
  146.  
  147. sub GetCounterNames
  148. {
  149.     my($machine,$href) = @_;
  150.     if(ref $href ne "HASH")
  151.     {
  152.     croak("usage: Win32::PerfLib::GetCounterNames(machine,hashRef)\n");
  153.     }
  154.     my($data,@data,$num,$name);
  155.     my $retval = PerfLibGetNames($machine,$data);
  156.     if($retval)
  157.     {
  158.     @data = split(/\0/, $data);
  159.     while(@data)
  160.     {
  161.         $num = shift @data;
  162.         $name = shift @data;
  163.         $href->{$num} = $name;
  164.     }
  165.     }
  166.     $retval;
  167. }
  168.  
  169. sub GetCounterHelp
  170. {
  171.     my($machine,$href) = @_;
  172.     if(ref $href ne "HASH")
  173.     {
  174.     croak("usage: Win32::PerfLib::GetCounterHelp(machine,hashRef)\n");
  175.     }
  176.     my($data,@data,$num,$name);
  177.     my $retval = PerfLibGetHelp($machine,$data);
  178.     if($retval)
  179.     {
  180.     @data = split(/\0/, $data);
  181.     while(@data)
  182.     {
  183.         $num = shift @data;
  184.         $name = shift @data;
  185.         $href->{$num} = $name;
  186.     }
  187.     }
  188.     $retval;
  189. }
  190.  
  191. sub GetObjectList
  192. {
  193.     my $self = shift;
  194.     my $object = shift;
  195.     my $data = shift;
  196.     if(ref $data ne "HASH")
  197.     {
  198.     croak("reference isn't a hash reference!\n");
  199.     }
  200.     return PerfLibGetObjects($self->{handle}, $object, $data);
  201. }
  202.  
  203. sub GetCounterType
  204. {
  205.     my $type = shift;
  206.     my $retval;
  207.     if( &Win32::PerfLib::PERF_100NSEC_MULTI_TIMER == $type )
  208.     {
  209.     $retval = "PERF_100NSEC_MULTI_TIMER";
  210.     }
  211.     elsif( &Win32::PerfLib::PERF_100NSEC_MULTI_TIMER_INV == $type )
  212.     {
  213.     $retval = "PERF_100NSEC_MULTI_TIMER_INV";
  214.     }
  215.     elsif( &Win32::PerfLib::PERF_100NSEC_TIMER == $type )
  216.     {
  217.     $retval = "PERF_100NSEC_TIMER";
  218.     }
  219.     elsif( &Win32::PerfLib::PERF_100NSEC_TIMER_INV == $type )
  220.     {
  221.     $retval = "PERF_100NSEC_TIMER_INV";
  222.     }
  223.     elsif( &Win32::PerfLib::PERF_AVERAGE_BASE == $type )
  224.     {
  225.     $retval = "PERF_AVERAGE_BASE";
  226.     }
  227.     elsif( &Win32::PerfLib::PERF_AVERAGE_BULK == $type )
  228.     {
  229.     $retval = "PERF_AVERAGE_BULK";
  230.     }
  231.     elsif( &Win32::PerfLib::PERF_AVERAGE_TIMER == $type )
  232.     {
  233.     $retval = "PERF_AVERAGE_TIMER";
  234.     }
  235.     elsif( &Win32::PerfLib::PERF_COUNTER_BULK_COUNT == $type )
  236.     {
  237.     $retval = "PERF_COUNTER_BULK_COUNT";
  238.     }
  239.     elsif( &Win32::PerfLib::PERF_COUNTER_COUNTER == $type )
  240.     {
  241.     $retval = "PERF_COUNTER_COUNTER";
  242.     }
  243.     elsif( &Win32::PerfLib::PERF_COUNTER_DELTA == $type )
  244.     {
  245.     $retval = "PERF_COUNTER_DELTA";
  246.     }
  247.     elsif( &Win32::PerfLib::PERF_COUNTER_LARGE_DELTA == $type )
  248.     {
  249.     $retval = "PERF_COUNTER_LARGE_DELTA";
  250.     }
  251.     elsif( &Win32::PerfLib::PERF_COUNTER_LARGE_QUEUELEN_TYPE == $type )
  252.     {
  253.     $retval = "PERF_COUNTER_LARGE_QUEUELEN_TYPE";
  254.     }
  255.     elsif( &Win32::PerfLib::PERF_COUNTER_LARGE_RAWCOUNT == $type )
  256.     {
  257.     $retval = "PERF_COUNTER_LARGE_RAWCOUNT";
  258.     }
  259.     elsif( &Win32::PerfLib::PERF_COUNTER_LARGE_RAWCOUNT_HEX == $type )
  260.     {
  261.     $retval = "PERF_COUNTER_LARGE_RAWCOUNT_HEX";
  262.     }
  263.     elsif( &Win32::PerfLib::PERF_COUNTER_MULTI_BASE == $type )
  264.     {
  265.     $retval = "PERF_COUNTER_MULTI_BASE";
  266.     }
  267.     elsif( &Win32::PerfLib::PERF_COUNTER_MULTI_TIMER == $type )
  268.     {
  269.     $retval = "PERF_COUNTER_MULTI_TIMER";
  270.     }
  271.     elsif( &Win32::PerfLib::PERF_COUNTER_MULTI_TIMER_INV == $type )
  272.     {
  273.     $retval = "PERF_COUNTER_MULTI_TIMER_INV";
  274.     }
  275.     elsif( &Win32::PerfLib::PERF_COUNTER_NODATA == $type )
  276.     {
  277.     $retval = "PERF_COUNTER_NODATA";
  278.     }
  279.     elsif( &Win32::PerfLib::PERF_COUNTER_QUEUELEN_TYPE == $type )
  280.     {
  281.     $retval = "PERF_COUNTER_QUEUELEN_TYPE";
  282.     }
  283.     elsif( &Win32::PerfLib::PERF_COUNTER_RAWCOUNT == $type )
  284.     {
  285.     $retval = "PERF_COUNTER_RAWCOUNT";
  286.     }
  287.     elsif( &Win32::PerfLib::PERF_COUNTER_RAWCOUNT_HEX == $type )
  288.     {
  289.     $retval = "PERF_COUNTER_RAWCOUNT_HEX";
  290.     }
  291.     elsif( &Win32::PerfLib::PERF_COUNTER_TEXT == $type )
  292.     {
  293.     $retval = "PERF_COUNTER_TEXT";
  294.     }
  295.     elsif( &Win32::PerfLib::PERF_COUNTER_TIMER == $type )
  296.     {
  297.     $retval = "PERF_COUNTER_TIMER";
  298.     }
  299.     elsif( &Win32::PerfLib::PERF_COUNTER_TIMER_INV == $type )
  300.     {
  301.     $retval = "PERF_COUNTER_TIMER_INV";
  302.     }
  303.     elsif( &Win32::PerfLib::PERF_ELAPSED_TIME == $type )
  304.     {
  305.     $retval = "PERF_ELAPSED_TIME";
  306.     }
  307.     elsif( &Win32::PerfLib::PERF_RAW_BASE == $type )
  308.     {
  309.     $retval = "PERF_RAW_BASE";
  310.     }
  311.     elsif( &Win32::PerfLib::PERF_RAW_FRACTION == $type )
  312.     {
  313.     $retval = "PERF_RAW_FRACTION";
  314.     }
  315.     elsif( &Win32::PerfLib::PERF_SAMPLE_BASE == $type )
  316.     {
  317.     $retval = "PERF_SAMPLE_BASE";
  318.     }
  319.     elsif( &Win32::PerfLib::PERF_SAMPLE_COUNTER == $type )
  320.     {
  321.     $retval = "PERF_SAMPLE_COUNTER";
  322.     }
  323.     elsif( &Win32::PerfLib::PERF_SAMPLE_FRACTION == $type )
  324.     {
  325.     $retval = "PERF_SAMPLE_FRACTION";
  326.     }
  327.     $retval;
  328. }
  329.  
  330.  
  331.  
  332. 1;
  333. __END__
  334.  
  335. =head1 NAME
  336.  
  337. Win32::PerfLib - accessing the Windows NT Performance Counter
  338.  
  339. =head1 SYNOPSIS
  340.  
  341.   use Win32::PerfLib;
  342.   my $server = "";
  343.   Win32::PerfLib::GetCounterNames($server, \%counter);
  344.   %r_counter = map { $counter{$_} => $_ } keys %counter;
  345.   # retrieve the id for process object
  346.   $process_obj = $r_counter{Process};
  347.   # retrieve the id for the process ID counter
  348.   $process_id = $r_counter{'ID Process'};
  349.  
  350.   # create connection to $server
  351.   $perflib = new Win32::PerfLib($server);
  352.   $proc_ref = {};
  353.   # get the performance data for the process object
  354.   $perflib->GetObjectList($process_obj, $proc_ref);
  355.   $perflib->Close();
  356.   $instance_ref = $proc_ref->{Objects}->{$process_obj}->{Instances};
  357.   foreach $p (sort keys %{$instance_ref})
  358.   {
  359.       $counter_ref = $instance_ref->{$p}->{Counters};
  360.       foreach $i (keys %{$counter_ref})
  361.       {
  362.       if($counter_ref->{$i}->{CounterNameTitleIndex} == $process_id)
  363.       {
  364.           printf( "% 6d %s\n", $counter_ref->{$i}->{Counter},
  365.               $instance_ref->{$p}->{Name}
  366.             );
  367.       }
  368.       }
  369.   }
  370.  
  371. =head1 DESCRIPTION
  372.  
  373. This module allows to retrieve the performance counter of any computer
  374. (running Windows NT) in the network.
  375.  
  376. =head1 FUNCTIONS
  377.  
  378. =head2 NOTE
  379.  
  380. All of the functions return false if they fail, unless otherwise noted.
  381. If the $server argument is undef the local machine is assumed.
  382.  
  383. =over 10
  384.  
  385. =item Win32::PerfLib::GetCounterNames($server,$hashref)
  386.  
  387. Retrieves the counter names and their indices from the registry and stores them
  388. in the hash reference
  389.  
  390. =item Win32::PerfLib::GetCounterHelp($server,$hashref)
  391.  
  392. Retrieves the counter help strings and their indices from the registry and
  393. stores them in the hash reference
  394.  
  395. =item $perflib = Win32::PerfLib->new ($server)
  396.  
  397. Creates a connection to the performance counters of the given server
  398.  
  399. =item $perflib->GetObjectList($objectid,$hashref)
  400.  
  401. retrieves the object and counter list of the given performance object.
  402.  
  403. =item $perflib->Close($hashref)
  404.  
  405. closes the connection to the performance counters
  406.  
  407. =item Win32::PerfLib::GetCounterType(countertype)
  408.  
  409. converts the counter type to readable string as referenced in L<calc.html> so
  410. that it is easier to find the appropriate formula to calculate the raw counter
  411. data.
  412.  
  413. =back
  414.  
  415. =head1 Datastructures
  416.  
  417. The performance data is returned in the following data structure:
  418.  
  419. =over 10
  420.  
  421. =item Level 1
  422.  
  423.   $hashref = {
  424.       'NumObjectTypes'   => VALUE
  425.       'Objects'          => HASHREF
  426.       'PerfFreq'         => VALUE
  427.       'PerfTime'         => VALUE
  428.       'PerfTime100nSec'  => VALUE
  429.       'SystemName'       => STRING
  430.       'SystemTime'       => VALUE
  431.   }
  432.  
  433. =item Level 2
  434.  
  435. The hash reference $hashref->{Objects} has the returned object ID(s) as keys and
  436. a hash reference to the object counter data as value. Even there is only one
  437. object requested in the call to GetObjectList there may be more than one object
  438. in the result.
  439.  
  440.   $hashref->{Objects} = {
  441.       <object1>  => HASHREF
  442.       <object2>  => HASHREF
  443.       ...
  444.   }
  445.  
  446. =item Level 3
  447.  
  448. Each returned object ID has object-specific performance information. If an
  449. object has instances like the process object there is also a reference to
  450. the instance information.
  451.  
  452.   $hashref->{Objects}->{<object1>} = {
  453.       'DetailLevel'           => VALUE
  454.       'Instances'             => HASHREF
  455.       'Counters'              => HASHREF
  456.       'NumCounters'           => VALUE
  457.       'NumInstances'          => VALUE
  458.       'ObjectHelpTitleIndex'  => VALUE
  459.       'ObjectNameTitleIndex'  => VALUE
  460.       'PerfFreq'              => VALUE
  461.       'PerfTime'              => VALUE
  462.   }
  463.  
  464. =item Level 4
  465.  
  466. If there are instance information for the object available they are stored in
  467. the 'Instances' hashref. If the object has no instances there is an 'Counters'
  468. key instead. The instances or counters are numbered.
  469.  
  470.   $hashref->{Objects}->{<object1>}->{Instances} = {
  471.       <1>     => HASHREF
  472.       <2>     => HASHREF
  473.       ...
  474.       <n>     => HASHREF
  475.   }
  476.   or
  477.   $hashref->{Objects}->{<object1>}->{Counters} = {
  478.       <1>     => HASHREF
  479.       <2>     => HASHREF
  480.       ...
  481.       <n>     => HASHREF
  482.   }
  483.  
  484. =item Level 5
  485.  
  486.   $hashref->{Objects}->{<object1>}->{Instances}->{<1>} = {
  487.       Counters               => HASHREF
  488.       Name                   => STRING
  489.       ParentObjectInstance   => VALUE
  490.       ParentObjectTitleIndex => VALUE
  491.   }
  492.   or
  493.   $hashref->{Objects}->{<object1>}->{Counters}->{<1>} = {
  494.       Counter               => VALUE
  495.       CounterHelpTitleIndex => VALUE
  496.       CounterNameTitleIndex => VALUE
  497.       CounterSize           => VALUE
  498.       CounterType           => VALUE
  499.       DefaultScale          => VALUE
  500.       DetailLevel           => VALUE
  501.       Display               => STRING
  502.   }
  503.  
  504. =item Level 6
  505.  
  506.   $hashref->{Objects}->{<object1>}->{Instances}->{<1>}->{Counters} = {
  507.       <1>     => HASHREF
  508.       <2>     => HASHREF
  509.       ...
  510.       <n>     => HASHREF
  511.   }
  512.  
  513. =item Level 7
  514.  
  515.   $hashref->{Objects}->{<object1>}->{Instances}->{<1>}->{Counters}->{<1>} = {
  516.       Counter               => VALUE
  517.       CounterHelpTitleIndex => VALUE
  518.       CounterNameTitleIndex => VALUE
  519.       CounterSize           => VALUE
  520.       CounterType           => VALUE
  521.       DefaultScale          => VALUE
  522.       DetailLevel           => VALUE
  523.       Display               => STRING
  524.   }
  525.  
  526. Depending on the B<CounterType> there are calculations to do (see calc.html).
  527.  
  528. =back
  529.  
  530. =head1 AUTHOR
  531.  
  532. Jutta M. Klebe, jmk@bybyte.de
  533.  
  534. =head1 SEE ALSO
  535.  
  536. perl(1).
  537.  
  538. =cut
  539.