home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 11 Util / 11-Util.zip / ptdem3.zip / PEGREXX.INF (.txt) < prev    next >
OS/2 Help File  |  1994-03-08  |  23KB  |  830 lines
  1.  
  2. ΓòÉΓòÉΓòÉ 1. Notices ΓòÉΓòÉΓòÉ
  3.  
  4.                             Pegasus Resource Monitor
  5.                                   Pegasus Tools
  6.                                      PegRexx
  7.                                   Version 1.10
  8.                         (c) 1993,1994 C.O.L. Systems Inc.
  9.                                All Rights Reserved
  10.  
  11. C.O.L. Systems Inc. has been in the business of software development and 
  12. consulting since 1987. Our software has, and will continue to be, geared 
  13. towards performance and capacity management needs. 
  14.  
  15. From the stand alone OS/2 station tools (Pegasus Resource Monitor and Pegasus 
  16. Tools) to heterogeneous performance and capacity management (Osrm2*), we 
  17. continue to meet the users needs in sophisticated low price software. 
  18.  
  19. *Osrm2 (c) 1991,1994 C.O.L. Systems Inc. 
  20.  
  21. Contact and Support 
  22.  
  23. We have moved to a new location with new phones as well: 
  24.  
  25. Mailing Address: 
  26.  
  27.                                C.O.L. Systems Inc.
  28.                                10 Watergate Drive
  29.                                Amawalk, NY. 10501
  30.  
  31. Telephone Numbers for: 
  32.  
  33. Voice  -       (914) 245-0442
  34. FAX    -       (914) 245-0452
  35. BBS    -       (914) 245-1561
  36.  
  37. Other Notices 
  38.  
  39. OS/2, OS/2 REXX, and DB2/2 are copyright by IBM Corporation. 
  40.  
  41.  
  42. ΓòÉΓòÉΓòÉ 2. What is the Pegasus System? ΓòÉΓòÉΓòÉ
  43.  
  44. The Pegasus System Is set of 32 bit application: 
  45.  
  46.      The Pegasus Resource Monitor is a kernel level, real time, Presentation 
  47.      Manager monitoring tool for system and application resource usage under 
  48.      OS/2 2.x. Including a configurable sample rate, thresholds settings, 
  49.      exception notification and logging, working set analysis, kill process 
  50.      options, as well as graphical indicators, the Pegasus Resource Monitor 
  51.      provides the most comprehensive monitoring tool for OS/2. 
  52.  
  53.      The Pegasus Tools utilities are a number of system measurement and 
  54.      reporting utilities designed to provide detailed insight of system 
  55.      resource activity through intensive monitoring, log collection and post 
  56.      processing reports. These utilities include: 
  57.  
  58.           o AppMon 
  59.           o FileMon 
  60.           o CacheMon 
  61.           o PEGREXX !!! 
  62.  
  63.  
  64. ΓòÉΓòÉΓòÉ 3. PegRexx ΓòÉΓòÉΓòÉ
  65.  
  66. PegRexx 
  67.  
  68. PegRexx provides a REXX interface for processing the output logs created by the 
  69. Pegasus Tools utilities. 
  70.  
  71. Why PegRexx? 
  72.  
  73.   1. Although the Pegasus Tools package contains a generic post processor 
  74.      (PegLog), we have released PegRexx to allow users to developer their own 
  75.      output. 
  76.  
  77.   2. Many users have indicated that they would like to feed data from the 
  78.      Pegasus Tools log files directly into IBM DB2/2 and other database 
  79.      management system that support REXX. 
  80.  
  81.   3. Some users are interested in creating value added applications for the 
  82.      Pegasus user base. 
  83.  
  84.   4. I thought it would be cool. 
  85.  
  86.  The remainder of this document focuses on how to use PegRexx and create your 
  87.  own REXX processors for Pegasus Tools output logs. You can jump to the 
  88.  following topics from here: 
  89.  
  90.  o Installation 
  91.  o REXX Housekeeping 
  92.  o Functions 
  93.  o The Stem Variable 
  94.  o Sample Procs 
  95.  
  96.  
  97. ΓòÉΓòÉΓòÉ 4. Installation ΓòÉΓòÉΓòÉ
  98.  
  99. Installing the PegRexx REXX Extension DLL 
  100.  
  101. For access to the PegRexx functions through the OS/2 REXX proc interface, you 
  102. need to make the PEGREXX.DLL visible. This can be accomplished in one of three 
  103. ways: 
  104.  
  105.   1. Copy the PEGREXX.DLL file to a path already setup in your config.sys 
  106.      LIBPATH statement. 
  107.  
  108.   2. Create a new DLL path for the PEGREXX.DLL and add the path to the LIBPATH 
  109.      statement in your config.sys file. This option will require that you 
  110.      reboot your machine. 
  111.  
  112.   3. Run all REXX procs that use the PEGREXX.DLL from the same directory where 
  113.      you have placed this file. 
  114.  
  115.  Your choice. 
  116.  
  117.  
  118. ΓòÉΓòÉΓòÉ 5. REXX Housekeeping ΓòÉΓòÉΓòÉ
  119.  
  120. Before using any of the PegRexx functions, you must make the DLL entry points 
  121. known to the OS/2 REXX interface. Before exiting a REXX proc, which has loaded 
  122. the PegRexx extension, it is good practice to exit in an orderly fashion if 
  123. possible. 
  124.  
  125. The following code fragments can can be used for any REXX proc you create that 
  126. uses PegRexx. Each line is discussed following the example: 
  127.  
  128. Housekeeping Fragments 
  129.  
  130. /***************************************/
  131. /* Pegasus Log Rexx Extension          */
  132. /* Version 1.0                         */
  133. /* (c) 1993,1994 C.O.L. Systems Inc.   */
  134. /* All Rights Reserved                 */
  135. /***************************************/
  136.  
  137. /************************/
  138. /* Load the extension   */
  139. /************************/
  140.  
  141. 001:  if RxFuncQuery('PegLoadFunctions') <> 0 then do
  142. 002:     rcy = RxFuncAdd('PegLoadFunctions','PEGREXX','PegLoadFunctions');
  143. 003:     if rcy = 0 then do
  144. 004:       rcy = PegLoadFunctions();
  145. 005:       if rcy > 0 then
  146.              signal BadLoad;
  147.              end;
  148. 006:     else do
  149.            signal BadAdd;
  150.            end;
  151.          end;
  152.  
  153.       /* Your code goes here! */
  154.  
  155. /************************/
  156. /* Drop the extension   */
  157. /************************/
  158.  
  159. 007: rcx = PegDropFunctions();
  160. 008: call RXFUNCDROP 'PEGLOADFUNCTIONS';
  161. 009: exit;
  162.  
  163. Explanation of Fragment 
  164.  
  165.   1. Here we use the OS/2 REXX function RxFuncQuery which tells us if the 
  166.      PegRexx function entry points have already been loaded. If not, the 
  167.      execution falls to line 2, otherwise the PegRexx functions are already 
  168.      resident and we skip past the startup code. 
  169.  
  170.   2. Here we use the OS/2 REXX function RxFuncAdd to add the PegRexx function 
  171.      PegLoadFunctions to the REXX interface. This adds ONLY one function entry 
  172.      point. Notice the PEGREXX argument, this directs REXX to the DLL that has 
  173.      the requested function. 
  174.  
  175.   3. We check for a successful return code. If good we continue to line 4, 
  176.      otherwise we drop to line 6 which will signal a load error routine not 
  177.      shown. 
  178.  
  179.   4. The PegLoadFunctions function loads all other PegRexx function entry 
  180.      points such as PegLoadFile, etc. If the function returns a successful 
  181.      completion code of zero (0), we are now ready to use the PegRexx 
  182.      functions. 
  183.  
  184.   5. A nonzero return code invokes an error handler which exits the REXX proc. 
  185.  
  186.   6. Code invokes an error handler which exits the REXX proc. We are here if 
  187.      the RxFuncAdd failed. 
  188.  
  189.   7. This call invokes another PegRexx entry point whose job it is to release 
  190.      all of the other PegRexx function entry points except the PegLoadFunctions 
  191.      call. 
  192.  
  193.   8. We drop the PegLoadFunctions call. 
  194.  
  195.   9. Exit the REXX proc. 
  196.  
  197.  
  198. ΓòÉΓòÉΓòÉ 6. Functions ΓòÉΓòÉΓòÉ
  199.  
  200. This section describes the PegRexx functions available to the REXX developer. 
  201. We have aimed at simplicity without sacrificing functionality. If there is 
  202. anything that you think would be a valuables addition to PegRexx let's hear it! 
  203.  
  204. Entry point Load and Unload Functions 
  205.  
  206. Before using any of the PegRexx functions, you must make the DLL entry points 
  207. known to the OS/2 REXX interface. Before exiting a REXX proc, which has loaded 
  208. the PegRexx extension, it is good practice to exit in an orderly fashion if 
  209. possible. 
  210.  
  211.      PegLoadFunctions 
  212.      PegDropFunctions 
  213.  
  214.  Log Handling Functions 
  215.  
  216.  It doesn't take much to load the log files created by the Pegasus Tools 
  217.  utilities, actually it only takes one call: 
  218.  
  219.      PegLoadFile 
  220.  
  221.  Date and Time Stamp Functions 
  222.  
  223.  If you have looked at the section on how PegRexx populates the stem variable 
  224.  passed to the PegLoadFile function you will have noticed reference to the Time 
  225.  and Date stamp on the data record. Here are two functions that can be used to 
  226.  convert this variable to a number of different time and date string formats: 
  227.  
  228.      GetDate 
  229.      GetTime 
  230.  
  231.  Metric Classification Functions 
  232.  
  233.  Originally put in as a means of self documentation, we found that with a 
  234.  little manipulation we could have this function assist in the construction of 
  235.  data group metric stem variables. 
  236.  
  237.      PegMetric 
  238.  
  239.  
  240. ΓòÉΓòÉΓòÉ 6.1. GetDate ΓòÉΓòÉΓòÉ
  241.  
  242.       GetDate ( options  , TDS )
  243.  
  244. GetDate returns the date and time information derived from the Time and Date 
  245. Stamp (TDS) in the format: dayname mon day hh:mm:ss yyyy (for example, Tue Jan 
  246. 25 23:29:42 1994), For mon and dayname, the first three characters of the 
  247. English name of the month and day will be used. 
  248.  
  249. The following options (of which only the capitalized letter is needed, all 
  250. others are ignored) can be used to obtain alternative formats: 
  251.  
  252.  European       Returns date in the format: dd/mm/yy. 
  253.  
  254.  Language       Returns date in an implementation and language dependent or 
  255.                 local date format. In the OS/2 operating system, the Language 
  256.                 format is dd Month yyyy. If no local format is available, the 
  257.                 default format is returned. 
  258.  
  259.  Month          Returns full English name of the current month, for example, 
  260.                 August. 
  261.  
  262.  Ordered        Returns date in the format: yy/mm/dd (suitable for sorting, and 
  263.                 so on.) 
  264.  
  265.  Sorted         Returns date in the format: yyyymmdd (suitable for sorting, and 
  266.                 so on.) 
  267.  
  268.  Usa            Returns date in the format: mm/dd/yy 
  269.  
  270.  Weekday        Returns the English name for the day of the week, in mixed 
  271.                 case. For example, Tuesday. 
  272.  
  273.  Here is an example: 
  274.  
  275.  
  276.      do count = 1 to Stem.Records
  277.         say   GetDate(,Stem.Records.count.TDS);
  278.         say   GetDate('O',Stem.Records.count.TDS);
  279.         say   GetDate('U',Stem.Records.count.TDS);
  280.         end;
  281.  
  282.  
  283. ΓòÉΓòÉΓòÉ 6.2. GetTime ΓòÉΓòÉΓòÉ
  284.  
  285.       GetTime ( 'M'  , tds )
  286.  
  287. GetTime returns the date and time information derived from the Time and Date 
  288. Stamp (TDS) in the format: dayname mon day hh:mm:ss yyyy (for example, Tue Jan 
  289. 25 23:29:42 1994), For mon and dayname, the first three characters of the 
  290. English name of the month and day will be used. 
  291.  
  292. The following options (of which only the capitalized letter is needed, all 
  293. others are ignored) can be used to obtain alternative formats: 
  294.  
  295.  Civil          Returns hh:mmxx, the time in Civil format, in which the hours 
  296.                 may take the values 1 through 12, and the minutes the values 00 
  297.                 through 59.  The minutes are followed immediately by the 
  298.                 letters "am" or "pm" to distinguish times in the morning 
  299.                 (midnight 12:00am through 11:59am) from noon and afternoon 
  300.                 (noon 12:00pm through 11:59pm).  The hour will not have a 
  301.                 leading zero. 
  302.  
  303.  Hours          Returns number of hours since midnight in the format: hh (no 
  304.                 leading zeros). 
  305.  
  306.  Minutes        Returns number of minutes since midnight in the format: mmmm 
  307.                 (no leading zeros). 
  308.  
  309.  Seconds        Returns number of seconds since midnight in the format: sssss 
  310.                 (no leading zeros). 
  311.  
  312.  Normal         Returns the time in the default format hh:mm:ss. 
  313.  
  314.  Here is an example: 
  315.  
  316.  
  317.      do count = 1 to Stem.Records
  318.         say   GetTime(,Stem.Records.count.TDS);
  319.         say   GetTime('S',Stem.Records.count.TDS);
  320.         say   GetTime('N',Stem.Records.count.TDS);
  321.         end;
  322.  
  323.  
  324. ΓòÉΓòÉΓòÉ 6.3. PegDropFunctions ΓòÉΓòÉΓòÉ
  325.  
  326.       PegDropFunctions ( )
  327.  
  328. The PegDropFunctions function deregisters all of the PegRexx function entry 
  329. points from the REXX interface. Once this function is called you will be unable 
  330. to call any of the PegRexx functions. 
  331.  
  332. The function will return '0' if no errors occured, otherwise it is the error 
  333. code returned from the REXX API call to deregister the function. 
  334.  
  335. Here is an example: 
  336.  
  337.  
  338.    rcx = PegDropFunctions();
  339.    if rcx == 0 then
  340.       say   'PegRexx functions no longer available';
  341.    else
  342.       say   'Unable to deregister PegRexx functions';
  343.  
  344.  
  345. ΓòÉΓòÉΓòÉ 6.4. PegLoadFunctions ΓòÉΓòÉΓòÉ
  346.  
  347.       PegLoadFunctions ( )
  348.  
  349. The PegLoadFunctions function registers all of the PegRexx function entry 
  350. points to the REXX interface. Once this function is called you will be able to 
  351. call any of the PegRexx functions. 
  352.  
  353. The function will return '0' if no errors occured, otherwise it is the error 
  354. code returned from the REXX API call to register the functions. 
  355.  
  356. Here is an example: 
  357.  
  358.  
  359.    if RxFuncQuery('PegLoadFunctions') <> 0 then do
  360.       rcy = RxFuncAdd('PegLoadFunctions','PEGREXX','PegLoadFunctions');
  361.       if rcy = 0 then do
  362.          rcy = PegLoadFunctions();
  363.          if rcy > 0 then
  364.             signal BadLoad;
  365.             end;
  366.       else do
  367.          signal BadAdd;
  368.          end;
  369.       end;
  370.  
  371.  
  372. ΓòÉΓòÉΓòÉ 6.5. PegLoadFile ΓòÉΓòÉΓòÉ
  373.  
  374.       PegLoadFile ( 'file' , 'stem.' )
  375.  
  376. The PegLoadFile function loads the Pegasus Tools utility log file and populates 
  377. the specified stem. variable. 
  378.  
  379. Note:  You must include the period '.' on the stem variable as well as 
  380. enclosing the entire argument in quotes in order for the function to correctly 
  381. build the resulting stem tree. For a full description of the stem variable 
  382. refer to Stem Variable. 
  383.  
  384. This function returns a zero (0) completion code if no errors where detected. 
  385.  
  386. Here is an example which assumes the PegRexx functions have been registered: 
  387.  
  388.  
  389.    MyStem. = "";
  390.  
  391.    Parse Arg FileFrmCmdLine
  392.  
  393.    rcx = PegLoadFile( FileFrmCmdLine, 'MyStem.' );
  394.  
  395.    if rcx == 0 then do
  396.       /* Your code goes here  */
  397.       end;
  398.  
  399.  
  400. ΓòÉΓòÉΓòÉ 6.6. PegMetric ΓòÉΓòÉΓòÉ
  401.  
  402.       PegMetric( 'group', index , 'D' )
  403.  
  404. The PegMetric returns various information about the Pegasus data group. If 
  405. called with just the group name, this function will return the count of data 
  406. metrics that may be used on the stem to retrieve data. If index is specified 
  407. then the function will return the metric name for that index. If the 'D' option 
  408. is also supplied, the a short description will be returned for the metric 
  409. specified in index. 
  410.  
  411. For group names that have no meaning, the error 'UNKNOWN' will be returned. For 
  412. indexes that accede the number of metrics, the error 'BOUNDS' will be returned. 
  413.  
  414. Here is a way to generate a group metric listing: 
  415.  
  416. count = PegMetric('CPU');
  417. say;
  418. say   'CPU metrics and descriptions. Number of metrics = 'count;
  419. say;
  420.  
  421. do items = 1 to count
  422.    say   left(PegMetric('CPU',items),14)' 'PegMetric('CPU',items,'D');
  423.    end;
  424.  
  425. Here is a way to have a self generating report: 
  426.  
  427.  
  428.    PegLoadFile(MyFile,'Data1.');
  429.  
  430.    metcnt = PegMetric('FIL');          /* Get for later calls  */
  431.  
  432.    do count = 1 to Data1.Records
  433.       do fcount = 1 to Data1.Records.count.FIL
  434.          do mcount = 1 to metcnt
  435.             dataRef = 'Data1.Records.'||count||'.FIL.'||fcount||PegMetric('FIL',mcount);
  436.             say 'File 'PegMetric('FIL',mcount)' = 'value(dataRef);
  437.             end;
  438.          end;
  439.       end;
  440.  
  441.  
  442. ΓòÉΓòÉΓòÉ 7. Stem Variable ΓòÉΓòÉΓòÉ
  443.  
  444. This section describes how PegRexx populates the Stem variable passed to the 
  445. PegLoadFile function. 
  446.  
  447. The Stem Graphic shows each of the stem variables and combinations that may 
  448. contain data once the log file has been read. Both the root stem and leaf 
  449. identifiers are linked to footnotes describing in detail their meaning. 
  450.  
  451.  
  452. ΓòÉΓòÉΓòÉ 7.1. Stem Graphic ΓòÉΓòÉΓòÉ
  453.  
  454. Following is the Stem layout graphic. For detailed information, double click on 
  455. any of the highlighted items. All of the items refer to Stem. which you would 
  456. substitute for the name of the REXX compound variable you use with the 
  457. PegLoadFile. 
  458.  
  459.                      Stem.
  460.                       Γöé
  461.                       Γö£ΓöÇΓöÇΓöÇ FileName
  462.                       Γöé
  463.                       Γö£ΓöÇΓöÇΓöÇ Title
  464.                       Γöé
  465.                       Γö£ΓöÇΓöÇΓöÇ Creator
  466.                       Γöé
  467.                       Γö£ΓöÇΓöÇΓöÇ Resources
  468.                       Γöé          Γöé
  469.                       Γöé          ΓööΓöÇΓöÇ Resources.N
  470.                       Γöé
  471.                       ΓööΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇ Records
  472.                          Γöé
  473.                          Γöé
  474.                          Γö£ΓöÇΓöÇΓöÇ Applications
  475.                          Γöé       |
  476.                          Γöé       ΓööΓöÇΓöÇ Applications.N
  477.                          Γöé             Γöé
  478.                          Γöé             Γö£ΓöÇ Name
  479.                          Γöé             Γöé
  480.                          Γöé             ΓööΓöÇ PID
  481.                          Γöé
  482.                          Γöé
  483.                          Γö£ΓöÇΓöÇΓöÇ Files
  484.                          Γöé       |
  485.                          Γöé       ΓööΓöÇΓöÇ Files.N
  486.                          Γöé             Γöé
  487.                          Γöé             Γö£ΓöÇ Name
  488.                          Γöé             Γöé
  489.                          Γöé             Γö£ΓöÇ PID
  490.                          Γöé             Γöé
  491.                          Γöé             ΓööΓöÇ UID
  492.                          Γöé
  493.                       ΓöîΓöÇΓöÇΓöÿ
  494.                       Γöé
  495.                   Record.N
  496.                       Γöé
  497.                       Γöé
  498.                       Γö£ΓöÇΓöÇΓöÇ TDS
  499.                       Γöé
  500.                       Γöé
  501.                       Γö£ΓöÇΓöÇΓöÇ MT
  502.                       Γöé
  503.                       Γöé
  504.                       Γö£ΓöÇΓöÇΓöÇ CPU
  505.                       Γöé
  506.                       Γöé
  507.                       Γö£ΓöÇΓöÇΓöÇ MEM
  508.                       Γöé
  509.                       Γöé
  510.                       Γö£ΓöÇΓöÇΓöÇ FC
  511.                       Γöé
  512.                       Γöé
  513.                       Γö£ΓöÇΓöÇΓöÇ HC
  514.                       Γöé
  515.                       Γöé
  516.      ΓöîΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö┤ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓö¼ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÉ
  517.      Γöé                         Γöé                         Γöé
  518.     DSK                       FIL                       THD
  519.      |                         |                         |
  520.   +--+--+                   +--+--+                   +--+--+
  521.   |     |                   |     |                   |     |
  522.  DSK.1 DSK.N               FIL.1 FIL.N               THD.1 THD.N
  523.  
  524. For details on each data group and their individual metrics, run the
  525. DATADICT.CMD file.
  526.  
  527.  
  528. ΓòÉΓòÉΓòÉ 8. Sample Procs ΓòÉΓòÉΓòÉ
  529.  
  530. This section describes the sample REXX procs included with the PegRexx OS/2 
  531. REXX extension. 
  532.  
  533.      o DataDict.Cmd - This proc can be used to generate a full listing of all 
  534.        the data group metrics and a short description of each. 
  535.  
  536.      o CpuSamp.Cmd - This proc can be used with the log file from any of the 
  537.        Pegasus Tools utilities that had the System Cpu track option set. The 
  538.        proc expects the name of the log file as input from the command line. 
  539.  
  540.      o MemSamp.Cmd - This proc can be used with the log file from the CacheMon 
  541.        utility if the Memory track option was set. The proc expects the name of 
  542.        the log file as input from the command line. 
  543.  
  544.      o FcSamp.Cmd - This proc can be used with the log file from the CacheMon 
  545.        utility if the FAT Cache track option was set. The proc expects the name 
  546.        of the log file as input from the command line. 
  547.  
  548.      o IOSamp.Cmd - This proc can be used with the log file from the FileMon 
  549.        utility if the Files track option was set. The proc expects the name of 
  550.        the log file as input from the command line. 
  551.  
  552.  
  553. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  554.  
  555. Usage Syntax:  Stem. 
  556.  
  557. The Stem. variable is the REXX compound variable that you pass to the PegRexx 
  558. PegLoadFile function. PegRexx uses this to store all the information processed 
  559. from the Pegasus Tools log input. This also provides a means to load more than 
  560. one log file at a time using unique stem variable names. 
  561.  
  562.  
  563. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  564.  
  565. Usage Syntax:  Stem.FileName 
  566.  
  567. The Stem.FileName variable contains the filename passed to the PegRexx 
  568. PegLoadFile function. 
  569.  
  570.  
  571. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  572.  
  573. Usage Syntax:  Stem.Title 
  574.  
  575. The Stem.Title variable contains the title placed in the log by the Pegasus 
  576. Tools utility that created it. 
  577.  
  578.  
  579. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  580.  
  581. Usage Syntax:  Stem.Creator 
  582.  
  583. The Stem.Creator variable contains the numeric ID of the Pegasus Tools utility 
  584. that created it. Possible values are: 
  585.  
  586.  o AppMon = 1 
  587.  o FileMon = 2 
  588.  o CacheMon = 3 
  589.  
  590.  
  591. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  592.  
  593. Usage Syntax:  Stem.Resources 
  594.  
  595. The Stem.Resources variable contains the number (count) of metric group flags 
  596. found in the information header of input log file. This count can be used to 
  597. setup a loop control for interrogating which metric resources were selected 
  598. with the log creating utility. See Stem.Resource.N for additional information. 
  599.  
  600.  
  601. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  602.  
  603. Usage Syntax:  Stem.Resources.N 
  604.  
  605. The Stem.Resources.N, where 1 <= N <= Stem.Resources, contains the text string 
  606. group name of resources that were flagged as collected in the Pegasus Tools 
  607. utility that created the log. 
  608.  
  609.  
  610. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  611.  
  612. Usage Syntax:  Stem.Records 
  613.  
  614. Contains the count of the number of data stem records attached to the stem 
  615. variable. Each record contains the detail data information for the measurements 
  616. collected by the creating utility. Each individual record is addressed by: 
  617.  
  618.  
  619.    Stem.Records.N
  620.  
  621.    where
  622.  
  623.       1 <= N <= Stem.Records.
  624.  
  625.  
  626. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  627.  
  628. Usage Syntax:  Stem.Applications 
  629.  
  630. Contains the count for the number of unique application entries in the 
  631. Application Table. 
  632.  
  633.  
  634. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  635.  
  636. Usage Syntax:  Stem.Applications.N.variable 
  637.  
  638. The Stem.Applications.N, where 1 <= N <= Stem.Applications, is a stem variable 
  639. for each application entry in the Application Table. For each application 
  640. entry, the following variables are present: 
  641.  
  642.      o Application Name - Name 
  643.      o Application Process ID - PID 
  644.  
  645.  
  646. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  647.  
  648. Usage Syntax:  Stem.Applications.N.Name 
  649.  
  650. This variable contains the application name string for the application entry. 
  651.  
  652.  
  653. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  654.  
  655. Usage Syntax:  Stem.Applications.N.PID 
  656.  
  657. This variable contains the process identifier (PID) for the application entry. 
  658.  
  659.  
  660. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  661.  
  662. Usage Syntax:  Stem.Files 
  663.  
  664. Contains the count for the number of unique file entries in the File Table. 
  665.  
  666.  
  667. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  668.  
  669. Usage Syntax:  Stem.Files.N.variable 
  670.  
  671. The Stem.Files.N, where 1 <= N <= Stem.Files, is a stem variable for each file 
  672. entry in the File Table. For each file entry, the following variables are 
  673. present: 
  674.  
  675.      o File Name - Name 
  676.      o Owner Process ID - PID 
  677.      o Unique ID - UID 
  678.  
  679.  
  680. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  681.  
  682. Usage Syntax:  Stem.Files.N.Name 
  683.  
  684. This variable contains the file name string for the file entry. 
  685.  
  686.  
  687. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  688.  
  689. Usage Syntax:  Stem.Files.N.PID 
  690.  
  691. This variable contains the process identifier (PID) for the application that 
  692. owns the file in the File Table. This can be used as a cross reference lookup 
  693. into the Application Table. 
  694.  
  695.  
  696. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  697.  
  698. Usage Syntax:  Stem.Files.N.UID 
  699.  
  700. This variable contains the unique identifier (UID) for the file. This can be 
  701. used as a lookup argument when processing the file metric groups in each record 
  702. to resolve file names. 
  703.  
  704.  
  705. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  706.  
  707. Usage Syntax:  Stem.Records.N.TDS 
  708.  
  709. Contains the time and date stamp that this record was created by the creating 
  710. Pegasus Tools utility. This value can be used with the PegRexx functions 
  711. GetDate and GetTime. 
  712.  
  713.  
  714. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  715.  
  716. Usage Syntax:  Stem.Records.N.MT 
  717.  
  718. Contains the number of milliseconds for the sample interval between the last 
  719. record and this. 
  720.  
  721.  
  722. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  723.  
  724. Usage Syntax:  Stem.Records.N.CPU 
  725.  
  726. Contains a Boolean (0 or 1) flag which indicates the presence of the CPU group 
  727. metrics in this record. 
  728.  
  729. Refer to the PegRexx PegMetric function to determine how many metrics, each of 
  730. their REXX variable names, and a description of the metric contained in this 
  731. group. 
  732.  
  733.  
  734. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  735.  
  736. Usage Syntax:  Stem.Records.N.MEM 
  737.  
  738. Contains a Boolean (0 or 1) flag which indicates the presence of the MEM group 
  739. metrics in this record. 
  740.  
  741. Refer to the PegRexx PegMetric function to determine how many metrics, each of 
  742. their REXX variable names, and a description of the metric contained in this 
  743. group. 
  744.  
  745.  
  746. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  747.  
  748. Usage Syntax:  Stem.Records.N.THD 
  749.  
  750. Contains the number of thread group metrics attached to this record. Each 
  751. individual thread group metric is addressed by: 
  752.  
  753.  
  754.    Stem.Records.N.THD.X.metric
  755.  
  756.    where:
  757.  
  758.        1 <= N <= Stem.Records
  759.  
  760.        1 <= X <= Stem.Records.N.THD
  761.  
  762. Refer to the PegRexx PegMetric function to determine how many metrics, each of 
  763. their REXX variable names, and a description of the metric contained in this 
  764. group. 
  765.  
  766.  
  767. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  768.  
  769. Usage Syntax:  Stem.Records.N.FIL 
  770.  
  771. Contains the number of file group metrics attached to this record. Each 
  772. individual file group metric is addressed by: 
  773.  
  774.  
  775.    Stem.Records.N.FIL.X.metric
  776.  
  777.    where:
  778.  
  779.        1 <= N <= Stem.Records
  780.  
  781.        1 <= X <= Stem.Records.N.FIL
  782.  
  783. Refer to the PegRexx PegMetric function to determine how many metrics, each of 
  784. their REXX variable names, and a description of the metric contained in this 
  785. group. 
  786.  
  787.  
  788. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  789.  
  790. Usage Syntax:  Stem.Records.N.DSK 
  791.  
  792. Contains the number of physical disk group metrics attached to this record. 
  793. Each individual disk group metric is addressed by: 
  794.  
  795.  
  796.    Stem.Records.N.DSK.X.metric
  797.  
  798.    where:
  799.  
  800.        1 <= N <= Stem.Records
  801.  
  802.        1 <= X <= Stem.Records.N.DSK
  803.  
  804. Refer to the PegRexx PegMetric function to determine how many metrics, each of 
  805. their REXX variable names, and a description of the metric contained in this 
  806. group. 
  807.  
  808.  
  809. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  810.  
  811. Usage Syntax:  Stem.Records.N.FC 
  812.  
  813. Contains a Boolean (0 or 1) flag which indicates the presence of the FAT Cache 
  814. group metrics in this record. 
  815.  
  816. Refer to the PegRexx PegMetric function to determine how many metrics, each of 
  817. their REXX variable names, and a description of the metric contained in this 
  818. group. 
  819.  
  820.  
  821. ΓòÉΓòÉΓòÉ <hidden>  ΓòÉΓòÉΓòÉ
  822.  
  823. Usage Syntax:  Stem.Records.N.HC 
  824.  
  825. Contains a Boolean (0 or 1) flag which indicates the presence of the HPFS Cache 
  826. group metrics in this record. 
  827.  
  828. Refer to the PegRexx PegMetric function to determine how many metrics, each of 
  829. their REXX variable names, and a description of the metric contained in this 
  830. group.