Optimization and Programming Guide

Transcription

1 IBM XL Fortran for Linux, V15.1 Optimization and Programming Guide Version 15.1 SC

2

3 IBM XL Fortran for Linux, V15.1 Optimization and Programming Guide Version 15.1 SC

4 Note Before using this information and the product it supports, read the information in Notices on page 317. First edition This edition applies to IBM XL Fortran for Linux, V15.1 (Program 5765-J10; 5725-C75) and to all subsequent releases and modifications until otherwise indicated in new editions. Make sure you are using the correct edition for the leel of the product. Copyright IBM Corporation 1990, US Goernment Users Restricted Rights Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

5 Contents About this information ii Who should read this information ii How to use this information ii How this information is organized ii Conentions iii Related information xii IBM XL Fortran information xii Standards and specifications xiii Other IBM information xi Technical support xi How to send your comments xi Chapter 1. Optimizing your applications 1 Distinguishing between optimization and tuning.. 1 Steps in the optimization process Basic optimization Optimizing at leel Optimizing at leel Adanced optimization Optimizing at leel An intermediate step: adding -qhot suboptions at leel Optimizing at leel Optimizing at leel Specialized optimization techniques High-order transformation (HOT) Interprocedural analysis (IPA) Profile-directed feedback Handling table of contents (TOC) oerflow Vector technology Using compiler reports to diagnose optimization opportunities Debugging optimized code Understanding different results in optimized programs Debugging in the presence of optimization Using -qoptdebug to help debug optimized programs Tracing procedures in your code Getting more performance Beyond performance: effectie programming techniques Chapter 2. Tuning XL compiler applications Tuning for your target architecture Using -qarch Using -qtune Using -qcache Before you finish tuning Further option drien tuning Options for proiding application characteristics 45 Options to control optimization transformations 47 Options to assist with performance analysis.. 49 Options that can inhibit performance Chapter 3. Adanced optimization concepts Aliasing Inlining Finding the right leel of inlining Chapter 4. Managing code size Steps for reducing code size Compiler option influences on code size The -qipa compiler option The -qinline inlining option The -qhot compiler option The -qcompact compiler option Other influences on code size High actiity areas Computed GOTOs and CASE constructs Code size with dynamic or static linking Chapter 5. Compiler-friendly programming techniques General practices Variables and pointers Arrays Choosing appropriate ariable sizes Submodules (Fortran 2008) Chapter 6. High performance libraries 67 Using the Mathematical Acceleration Subsystem libraries (MASS) Using the scalar library Using the ector libraries Using the SIMD libraries Compiling and linking a program with MASS.. 79 Using the Basic Linear Algebra Subprograms BLAS BLAS function syntax Linking the libxlopt library Chapter 7. Parallel programming with XL Fortran Compiling your parallelized code The _OPENMP C preprocessor macro and conditional compilation Setting runtime options XLSMPOPTS Enironment ariables for OpenMP Optimizing your SMP code Deeloping and running SMP applications An introduction to parallelization directies Parallel region construct Work-sharing constructs Combined parallel work-sharing constructs Synchronization constructs Other OpenMP directies Copyright IBM Corp. 1990, 2014 iii

