# Compaq KAP Fortran/OpenMP
for Tru64 UNIX
User Guide

Previous | Contents | Index

# Chapter 9
KAP Listing File

This chapter describes the information found in the optional KAP Fortran/OpenMP listing file and the messages KAP produces. To help you understand its actions, KAP lists the optimizations it performed and provides explanations for the places where no optimization was done.

For example, if three loops could have been optimized but KAP optimized only the one it determined most profitable, the listing file will contain notes giving reasons for the choices. Also, often a small DO loop is left unchanged because it will be faster to process in that form. Such situations can produce unexpected but correct code, so KAP produces an annotated listing to explain its output. The listing may also identify places where the use of directives or assertions may improve KAP effectiveness.

Section 9.1 presents the optional information selected by the `-listoptions` command-line switch. Section 9.1.1 shows an annotated listing of the original and transformed program. An introduction to the diagnostic messages that KAP can generate ends the chapter. Appendix F contains the main listing of KAP diagnostic messages.

# 9.1 Listing Switches

The `-listoptions` command-line switch tells KAP what information to include in the listing and error files. The listing and error files can contain any combination of the following messages about the optimizations performed, identified by the single-letter switches listed. The following sections present examples of the output selected by these switches.

See the `-cmpoptions` command-line switch for the optional information in the transformed code file.

The following examples used Compaq KAP Fortran/OpenMP for Tru64 UNIX default switch values, except for `-listoptions=cklnopst` :

- Original program listing (default)
- Calling tree of the entire program
- KAP switches used listed after each program unit
- Loop table after each program unit
- Print program unit names in error file as they are processed
- Compilation performance statistics
- Loop summary table
- Transformed program listing

The following sections explain the format of these listings.

## 9.1.1 Original Program Listing (O)

The `o` switch requests an annotated listing of the original program, for example:

     KAP/Tru64_U_F90   4.4 k340504 20010517  ATIMESB  Source   01-Sep-2001  09:31:22
     Page 1

     Footnotes  Actions   DO Loops  Line

                                     1
                                     2   C Simple Matrix Multiply example.
                                     3
                                     4     PROGRAM ATIMESB
                                     5
                                     6     PARAMETER M=500, N=400, P=500
                                     7
                                     8     DIMENSION A(1:M,1:N),B(1:N,1:P),C(1:M,1:P)
                                     9
                                    10
                                    11   C Initialize the matrices
                                    12
     1                    +---------13    DO 10 J=1,N
     2          SO        !+--------14      DO 10 I=1,M
                SO        !*        15      A(I,J) = 1.5
                          !*________16   10   CONTINUE
                                    17
     1                    +---------18    DO 20 J=1,P
     2          SO        !+--------19      DO 20 I=1,N
                SO        !*        20      B(I,J) = 3.0
                          !*________21   20   CONTINUE
                                    22
                                    23   C Compute C = A * B
                                    24
                SO                  25    CALL MATMUL(A, M, B, N, C, P)
                                    26    END

     Abbreviations Used
      SO       scalar optimization

     Footnote List
       1: not vectorized             Not an inner loop.
       2: scalar optimization        Loop unrolled 4 times to improve scalar performance.

     KAP/Tru64_U_F90   4.4 k340504 20010517  ATIMESB  Source   01-Sep-2001  09:31:22
     Page 2

     Footnotes     Actions     DO    Line
                               Loops
                                     27
                                     28
                                     29   SUBROUTINE MATMUL(A, LDA, B, LDB, C, LL)
                                     30   REAL A(LDA,LDB), B(LDB,LL), C(LDA,LL)
                                     31   INTEGER LDA,LDB,LL
                                     32
     1 2 3 4 5 6   NO SO        +----33   DO 20 J=1,LL
     1 3 4 5 6     NO LR SO     !+---34     DO 20 I=1,LDA
                   SO           !*   35     C(I,J) =0.0
     1 5 6 7       NO LR SO INF !*+--36       DO 20 K=1,LDB
     8             DD SO        !*!  37       C(I,J) = C(I,J) + ( A(I,K) * B(K,J) )
                                !*!__38 20   CONTINUE
                                     39
                                     40    RETURN
                                     41
                                     42    END

     Abbreviations Used
      NO       not optimized
      LR       loop reordering
      DD       data dependence
      SO       scalar optimization
      INF      informational

     Footnote List
       1: not optimized          Loop was asserted serial by directive.
       2: not vectorized         Not an inner loop.
       3: scalar optimization    Cleanup-loop for loop unrolling added.
       4: scalar optimization    Loop unrolled 3 times to improve scalar performance.
       5: scalar optimization    Strip loop for strip mining with block size 24.
       6: scalar optimization    Block loop for strip mining with block size 24.
       7: informational          Unrolling of this loop was not done because
                                 heuristic says size is ok asis.
       8: data dependence        Data dependence involving this line due to variable C.

