Wednesday, February 01, 2006



     XPEDITER/TSO is a debugging and testing tool that automates the tasks of
    identifying problems, applying solutions, analyzing the impacts of
    changes, and testing the fixes.

1.1 Changes for This Release

    *   Batch Connect Facility Enhancements

        DB2 and DB2/DLI JCL statements that previously required manual changes
        are now automatically converted for submitting a job in batch connect
        mode.  Three new commands have also been added to further enhance JCL
        conversion, submitting the job, and connecting to the job.

    *   Abend-AID Integration

        Enhances XPEDITER's fault diagnosis function by providing a direct
        connection to Abend-AID during an XPEDITER/TSO test session.
        Abend-AID analyzes the abend and XPEDITER/TSO displays the information
        in a report formatted by Abend-AID.

    *   COBOL/370 Compatibility

        Provides support for IBM's newest COBOL release--COBOL/370.

    *   Test Case Facility (TCF) Support

        Automatically collects the data read by the program during an
        XPEDITER/TSO test session.  With Compuware's File-AID/PC product, the
        collected data can be downloaded, browsed and edited, and used for
        testing on the workstation.

    *   User Interface Enhancements

        Further refinement of XPEDITER screens, commands, and functions.

    *   Performance Improvement

        Access to the source code display is now faster than ever.

    *   Documentation Changes

        XPEDITER/TSO and XPEDITER/IMS documentation has been updated to
        include information about the installation and use of the above

1.2 Changes for the Previous Release

    *   Product Integration

        XPEDITER/TSO has been integrated with File-AID for DB2, Compuware's
        easy to use DB2 database management and SQL development and analysis
        tool.  To use the integrated product, you must be licensed for
        XPEDITER for DB2 Extension and File-AID for DB2.  The (FADB2) option
        was added to the Primary Menu for direct access to File-AID for DB2.
        You can also access File-AID for DB2 from within an XPEDITER/TSO
        debugging session.

    *   Batch Connect Facility

        With this feature, you can submit an XPEDITER/TSO debugging session as
        a Batch Connect job allowing you to interactively connect to a batch

    *   Sourceless Debugging

        XPEDITER/TSO now allows you to test and debug programs that do not
        have the source (no SIR records) available.  The new AT command can be
        used to set breakpoints in sourceless programs.

    *   Profile Handling Enhancement

        This feature provides a flexible and easy to use method for using and
        maintaining multiple profiles.  Multiple profiles are useful since
        some of the data you see during an XPEDITER/TSO debugging session
        depends on the values in the current profile.  This includes
        installation defaults established by your system programming staff,
        and most importantly, environment parameters and SETUP options for the
        current debugging session.

    *   Single Point of Entry

        This feature lets you access a CICS region from a Primary Menu option
        without logging off the TSO session.  Pressing a PF key returns you to

    *   Programmer Command Center Results Interface

        For Programmer Command Center customers, XPEDITER offers a results
        interface that notifies you of the status of your Batch Connect jobs.

    *   Documentation Changes

        The XPEDITER/TSO and XPEDITER/IMS documentation has been updated to
        include information about the installation and use of XPEDITER for DB2
        Extension and File-AID for DB2, Profile handling, and the VTAM Batch
        Connect facility.