6 Non-OpenMP SMP directies Deprecated directie Detailed descriptions of parallelization directies 101 ATOMIC BARRIER CRITICAL / END CRITICAL DO / END DO DO SERIAL FLUSH MASTER / END MASTER ORDERED / END ORDERED PARALLEL / END PARALLEL PARALLEL DO / END PARALLEL DO PARALLEL SECTIONS / END PARALLEL SECTIONS PARALLEL WORKSHARE / END PARALLEL WORKSHARE SCHEDULE SECTIONS / END SECTIONS SINGLE / END SINGLE TASK / END TASK TASKWAIT TASKYIELD THREADLOCAL THREADPRIVATE WORKSHARE / END WORKSHARE Data sharing attribute rules Directie clauses COLLAPSE COPYIN COPYPRIVATE DEFAULT FINAL FIRSTPRIVATE IF LASTPRIVATE MERGEABLE NUM_THREADS ORDERED PRIVATE REDUCTION SCHEDULE SHARED UNTIED Routines for OpenMP omp_destroy_lock(sar) omp_destroy_nest_lock(nar) omp_get_actie_leel() omp_get_ancestor_thread_num(leel) omp_get_dynamic() omp_get_leel() omp_get_max_actie_leels() omp_get_max_threads() omp_get_nested() omp_get_num_procs() omp_get_num_threads() omp_get_schedule(kind, modifier) omp_get_team_size(leel) omp_get_thread_limit() omp_get_thread_num() omp_get_wtick() omp_get_wtime() omp_in_final() omp_in_parallel() omp_init_lock(sar) omp_init_nest_lock(nar) omp_set_dynamic(enable_expr) omp_set_lock(sar) omp_set_max_actie_leels(max_leels) omp_set_nested(enable_expr) omp_set_nest_lock(nar) omp_set_num_threads(number_of_threads_expr) 195 omp_set_schedule(kind, modifier) omp_test_lock(sar) omp_test_nest_lock(nar) omp_unset_lock(sar) omp_unset_nest_lock(nar) Pthreads library module Pthreads data structures, functions, and subroutines f_maketime(delay) f_pthread_attr_destroy(attr) f_pthread_attr_getdetachstate(attr, detach) f_pthread_attr_getguardsize(attr, guardsize) f_pthread_attr_getinheritsched(attr, inherit) f_pthread_attr_getschedparam(attr, param) f_pthread_attr_getschedpolicy(attr, policy) f_pthread_attr_getscope(attr, scope) f_pthread_attr_getstack(attr, stackaddr, ssize) 207 f_pthread_attr_init(attr) f_pthread_attr_setdetachstate(attr, detach) f_pthread_attr_setguardsize(attr, guardsize) f_pthread_attr_setinheritsched(attr, inherit) f_pthread_attr_setschedparam(attr, param) f_pthread_attr_setschedpolicy(attr, policy) f_pthread_attr_setscope(attr, scope) f_pthread_attr_setstack(attr, stackaddr, ssize) 212 f_pthread_attr_t f_pthread_cancel(thread) f_pthread_cleanup_pop(exec) f_pthread_cleanup_push(cleanup, flag, arg) f_pthread_cond_broadcast(cond) f_pthread_cond_destroy(cond) f_pthread_cond_init(cond, cattr) f_pthread_cond_signal(cond) f_pthread_cond_t f_pthread_cond_timedwait(cond, mutex, timeout) f_pthread_cond_wait(cond, mutex) f_pthread_condattr_destroy(cattr) f_pthread_condattr_getpshared(cattr, pshared) 219 f_pthread_condattr_init(cattr) f_pthread_condattr_setpshared(cattr, pshared) 220 f_pthread_condattr_t f_pthread_create(thread, attr, flag, ent, arg) f_pthread_detach(thread) f_pthread_equal(thread1, thread2) f_pthread_exit(ret) f_pthread_getconcurrency() f_pthread_getschedparam(thread, policy, param) 225 f_pthread_getspecific(key, arg) f_pthread_join(thread, ret) i XL Fortran: Optimization and Programming Guide

7 f_pthread_key_create(key, dtr) f_pthread_key_delete(key) f_pthread_key_t f_pthread_kill(thread, sig) f_pthread_mutex_destroy(mutex) f_pthread_mutex_init(mutex, mattr) f_pthread_mutex_lock(mutex) f_pthread_mutex_t f_pthread_mutex_trylock(mutex) f_pthread_mutex_unlock(mutex) f_pthread_mutexattr_destroy(mattr) f_pthread_mutexattr_getpshared(mattr, pshared) 233 f_pthread_mutexattr_gettype(mattr, type) f_pthread_mutexattr_init(mattr) f_pthread_mutexattr_setpshared(mattr, pshared) 235 f_pthread_mutexattr_settype(mattr, type) f_pthread_mutexattr_t f_pthread_once(once, initr) f_pthread_once_t f_pthread_rwlock_destroy(rwlock) f_pthread_rwlock_init(rwlock, rwattr) f_pthread_rwlock_rdlock(rwlock) f_pthread_rwlock_t f_pthread_rwlock_tryrdlock(rwlock) f_pthread_rwlock_trywrlock(rwlock) f_pthread_rwlock_unlock(rwlock) f_pthread_rwlock_wrlock(rwlock) f_pthread_rwlockattr_destroy(rwattr) f_pthread_rwlockattr_getpshared(rwattr, pshared) f_pthread_rwlockattr_init(rwattr) f_pthread_rwlockattr_setpshared(rwattr, pshared) f_pthread_rwlockattr_t f_pthread_self() f_pthread_setcancelstate(state, oldstate) f_pthread_setcanceltype(type, oldtype) f_pthread_setconcurrency(new_leel) f_pthread_setschedparam(thread, policy, param) 247 f_pthread_setspecific(key, arg) f_pthread_t f_pthread_testcancel() f_sched_param f_sched_yield() f_timespec Chapter 8. Interlanguage calls Conentions for XL Fortran external names Mixed-language input and output Mixing Fortran and C Making calls to C functions work Passing data from one language to another Passing arguments between languages Passing global ariables between languages Passing character types between languages Passing arrays between languages Passing pointers between languages Passing arguments by reference or by alue Passing COMPLEX alues to/from gcc Returning alues from Fortran functions Arguments with the OPTIONAL attribute Assembler-leel subroutine linkage conentions 262 The stack The Linkage Area and Minimum Stack Frame 266 The input parameter area The register sae area The local stack area The output parameter area Linkage conention for argument passing Argument passing rules (by alue) Order of arguments in argument list Linkage conention for function calls Pointers to functions Function alues The stack floor Stack oerflow Prolog and epilog Traceback Chapter 9. Implementation details of XL Fortran Input/Output (I/O) Implementation details of file formats File names Preconnected and Implicitly Connected Files File positioning I/O redirection How XL Fortran I/O interacts with pipes, special files, and links Default record lengths File permissions Selecting error messages and recoery actions Flushing I/O buffers Choosing locations and names for Input/Output files Naming files that are connected with no explicit name Naming scratch files Asynchronous I/O Execution of an asychronous data transfer operation Usage Performance Compiler-generated temporary I/O items Error handling XL Fortran thread-safe I/O library Synchronization of I/O operations Parallel I/O issues Use of I/O statements in signal handlers Asynchronous thread cancellation Chapter 10. Implementation details of XL Fortran floating-point processing. 291 IEEE floating-point oeriew Compiling for strict IEEE conformance IEEE Single- and double-precision alues IEEE extended-precision alues Infinities and NaNs Exception-handling model Hardware-specific floating-point oeriew Single- and double-precision alues Extended-precision alues Contents