## 9.1.2 Calling Tree (C)

The calling tree is listed after all program units have been compiled. Each program unit's calling tree consists of the SUBROUTINEs and FUNCTIONs called in that program unit. A listing of variables and arrays used (both from the original source program and in code which KAP added) precedes the calling information.

After the cross-reference and calling tree information for the last program unit in the file, the calling tree information for the entire source file is summarized, for example:

          CALL SUMMARY TABLE

          CROSS REFERENCE TABLE

      Name            Type      Class     Storage
    -----------------------------------------------------------------------------
    A                 s.REAL   Array
    LDA               s.INT    Var
    B                 s.REAL   Array
    LDB               s.INT    Var
    C                 s.REAL   Array
    LL                s.INT    Var
    J                 s.INT    Var
    I                 s.INT    Var
    K                 s.INT    Var
    II1               s.INT    Var
    II2               s.INT    Var
    II3               s.INT    Var
    II4               s.INT    Var
    II5               s.INT    Var
       .
       .
       .
    RR1               s.REAL   Var
    RR2               s.REAL   Var
    RR3               s.REAL   Var
    RR4               s.REAL   Var
    RR5               s.REAL   Var
    RR6               s.REAL   Var
    RR7               s.REAL   Var
       .
       .
       .

    Abbreviations used in Source Program References

     A = used as actual argument
     D = Declared or Defined
     M = Contents may get modified
     U = Its value is used

     CALL SUMMARY TABLE

    16-Feb-2002 15:02:20

     Calling Tree

    line#         routines          at nest    max. aggregate nest

     4           program ATIMESB
    25              call MATMUL     0          0

    29           subroutine MATMUL

     Calling Tree

    ATIMESB
        MATMUL

    Code Modules

     ATIMESB   called from
     MATMUL    called from ATIMESB

## 9.1.3 KAP Switches (K)

The KAP switches table lists the settings of the command switches related to optimization used for this program unit. Some of the values may be changed within the program unit by using directives. Not all of these switches can be changed by the user. An example of a KAP switches table for an EV6 architecture follows.

    KAP/Tru64_U_F90 4.4 k340504 20010517  ATIMESB  Source  01-Sep-2001 09:31:22

                         Page   1

    Switches Used for this Program Unit

            no aggressive
               align_common=8
               align_struct=4
               arclimit=5000
               assume=cel

            no blank_padding

               cache_prefetch_line_count=0
               cacheline=64,64
               cachesize=32
               chunk=1
               cmp=./mat.cmp.f
            no cmpoptions
               complex=8
            no concurrentize

               datasave
               directives=akpv
            no dlines
               dpregisters=32

               eiifg=20
            no escape

               fpregisters=32
            no freeformat
            no fuse
               fuselevel=0

            no generateh

            no hdir
               heaplimit=3433
               hli=1

            no ignoreoptions
            no include
            no inline
            no inline_and_copy
            no inline_create
               inline_depth=2
            no inline_from_files
            no inline_from_libraries
               inline_looplevel=2
            no inline_manual
               inline_optimize=0
               input=mat.f
               integer=4
               interchange

               interleave
               intlog
            no ipa
            no ipa_create
               ipa_depth=2
            no ipa_from_files
            no ipa_from_libraries
               ipa_looplevel=2
            no ipa_manual
               ipa_optimize=0

            no library_calls
               limit=10
               lines=55
               list=mat.out
               listingwidth=132
               listoptions=klo
               logical=4

               machine=s
               make_sequenced
               miifg=500
               minconcurrent=1000

            no namepartitioning

               optimize=5
            no onetrip

            no parallelio
            no parallelrtl
               pdefault=safe
               processors=1
               psyntax=openmp

               real=4
            no recursion
               roundoff=3

               save=manual_adjust
               scalaroptimize=3
               scan=72
               scheduling=e
               setassociativity=1
            no skip
            no small_loops
            no srlcd
            no suppress
            no syntax

               tablesize=24000000
               tune=EV6
            no type

               unroll=4
               unroll2=160
               unroll3=1
               useh

