April 1997
This document lists KAP Fortran for OpenVMS Alpha command-line options.
For more information about these options, see the KAP Fortran for OpenVMS Alpha User Guide.
| Revision /Update Information | This is a revised document. |
| Operating System and Version: | OpenVMS Alpha, Version 7.1 |
| Software Version: | KAP Fortran, Version 3.1 |
Digital Equipment Corporation
Maynard, Massachusetts
_____________________________________________________________________
First Printing, 1993
Revised, April 1997
Possession, use, or copying of the software described in this publication is authorized only pursuant to a valid written license from Digital or an authorized sublicensor.
Digital Equipment Corporation makes no representations that the use of its products in the manner described in this publication will not infringe on existing or future patent rights, nor do the descriptions contained in this publication imply the granting of licenses to make, use, or sell equipment or software in accordance with the description. © Digital Equipment Corporation 1993, 1996, 1997. All rights reserved. © Kuck & Associates, Inc. 1993, 1996, 1997. All rights reserved.
The following are trademarks of Digital Equipment Corporation: AlphaGeneration, Digital Fortran, Digital, OpenVMS, VAX DOCUMENT, and the DIGITAL logo.
KAP is a trademark of Kuck & Associates, Inc.
All other trademarks and registered trademarks are the property of their respective holders.
This document is available on CD-ROM.
This document was produced using SDMLWEB. 1
| Long Name | Short Name | Default Value |
|---|---|---|
| General Optimization | ||
| [no]interchange | interchange | interchange |
| [no]namepartitioning= <integer>,<integer> | [n]namepart= <integer>,<integer> | nonamepart |
| optimize=<integer> | o=<integer> | o=5 |
| roundoff=<integer> | r=<integer> | r=3 |
| routine=<routine_name> /<limited qualifiers> | rt=<routine_name> /<limited qualifiers> | off |
| scalaropt=<integer> | so=<integer> | so=3 |
| [no]skip | [n]sk | nosk |
| tune=<architecture> | tune= <architecture> | tune= <architecture> |
| Parallel Processing | ||
| [no]concurrentize | [n]conc | noconc |
| minconcurrent=<integer> | mc | mc=1000 |
| [no]parallelio | [n]pio | nopio |
| Fortran Language | ||
| assume=<list> | a=<list> | a=cel |
| noassume | na | |
| [no]case | [n]case | ncase |
| [no]datasave | [n]ds | ds |
| [no]dlines | [n]dl | ndl |
| [no]escape | escape | |
| integer=<integer> | int=<integer> | int=4 |
| [no]intlog | [n]intl | intlog |
| logical=<integer> | log=<integer> | log=4 |
| [no]natural | see User Guide | |
| [no]onetrip | [n]1 | n1 |
| real=<integer> | rl=<integer> | real=4 |
| [no]recursion | [n]rc | nrc |
| save=<list> | sv=<list> | sv=manual_adjust |
| scan=<integer> | scan=<integer> | scan=72 |
| syntax=<list> | sy=<list> | off |
| [no]type | [n]ty | ntype |
| Directives | ||
| directives=<list> | dr=<list> | dr=ak |
| nodirectives=<list> | ndr | |
| [no]ignoreoptions | [n]ig | nig |
| Inlining and IPA | ||
| inline[=<names>] | inl[=<names>] | off |
| noinline[=<names>] | ninl[=<names>] | off |
| ipa[=<names>] | ipa[=<names>] | off |
| noipa[=<names>] | nipa[=<names>] | off |
| inline_and_copy=<names> | inlc=<names> | off |
| inline_create=<file> | incr=<file> | off |
| ipa_create=<file> | ipacr=<file> | off |
| inline_depth=<file> | ind=<file> | ind=2 |
| inline_from_files=<file>,<file> | inff=<file>,<file> | current source file |
| ipa_from_files=<file>,<file> | ipaff=<file>,<file> | current source file |
| inline_from_libraries= <library>,<library> | infl=<library>, <library> | off |
| ipa_from_ libraries= <library>,<library> | ipafl=<library>, <library> | off |
| inline_ looplevel=<integer> | inll=<integer> | inll=2 |
| ipa_ looplevel=<integer> | ipall=<integer> | ipall=2 |
| inline_manual | inm | off |
| ipa_ manual | ipam | off |
| inline_optimize=<integer> | inline_optimize=0 | |
| ipa_ optimize=<integer> | ipa_ optimize=0 | |
| Input-Output | ||
| cmp=<file> | cmp=<file> | <file>.cmp |
| nocmp=<file> | ncmp=<file> | |
| fortran=<file> | f=<file> | see User Guide |
| nofortran=<file> | nf | |
| list[=<file>] | l[=<file>] | see User Guide |
| nolist | nl | |
| Listing | ||
| cmpoptions[=<list>] | cp[=<list>] | cp=n |
| nocmpoptions | ncp | |
| lines=<integer> | ln=<integer> | ln=55 |
| listingwidth=<integer> | lw=<integer> | lw=132 |
| listoptions=<list> | lo=<list> | l=0 |
| suppress=<list> | su=<list> | off |
| Advanced Optimization | ||
| [no]aggressive=<list> | [n]ag=<list> | nag |
| [no]arclimit=<integer> | [n]arclm=<integer> | arclm=5000 |
| cacheline=<integer> | chl=<integer> | chl=32,32 |
| cache_prefetch_line_count= <integer>[,integer] | cplc=<integer> | cplc=0 |
| cachesize=<integer> | chs=<integer> | chs=8 |
| dpregisters=<integer> | dpr=<integer> | dpr=32 |
| each_invariant_if_growth= <integer> | eiifg=<integer> | eiifg=20 |
| fpregisters=<integer> | fpr=<integer> | fpr=32 |
| [no]fuse | fuse | nofuse |
| fuselevel=<integer> | fuselevel=<integer> | fuselevel=0 |
| heaplimit=<integer> | heap=<integer> | heaplimit=116 |
| hoist_loop_invariants= <integer> | hli= <integer> | hli=1 |
| [no]interleave | intl | interleave |
| library_calls=<name> | lc=<name> | off |
| limit=<integer> | lm=<integer> | lm=20000 |
| [no]machine=<list> | [no]ma=<list> | ma=s |
| max_invariant_if_growth= <integer> | miifg=<integer> | miifg=500 |
| routine=<routine_name> /<limited qualifiers> | rt=<routine_name> /<limited qualifiers> | off |
| setassociativity=<integer> | sasc=<integer> | sasc=1 |
| [no]srlcd | srlcd | nosrlcd |
| unroll=<integer> | ur=<integer> | ur=4 |
| unroll2=<integer> | ur2=<integer> | ur2=160 |
| unroll3=<integer> | ur3=<integer> | ur3=20 |
| Value | Meaning |
|---|---|
| assume | |
| a | c*$* assert argument aliasing |
| b | c*$* assert bounds violations |
| c | c*$* assert temporaries for constant arguments |
| e | c*$* assert equivalence hazard |
| l | c*$* assert last value needed |
| directives | |
| a | KAP assertions |
| k | KAP c*$* directives |
| p | KAP Parallel Computing Forum directives |
| v | VAST cvd$ directives |
| listoptions | |
| c | Calling tree at end of program listing |
| k | KAP options used, printed at end of each program unit |
| l | Loop-by-loop optimization table |
| n | Names of program unit |
| o | Original program listing |
| p | Performance statistics compilation |
| s | Summary of optimizations performed |
| t | Transformed program listing |
| machine | |
| n | Prefer nonstride-1 array access |
| o | Directs KAP to parallelize only outer loops |
| s | Prefer optimization of DO loop stride-1 references |
| optimize | |
| 0 | No optimization performed |
| 1 | Only simple analysis and optimization performed Induction variables recognized DO loop interchanging techniques applied |
| 2 | Lifetime analysis performed More powerful data dependence tests used |
| 3 | More loop interchanging performed Special case data dependence tests performed Wraparound variables recognized |
| 4 | Loop interchanging around reductions More exact data dependence tests performed |
| 5 | Array expansion enabled |
| other | |
| Limit | >0 |
| Arclimit | >0 |
| Library_calls | BLAS |
| roundoff | |
| 0 | No roundoff- changing transformations |
| 1 | Expression simplification and code floating enabled Arithmetic reductions recognized Loop interchanging around arithmetic reductions allowed if -optimize is greater than 4 Loop rerolling allowed when -scalaropt is greater than 1 |
| 2 | Reciprocal substitution performed to move an expensive division outside of loop |
| 3 | Recognize real induction variables if -scalaropt is greater than 2 or -optimize is greater than 1 Memory management enabled if -scalaropt=3 Expressions such as A / B / C can be rotated to A / (B*C) |
| scalaropt | |
| 0 | No scalar optimizations performed |
| 1 | IF loops changed into DO loops Simple code floating out of loops performed Inaccessible or unused code is removed Forward substitution of variables performed Dusty deck IF transformations enabled |
| 2 | Full range of scalar optimizations enabled Floating invariant IFs out of loops Induction variable recognition Loop rerolling if -roundoff is greater than 1 Loop peeling, loop fusion, loop unrolling |
| 3 | Memory management performed if -roundoff=3 Additional dead-code elimination performed during output conversion |
| suppress | |
| d | Disables data dependence messages |
| e | Disables syntax error messages |
| i | Disables informational messages |
| n | Disables not optimized messages |
| q | Disables questions |
| s | Disables standardized messages |
| w | Disables syntax warning messages |
| syntax | |
| a | Strict compliance with ANSI Fortran |
| v | Accepts Digital Fortran source files |
| unroll - enabled only with -scalaropt=2 | |
| - unroll=<#it> and -unroll2=<weight> | |
| where:
<#it> is the maximum number of iterations to unroll. =0 use default values to unroll =1 no unrolling <weight> is the maximum weight, estimate of work, in an unrolled loop. Work is estimated by counting operands and operators in a loop. The default is at most 4 iterations and maximum work of 100 per unrolled iteration. | |
| KAP Assertion | Duration |
|---|---|
| c*$* assert [no]argument aliasing | Until reset |
| c*$* assert [no]bounds violations | Until reset |
| c*$* assert [no]equivalence hazard | Until reset |
| c*$* assert [no]interchange | Next loop |
| c*$* assert [no]last value needed | Until reset |
| c*$* assert permutation (name) | Next loop |
| c*$* assert no recurrence (<names>) | Next loop |
| c*$* assert relation (name .xx. variable/constant) | Next loop |
| c*$* assert no sync | Next loop |
| c*$* assert [no]temporaries for constant arguments | Until reset |
| Parallel Processing: | |
| c*$* assert concurrent call | End of loop |
| c*$* assert do (concurrent) | End of loop |
| c*$* assert do (concurrent call) | End of loop |
| c*$* assert do (serial) | End of loop |
| c*$* assert do prefer (concurrent) | End of loop |
| c*$* assert do prefer (serial) | End of loop |
| KAP Directive | Range of Values |
| Optimization: | |
| c*$* arclimit (n) | 0-5000 |
| c*$* beginblock | <directive block> |
| c*$* endblock | |
| c*$* each_ invariant_if_growth (n) | 0-20 |
| c*$* limit (n) | >0 |
| c*$* max_invariant_if_growth (n) | 0-500 |
| c*$* optimize (n) | 0-5 |
| c*$* roundoff (n) | 0-3 |
| c*$* scalar optimize (n) | 0-3 |
| c*$* unroll (n1[,n2]) n1 for unroll, n2 for unroll2 | n1,n2>0 |
| Parallel Processing: | |
| c*$* [no]concurrentize | 0-5 |
| c*$* minconcurrent | 0-999999 |
| Inlining and Interprocedural Analysis: | |
| c*$*[no]inline [scope] [(name)] | On/off |
| c*$*[no]ipa [scope] [(name)] | On /off |
| Memory Management: | |
| c*$* padding (name) | (var-list) |
| c*$* storage order (names) | (var-list) |
| Assertions: | |
| c*$*[no]assertions | On/off |