8 How XL Fortran rounds floating-point calculations 296 Selecting the rounding mode Minimizing rounding errors Minimizing oerall rounding Delaying rounding until run time Ensuring that the rounding mode is consistent 298 Duplicating the floating-point results of other systems Maximizing floating-point performance Detecting and trapping floating-point exceptions 300 Compiler features for trapping floating-point exceptions Installing an exception handler Producing a core file Controlling the floating-point status and control register xlf_fp_util procedures fpgets and fpsets subroutines Sample programs for exception handling Causing exceptions for particular ariables Minimizing the performance impact of floating-point exception trapping Chapter 11. Porting programs to XL Fortran Outline of the porting process Portability of directies Common industry extensions that XL Fortran supports Mixing data types in statements Date and time routines Other libc routines Changing the default sizes of data types Name conflicts between your procedures and XL Fortran intrinsic procedures Reproducing results from other systems Chapter 12. Sample Fortran programs 311 Example 1-XL Fortran source file Example 2 - alid C routine source file Example 3 - alid Fortran SMP source file Example 4 - inalid Fortran SMP source file Programming examples using the Pthreads library module Notices Trademarks and serice marks Index i XL Fortran: Optimization and Programming Guide

9 About this information This information is part of the IBM XL Fortran for Linux, V15.1 information suite. It proides both reference information and practical tips for using XL Fortran's optimization and tuning capabilities to maximize application performance, as well as expanding on programming concepts such as I/O and interlanguage calls. Who should read this information How to use this information This information is for anyone who wants to exploit the XL Fortran compiler's capabilities for optimizing and tuning Fortran programs. Readers should be familiar with their Linux operating system and hae extensie Fortran programming experience with complex applications. Howeer, users new to XL Fortran can still use this information to help them understand how the compiler's features can be used for effectie program optimization. This guide focuses on specific programming and compilation techniques that can maximize XL Fortran application performance. It coers optimization and tuning strategies, recommended programming practices and compilation procedures, debugging, and information on using XL Fortran adanced language features. This guide also contains cross-references to releant topics of other reference guides in the XL Fortran information suite. Topics not described in this information are aailable as indicated in the following: Installation, system requirements, last-minute updates: see the XL Fortran Installation Guide and product README. Oeriew of XL Fortran features: see the Getting Started with XL Fortran. Syntax, semantics, and implementation of the XL Fortran programming language: see the XL Fortran Language Reference. Compiler setup, compiling and running programs, compiler options, diagnostics: see the XL Fortran Compiler Reference. Operating system commands related to the use of the compiler: consult your Linux-specific distribution's man page help and information. How this information is organized This guide includes the following topics: Chapter 1, Optimizing your applications, on page 1 proides an oeriew of the optimization process. Chapter 2, Tuning XL compiler applications, on page 41 discusses the compiler options aailable for optimizing and tuning code. Chapter 3, Adanced optimization concepts, on page 51, Chapter 4, Managing code size, on page 55, and Debugging optimized code on page 30 discuss adanced techniques like optimizing loops and inlining code, and debug considerations for optimized code. Copyright IBM Corp. 1990, 2014 ii