## 9.1.4 Loop Table (L)

The loop table shows what KAP did for each DO loop in the program unit. If the loop could not be optimized, a reason is listed. The possible Status entries and brief explanations are in the Loop Table Messages, as shown in the following example:

    KAP/Tru64_U_F90  4.4 k340504 20010517 ATIMESB Loop Summary   01-Sep-2001  09:31:22

    Loop Summary

            From To   Loop  Loop   at   Unroll Unroll Iteration
    Loop#   line line label index  nest weight factor workload  Status
    1       13   16   Do 10 J      1                            not inner loop
    2       14   16   Do 10 I      2    3      4                left as DO loop
    3       18   21   Do 20 J      1                            not inner loop
    4       19   21   Do 20 I      2    3      4                left as DO loop
       .
       .
       .

## 9.1.5 Name (N)

The program unit names, as processed, are printed to the standard error file ( `stderr` ), preceded by the source file name. If the source is read from standard input, the source file name is left blank.

## 9.1.6 Compilation Performance Statistics (P)

The compilation performance statistics list the number of lines in the program unit, the compilation time, the compilation rate in lines per minute, and temporary file use (for large program units or inlining). After all program units have been compiled, the cumulative totals are given, along with the final number of lines in the transformed code file. The cumulative values version is shown in the following example:

     KAP/Tru64_U_F90  4.4 k340504 20010517  ATIMESB  Compilation Statistics
     01-Sep-2001  09:31:22

    Compilation Statistics For the Routine ATIMESB
       26  Lines in Program Unit
       23  Noncomment Lines in Program Unit
     0.13  CPU Time
    12000  Lines Per Minute
    10615  Non Comment Lines Per Minute
        0  Symbol Cache File Writes
        0  Symbol Cache File Reads
      110  Source Saver File Reads
       26  Source Saver File Writes
        1  Source Saver File Opens
        0  Name Table File Writes
        0  Name Table File Reads

    Compilation Statistics For the Routine MATMUL
      16  Lines in Program Unit
      16  Noncomment Lines in Program Unit
    0.90  CPU Time
    1066  Lines Per Minute
    1066  Non Comment Lines Per Minute
       0  Symbol Cache File Writes
       0  Symbol Cache File Reads
     165  Source Saver File Reads
      16  Source Saver File Writes
       0  Source Saver File Opens
       0  Name Table File Writes
       0  Name Table File Reads

    Cumulative Compilation Statistics
      42  Lines in Source File
      39  Noncomment Lines in Source File
       2  Program Units in Source File
    1.03  CPU Time
    2446  Lines Per Minute
    2271  Non Comment Lines Per Minute
       0  Symbol Cache File Writes
       0  Symbol Cache File Reads
     275  Source Saver File Reads
      42  Source Saver File Writes
       1  Source Saver File Opens
       0  Name Table File Writes
       0  Name Table File Reads
     259  Lines in Compile File

## 9.1.7 Summary Table (S)

The summary table shows how many loops appeared in the program unit and how many loops were optimized in different ways, for example:

     KAP/Tru64_U_F90  4.4 k340504 20010517  ATIMESB  Optimization Summary
     01-Sep-2001  09:31:22

    4 loops total
    2 loops vectorized
    2 with inner loop

     KAP/Tru64_U_F90  4.4 k340504 20010517  ATIMESB  Optimization Summary
     01-Sep-2001  09:31:22

    3 loops total
    1 loops vectorized
    2 with scalar directive

## 9.1.8 Transformed Program Listing (T)

