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