10 The following sections contain information on how to write optimization friendly, portable XL Fortran code, that is interoperable with other languages. Also included is a description of XL Fortran's OpenMP and SMP support with guidelines for writing parallel code. Chapter 5, Compiler-friendly programming techniques, on page 61 Chapter 6, High performance libraries, on page 67 Chapter 7, Parallel programming with XL Fortran, on page 85 Chapter 8, Interlanguage calls, on page 251 The following sections contain information about XL Fortran and its implementation that can be useful for new and experienced users alike, as well as those who want to moe their existing Fortran applications to the XL Fortran compiler: Chapter 9, Implementation details of XL Fortran Input/Output (I/O), on page 275 Chapter 10, Implementation details of XL Fortran floating-point processing, on page 291 Chapter 11, Porting programs to XL Fortran, on page 307 Conentions Typographical conentions The following table shows the typographical conentions used in the IBM XL Fortran for Linux, V15.1 information. Table 1. Typographical conentions Typeface Indicates Example lowercase bold Inocation commands, executable names, and compiler options. The compiler proides basic inocation commands, xlf, along with seeral other compiler inocation commands to support arious Fortran language leels and compilation enironments. The default file name for the executable program is a.out. italics underlining monospace UPPERCASE bold Parameters or ariables whose actual names or alues are to be supplied by the user. Italics are also used to introduce new terms. The default setting of a parameter of a compiler option or directie. Examples of program code, reference to program code, file names, path names, command strings, or user-defined names. Fortran programming keywords, statements, directies, and intrinsic procedures. Uppercase letters may also be used to indicate the minimum number of characters required to inoke a compiler option/suboption. Make sure that you update the size parameter if you return more than the size requested. nomaf maf To compile and optimize myprogram.f, enter: xlf myprogram.f -O3. The ASSERT directie applies only to the DO loop immediately following the directie, and not to any nested DO loops. iii XL Fortran: Optimization and Programming Guide

11 Qualifying elements (icons and bracket separators) In descriptions of language elements, this information uses icons and marked bracket separators to delineate the Fortran language standard text as follows: Table 2. Qualifying elements Icon F2008 F2008 Bracket separator text N/A Meaning The text describes an IBM XL Fortran implementation of the Fortran 2008 standard. Fortran 2003 begins / ends The text describes an IBM XL Fortran implementation of the Fortran 2003 standard, and it applies to all later standards. IBM extension begins / ends The text describes a feature that is an IBM XL Fortran extension to the standard language specifications. TS TS N/A The text describes a feature in a Technical Specification that is not part of the current Fortran standard. Note: If the information is marked with a Fortran language standard icon or bracket separators, it applies to this specific Fortran language standard and all later ones. If it is not marked, it applies to all Fortran language standards. Syntax diagrams Throughout this information, diagrams illustrate XL Fortran syntax. This section will help you to interpret and use those diagrams. Read the syntax diagrams from left to right, from top to bottom, following the path of the line. The symbol indicates the beginning of a command, directie, or statement. The symbol indicates that the command, directie, or statement syntax is continued on the next line. The symbol indicates that a command, directie, or statement is continued from the preious line. The symbol indicates the end of a command, directie, or statement. Fragments, which are diagrams of syntactical units other than complete commands, directies, or statements, start with the symbol and end with the symbol. IBM XL Fortran extensions are marked by a number in the syntax diagram with an explanatory note immediately following the diagram. Program units, procedures, constructs, interface blocks and deried-type definitions consist of seeral indiidual statements. For such items, a box encloses the syntax representation, and indiidual syntax diagrams show the required order for the equialent Fortran statements. Required items are shown on the horizontal line (the main path): About this information ix

12 keyword required_argument Optional items are shown below the main path: keyword optional_argument Note: Optional items (not in syntax diagrams) are enclosed by square brackets ([ and ]). For example, [UNIT=]u If you can choose from two or more items, they are shown ertically, in a stack. If you must choose one of the items, one item of the stack is shown on the main path. keyword required_argument1 required_argument2 If choosing one of the items is optional, the entire stack is shown below the main path. keyword optional_argument1 optional_argument2 An arrow returning to the left aboe the main line (a repeat arrow) indicates that you can make more than one choice from the stacked items or repeat an item. The separator character, if it is other than a blank, is also indicated:, keyword repeatable_argument The item that is the default is shown aboe the main path. keyword default_argument alternate_argument Keywords are shown in nonitalic letters and should be entered exactly as shown. Variables are shown in italicized lowercase letters. They represent user-supplied names or alues. If a ariable or user-specified name ends in _list, you can proide a list of these terms separated by commas. If punctuation marks, parentheses, arithmetic operators, or other such symbols are shown, you must enter them as part of the syntax. Sample syntax diagram The following is an example of a syntax diagram with an interpretation: x XL Fortran: Optimization and Programming Guide

13 (1) EXAMPLE char_constant a b c d, e name_list Notes: 1 IBM extension Interpret the diagram as follows: Enter the keyword EXAMPLE. EXAMPLE is an IBM extension. Enter a alue for char_constant. Enter a alue for a or b, but not for both. Optionally, enter a alue for c or d. Enter at least one alue for e. If you enter more than one alue, you must put a comma between each. Enter the alue of at least one name for name_list. If you enter more than one alue, you must put a comma between each. (The _list syntax is equialent to the preious syntax for e.) How to read syntax statements Syntax statements are read from left to right: Indiidual required arguments are shown with no special notation. When you must make a choice between a set of alternaties, they are enclosed by { and } symbols. Optional arguments are enclosed by [ and ] symbols. When you can select from a group of choices, they are separated by characters. Arguments that you can repeat are followed by ellipses (...). Example of a syntax statement EXAMPLE char_constant {a b}[c d]e[,e]... name_list{name_list}... The following list explains the syntax statement: Enter the keyword EXAMPLE. Enter a alue for char_constant. Enter a alue for a or b, but not for both. Optionally, enter a alue for c or d. Enter at least one alue for e. If you enter more than one alue, you must put a comma between each. Optionally, enter the alue of at least one name for name_list. If you enter more than one alue, you must put a comma between each name. Note: The same example is used in both the syntax-statement and syntax-diagram representations. About this information xi