The following example shows the annotated transformed program in the listing file. Much of this information is always recorded in the transformed code file regardless of whether the user specifies `-listoptions=t` .

    KAP/Tru64_U_F90 4.4 k340504 20010517 ATIMESB  Transformed  01-Sep-2001 09:31:22
    Page   1

    Footnotes   Actions    DO      Line
                           Loops
                                     1
                                     2 C Simple Matrix Multiply example.
                                     3
                                     4  PROGRAM ATIMESB
                                     5
                                     6    PARAMETER M = 200, N = 300, P = 200
                                     7
                                     8    DIMENSION A(1:200,1:300), B(1:300,1:200), C(1:200,1:200)
                I                    8    INTEGER II2, II1
                I                    8    PARAMETER (II2 = 300, II1 = 200)
                                     9
                                    10
                                    11 C Initialize the matrices
                                    12
    1           LM           +------13    DO 2 J=1,300
    2           LM INF       !+-----14      DO 2 I=1,200
                             !!     15        A(I,J) = 1.5
                I            !!_____16 2      CONTINUE
                                    17
    1           LM           +------18    DO 3 J=1,200
    2           LM INF       !+-----19      DO 3 I=1,300
                             !!     20        B(I,J) = 3.0
                I            !!_____21 3      CONTINUE
                                    22
                                    23 C Compute C = A * B
                                    24
                SO                  25    CALL MATMUL (A,(II1),B,(II2),C,(II1))
                                    26  END

    Abbreviations Used
      LM       label modification
      SO       scalar optimization
      I        inserted
      INF      informational

    Footnote List
       1: not vectorized   Not an inner loop.
       2: informational    Unrolling of this loop was not done because heuristic
                           says size is ok as is.

    KAP/Tru64_U_F90  4.4 k340504 20010517  MATMUL  Transformed  01-Sep-2001  09:31:22

     Footnotes Actions DO Loops    Line

                                      27
                                      28
                                      29  SUBROUTINE MATMUL (A, LDA, B, LDB, C, LL )
                                      30    REAL A(LDA,LDB), B(LDB,LL), C(LDA,LL)
                                      31    INTEGER LDA, LDB, LL
                I                     31    INTEGER II17, II16
                I                     31    PARAMETER (II17 = 25, II16 = 1)
                I                           INTEGER II1,II2,II3,II4,II5,II6,II7,II8
                                         X     ,II9,II10,II11, II12,II13,II14,II15
                I                           REAL RR1
                I                     33    II1 = MOD (LL - II16, II17) + II16
                I                     36    II5 = MOD (LDB - II16, II17) + II16
                I                     34    II9 = MOD (LDA - II16, II17) + II16
                                      32
    1           LM          +---------33    DO 2 J=1,LL
    2           LM INF      !+--------34      DO 2 I=1,LDA
                            !!        35        C(I,J) = 0.
                I           !!________38 2      CONTINUE
                I                     33    II3 = II16
                I                     33    II2 = II1
    3 4 5       I NO SO     +---------33    DO 7 II4=II16,LL,II17
                I           !         36      II7 = II16
                I           !         36      II6 = II5
                I           !         36      II15 = II3 + II2 - II16
    3 4 5       I NO SO     !+--------36      DO 6 II8=II16,LDB,II17
                I           !!        34        II11 = II16
                I           !!        34        II10 = II9
                I           !!        34        II13 = II7 + II6 - II16
    3 4 5       I NO SO     !!+-------34        DO 5 II12=II16,LDA,II17
                            !!!       32
                I           !!!       33          II14 = II11 + II10 - II16
    6           LM SO       !!!+------33          DO 4 J=II3,II15,II16
    6           LM LR SO    !!!!+-----34            DO 4 I=II11,II14,II16
                I           !!!!!     34              RR1 = C(I,J)
    2 6         LM LR SO INF!!!!!+----36              DO 3 K=II7,II13,II16
    7                       !!!!!!    37                RR1 = RR1+(A(I,K) * B(K,J))
                I           !!!!!!____38 3              CONTINUE
                I           !!!!!     38              C(I,J) = RR1
                I           !!!!!_____38 4            CONTINUE
                I           !!!       38          II11 = II11 + II10
                I           !!!       38          II10 = II17
                I           !!!_______38 5        CONTINUE
                I           !!        38        II7 = II7 + II6
                I           !!        38        II6 = II17
                I           !!________38 6      CONTINUE
                I           !         38      II3 = II3 + II2
                I           !         38      II2 = II17
                I           !_________38 7    CONTINUE
                                      39
                                      40    RETURN
                                      41
                                      42   END

     Abbreviations Used
      LM       label modification
      NO       not optimized
      LR       loop reordering
      SO       scalar optimization
      I        inserted
      INF      informational

     Footnote List
       1: not vectorized       Not an inner loop.
       2: informational        Unrolling of this loop was not done because
                               heuristic says size is ok as is.
       3: inserted             DO loop was inserted here.
       4: scalar optimization  Block loop for strip mining with block size 25.
       5: not optimized        Loop was asserted serial by directive.
       6: scalar optimization  Strip loop for strip mining with block size 25.
       7: data dependence      Data dependence involving this line due to variable C.