1.3 Overview

    When you run your program under interactive XPEDITER/TSO, the source code
    is displayed in a fully scrollable window where you can view the inner
    workings of the program as each statement is executed.  For instance, you
    can see the execution arrow moving from a PERFORM statement to the actual
    out-of-line perform paragraph, or you can see a data identifier changing
    its value as the MOVE, INITIALIZE, STRING, or COMPUTE statements are

    Figure 1-1 shows the source display screen under XPEDITER/TSO.  All
    debugging and testing functions are accessible from this screen without
    having to exit to a separate panel.

    XPEDITER/TSO does not require any source code or load module changes;
    however, you need to create a "symbolic" information dataset called the
    Shared Information Repository (SIR) to debug at the source level.  The SIR
    records are created during the compile step after the compiler generates
    the compiler listing.  The SIR processor analyzes the listing information
    and outputs the SIR records into a PDS file.  XPEDITER/TSO displays and
    processes the SIR source records during the testing session.

    |                                                                                  |
    | ------------------------------ XPEDITER/TSO - SOURCE ----------------------------|
    | COMMAND ===>                                                     SCROLL===> CSR  |
    |                       Before Breakpoint Encountered                              |
    | ------   ------------------------------------------------------ Before TRIMAIN --|
    | =====> B PROCEDURE DIVISION.                                                     |
    | 000035   MAIN-PARA.                                                              |
    | 000036       PERFORM INIT-PARA.                                                  |
    | 000037       PERFORM ANALYZE-NEXT-REC                                            |
    | 000038           UNTIL OUT-OF-RECS = 'Y'.                                        |
    | 000039       PERFORM ENDING-PARA.                                                |
    | 000040 A     GOBACK.                                                             |
    | 000041   INIT-PARA.                                                              |
    | 000042       MOVE ZERO TO N-CNTR (1) N-CNTR (2) N-CNTR (3) N-CNTR (4).           |
    | 000043       OPEN INPUT INFILE.                                                  |
    | 000044       MOVE 'N' TO OUT-OF-RECS.                                            |
    | 000045   ANALYZE-NEXT-REC.                                                       |
    | 000046       READ INFILE INTO WORK-REC                                           |
    | 000047          AT END                                                           |
    | 000048          MOVE 'Y' TO OUT-OF-RECS.                                         |
    | 000049       IF OUT-OF-RECS = 'N'                                                |
    | 000050          MOVE ZERO TO TRIANGLE-TYPE                                       |
    | 000051          CALL 'TRITST' USING WORK-REC TRIANGLE-TYPE                       |
    | 000052          SET TX TO TRIANGLE-TYPE                                          |
    | 000053          ADD 1 TO N-CNTR (TX).                                            |
    |                                                                                  |

    Figure  1-1. Source Display Screen Under XPEDITER/TSO

1.3.1 Major XPEDITER/TSO Debugging and Testing Features

    The capabilities of XPEDITER/TSO are extensive enough to assist the power
    programmers' needs, and yet the implementation is simple and efficient to
    curtail the learning curve that novice programmers generally experience.
    The following list summarizes XPEDITER/TSO's major features:

    *   Intercept application program abends.

         XPEDITER/TSO detects application abends before the offending
        instruction is executed and displays a diagnostic message.  You can
        request an Abend-AID formatted report if you have Abend-AID Release
        6.1.4 or higher or you can view the log for more information.  If the
        problem is a recoverable error, you can fix the error dynamically and
        resume execution.

    *   Start or stop execution at any point.

         You can set conditional or unconditional breakpoints, so you can stop
        and figure out what the program has processed so far, and what the
        consequences of any changes could be.  You can also step through code
        line-by-line to understand how each statement affects the program.

    *   Display and modify variable, register, and storage contents.

         You can view the variable contents and alter the values as if the
        program had actually moved in the value you requested.  Tables can be
        displayed by dimension, and you can browse through each entry by
        incrementing and decrementing the index or subscript.  General-purpose
        registers and memory can be displayed in a Keep window to analyze the
        problem at the lower level.

    *   Trace logic flow.

         Statements can be highlighted to identify the execution path as
        XPEDITER/TSO traces through the program.  You can control the speed of
        the execution so that you can follow the logic interactively at a
        speed that best suits you.

    *   Logically review execution in the reverse direction.

         XPEDITER/TSO can display the execution history in the reverse
        direction to allow you to review the execution path with associated
        data values.  The execution arrow moves backwards, and the data
        display shows the original values.

    *   Monitor execution coverage.

         You can set counters on statements to test execution coverage or to
        monitor loops and procedure calls for optimization.

    *   Alter logic.

        You can dynamically change the control flow by modifying the data
        values or by forcing a wild branch to test an alternate path.

    *   Bypass unwanted code.

         A range of statements or programs can be skipped in lieu of providing
        program stubs.

    *   Temporarily insert XPEDITER/TSO debugging statements.

         You can imbed XPEDITER/TSO commands to control debugging conditions
        to take place at a certain location, and to force data and logic
        changes.  This feature lets you prototype some COBOL-like constructs.
        If you have XPEDITER for DB2 Extension and File-AID for DB2, you can
        also insert SQL statements.

    *   Analyze program structure and data flow.

         XPEDITER/TSO identifies certain COBOL program structures
        (conditionals, branches, I/Os, statements that alter data values,
        etc.) by highlighting the applicable statements when requested.  Also,
        statements that make references (MODIFY or USE) to a particular data
        item can be identified.

    *   Display file status and DCBs.

         VSAM file status and last I/O operation can be retrieved through
        XPEDITER/TSO.  DCB information can also be checked in the case of I/O
        error.  When a DD statement is not preallocated, XPEDITER/TSO
        intercepts execution and gives you an opportunity to allocate the
        missing files before resuming execution.

    *   Display called module stacking.

         The called module configuration such as the load address, entry
        point, size, attribute, AMODE, RMODE, and language can be retrieved.

    *   Maintain multiple profiles.

        XPEDITER/TSO's Profile Handling facility provides a flexible and
        easy-to-use method for using and maintaining multiple profiles.
        Multiple profiles are used because some of the data you see during an
        XPEDITER/TSO debugging session depends on the current profile.  This
        includes installation defaults established by your system programming
        staff, and most importantly, environment parameters and SETUP options
        for the debugging session.

    *   Interactively connect to a batch job.

        The Batch Connect facility enables you to run an XPEDITER/TSO
        debugging session in batch and interactively connect to the batch job.

    *   Optionally run in unattended batch mode.

        XPEDITER/TSO can be submitted as a batch job to debug programs that
        require large region size, a tape input, or multiple job steps that
        process files.  Command stream is read as input, and any functions
        that require terminal interaction do not pause but write to the log
        indicating that the functions were performed.