14 Related information Examples in this information The examples in this information, except where otherwise noted, are coded in a simple style that does not try to consere storage, check for errors, achiee fast performance, or demonstrate all possible methods to achiee a specific result. The examples for installation information are labelled as either Example or Basic example. Basic examples are intended to document a procedure as it would be performed during a basic, or default, installation; these need little or no modification. Notes on the terminology used Some of the terminology in this information is shortened as follows: The term free source form format often appears as free source form. The term fixed source form format often appears as fixed source form. The term XL Fortran often appears as XLF. The following sections proide related information for XL Fortran: IBM XL Fortran information XL Fortran proides product information in the following formats: README files README files contain late-breaking information, including changes and corrections to the product information. README files are located by default in the XL Fortran directory and in the root directory of the installation CD. Installable man pages Man pages are proided for the compiler inocations and all command-line utilities proided with the product. Instructions for installing and accessing the man pages are proided in the IBM XL Fortran for Linux, V15.1 Installation Guide. Information center The fully searchable HTML-based documentation is iewable on the web at com.ibm.compilers.linux.doc/welcome.html. PDF documents PDF documents are located by default in the /opt/ibm/xlf/15.1.0/doc/lang/ pdf/ directory, where LANG is one of en_us or ja_jp. The PDF files are also aailable on the web at dociew.wss?uid=swg The following files comprise the full set of XL Fortran product information: Table 3. XL Fortran PDF files Document title IBM XL Fortran for Linux, V15.1 Installation Guide, SC PDF file name install.pdf Description Contains information for installing XL Fortran and configuring your enironment for basic compilation and program execution. xii XL Fortran: Optimization and Programming Guide

15 Table 3. XL Fortran PDF files (continued) Document title Getting Started with IBM XL Fortran for Linux, V15.1, SC IBM XL Fortran for Linux, V15.1 Compiler Reference, SC IBM XL Fortran for Linux, V15.1 Language Reference, SC IBM XL Fortran for Linux, V15.1 Optimization and Programming Guide, SC PDF file name getstart.pdf compiler.pdf langref.pdf proguide.pdf Description Contains an introduction to the XL Fortran product, with information on setting up and configuring your enironment, compiling and linking programs, and troubleshooting compilation errors. Contains information about the arious compiler options and enironment ariables. Contains information about the Fortran programming language as supported by IBM, including language extensions for portability and conformance to nonproprietary standards, compiler directies and intrinsic procedures. Contains information on adanced programming topics, such as application porting, interlanguage calls, floating-point operations, input/output, application optimization and parallelization, and the XL Fortran high-performance libraries. To read a PDF file, use Adobe Reader. If you do not hae Adobe Reader, you can download it (subject to license terms) from the Adobe website at More information related to XL Fortran including IBM Redbooks publications, white papers, tutorials, documentation errata, and other articles, is aailable on the web at: Note: Documentation errata is reflected only in the English ersion of the information center. For more information about Fortran, see the Fortran café at communityiew?communityuuid=b10932b4-0edd-4e61-89f2-6e478ccba9aa. Standards and specifications XL Fortran is designed to support the following standards and specifications. You can refer to these standards for precise definitions of some of the features found in this information. American National Standard Programming Language FORTRAN, ANSI X American National Standard Programming Language Fortran 90, ANSI X ANSI/IEEE Standard for Binary Floating-Point Arithmetic, ANSI/IEEE Std Federal (USA) Information Processing Standards Publication Fortran, FIPS PUB Information technology - Programming languages - Fortran, ISO/IEC :1991. (This information uses its informal name, Fortran 90.) Information technology - Programming languages - Fortran - Part 1: Base language, ISO/IEC :1997. (This information uses its informal name, Fortran 95.) Information technology - Programming languages - Fortran - Part 1: Base language, ISO/IEC :2004. (This information uses its informal name, Fortran 2003.) About this information xiii

16 Information technology - Programming languages - Fortran - Part 1: Base language, ISO/IEC :2010. (This information uses its informal name, Fortran We currently proide partial support to this standard.) Military Standard Fortran DOD Supplement to ANSI X , MIL-STD-1753 (United States of America, Department of Defense standard). Note that XL Fortran supports only those extensions documented in this standard that hae also been subsequently incorporated into the Fortran 90 standard. OpenMP Application Program Interface Version 4.0 (Partial support), aailable at Other IBM information Technical support How to send your comments ESSL for AIX V5.1/ESSL for Linux on POWER V5.1 Guide and Reference aailable at the Engineering and Scientific Subroutine Library (ESSL) and Parallel ESSL web page. Additional technical support is aailable from the XL Fortran Support page at xl_fortran_for_linux. This page proides a portal with search capabilities to a large selection of Technotes and other support information. If you cannot find what you need, you can send to compinfo@ca.ibm.com. For the latest information about XL Fortran, isit the product information site at Your feedback is important in helping to proide accurate and high-quality information. If you hae any comments about this information or any other XL Fortran information, send your comments by to compinfo@ca.ibm.com. Be sure to include the name of the manual, the part number of the manual, the ersion of XL Fortran, and, if applicable, the specific location of the text you are commenting on (for example, a page number or table number). xi XL Fortran: Optimization and Programming Guide