# 9.2 Listing Information

This section presents KAP annotated listing information. Unless overridden with the `-suppress` command-line switch, KAP presents the following information in every KAP source ( `-listoptions=o` ) or transformed ( `-listoptions=t` ) program listing:

- Line numbers
- DO loop markings
- INCLUDE file markings
- Footnotes
- Syntax error/Warning messages
- Questions generated by KAP
- Action summary

The following sections explain the format of these entries.

## 9.2.1 Line Numbers

A statement in the KAP listing labeled with a line number of 21, for example, is either the same as line 21 from the original program, or is derived from line 21. These line numbers are useful when inspecting the KAP transformed program listing. KAP sometimes generates several lines of code from a single line of the original program; in that case, each of the new lines of code is labeled with the same number as that of the original program. Consequently, lines of the KAP transformed program listing may be easily related to the lines of the original program listing. Lines from an INCLUDE file are numbered starting from 1 for the first line in the included file.

## 9.2.2 DO Loop Markings

DO loops are graphically displayed in a column headed `DO Loops.` Brackets mark the extent of each DO loop (up to nest level 10), as shown in the following example:

    DO Loops     Line
     +---------  5  DO 99  I = 1,1000
     *           6    A(I,1) = B(1)
     *+--------  7    DO 95 J = 2,1000
     *!          8       A(I,J) = B(J)*A(I,J-1)
     *!________  9    95 CONTINUE
     *_________  10   99  CONTINUE

A statement that is enclosed by `n` DO loops has `n` exclamation marks (!) on that line. Loops that have been optimized in a major way have asterisks (*) instead of exclamation points in the source listing.

Note Compaq KAP Fortran/OpenMP for Tru64 UNIX recognizes certain operations, such as matrix multiplication, as basic entities. Frequently, the loops forming such operations will not be marked.

## 9.2.3 INCLUDE File Markings

If the INCLUDE Fortran 90 statement is used within a program, the code that was included appears in the listing file with a plus sign (+) immediately after the line number on each line of the file. INCLUDEd lines are numbered separately from the lines of the main file. An example of this (from an `-lo=o` listing) follows:

    2 subroutine fr (w)
    3 real w
    4 INCLUDE  'b.f'
    1 + a = 1.0
    2 + w = w - a
    5 return
    6 end

## 9.2.4 Footnotes

Important details about the actions taken by KAP are given in the Footnotes listing. The Footnotes are numbered and printed at the bottom of each program unit under the `Footnote List` heading. References to the footnotes are displayed in the listing under the column headed `Footnotes.` An example of a footnote follows.

In the listing the following appears:

    13  DD  1790  if (b(i).le.6) ib(j*i) = i+j

At the end of the listing under the heading, `Footnotes` , is the following:

    13: data dependence  Data dependence involving this line due to variable IB

In this example, `13` is the footnote number, `DD` , meaning data dependence, is the class of message issued by KAP, and the `if` statement on line `1790` is the reference for this footnote.

## 9.2.5 Syntax Error/Warning Messages

When KAP detects syntax errors, it simply copies the input program unit to the transformed code file with no attempt to optimize the code.