1.3.2 XPEDITER/TSO Execution Operating Modes

     XPEDITER/TSO can be used in three ways:

    1.  In interactive mode.

         The chief advantage of using XPEDITER/TSO interactively is the
        ability to "pause" and resume execution of your program throughout a
        debugging session.  Interactive mode is preferable to batch mode
        testing when you have a specific problem for which you want to
        dynamically try out a solution.

    2.  In unattended batch mode.

         During a batch session, you cannot interact with the XPEDITER/TSO
        debugging session from your terminal.  In batch mode, XPEDITER/TSO
        receives its input from a test script file and writes to the log file.

        Some reasons for using batch mode testing are the following:

        *   Uses less processor resources than debugging in interactive mode.

        *   Allows testing of programs that require tape files.

        *   Executes long running programs and programs that perform many I/O
            operations in the background.

        *   Tests a job stream that has multiple job steps.

        *   Collects execution coverage and regression testing results.

    3.  In Batch Connect Mode.

        You can submit an XPEDITER/TSO session through the Batch Connect
        facility to run the job in batch and interactively connect to that
        batch job.  The source is displayed allowing you to interactively set
        breakpoints, display and modify variables, etc..

1.3.3 Primary Input to XPEDITER/TSO

    The primary input to XPEDITER/TSO is the following:

    1.  Shared Information Repository (SIR) data library.

    2.  Load libraries containing the module(s) to be tested and debugged.

        Note:   The SIR data library and your load libraries are the output of
        the compile and link process discussed in "Compiling With the SIR
        Processor" in topic 4.2.

    3.  JCL, file list, or CLIST that can be processed to allocate the input
        files or databases needed by your program.

    4.  Optionally, a test script library.

1.3.4 Output From the Execution of XPEDITER/TSO

    The primary output of the debugging session is:

    1.  Data files generated by the execution of the program.

    2.  Session log.

         XPEDITER/TSO automatically records (to the log file) the commands
        entered and the responses made to each command during a debugging
        session.  The log dataset can have an LRECL of 133 or 80.  The log
        does not contain the interactive manipulation commands nor does it
        contain the actual program displays.

         In batch mode, the log file shows the output of a batch test and is
        available after the completion of the debugging session.  In
        interactive mode, it is available at all times.

        The log file can be kept as part of the documentation, to be
        referenced whenever maintenance is performed on the program.  It can
        be viewed for further information in determining the cause and
        possible resolution of an abend.  Chapter 8, "Handling Run-Time
        Errors" in topic 8.0 contains an example of the log display and shows
        what is recorded in the log as a result of a S0C7 abend.

    3.  Session script, which can be saved as a member of a test script

         XPEDITER/TSO automatically records the commands entered to a
        sequential test script file.  After the session is terminated, you can
        save, copy, or move the generated test script to a member of a test
        script library (INCLUDE dataset), which can then be used as input to
        another debugging session.

        Test scripts can be used to set up, run, or rerun a session.  They are
        used to gather information at the close of a session (a post script),
        and in batch mode, to specify a series of commands to be executed when
        an abend occurs (abend script).  It is also used to store any
        customization made to XPEDITER/TSO or shop defaults.