17 Chapter 1. Optimizing your applications The XL compilers enable deelopment of high performance 32-bit and 64-bit applications by offering a comprehensie set of performance enhancing techniques that exploit the multilayered PowerPC architecture. These performance adantages depend on good programming techniques, thorough testing and debugging, followed by optimization, and tuning. Distinguishing between optimization and tuning You can use optimization and tuning separately or in combination to increase the performance of your application. Understanding the difference between them is the first step in understanding how the different leels, settings, and techniques can increase performance. Optimization Optimization is a compiler drien process that searches for opportunities to restructure your source code and gie your application better oerall performance at run time, without significantly impacting deelopment time. The XL compiler optimization suite, which you control using compiler options and directies, performs best on well-written source code that has already been through a thorough debugging and testing process. These optimization transformations can: Reduce the number of instructions your application executes to perform critical operations. Restructure your object code to make optimal use of the PowerPC architecture. Improe memory subsystem usage. Exploit the ability of the architecture to handle large amounts of shared memory parallelization. Each basic optimization technique can result in a performance benefit, although not all optimizations can benefit all applications. Consult the Steps in the optimization process on page 2 for an oeriew of the common sequence of steps you can use to increase the performance of your application. Tuning While optimization applies general transformations designed to improe the performance of any application in any supported enironment, tuning offers you opportunities to adjust specific characteristics or target execution enironments of your application to improe its performance. Een at low optimization leels, tuning for your application and target architecture can hae a positie impact on performance. With proper tuning the compiler can: Select more efficient machine instructions. Generate instruction sequences that are more releant to your application. Select from more focussed optimizations to improe your code. For instructions, see Tuning XL compiler applications. Copyright IBM Corp. 1990,

18 Steps in the optimization process Basic optimization As you begin the optimization process, consider that not all optimization techniques suit all applications. Trade-offs sometimes occur between an increase in compile time, a reduction in debugging capability, and the improements that optimization can proide. Learning about, and experimenting with different optimization techniques can help you strike the right balance for your XL compiler applications while achieing the best possible performance. Also, though it is unnecessary to hand-optimize your code, compiler-friendly programming can be extremely beneficial to the optimization process. Unusual constructs can obscure the characteristics of your application and make performance optimization difficult. Use the steps in this section as a guide for optimizing your application. 1. The Basic optimization step begins your optimization processes at leels 0 and The Adanced optimization step exposes your application to more intense optimizations at leels 3, 4 and The High-order transformation (HOT) step can help you reduce loop execution time. 4. The Interprocedural analysis (IPA) step can optimize your entire application at once. 5. The Profile-directed feedback (PDF) step focuses optimizations on specific characteristics of your application. 6. The Debugging optimized code step can help you identify issues and problems that can occur with optimized code. 7. The Getting more performance section offers other strategies and tuning alternaties to compiler-drien optimization. The section Compiler-friendly programming techniques contains tips for writing more easily optimized source code. The XL compiler supports seeral leels of optimization, with each option leel building on the leels below through increasingly aggressie transformations, and consequently using more machine resources. Ensure that your application compiles and executes properly at low optimization leels before trying more aggressie optimizations. This topic discusses two optimizations leels, listed with complementary options in the Basic optimizations table. The table also includes a column for compiler options that can hae a performance benefit at that optimization leel for some applications. Table 4. Basic optimizations Additional options Complementary Other options with Optimization leel implied by default options possible benefits -O0 None -qarch None -O2 -qmaxmem=8192 -qarch -qtune -qmaxmem=-1 -qhot=leel=0 Note: Specifying -O without including a leel implies -O2. 2 XL Fortran: Optimization and Programming Guide