When a program has syntax errors, messages are presented in the source ( `-listoptions=o` ) listing, interspersed with the user's code. Regardless of whether an original listing is requested, `stderr:` notes syntax errors and warnings. To locate the error messages in the source listing, look for lines beginning with the symbols `###` , for example:

    Footnotes Actions  DO Loops Line
                                1   SUBROUTINE Z(A, B, N)
                                2   REAL  A(N,N), B(N,N)
                       +--------3   DO 20 I=1,N
                       !+-------4   DO 20 J=1,N
                       !!       5   X = A(I,J)
                       !!       6   Y = B(I,J)
                       !!_______7   20  C(I,J) = X + Y

    ### line(7)
    ### error %KAP-E-DO_NON_EXE, DO loop ends on a non-executable statement.
    ### error %KAP-E-STMT_FUNCTION_O, Array not declared or statement
              function declared after executable statements.
                                8   PRINT *, X
                                9   RETURN
                               10   END

KAP also may intersperse syntax warning messages with the user's code, but optimization proceeds. Syntax warnings are for constructs that are not legal, but whose intent is clear.

## 9.2.6 Questions Generated by KAP

At times KAP needs additional information on which to base optimization decisions. In these cases KAP may ask a question to indicate what additional information is needed.

The following loop comes from an example for `-listoptions=o` :

    1 2  q  so  +--------- 24      DO 135 I = 1,N
    3    DD SO  !_________ 25  135 D(IP(I)) = C(I) + 3
    3: question %KAP-I-PERMUTATION_VEC, Is "IP" a permutation vector?

If you know IP is a permutation vector (or, at least, contains no duplicate values), this information can be passed to KAP with the following assertion:

    !*$* assert permutation (ip)
        DO 135 I = 1,N
    135   D(IP(I)) = C(I) + 3

This information may enable KAP to optimize the loop or the surrounding code. See Chapter 6 for information about KAP assertions.

## 9.2.7 Action Summary

Statements that are translated or modified by KAP are identified by abbreviations in the Action Summary listing field. The notations tell which class(es) of messages were issued for each line or statement. The following list explains each of these classes. KAP lists the abbreviated explanation of its actions at the bottom of the listing. For the DIR class, the class itself usually serves as the message; no detailed message follows. All other class abbreviations indicate a message follows in this class.

The abbreviations and meanings of these classes are as follows:

- DD (Data Dependence) --- This message indicates that a data dependence involving this statement prevented optimization.
- DIR (Directive) --- This class is used in conjunction with the footnotes, and concerns compiler directives. If you coded a compiler directive and that line does not have the DIR abbreviation in the listing, KAP did not recognize the directive. Check the setting of the `-directives` switch and the syntax of the directive.
- E (Syntax Error) --- These messages indicate syntax errors. These may refer to missing or extra characters, illegal keywords, or text placed in the wrong column. Optimization of such program units is inhibited; the Fortran 90 output file contains a copy of this program unit unmodified by KAP.
- EX (Extension) --- These messages show where a construct in the original program is not allowed in the language dialect KAP produces. In some cases an operation or type is allowed in the input language, but not in the output language.
- I (Inserted) --- These messages indicate a statement was added by KAP. In several of the scalar transformations, and in output generation, statements must be inserted into the transformed code.
- INF (Informational) --- These messages provide noncritical information to the user.
- INL (Inlined Subprogram) --- These messages mark lines where a subroutine or function was inlined or interprocedural analyzed. The text of the inlined routine, with appropriate substitutions, appears in the transformed code.
- LR (Loop Reordering) --- These messages inform you that a Fortran 90 statement has been modified in the process of interchanging loops. If during optimization KAP ascertains that an outer loop would be more efficient if innermost, and if it is legal to reorder the loops, KAP places the outer loop inside. In the process of doing this, KAP may have to change loop bounds (for triangular loops) or distribute loops or float IF assignments. Only the statements modified to do the exchange are marked where they occurred. Not all statements in the exchanged loops are marked.
- MIS (Miscellaneous) --- These messages inform you that some KAP diagnostic information has been lost. This does not mean the program has been transformed improperly, but that some messages generated in the process have been lost.
- NO (Program Too Large) --- These messages tell you that the program unit being processed is too large for KAP to optimize due to KAP data structure size limitations. KAP stops optimization and passes the original program unit to the transformed code file unchanged. You must split the program into smaller sections for KAP to process. This class of message rarely appears.
- OT (Output Translation) --- These messages indicate KAP changed the name of a modification to avoid a conflict with an intrinsic function name.
- OTF (Output Translation Fails) --- These messages mark statements that have constructs that exist in the input language but are not representable in the output language.
- OW (Option Error) --- The marked line appears to have a directive or assertion, but either KAP does not recognize it, or it has a syntax error.
- Q (Question) --- These messages inform you that KAP attempted to optimize a loop nest, but discovered a data dependence that it could not break at compilation time without further information. The information may be available to you and you can answer the question with an appropriate assertion.
- STD (Standardized) --- These messages mark where a program has been changed to a more standard form to improve the chance of finding optimizable code. The dusty-deck transformations KAP performs (for example, converting an IF/GOTO into a block IF) use this notation.
- TE (Translator Error) --- These messages inform you of an internal KAP error. A traceback is written to the listing file. The traceback and the code that caused it should be sent to your software vendor so a correction can be made. If the error can be reproduced in a small program unit, that small program unit will be easier to work from and may speed isolating the problem.
- W (Warning) --- These messages contain syntax warnings.