1.3.5 LOGON Region Size Requirements

     Debugging with XPEDITER/TSO may require an increase to the default TSO
    LOGON region size.  This provides protection against abends caused by
    insufficient space.

    XPEDITER/TSO requires about 640K bytes minimum, in addition to the
    application programs to be tested and debugged.  Additional storage could
    be required, depending on the number and size of the programs that are
    referenced symbolically during the debugging session.

    It has been our experience that 2048K to 4096K (2M to 4M) is sufficient
    size for debugging most applications.

1.4 Restrictions and Warnings

    The following list explains some of the technical restrictions and
    questions related to the functioning of XPEDITER/TSO:

    Attention (User Interrupt--PA1 Key) Processing:

    Depending on the timing in your use of the PA1 key/user interrupt from
    within XPEDITER/TSO, the result can be a recursive abend.

    Multitasking Support:

    Compuware does not support multitasking applications within XPEDITER/TSO,
    except in the dialog environment, where single task testing is supported
    within a multitasking environment.

    Optimized Code:

    XPEDITER/TSO displays the source for optimized code as it was originally
    written, but executes the code generated by the optimizer.  As a result,
    depending on the optimizing algorithm applied to the code, the following
    can occur:

    *   Highlighting during execution of the trace of the optimized code can
        be misleading.

    *   Abends can occur when you use XPEDITER/TSO commands that alter the
        program execution paths, such as GOTO and SKIP.  These abends occur
        when the altered execution paths are in conflict with path
        dependencies generated by the optimizer.

    *   If you have used Copy Suppress in the Procedure Division you might not
        be able to set a breakpoint on the first statement following the
        copied code.

    IMS Testing:

    *   Retention of breakpoints across IMS transactions is not supported.

    *   Transactions specified on the test MPP screen are queued up to run in
        the XPEDITER/TSO region regardless of where the transactions were
        initiated.  XPEDITER/TSO assigns a unique class to each of the
        specified transaction codes and forces them to run only in your
        XPEDITER/TSO region.  The transaction codes are not reassigned to
        their original class until you have completely finished testing in the
        MPP region.

    *   If a DLI program uses the XRST facility, the first DLI call must be
        the XRST call.  Otherwise, you can cause an abend 04E with reason code

    *   Within a BTS/DLI setup, recovery of DB2 tables and IMS databases are
        uncoordinated.  An SQL COMMIT/ROLLBACK call commits or rolls back
        changes made to DB2 tables only, not your IMS databases.

    *   Customers who are experiencing system abends while using the BTS TRACE
        to monitor DB2 activity should check with IBM for fixes available for
        the BTS program product.  Problems have occurred in MVS/XA IMS 1.3 and
        BTS 1.3, as well as MVS/ESA IMS 3.1 and BTS 3.1.

    MVS/ESA Support:

    For assembler programs, all ESA instructions are supported except the
    instructions that use the access registers.
    Naming Convention:

    Program names should not begin with IBM reserved prefixes such as IHO,
    ILBO, IGZ, etc.

    COBOL Ready Trace:

    Unpredictable results can occur in XPEDITER/TSO when the COBOL READY TRACE
    command is used.

    Memory Allocations:

    User programs and other vendor packages that perform FREEMAINs on
    subpool=0 or subpool=3 are not supported.

    COBOL Declaratives Section:

    Breakpoints or GOTOs in the Declaratives Section are not supported.

2.0 Chapter 2.  User Interface to XPEDITER/TSO

    This chapter describes how to interact with XPEDITER/TSO in general.  The
    screen format, PF key assignments, command processing, HELP, and tutorial
    are discussed.


Post a Comment

<< Home