19 Optimizing at leel 0 Benefits at leel 0 Minimal performance improement, with minimal impact on machine resources. Exposes some source code problems, helping in the debugging process. Begin your optimization process at -O0 which the compiler already specifies by default. This leel performs basic analytical optimization by remoing obiously redundant code, and can result in better compile time. It also ensures your code is algorithmically correct so you can moe forward to more complex optimizations. -O0 also includes some redundant instruction elimination and constant folding. The option -qfloat=nofold can be used to suppress folding floating-point operations. Optimizing at this leel accurately preseres all debugging information and can expose problems in existing code, such as uninitialized ariables. Additionally, specifying -qarch at this leel targets your application for a particular machine and can significantly improe performance by ensuring your application takes adantage of all applicable architectural benefits. Note: For SMP programs, you need to add an additional option -qsmp=noopt. For more information on tuning, consult Tuning for Your Target Architecture. See "-O" in the XL Fortran Compiler Reference for information on the -O leel syntax. Optimizing at leel 2 Benefits at leel 2 Eliminates redundant code Basic loop optimization Can structure code to take adantage of -qarch and -qtune settings After successfully compiling, executing, and debugging your application using -O0, recompiling at -O2 opens your application to a set of comprehensie low-leel transformations that apply to subprogram or compilation unit scopes and can include some inlining. Optimizations at -O2 are a relatie balance between increasing performance while limiting the impact on compilation time and system resources. You can increase the memory aailable to some of the optimizations in the -O2 portfolio by proiding a larger alue for the -qmaxmem option. Specifying -qmaxmem=-1 allows the optimizer to use memory as needed without checking for limits but does not change the transformations the optimizer applies to your application at -O2. Starting to tune at leel 2 Choosing the right hardware architecture target or family of targets becomes een more important at -O2 and higher. By targeting the proper hardware, the optimizer can make the best use of the hardware facilities aailable. If you choose a family of hardware targets, the -qtune option can direct the compiler to emit code consistent with the architecture choice, but executes optimally on the chosen tuning hardware target. With this option, you can compile for a general set of targets but hae the code run best on a particular target. See the Chapter 2, Tuning XL compiler applications, on page 41 topics for details on the -qarch and -qtune options. Chapter 1. Optimizing your applications 3

20 Adanced optimization The -O2 option can perform a number of additional optimizations, including: Common subexpression elimination: Eliminates redundant instructions. Constant propagation: Ealuates constant expressions at compile-time. Dead code elimination: Eliminates instructions that a particular control flow does not reach, or that generate an unused result. Dead store elimination: Eliminates unnecessary ariable assignments. Graph coloring register allocation: Globally assigns user ariables to registers. Value numbering: Simplifies algebraic expressions, by eliminating redundant computations. Instruction scheduling for the target machine. Loop unrolling and software pipelining. Moing loop-inariant code out of loops. Simplifying control flow. Strength reduction and effectie use of addressing modes. Widening, which merges adjacent load/stores and other operations. Pointer aliasing improements to enhance other optimizations. Een with -O2 optimizations, some useful information about your source code is made aailable to the debugger if you specify -g. Using a higher -g leel increases the information proided to the debugger, but reduces the optimization that can be done. Conersely, higher optimization leels can transform code to an extent to which debugging information is no longer accurate. Use that information with discretion. The section on Debugging optimized code on page 30 discusses other debugging strategies in detail. See "-O" in the XL Fortran Compiler Reference for information on the -O leel syntax. Higher optimization leels can hae a tremendous impact on performance, but some trade-offs can occur in terms of code size, compile time, resource requirements, and numeric or algorithmic precision. After applying Basic optimization on page 2 and successfully compiling and executing your application, you can apply more powerful optimization tools. The XL compiler optimization portfolio includes many options for directing adanced optimization, and the transformations your application undergoes are largely under your control. The discussion of each optimization leel in Table 5 includes information on not only the performance benefits, and the possible trade-offs as well, but information on how you can help guide the optimizer to find the best solutions for your application. Table 5. Adanced optimizations Additional options Optimization Leel implied -O3 -qnostrict -qmaxmem=-1 -qhot=leel=0 Complementary options -qarch -qtune Options with possible benefits -qpdf 4 XL Fortran: Optimization and Programming Guide

21 Table 5. Adanced optimizations (continued) Optimization Leel Additional options implied Complementary options Options with possible benefits -O4 -qnostrict -qmaxmem=-1 -qhot -qipa -qarch=auto -qtune=auto -qcache=auto -O5 All of -O4 -qipa=leel=2 -qarch -qtune -qcache -qarch -qtune -qcache -qpdf -qsmp=auto -qpdf -qsmp=auto When you compile programs with any of the following sets of options: -qhot -qnostrict -qhot -O3 -O4 -O5 the compiler automatically attempts to ectorize calls to system math functions by calling the equialent ector functions in the Mathematical Acceleration Subsystem libraries (MASS), with the exceptions of functions atan2, satan2, dnint, dint, cosisin, scosisin, qdrt, sqdrt, rqdrt, srqdrt, popcnt4, and popcnt8. Ifthe compiler cannot ectorize, it automatically tries to call the equialent MASS scalar functions. For automatic ectorization or scalarization, the compiler uses ersions of the MASS functions contained in the system library libxlopt.a. In addition to any of the preceding sets of options, when the -qipa option is in effect, if the compiler cannot ectorize, it tries to inline the MASS scalar functions before deciding to call them. Optimizing at leel 3 Benefits at leel 3 In-depth Aliasing on page 51 analysis Better loop scheduling High-order loop analysis and transformations (-qhot=leel=0) Inlining of small procedures within a compilation unit by default Eliminating implicit compile-time memory usage limits Specifying -O3 initiates more intense low-leel transformations that remoe many of the limitations present at -O2. For instance, the optimizer no longer checks for memory limits, by defaulting to -qmaxmem=-1. Additionally, optimizations encompass larger program regions and attempt more in-depth analysis. While not all applications contain opportunities for the optimizer to proide a measurable increase in performance, most applications can benefit from this type of analysis. Potential trade-offs at leel 3 With the in-depth analysis of -O3 comes a trade-off in terms of compilation time and memory resources. Also, since -O3 implies -qnostrict, the optimizer can alter Chapter 1. Optimizing your applications 5