# 9.3 Loop Table Messages

The Loop Table listing ( `-listoptions=l` ) includes an entry for each loop indicating whether it was optimized, or why it was not. This section lists the possible messages and gives a brief explanation for each. The two most common reasons for a loop to be left serial are that the iterations were not independent (the listing should give a Data Dependence message) and that the loop contained I/O statements.

- Bad intrinsic call --- Code rearrangement by KAP may give unpredictable results.
- Bad operator --- Code rearrangement by KAP may give unpredictable results.
- Branches out of/into loop --- Code may be iteration-order dependent.
- CALL with alternate returns --- Program flow too uncertain.
- IO statements in loop --- Input/Output assumed order-dependent.
- Cannot allocate temporary array --- Usually, a Data Dependence could have been lifted by expanding a scalar into an array, but there was a name conflict.
- Distributed --- Loop divided into smaller loops, some of which may be otherwise optimized.
- DO statement not optimizable --- For example, iteration count of a DO WHILE loop is not known.
- Fused with other loops --- Adjacent loops joined into a larger loop to reduce overhead.
- GOTO in loop --- Possible flow patterns too complicated for KAP.
- Left as DO loop --- Usually, a Data Dependence prevented optimization.
- Left as a serial loop --- Usually, too much synchronization required.
- Nested IFs --- The branching pattern was too complicated.
- No optimizable statements --- For example, no arithmetic in loop.
- Not enough work --- Optimization overhead greater than expected gain.
- Optimization disabled --- By a directive or assertion.
- Scalar directive --- A directive or assertion turned off optimization.
- Scalar mode preferable --- Usually, too much synchronization needed.
- Too many inner loops: LIMIT > integer --- VERY complicated loop nest; KAP will try to optimize inner loops.
- Too many stmts/DD arcs --- VERY complicated loop nest; try increasing `-arclimit` .
- Unoptimizable call --- SUBROUTINE or FUNCTION with unknown side effects.
- Unoptimizable intrinsic call --- Unknown side effects.
- Unoptimizable operation --- For example, character string manipulation.
- Unoptimizable statements in loop --- Usually I/O.
- Unoptimizable symbol use --- Variable used in a complicated way, such as with COMMON or EQUIVALENCE.
- Unoptimizable variable or operation type --- Only numerical work is easily optimized by Compaq KAP Fortran/OpenMP for Tru64 UNIX.
- Unrolled --- Loop would run more efficiently than rolled up (see explanations in Chapter 4 and Chapter 8).

# 9.4 KAP Listing Messages

Appendix F provides a complete list of the diagnostic messages that can appear in the program listing (original or transformed).

In addition to the listing file, some messages (such as for command-line switch errors or missing files) are written to the error file. These are intended to be self-explanatory.

Previous | Next | Contents | Index