How MSU and MIPS Columns Are Included in Staged Tables for the SMF Adapter

Overview of the MIPS and MSU Automation Process

In SAS IT Resource Management 3.2 and later, additional columns are included. These columns enhance the reporting of resource utilization for various categories of SMF activity, such as systems, LPARs, workloads, workload periods, jobs, TSO and OMVS sessions, and more. The additional columns reflect MSU (millions of service units) and MIPS (millions of instructions per second) based on CPU time expended during the activity. These columns are distinct from other MSU-related columns that are already present in the SMF raw data. The following topics explain how the population of these new resource utilization columns in several of the SMF performance-based adapters and tables were automated.

Calculation Dependencies for MIPS and MSU Columns

The calculation of MIPS and MSU columns for SMF staged tables depend on the following items:
  • the creation of the MXG RMF interval data set. The following columns are extracted directly or derived from this data:
    • ID of the physical machine (MXG column SYSTEM)
    • ID of the physical CEC (MXG column CECSER)
    • CPU Model ID (MXG column CPCFNAME)
    • CPU Model Capacity Type (Full or Sub, value determined from CPCFNAME value)
    • Number of CPUs for the CPU model (MXG column NRCPUS)
    • Number of IFA specialty engines configured for use (MXG column NRIFAS)
    • Number of ZIP specialty engines configured for use (MXG column NRZIPS)
    • Total configured CPU engines. This column is the key merge column with the IBM Large System Performance Reference (LSPR) information.
      • If the CPU model is full capacity, this column is calculated as the sum of all configured standard, IFA, and ZIP engines.
      • If the CPU model is sub-capacity, the MXG column NRCPUS value is used.
    • Adjusted CPU Model ID:
      • If the CPU model is full capacity, the value of this column is determined by recalculating CPU engine specification to include the quantity of those IFA and ZIP engines that are also configured.
      • If the CPU model is sub-capacity, the MXG column CPCFNAME value is used.
    • Software service unit rate constant (MXG column CECSUSEC)
    • Hardware service unit rate constant (MXG column SU_SEC)
    • CPU Model MSU capacity (MXG column CPCMSU)
    • Minimum datetime present in the RMF interval data for the combination of the previously listed columns
    • Maximum datetime present in the RMF interval data for the combination of the previously listed columns
  • the availability of Vendor-supplied LSPR Resource Chart from IBM, from which the following columns are extracted:
    • CPU Model ID (This column is labeled Processor in the Vendor-Supplied LSPR Resource Chart. It is a key column that is used for merging with RMF interval data.)
    • CPU model available CPUs (This column is labeled #CP in the resource chart.)
    • IBM Processor Capacity Index (Also known as MIPS, this column is labeled PCI in the Vendor-Supplied LSPR Resource Chart.)
    • CPU Model MSU capacity (Also known as MSU, this column is labeled MSU in the Vendor-Supplied LSPR Resource Chart.)
  • the normalization of all CPU times used in MSU and MIPS calculations. (Based on current information, these CPU times are normalized in MXG.)
As noted in the preceding list of required items, MSU columns and MIPS columns require that the MXG RMF Interval data set be created. This table requires SMF record types 70, 71, 72, 75, and 78 to be present in the raw data that is being processed. If these record types are not present, the RMF Interval data set will be empty and the MIPS columns will be missing. For more information, see New MSU and MIPS Fields in the XJOBS Table That Depend on RMF Data.
The presence of these record types is especially important when staging the XJOBS table if you have a separate staging job for the XJOBS staged table. If the RMF data is not stored on the same raw data file as the SMF records for jobs, concatenate the two SMF files together. Thus, SMF records that are related to jobs and RMF data are both available to the XJOBS staging job. It is not necessary to add the RMF Interval table, XRMFINT, to the XJOBS staging job.

Working with LSPR Tables

SAS IT Resource Management supplies an initial copy of a SAS data set that is called ITMS_SMF_LSPRDATA. The version of the Large System Performance Reference (LSPR) table that forms the basis for the table that is shipped with SAS IT Resource Management 3.6 and later is z/OS V2 R1. It is dated January 2015.
This data set is stored in the SASHELP library and contains LSPR information that is based on the IBM table for z/OS V2 R1. The data set also contains columns that enhance the reporting of resource utilization for various categories of System Management Facility (SMF) activity. Among these categories are systems, logical partitions (LPARs), workloads, workload periods, TSO and OMVS sessions, and jobs. The additional columns are distinct from other MSU-related columns that are already present in the SMF raw data. They reflect MSU and MIPS and are based on the CPU time expended during the activity. You can use the LSPR tables to prepare and initialize the MIPS and MSU columns.
SAS IT Resource Management can merge the LSPR information with staged Resource Management Facility (RMF) interval data. For information about this topic, see Staging Methodology for MIPS and MSU Columns.
Note: IBM might update this information with new processors or other information at a later date. IBM might also change the location of the LSPR table. Therefore, the LSPR information might need to be updated. If an update is needed, then one of the following two methods can be used to create an updated copy of the LSPR information. If LSPR data is derived or updated from a different vendor, values might be represented differently from what SAS IT Resource Management expects. This data might cause unpredictable results in the staging job.

Initialization and Preparation of the MIPS and MSU Columns

Methods for Including MIPS and MSU Columns in Staging Tables

Tip
The following methods update the IT Resource Management Admin library. Therefore, make sure that you have a backup copy of that library before you proceed.
To import MIPS and MSU columns for inclusion in your staging tables and to save them into a permanent SAS data set, perform one of the two following methods:
  • Method 1, which is applicable to all operating systems
  • Method 2, which is applicable to all operating systems except z/OS
The following method, Method 1, is applicable to all operating systems.
Tip
Be sure to specify http instead of https in the FILENAME statement. In addition, verify that the URL specified for lsprurl is the location of the LSPR table that is appropriate for your site.
Run the following code:
filename lsprurl url 'http://www-304.ibm.com/servers/
                    resourcelink/lib03060.nsf/pages/
                    lsprITRzOSv2r1?OpenDocument';

libname admin "<location-of-the-ADMIN-library>";


data work.lsprdata;
   infile lsprurl;
   retain found_toc found_thead found_th td_idx 0;
   retain CPCFMODL LSPRCPUS LSPRPCI LSPRMSU;
   length CPCFMODL $8;
   keep CPCFMODL LSPRCPUS LSPRPCI LSPRMSU;
   array td_array{3} LSPRCPUS LSPRPCI LSPRMSU;
   input @;

   if not found_toc and index(_infile_,'Table of contents') = 0 
      then return;

   found_toc=1;

if index(_infile_,'<thead>') then found_thead=1;
if index(_infile_,'</thead>') then found_thead=0;

if not found_thead and index(_infile_,'<th ') 
   then do;

    found_th = 1;
    CPCFMODL = reverse(scan(reverse(_infile_),2,'<>');
    end;

else if not found_thead and found_th and index(_infile_,'<td ') 
     then do;
       td_idx + 1;
       td_array{td_idx} = input(reverse(scan(reverse(_infile_),2,'<>'),comma10.);   
       if td_idx = 3 
       then do;        
         output;   
         td_idx = 0;    
         found_th = 0;       
         end;   
      end;   
run;


proc sort data=work.lsprdata out=admin.itms_smf_lsprdata;
   by CPCFMODL;
   run;
Note: The filename statement of the preceding code is lengthy. After you copy and paste it into your SAS Program Editor, edit the statement so that it does not use more than one line. In addition, make sure that there are no extraneous spaces in the statement.
The following method, Method 2, is applicable to all operating systems except z/OS.
  1. Create a Microsoft Excel spreadsheet that contains selected information from published (and currently available) IBM LSPR information. (You must reference the current published location of the IBM LSPR information. This information is currently located at https://www-304.ibm.com/servers/resourcelink/lib03060.nsf/pages/lsprindex?OpenDocument.)
    Copy and paste a selected set of columns from the published LSPR data into a Windows Excel spreadsheet. The resulting workbook should look like the following table and reflect the information that is documented in the topic called Calculation Dependencies for MIPS and MSU Columns.
    Partial View of LSPR Data in Windows Excel Worksheet
  2. Once created, the Microsoft Excel spreadsheet can be used as input in the following PROC IMPORT and DATA step code. This code creates a permanent SAS data set that resides in an IT Resource Management Admin library.
  3. Run the following code:
    /* Read the Microsoft Excel workbook that contains extracted information 
    from IBM LSPR documentation and create a SAS data set from it. */ 
    
    PROC IMPORT OUT=WORK.LSPRDATA  
         DATAFILE=<"location-of-spreadsheet">
         DBMS=EXCEL REPLACE;
         SHEET="Sheet1$"; 
     	    GETNAMES=NO;
         MIXED=NO; 
         SCANTEXT=YES; 
         USEDATE=YES;  
         SCANTIME=YES;
     RUN;
     
    /* Extract selected fields of information from the vendor-supplied 
    LSPR resource information. */
    
    DATA WORK.LSPRDATA(keep=CPCFMODL LSPRCPUS LSPRPCI LSPRMSU);
        SET WORK.LSPRDATA;
      	 LENGTH CPCFMODL $ 8; 
     		 IF _n_=1 THEN DELETE;
      	 CPCFMODL=F1; 
     		 LSPRCPUS=F2; 
     		 LSPRPCI=F3;
      	 LSPRMSU=F4; 
    run; 
    
    /* Store IBM LSPR resource information in SAS data set in 
    IT Resource Management Admin library. */  
    
    LIBNAME ADMIN <'location-of-ITRM-Admin-library'>;
    PROC SORT DATA=WORK.LSPRDATA out=ADMIN.ITMS_SMF_LSPRDATA;
        BY CPCFMODL; 
    RUN;
    

How to Retain the Original LSPR Table

Applying software maintenance or hot fixes might automatically update the LSPR table in SASHELP. If you backed up the SASHELP library from your original SAS IT Resource Management installation, you can restore the default LSPR table information that was included in that library. To do so, perform the following steps:
Note: You need to have exclusive access to the SASHELP library before you restore the original LSPR table in the SASHELP library.
  1. Make a backup copy of the SASHELP library.
  2. Submit the following SAS code:
     
    /*Allocate the backup copy of the SASHELP library      */
    /*that uses PROC COPY to copy only the LSPR table      */
    /*with the SELECT statement.                           */
    /*Make sure you have exclusive udate access to the     */
    /*SASHELP SAS library before you submit code.          */ 
         libname bkuphelp '<physical-location-of-backup-sashelp>';
         proc copy in=bkuphelp out=SASHELP;   
              select ITMS_SMF_LSPRDATA;     
         run;  
    Sample JCL for z/OS sites:
    //jobname JOB          
    //STEP1 EXEC SASPROC,OPTIONS=’SASHELP=SASHELP’         
    //SASHELP DD DSN='&prefix.llWn.SASHELP',DISP=OLD
    //SYSIN   DD *         
       libname bkuphelp '<physical-location-of-backup-sashelp> '; 
       proc copy in=bkuphelp out=SASHELP;    
            select ITMS_SMF_LSPRDATA;        
       run;      
    /*Ouput contents of LSPR data information              */
       PROC PRINT=SASHELP.ITMS_SMF_LSPRDATA;   
       RUN; 
    Note:
    • &prefix is the prefix specified at the time of your installation.
    • ll is the code for the language of your installation.
    • Wn is the encoding for your installation.
    Sample names for the configuration file and SASHELP libraries are here:
    USERID.CONFIG(ENW0)
    USERID.ENW0.SASHELP
    USERID.D54002.ENW0.SASHELP
  3. Review the output from the PRINT procedure to make sure that the SAS data set with the LSPR information has been updated.

Staging Methodology for MIPS and MSU Columns

The following steps describe the methodology that SAS IT Resource Management uses to stage RMF interval data.
  1. After MXG stages the RMF interval data and before IT Resource Management begins its staging transformation processing, code is executed to extract the necessary columns from the RMF interval data (MXG data set RMFINTRV). This code captures the distinct resource utilization entries from the RMF interval data that has just been staged. Another code step also extracts the current contents of the existing Resource Utilization table.
  2. Using the recently staged RMF interval data, code is executed to determine whether the available CPU models in the data are full capacity models or sub-capacity models. This model capacity information and a calculation of total available CPUs for the full capacity models are included with the rest of the RMF interval data extracted previously.
  3. The existing Resource Utilization table is merged with the staged RMF interval data in preparation for merging with the IBM LSPR information.
  4. The latest available LSPR information from IBM is read so that it can be included in the Resource Utilization table. The latest available LSPR information is available from one of the following two sources:
    • an IT Resource Management supplied SAS data set in a SASHELP library
    • an updated copy in an IT Resource Management Admin library that was created by the customer. For information about this process, see Working with LSPR Tables.
  5. The combined Resource Utilization table information (from the previous resource utilization table data and the new RMF interval data) and the extracted IBM LSPR resource information are merged together by the common column CPCFMODL. The merged result is the adjusted CPU model. This merge creates a new current copy of the Resource Utilization table, which replaces the existing copy. (The staging code created an empty Resource Utilization Table for this purpose.)
    As a result of this merge, a machine in your RMF data might not be listed in your LSPR table. In that case, SAS IT Resource Management halts the staging job and writes the following ERROR message to the SAS log.
    ERROR: The SMF data for system  is associated with a 
             mainframe model
    ERROR: <number> which does not appear in your LSPR table.
    ERROR: To preserve the integrity of your data mart, this job will stop. 
    • If the LSPR information and the subsequent calculations that are based on it are important to you, you should update your LSPR table as soon as possible. Do not attempt to rerun the staging job until the updated table has been implemented and stored in your Admin library. For information about updating your LSPR table, see Working with LSPR Tables.
    • If you are not interested in the LSPR information, you can bypass the error and continue processing the data. To do so, set the LSPR_ERROR_ON macro variable at the beginning of your staging job. The following code bypasses the error and enables processing to continue:
      %LET LSPR_ERROR_ON=N;
      This code sets all subsequent calculations that are based on the LSPR information to missing values. This results in other computed columns also having missing values. This situation is not statistically incorrect, but it can misrepresent MIPS and MSU usage in aggregations. The SAS log will contain notes about this instead of errors.
      NOTE: The SMF data for system  is associated with a mainframe model
      NOTE: <number> which does not appear in your LSPR table.
      NOTE: You coded LSPR_ERROR_ON=N to ignore this problem. 
  6. The newly updated Resource Utilization table data can be used to include various parts of this information in staging extracts so that resource utilization computed columns for MSU and MIPS can be calculated. Lookups can be done using System, CEC, or CPU Model columns present in the Resource Utilization table. The following table shows the type of columns and the corresponding information for those columns that is available in the Resource Utilization table.
Note: The RMF CPU Resource Table consists of 17 columns and a variable number of rows. (In the following example, the table contains sample data for two rows.) In order to present all the columns that are available in the table in a legible format, the table was rotated 90 degrees. Each column was displayed as rows, and each row was displayed as columns.
RMF CPU Resource Table: Column Names and Two
Name of the Column in the Resource Utilization Table
Sample Values for First Row of the Table
Sample Values for Second Row of the Table
System ID
DEVA
POA2
Cec ID
(from RMF)
B77A
3A7A
CPU Model
(from RMF)
2094-706
2066-0A2
Cpu Model Capacity Type
(extrapolated from CPU Model ID from RMF)
Full
Sub
Standard CPU Engines
(from RMF)
6
2
IFA CPU Engines
(from RMF)
2
0
ZIP CPU Engines
(from RMF)
1
0
Total CPU Engines
(calculated if full capacity model, else standard CPUs from RMF)
9
2
CPU Model
extrapolated if full capacity model, else CPU model from RMF)
2094-709
2066-0A2
CPU Model CPUs
(from LSPR)
9
2
CEC Su/Sec
(CEC Service constant from RMF)
19536.019536
6165.7032755
Su/Sec
(CPU Conversion constant from RMF)
25559.105431
6341.6567578
CPU Model MSU Capacity
(from RMF)
422.00
44.00
CPU Model MSU Capacity
(from LSPR)
584.00
44.00
IBM Processor Capacity Index
(also known as MIPS from LSPR)
4,366.00
234.00
Minimum Datetime
(from RMF)
01Mar08:00:00:00
01Mar08:00:00:00
Maximum Datetime
(from RMF)
01Mar08:23:45:00
01Mar08:23:30:00
MSU/MIPS Conversion Factor
(calculated)
7.48
5.32

New MSU and MIPS Fields in the XJOBS Table That Depend on RMF Data

In SAS IT Resource Management 3.2 and later, there are new MSU and MIPS columns in the XJOBS staging table. These columns require Resource Management Facility (RMF) interval data to be present in the input System Management Facility (SMF) file. If the SMF data does not contain the RMF 70, 71, 72, 75, and 78 type data records, the following XJOBS MIPS-related columns are set to missing:
  • IFAMIPS
  • IFAMSU
  • MIPSFACT
  • SYSMIPS
  • SYSMSU
  • TOTMIPS
  • TOTMSU
  • ZIPMIPS
  • ZIPMSU
To ensure that these MIPS columns are calculated in the XJOBS table, process the RMF and XJOBS SMF data together in the same staging job. If the SMF records that populate XJOBS were separated from the ones that populate the RMF tables XRMFSYS, XRMFINT, XASM70L, XASMCEL, XRMFWKL, XRMFWKP, and XTY72GO, then concatenate the two files together. This enables the staging job to make the RMF data accessible for the MSU and MIPS fields in the XJOBS table. You do not have to add the RMF tables to the staging job for this technique to work correctly. For more information about these columns, see Additional Notes about MIPS and MSU Calculations.

Additional Notes about MIPS and MSU Calculations

The following notes pertain to the calculation of the MIPS and MSU columns.
  • When dealing with a full capacity model, any additional specialty CPU engines, such as IFA and ZIP, that have been configured for your system must be included in the calculations. These specialty CPU engines are added to the Total CPU Engines and this new value is stored in the resource table under a column labeled Total CPU Engines (calculated if full capacity model, else standard CPUs from RMF).
    The CPU Model ID value is adjusted to reflect the addition of any specialty engines. For example, suppose there are three additional specialty engines on a full capacity model (2094-706): two engines for IFA and one for ZIP. As a result, the CPU model value is adjusted from 2094-706 to 2094-709 to account for the three additional specialty engines. The latter model ID specification is used to match up to the IBM LSPR information to retrieve the relevant MSU and MIPS ratings. These ratings are then used to calculate the MSU/MIPS conversion factor. This refined methodology for the full capacity CPU model results in a different MsuMipsConversionFactor. The difference is due to using an adjusted CPU model and the LSPR MSU and MIPS ratings that are associated with this adjusted CPU model.
    In our sample, without using an adjusted CPU model, the calculation of the MsuMipsConversionFactor is 7.32. Using an adjusted CPU model for the calculation, the MsuMipsConversionFactor is calculated to be 7.48. This results in higher MIPS amounts for CPU activity on the full capacity models that include additional specialty engines.
  • The calculation of MIPS is done in two distinct ways, depending on the IT Resource Management table that is being staged.
    • For systems (IT Resource Management tables XRMFSYS and XRMFINT) and LPARs (IT Resource Management tables XASM70L and XASMCEL), MSU is calculated using the hardware-based active CPU times from the RMF type 70 records and the hardware service adjustment factor (SUSEC). MIPS are then calculated by multiplying the MSU result by the appropriate MsuMipsConversionFactor for the associated processor type.
    • For workloads and workload periods (IT Resource Management tables XRMFWKL, XRMFWKP, XTY72GO) and batch jobs, TSO sessions, and OMVS sessions (XJOBS), SAS IT Resource Management calculates MSU by using the application-based active CPU times from the RMF type 72 records and the software service adjustment factor (CECSUSEC). MIPS are then calculated by multiplying the MSU result by the appropriate MsuMipsConversionFactor for the associated processor type.
    Note: For details about the specific calculations, see MSU and MIPS Calculations.
  • If comparisons are performed between system and LPAR MIPS values that are based on RMF type70 hardware-based active CPU times and other MIPS values, such as workload, workload period, jobs, and so on, that are based on RMF type72 application-based active CPU times, the system-based and LPAR-based MIPS will be larger. The reason that the times are different is because the uncaptured CPU time is not available in the type72 record. The difference in values is typically in the 5-15% range.

SAS Enterprise Guide Projects Using Software Application-based CPU Times for CEC, LPAR, and System Reports

SAS IT Resource Management supplies SAS Enterprise Guide projects that use software application-based active CPU times to calculate MSU and MIPS values for a collection of RMF CEC, LPAR, and System domain categories. These projects are provided for customers who choose to examine the performance and capacity of their CEC, LPAR, and System hardware components by using software application-based calculations. (The primary reason for using these calculations is to match CEC, LPAR, and system measurements against workload, workload period, jobs, and other comparable measurements.)
These supplied projects are delivered with the SAS IT Resource Management. They are installed on each client machine to which SAS Enterprise Guide is deployed during the installation of SAS IT Resource Management. The projects can be accessed by navigating to the location where you installed SAS IT Resource Management. They are typically located at C:\Program Files\SASHome\SASITResourceManagementSASEnterpriseGuideComponents\. These projects can be executed to create report definitions for use in SAS IT Resource Management report jobs. You can also create a report definition and select that definition in the Performance Report transformation for inclusion in a report job. For more information, see Chapter 7, “Working with the ITRM Report Definition Task in SAS Enterprise Guide” in the SAS IT Resource Management 3.7: Reporting Guide.

MSU and MIPS Calculations

All calculations listed in the following table are calculated from normalized CPU times, as provided by MXG.
Table of Calculations for MIPS and MSU Values
Domain Category
Staged Table
Computed Column
Column Label
Calculation
System
XRMFSYS
XRMFINT
SYSMSU
SystemCpuMsuUsage
if CPACTTM > 0 then SYSMSU= CPACTTM * SUSEC / 1000000; else SYSMSU=.;
SYSMIPS
SystemCpuMipsUsage
if MIPSFACT ^= . and CPACTTM > 0 then SYSMIPS=(CPACTTM * SUSEC / 1000000) * MIPSFACT; else SYSMIPS=.;
IFAMSU
IfaCpuMsuUsage
if IFAACTT > 0 then IFAMSU= IFAACTT * SUSEC / 1000000; else IFAMSU=.;
IFAMIPS
IfaCpuMipsUsage
if MIPSFACT ^= . and IFAACTT > 0 then IFAMIPS= ( IFAACTT * SUSEC / 1000000) * MIPSFACT; else IFAMIPS=.;
ZIPMSU
ZipCpuMsuUsage
if ZIPACTT > 0 then ZIPMSU= ZIPACTT * SUSEC / 1000000; else ZIPMSU=.;
ZIPMIPS
ZipCpuMipsUsage
if MIPSFACT ^= . and ZIPACTT > 0 then ZIPMIPS= ( ZIPACTT * SUSEC / 1000000) * MIPSFACT; else ZIPMIPS=.;
TOTMSU
AllEngCpuMsuUsage
AllEngCpuMsuUsage if CPACTTM > 0 or IFAACTT > 0 or ZIPACTT > 0 then TOTMSU=(sum(CPACTTM, IFAACTT, ZIPACTT) * SUSEC) / 1000000; else TOTMSU=.;
TOTMIPS
AllEngCpuMipsUsage
if MIPSFACT ^= . then TOTMIPS=(sum(CPACTTM, IFAACTT, ZIPACTT) * SUSEC / 1000000) * MIPSFACT; else TOTMIPS=.;
MSUCAP
SystemMsuCapacity
DURATION * NRCPUS * SUSEC / 1000000
MIPSCAP
SystemMipsCapacity
if MIPSFACT ^= . then MIPSCAP=FLOOR(MIPSFACT * (DURATION * NRCPUS * SUSEC / 1000000)); else MIPSCAP=.;
Lpar
CecLpar
XASM70L
XASMCEL
LPRSYSMSU
LparCpMsuUsage
if LCPUPDT > 0 then LPRSYSMSU= LCPUPDT * SUSEC / 1000000; else LPRSYSMSU=.;
LPRSYSMIPS
LparCpMipsUsage
if MIPSFACT ^= . and LCPUPDT > 0 then LPRSYSMIPS= ( LCPUPDT * SUSEC / 1000000) * MIPSFACT; else LPRSYSMIPS=.;
LPRIFAMSU
LparIfaMsuUsage
if IFAACTT > 0 then LPRIFAMSU=IFAACTT * SUSEC / 1000000; else LPRIFAMSU=.;
LPRIFAMIPS
LparIfaMipsUsage
if MIPSFACT ^= . and IFAACTT > 0 then LPRIFAMIPS=(IFAACTT* SUSEC / 1000000) * MIPSFACT; else LPRIFAMIPS=.;
LPRZIPMSU
LparZipMsuUsage
if ZIPACTT > 0 then LPRZIPMSU=ZIPACTT * SUSEC / 1000000; else LPRZIPMSU=.;
LPRZIPMIPS
LparZipMipsUsage
if MIPSFACT ^= . and ZIPACTT > 0 then LPRZIPMIPS=(ZIPACTT * SUSEC / 1000000) * MIPSFACT; else LPRZIPMIPS=.;
LPRTOTMSU
LparAllEngMsuUsage
if LCPUPDT > 0 or IFAACTT > 0 or ZIPACTT > 0 then LPRTOTMSU=(sum(LCPUPDT, IFAACTT, ZIPACTT)* SUSEC) / 1000000; else LPRTOTMSU=.;
LPRTOTMIPS
LparAllEngMipsUsage
if MIPSFACT ^= . then LPRTOTMIPS= (sum(LCPUPDT, IFAACTT, ZIPACTT) * SUSEC / 1000000) * MIPSFACT; else LPRTOTMIPS=.;
Workload
XRMFWKL
WKLMSU
WorkloadCpuMsuUsage
Workload XRMFWKL WKLMSU WorkloadCpuMsuUsage if WKLCPU > 0 then WKLMSU=(WKLCPU*CECSUSE) / 1000000; else WKLMSU=.;
WKLMIPS
WorkloadCpuMipsUsage
if MIPSFACT ^= . and WKLCPU > 0 then WKLMIPS=((WKLCPU*CECSUSE) / 1000000) * MIPSFACT; else WKLMIPS=.;
WKLIFAMSU
WorkloadIfaCpuMsuUsage
if WKLIFA > 0 then WKLIFAMSU=(WKLIFA*CECSUSE) / 1000000; else WKLIFAMSU=.;
WKLIFAMIPS
WorkloadIfaCpuMipsUsage
if MIPSFACT ^= . and WKLIFA > 0 then WKLIFAMIPS=((WKLIFA*CECSUSE) / 1000000) * MIPSFACT; else WKLIFAMIPS=.;
WKLZIPMSU
WorkloadZipCpuMsuUsage
if WKLZIP > 0 then WKLZIPMSU=(WKLZIP*CECSUSE) / 1000000; else WKLZIPMSU=.;
WKLZIPMIPS
WorkloadZipCpuMipsUsage
if MIPSFACT ^= . and WKLZIP > 0 then WKLZIPMIPS=((WKLZIP*CECSUSE) / 1000000) * MIPSFACT; else WKLZIPMIPS=.;
WKLTOTMSU
WorkloadAllEngCpuMsuUsage
if WKPCPU > 0 or WKPIFA > 0 or WKPZIP > 0 then WKLTOTMSU=(sum(WKPCPU,WKPIFA,WKPZIP) * CECSUSE) / 1000000; else WKLTOTMSU=.;
WKLTOTMIPS
WorkloadAllEngCpuMipsUsage
if MIPSFACT ^= . then WKLTOTMIPS=(sum(WKPCPU,WKPIFA,WKPZIP) * CECSUSE/ 1000000)*MIPSFA CT; else WKLTOTMIPS=.;
Workload Period
XRMFWKP
WKPMSU
WorkloadPeriodCpuMsuUsage
if WKPCPU > 0 then WKPMSU=(WKPCPU*CECSUSE) / 1000000; else WKPMSU=.;
WKPMIPS
WorkloadPeriodCpuMipsUsage
if MIPSFACT ^= . and WKPCPU > 0 then WKPMIPS=((WKPCPU*CECSUSE) / 1000000) * MIPSFACT; else WKPMIPS=.;
WKPIFAMSU
WorkloadPeriodIfaCpuMsuUsage
if WKPIFA > 0 then WKPIFAMSU=(WKPIFA*CECSUSE) / 1000000; else WKPIFAMSU=.;
WKPIFAMIPS
WorkloadPeriodIfaCpuMipsUsage
if MIPSFACT ^= . and WKPIFA > 0 then WKPIFAMIPS=((WKPIFA*CECSUSE) / 1000000) * MIPSFACT; else WKPIFAMIPS=.;
WKPZIPMSU
WorkloadPeriodZipCpuMsuUsage
if WKPZIP > 0 then WKPZIPMSU=(WKPZIP*CECSUSE) / 1000000; else WKPZIPMSU=.;
WKPZIPMIPS
WorkloadPeriodZipCpuMipsUsage
if MIPSFACT ^= . and WKPZIP > 0 then WKPZIPMIPS=((WKPZIP*CECSUSE) / 1000000) * MIPSFACT; else WKPZIPMIPS=.;
WKPTOTMSU
WorkloadPeriodAllEngCpuMsuUsage
if WKPCPU > 0 or WKPIFA > 0 or WKPZIP > 0 then WKPTOTMSU=(sum(WKPCPU,WKPIFA,WKPZIP) * CECSUSE) / 1000000; else WKPTOTMSU=.;
WKPTOTMIPS
WorkloadPeriodAllEngCpuMipsUsage
if MIPSFACT ^= . then WKPTOTMIPS=(sum(WKPCPU,WKPIFA,WKPZIP) * CECSUSE/1000000)*MIPSFACT; else WKPTOTMIPS=.;
Goal Mode Period
XTY72GO
PRDMSU
PeriodCpuMsuUsage
if CPUTM > 0 then PRDMSU=CPUTM*CECSUSE/1000000; else PRDMSU=.;
PRDMIPS
PeriodCpuMipsUsage
if MIPSFACT ^= . and CPUTM > 0 then PRDMIPS=(CPUTM*CECSUSE/1000000) * MIPSFACT; else PRDMIPS=.;
PRDIFAMSU
PeriodIfaCpuMsuUsage
if CPIFATM > 0 then PRDIFAMSU=CPIFATM*CECSUSE/1000000; else PRDIFAMSU=.;
PRDIFAMIPS
PeriodIfaCpuMipsUsage
if MIPSFACT ^= . and CPIFATM > 0 then PRDIFAMIPS=(CPIFATM*CECSUSE/1000000) * MIPSFACT; else PRDIFAMIPS=.;
PRDZIPMSU
PeriodZipCpuMsuUsage
if CPZIPTM > 0 then PRDZIPMSU=CPZIPTM*CECSUSE/1000000; else PRDZIPMSU=.;
PRDZIPMIPS
PeriodZipCpuMipsUsage
if MIPSFACT ^= . and CPZIPTM > 0 then PRDZIPMIPS=(CPZIPTM*CECSUSE/1000000) * MIPSFACT; else PRDZIPMIPS=.;
PRDTOTMSU
AllEngCpuTimeMsuUsage
if CPUTM > 0 or CPIFATM > 0 or CPZIPTM > 0 then PRDTOTMSU=(sum(CPUTM,CPIFATM,CPZIPTM) * CECSUSE) / 1000000; else PRDTOTMSU=.;
PRDTOTMIPS
AllEngCpuTimeMipsUsage
if MIPSFACT ^= . then PRDTOTMIPS= (sum(CPUTM,CPIFATM,CPZIPTM) * CECSUSE/1000000)*MIPSFACT; else PRDTOTMIPS=.;
Batch Jobs
TSO
OMVS
XJOBS
SYSMSU
SystemCpuMsuUsage
if CPUTM > 0 then SYSMSU=CPUTM*CECSUSE/1000000; else SYSMSU=.;
SYSMIPS
SystemCpuMipsUsage
if MIPSFACT ^= . and CPUTM > 0 then SYSMIPS=(CPUTM*CECSUSE/1000000) * MIPSFACT; else SYSMIPS=.;
IFAMSU
IfaCpuMsuUsage
if CPIFATM > 0 then IFAMSU=CPIFATM*CECSUSE/1000000; else IFAMSU=.;
IFAMIPS
IfaCpuMipsUsage
if MIPSFACT ^= . and CPIFATM > 0 then IFAMIPS=(CPIFATM*CECSUSE/1000000) * MIPSFACT; else IFAMIPS=.;
ZIPMSU
ZipCpuMsuUsage
if CPZIPTM > 0 then ZIPMSU=CPZIPTM*CECSUSE/1000000; else ZIPMSU=.;
ZIPMIPS
ZipCpuMipsUsage
if MIPSFACT ^= . and CPZIPTM > 0 then ZIPMIPS=(CPZIPTM*CECSUSE/1000000)*MIPSFACT; else ZIPMIPS=.;
TOTMSU
AllEngCpuMsuUsage
if CPUTM > 0 or CPIFATM > 0 or CPZIPTM > 0 then TOTMSU=(sum(CPUTM,CPIFATM,CPZIPTM) * CECSUSE) / 1000000; else TOTMSU=.;
TOTMIPS
AllEngCpuMipsUsage
if MIPSFACT ^= . then TOTMIPS=(sum(CPUTM,CPIFATM,CPZIPTM) * CECSUSE/1000000)*MIPSFACT; else TOTMIPS=.;