22 certain floating-point semantics in your application to gain execution speed. This typically inoles precision trade-offs as follows: Reordering of floating-point computations. Reordering or elimination of possible exceptions, such as diision by zero or oerflow. Using alternatie calculations that might gie slightly less precise results or not handle infinities or NaNs in the same way. You can still gain most of the -O3 benefits while presering precise floating-point semantics by specifying -qstrict. Compiling with -qstrict is necessary if you require the same absolute precision in floating-point computational accuracy as you get with -O0, -O2, or-qnoopt results. The option -qstrict=ieeefp also ensures adherence to all IEEE semantics for floating-point operations. If your application is sensitie to floating-point exceptions or the order of ealuation for floating-point arithmetic, compiling with -qstrict, -qstrict=exceptions, or-qstrict=order helps to ensure accurate results. You should also consider the impact of the -qstrict=precision suboption group on floating-point computational accuracy. The precision suboption group includes the indiidual suboptions: subnormals, operationprecision, association, reductionorder, and library (described in the -qstrict option in the XL Fortran Compiler Reference). Without -qstrict, the difference in computation for any one source-leel operation is ery small in comparison to Basic optimization on page 2. Although a small difference can be compounded if the operation is in a loop structure where the difference becomes additie, most applications are not sensitie to the changes that can occur in floating-point semantics. See "-O" in the XL Fortran Compiler Reference for information on the -O leel syntax. An intermediate step: adding -qhot suboptions at leel 3 At -O3, the optimization includes minimal -qhot loop transformations at leel=0 to increase performance. You can further increase your performance benefit by increasing the leel and therefore the aggressieness of -qhot. Try specifying -qhot without any suboptions, or -qhot=leel=1. The following -qhot suboptions can also proide additional performance benefits, depending on the characteristics of your application: -qhot=ector to enable long ectorization -qhot=arraypad to enable array padding -qhot=fastmath to enable the replacement of math routines with those from the XLOPT library For more information on -qhot, see High-order transformation (HOT) on page 9. Conersely, if the application does not use loops processing arrays (which -qhot improes), you can improe compile speed significantly, usually with minimal performance loss by using -qnohot after -O3. Optimizing at leel 4 Benefits at leel 4 6 XL Fortran: Optimization and Programming Guide Propagation of global and argument alues between compilation units Inlining code from one compilation unit to another Reorganization or elimination of global data structures

23 An increase in the precision of aliasing analysis Optimizing at -O4 builds on -O3 by triggering -qipa=leel=1 which performs interprocedural analysis (IPA), optimizing your entire application as a unit. This option is particularly pertinent to applications that contain a large number of frequently used routines. To make full use of IPA optimizations, you must specify -O4 on the compilation and link steps of your application build as interprocedural analysis occurs in stages at both compile and link time. Potential trade-offs at leel 4 In addition to the trade-offs already mentioned for -O3, specifying -qipa can significantly increase compilation time, especially at the link step. See "-O" in the XL Fortran Compiler Reference for information on the -O leel syntax. The IPA process 1. At compile time optimizations occur on a file-by-file basis, as well as preparation for the link stage. IPA writes analysis information directly into the object files the compiler produces. 2. At the link stage, IPA reads the information from the object files and analyzes the entire application. 3. This analysis guides the optimizer on how to rewrite and restructure your application and apply appropriate -O3 leel optimizations. The Interprocedural analysis (IPA) on page 11 section contains more information on IPA including details on IPA suboptions. Beyond -qipa, -O4 enables other optimization options: -qhot Enables more aggressie HOT transformations to optimize loop constructs and array language. -qhot=ector Optimizes array data to run mathematical operations in parallel where applicable. -qarch=auto and -qtune=auto Optimizes your application to execute on a hardware architecture identical to your build machine. If the architecture of your build machine is incompatible with your application's execution enironment, you must specify a different -qarch suboption after the -O4 option. This oerrides -qarch=auto. -qcache=auto Optimizes your cache configuration for execution on specific hardware architecture. The auto suboption assumes that the cache configuration of your build machine is identical to the configuration of your execution architecture. Specifying a cache configuration can increase program performance, particularly loop operations by blocking them to process only the amount of data that can fit into the data cache at a time. If you want to execute your application on a different machine, specify correct cache alues. Chapter 1. Optimizing your applications 7