IBM. Optimization and Programming Guide for Little Endian Distributions. IBM XL Fortran for Linux, V16.1. Version 16.

Transcription

1 IBM XL Fortran for Linux, V16.1 IBM Optimization and Programming Guide for Little Endian Distributions Version 16.1 SC

2

3 IBM XL Fortran for Linux, V16.1 IBM Optimization and Programming Guide for Little Endian Distributions Version 16.1 SC

4 Note Before using this information and the product it supports, read the information in Notices on page 381. First edition This edition applies to IBM XL Fortran for Linux, V16.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 level of the product. Copyright IBM Corporation 1990, US Government Users Restricted Rights Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

5 Contents About this document vii Who should read this document vii How to use this document vii How this document is organized vii Conventions viii Related information xii Available help information xii Standards and specifications xiv Other IBM information xv Technical support xv How to send your comments xv 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 activity areas Computed GOTOs and CASE constructs Code size with dynamic or static linking Chapter 1. Optimizing your applications 1 Distinguishing between optimization and tuning.. 1 Steps in the optimization process Basic optimization Optimizing at level Optimizing at level Advanced optimization Optimizing at level An intermediate step: adding -qhot suboptions at level Optimizing at level Optimizing at level Specialized optimization techniques High-order transformation (HOT) Interprocedural analysis (IPA) Profile-directed feedback Vector technology Using compiler reports to diagnose optimization opportunities Tracing procedures in your code Getting more performance Beyond performance: effective 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 driven tuning Options for providing application characteristics 38 Options to control optimization transformations 40 Options to assist with performance analysis.. 41 Options that can inhibit performance Chapter 3. Advanced optimization concepts Aliasing Inlining Finding the right level of inlining Chapter 5. Debugging optimized code 53 Understanding different results in optimized programs Debugging in the presence of optimization Chapter 6. Compiler-friendly programming techniques General practices Variables and pointers Arrays Choosing appropriate variable sizes Submodules (Fortran 2008) Chapter 7. Exploiting POWER9 technology POWER9 compiler options High-performance libraries that are tuned for POWER POWER9 intrinsic procedures Chapter 8. High performance libraries 67 Using the Mathematical Acceleration Subsystem (MASS) libraries Using the scalar library Using the vector libraries Using the SIMD libraries Compiling and linking a program with MASS.. 79 Using the Basic Linear Algebra Subprograms - BLAS 80 BLAS function syntax Linking the libxlopt library Chapter 9. Parallel programming with XL Fortran Compiling your parallelized code The _OPENMP C preprocessor macro and conditional compilation Setting runtime options XLSMPOPTS Environment variables for OpenMP Optimizing your SMP code Developing and running SMP applications Parallelization directives Copyright IBM Corp. 1990, 2018 iii

6 Summary of supported parallelization directives 108 Detailed descriptions of parallelization directives 111 Data sharing attribute rules Directive clauses Routines for OpenMP omp_destroy_lock(svar) omp_destroy_nest_lock(nvar) omp_get_active_level() omp_get_ancestor_thread_num(level) omp_get_cancellation() omp_get_default_device() omp_get_dynamic() omp_get_initial_device() omp_get_level() omp_get_max_active_levels() omp_get_max_threads() omp_get_nested() omp_get_num_devices() omp_get_num_places() omp_get_num_procs() omp_get_num_teams() omp_get_num_threads() omp_get_partition_num_places() omp_get_partition_place_nums(place_nums) 239 omp_get_place_num() omp_get_place_num_procs(place_num) omp_get_place_proc_ids(place_num, ids) omp_get_proc_bind() omp_get_schedule(kind, modifier) omp_get_team_num() omp_get_team_size(level) omp_get_thread_limit() omp_get_thread_num() omp_get_wtick() omp_get_wtime() omp_in_final() omp_in_parallel() omp_init_lock(svar) omp_init_nest_lock(nvar) omp_is_initial_device() omp_set_default_device(device_num) omp_set_dynamic(enable_expr) omp_set_lock(svar) omp_set_max_active_levels(max_levels) omp_set_nested(enable_expr) omp_set_nest_lock(nvar) omp_set_num_threads(number_of_threads_expr) 254 omp_set_schedule(kind, modifier) omp_test_lock(svar) omp_test_nest_lock(nvar) omp_unset_lock(svar) omp_unset_nest_lock(nvar) 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) 266 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) 271 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) 279 f_pthread_condattr_init(cattr) f_pthread_condattr_setpshared(cattr, pshared) 280 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) 285 f_pthread_getspecific(key, arg) f_pthread_join(thread, ret) 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) 292 f_pthread_mutexattr_gettype(mattr, type) f_pthread_mutexattr_init(mattr) f_pthread_mutexattr_setpshared(mattr, pshared) 294 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) iv XL Fortran: Optimization and Programming Guide for Little Endian Distributions

7 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_level) f_pthread_setschedparam(thread, policy, param) 306 f_pthread_setspecific(key, arg) f_pthread_t f_pthread_testcancel() f_sched_param f_sched_yield() f_timespec Chapter 10. Offloading computations to the NVIDIA GPUs System prerequisites for offloading to the NVIDIA GPUs Programming with OpenMP device constructs Extensions from OpenMP Technical Reports Programming with supported CUDA Fortran features Limitations Chapter 11. Interlanguage calls Conventions 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 variables between languages Passing character types between languages Passing arrays between languages Passing pointers between languages Passing arguments by reference or by value Passing COMPLEX values to/from gcc Returning values from Fortran functions Arguments with the OPTIONAL attribute Assembler-level subroutine linkage conventions 328 The stack The Linkage Area and Minimum Stack Frame 331 The input parameter area The register save area The local stack area The output parameter area Linkage convention for argument passing Argument passing rules (by value) Order of arguments in argument list Linkage convention for function calls Pointers to functions Function values The stack floor Stack overflow Prolog and epilog Traceback Chapter 12. 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 recovery 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 13. Implementation details of XL Fortran floating-point processing. 355 IEEE floating-point overview Compiling for strict IEEE conformance IEEE single-precision and double-precision values IEEE extended-precision values Infinities and NaNs Exception-handling model Hardware-specific floating-point overview Single-precision and double-precision values 358 Extended-precision values How XL Fortran rounds floating-point calculations 360 Selecting the rounding mode Minimizing rounding errors Minimizing overall rounding Delaying rounding until run time Ensuring that the rounding mode is consistent 362 Duplicating the floating-point results of other systems Maximizing floating-point performance Detecting and trapping floating-point exceptions 364 Compiler features for trapping floating-point exceptions Installing an exception handler Contents v

8 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 variables Minimizing the performance impact of floating-point exception trapping Chapter 14. Vector element order toggling Example 2 - valid C routine source file Example 3 - valid Fortran SMP source file Example 4 - invalid Fortran SMP source file Programming examples using the Pthreads Library Module Notices Trademarks Index Chapter 15. Sample Fortran programs 375 Example 1 - XL Fortran source file vi XL Fortran: Optimization and Programming Guide for Little Endian Distributions

9 About this document This document is part of the IBM XL Fortran for Linux, V16.1 information suite. It provides both reference information and practical tips for using the optimization and tuning capabilities of XL Fortran to maximize application performance, as well as expanding on programming concepts such as I/O and interlanguage calls. Who should read this document How to use this document This document is for anyone who wants to exploit the capabilities of XL Fortran for optimizing and tuning Fortran programs. Readers should be familiar with their Linux operating system and have extensive Fortran programming experience with complex applications. However, users new to XL Fortran can still use this information to help them understand how the compiler's features can be used for effective program optimization. This guide focuses on specific programming and compilation techniques that can maximize XL Fortran application performance. It covers optimization and tuning strategies, recommended programming practices, and compilation procedures, debugging, and information about using XL Fortran advanced language features. This guide also contains cross-references to relevant topics of other reference guides in the XL Fortran information suite. Topics not described in this information are available as follows: v Installation, system requirements, last-minute updates: see the XL Fortran Installation Guide and product README file. v Migration considerations and guide: see the XL Fortran Migration Guide. v Overview of XL Fortran features: see the Getting Started with XL Fortran book. v Syntax, semantics, and implementation of the XL Fortran programming language: see the XL Fortran Language Reference book. v Compiler setup, compiling and running programs, compiler options, diagnostics: see the XL Fortran Compiler Reference book. v CUDA Fortran support to exploit NVIDIA GPU on OpenPOWER systems: see the Getting Started with CUDA Fortran programming using XL Fortran. v Operating system commands related to the use of the compiler: consult the man page help and information of your Linux distribution. How this document is organized This guide includes the following topics: v Chapter 1, Optimizing your applications, on page 1 provides an overview of the optimization process. v Chapter 2, Tuning XL compiler applications, on page 35 discusses the compiler options available for optimizing and tuning code. v Chapter 3, Advanced optimization concepts, on page 43, Chapter 4, Managing code size, on page 47, and Chapter 5, Debugging optimized code, on page 53 discuss advanced techniques, such as optimizing loops and inlining code, and debug considerations for optimized code. Copyright IBM Corp. 1990, 2018 vii

10 v The following sections contain information about how to write optimization friendly and portable XL Fortran code that is interoperable with other languages. Also included is a description of XL Fortran support for OpenMP and SMP with guidelines for writing parallel code. Chapter 6, Compiler-friendly programming techniques, on page 57 Chapter 8, High performance libraries, on page 67 Chapter 9, Parallel programming with XL Fortran, on page 85 Chapter 11, Interlanguage calls, on page 317 v Chapter 10, Offloading computations to the NVIDIA GPUs, on page 311 provides an overview of the methods to exploit the NVIDIA GPUs by using XL Fortran. v The following sections contain information about XL Fortran and its implementation that can be useful for new and experienced users alike: Chapter 12, Implementation details of XL Fortran Input/Output (I/O), on page 339 Chapter 13, Implementation details of XL Fortran floating-point processing, on page 355 Chapter 14, Vector element order toggling, on page 371 v Chapter 15, Sample Fortran programs, on page 375 provides coding examples for XL Fortran. Conventions Typographical conventions The following table shows the typographical conventions used in the IBM XL Fortran for Linux, V16.1 information. Table 1. Typographical conventions Typeface Indicates Example lowercase bold italics underlining monospace Invocation commands, executable names, and compiler options. Parameters or variables whose actual names or values 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 directive. Examples of program code, reference to program code, file names, path names, command strings, or user-defined names. The compiler provides basic invocation commands, xlf, along with several other compiler invocation commands to support various Fortran language levels and compilation environments. The default file name for the executable program is a.out. 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. viii XL Fortran: Optimization and Programming Guide for Little Endian Distributions

11 Table 1. Typographical conventions (continued) Typeface Indicates Example UPPERCASE bold Fortran programming keywords, statements, directives, and intrinsic procedures. Uppercase letters may also be used to indicate the minimum number of characters required to invoke a compiler option/suboption. The ASSERT directive applies only to the DO loop immediately following the directive, and not to any nested DO loops. Qualifying elements (icons and bracket separators) In descriptions of language elements or programming models, this information uses icons and marked bracket separators to delineate segments of text as follows: Table 2. Qualifying elements Icon F2008 F2008 F2003 F2003 TS TS Bracket separator text Fortran 2008 begins / Fortran 2008 ends Fortran 2003 begins / Fortran 2003 ends TS begins / TS ends Meaning The text describes an IBM XL Fortran implementation of the Fortran 2008 standard. 1 The text describes an IBM XL Fortran implementation of the Fortran 2003 standard, and it applies to all later standards. 1 The text describes an IBM XL Fortran implementation of Technical Specification 29113, referred to as TS IBM IBM CUDA Fortran IBM extension begins / IBM extension ends CUDA Fortran begins / The text describes a feature that is an IBM XL Fortran extension to the standard language specifications. The text describes CUDA Fortran, the CUDA Fortran support provided by IBM XL Fortran, or both. CUDA Fortran GPU GPU CUDA Fortran ends GPU begins / GPU ends The text describes the information that is relevant to offloading computations to the NVIDIA GPUs. Note: 1. 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. Otherwise, it applies to all Fortran language standards. About this document ix

12 Syntax diagrams Throughout this information, diagrams illustrate XL Fortran syntax. This section helps you to interpret and use those diagrams. v 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, directive, or statement. The symbol indicates that the command, directive, or statement syntax is continued on the next line. The symbol indicates that a command, directive, or statement is continued from the previous line. The symbol indicates the end of a command, directive, or statement. Fragments, which are diagrams of syntactical units other than complete commands, directives, 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 derived-type definitions consist of several individual statements. For such items, a box encloses the syntax representation, and individual syntax diagrams show the required order for the equivalent Fortran statements. v Required items are shown on the horizontal line (the main path): keyword required_argument v 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 v If you can choose from two or more items, they are shown vertically, 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 v An arrow returning to the left above 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: x XL Fortran: Optimization and Programming Guide for Little Endian Distributions

13 , keyword repeatable_argument v The item that is the default is shown above the main path. keyword default_argument alternate_argument v Keywords are shown in nonitalic letters and should be entered exactly as shown. v Variables are shown in italicized lowercase letters. They represent user-supplied names or values. If a variable or user-specified name ends in _list, you can provide a list of these terms separated by commas. v 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: (1) EXAMPLE char_constant a b c d, e name_list Notes: 1 IBM extension Interpret the diagram as follows: v Enter the keyword EXAMPLE. v EXAMPLE is an IBM extension. v Enter a value for char_constant. v Enter a value for a or b, but not for both. v Optionally, enter a value for c or d. v Enter at least one value for e. If you enter more than one value, you must put a comma between each. v Enter the value of at least one name for name_list. If you enter more than one value, you must put a comma between each. (The _list syntax is equivalent to the previous syntax for e.) How to read syntax statements Syntax statements are read from left to right: v Individual required arguments are shown with no special notation. v When you must make a choice between a set of alternatives, they are enclosed by { and } symbols. v Optional arguments are enclosed by [ and ] symbols. v When you can select from a group of choices, they are separated by characters. v Arguments that you can repeat are followed by ellipses (...). About this document xi

14 Related information 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: v Enter the keyword EXAMPLE. v Enter a value for char_constant. v Enter a value for a or b, but not for both. v Optionally, enter a value for c or d. v Enter at least one value for e. If you enter more than one value, you must put a comma between each. v Optionally, enter the value of at least one name for name_list. If you enter more than one value, you must put a comma between each name. Note: The same example is used in both the syntax-statement and syntax-diagram representations. Examples in this information The examples in this information, except where otherwise noted, are coded in a simple style that does not try to conserve storage, check for errors, achieve fast performance, or demonstrate all possible methods to achieve 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 default installation; these need little or no modification. Notes on the terminology used Some of the terminology in this information is shortened as follows: v The term free source form format often appears as free source form. v The term fixed source form format often appears as fixed source form. v The term XL Fortran often appears as XLF. The following sections provide related information for XL Fortran: Available help information IBM XL Fortran information XL Fortran provides product information in the following formats: v Quick Start Guide The Quick Start Guide (quickstart.pdf) is intended to get you started with IBM XL Fortran for Linux, V16.1. It is located by default in the XL Fortran directory and in the \quickstart directory of the installation DVD. v 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 and subdirectories of the installation DVD. v Installable man pages xii XL Fortran: Optimization and Programming Guide for Little Endian Distributions

15 Man pages are provided for the compiler invocations and all command-line utilities provided with the product. Instructions for installing and accessing the man pages are provided in the IBM XL Fortran for Linux, V16.1 Installation Guide. v Online product documentation The fully searchable HTML-based documentation is viewable in IBM Knowledge Center at com.ibm.compilers.linux.doc/welcome.html. v PDF documents PDF documents are available on the web at knowledgecenter/ssat4t_16.1.0/com.ibm.compilers.linux.doc/ download_pdf.html. The following files comprise the full set of XL Fortran product information. Note: To ensure that you can access cross-reference links to other XL Fortran PDF documents, download and unzip the.zip file that contains all the product documentation files, or you can download each document into the same directory on your local machine. Table 3. XL Fortran PDF files Document title PDF file name Description What's New for IBM XL Fortran for Linux, V16.1, GC Getting Started with IBM XL Fortran for Linux, V16.1, GI IBM XL Fortran for Linux, V16.1 Installation Guide, GC IBM XL Fortran for Linux, V16.1 Migration Guide, GC IBM XL Fortran for Linux, V16.1 Compiler Reference, SC IBM XL Fortran for Linux, V16.1 Language Reference, SC whats_new.pdf getstart.pdf install.pdf migrate.pdf compiler.pdf langref.pdf Provides an executive overview of new functions in the IBM XL Fortran for Linux, V16.1 compiler, with new functions categorized according to user benefits. Contains an introduction to XL Fortran, with information about setting up and configuring your environment, compiling and linking programs, and troubleshooting compilation errors. Contains information for installing XL Fortran and configuring your environment for basic compilation and program execution. Contains migration considerations for using XL Fortran to compile programs that were previously compiled on different platforms, by previous releases of XL Fortran, or by other compilers. Contains information about the various compiler options and environment variables. Contains information about the Fortran programming language as supported by IBM, including language extensions for portability and conformance to nonproprietary standards, compiler directives and intrinsic procedures. About this document xiii

16 Table 3. XL Fortran PDF files (continued) Document title PDF file name Description IBM XL Fortran for Linux, V16.1 Optimization and Programming Guide, SC Getting Started with CUDA Fortran programming using IBM XL Fortran for Linux, V16.1, GI proguide.pdf getstart_cudaf.pdf Contains information on advanced programming topics, such as application porting, interlanguage calls, floating-point operations, input/output, application optimization and parallelization, and the XL Fortran high-performance libraries. Contains detailed information about the CUDA Fortran support that is provided in XL Fortran, including the compiler flow for CUDA Fortran programs, compilation commands, useful compiler options and macros, supported CUDA Fortran features, and limitations. To read a PDF file, use Adobe Reader. If you do not have 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, and other articles, is available on the web at support/docview.wss?uid=swg For more information about the compiler, see the XL compiler on Power community at Other IBM information v ESSL product documentation available at knowledgecenter/ssfhy8/essl_welcome.html?lang=en Standards and specifications XL Fortran is designed to support the following standards and specifications. You can refer to these standards and specifications for precise definitions of some of the features found in this information. v American National Standard Programming Language FORTRAN, ANSI X v American National Standard Programming Language Fortran 90, ANSI X v ANSI/IEEE Standard for Binary Floating-Point Arithmetic, ANSI/IEEE Std v Federal (USA) Information Processing Standards Publication Fortran, FIPS PUB v Information technology - Programming languages - Fortran, ISO/IEC :1991. (This information uses its informal name, Fortran 90.) v Information technology - Programming languages - Fortran - Part 1: Base language, ISO/IEC :1997. (This information uses its informal name, Fortran 95.) v Information technology - Programming languages - Fortran - Part 1: Base language, ISO/IEC :2004. (This information uses its informal name, Fortran 2003.) v Information technology - Programming languages - Fortran - Part 1: Base language, ISO/IEC :2010. (This information uses its informal name, Fortran We currently provide partial support to this standard.) v Information technology - Further interoperability of Fortran with C, ISO/IEC TS 29113:2012. (This information uses its informal name, Technical specification 29113, referred to as TS We currently provide partial support to this specification.) xiv XL Fortran: Optimization and Programming Guide for Little Endian Distributions

17 v 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 have also been subsequently incorporated into the Fortran 90 standard. v OpenMP Application Program Interface Version 3.1 (full support), OpenMP Application Program Interface Version 4.0 (partial support), and OpenMP Application Program Interface Version 4.5 (partial support), available at Other IBM information Technical support How to send your comments v ESSL product documentation available at knowledgecenter/ssfhy8/essl_welcome.html?lang=en Additional technical support is available from the XL Fortran Support page at XL_Fortran_for_Linux. This page provides 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 an to compinfo@cn.ibm.com. For the latest information about XL Fortran, visit the product information site at Your feedback is important in helping us to provide accurate and high-quality information. If you have any comments about this information or any other XL Fortran information, send your comments to compinfo@cn.ibm.com. Be sure to include the name of the manual, the part number of the manual, the version of XL Fortran, and, if applicable, the specific location of the text you are commenting on (for example, a page number or table number). About this document xv

18 xvi XL Fortran: Optimization and Programming Guide for Little Endian Distributions

19 Chapter 1. Optimizing your applications The XL compilers enable development of high performance applications by offering a comprehensive set of performance enhancing techniques that exploit the multilayered PowerPC architecture. These performance advantages 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 levels, settings, and techniques can increase performance. Optimization Optimization is a compiler-driven process that searches for opportunities to restructure your source code and give your application better overall performance at run time, without significantly impacting development time. The XL compiler optimization suite, which you control using compiler options and directives, performs best on well-written source code that has already been through a thorough debugging and testing process. These optimization transformations can bring the following benefits: v Reduce the number of instructions that your application executes to perform critical operations. v Restructure your object code to make optimal use of the PowerPC architecture. v Improve memory subsystem usage. v 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 overview of the common sequence of steps that you can use to increase the performance of your application. Tuning Tuning is a user-driven process where you experiment with changes, for example to source code or compiler options, to make the compiler better optimize your program. While optimization applies general transformations designed to improve the performance of any application in any supported environment, tuning offers you opportunities to adjust specific characteristics or target execution environments of your application to improve its performance. Even at low optimization levels, tuning for your application and target architecture can have a positive impact on performance. With proper tuning, the compiler can make the following improvements: v Select more efficient machine instructions. v Generate instruction sequences that are more relevant to your application. v Select from more focussed optimizations to improve your code. Copyright IBM Corp. 1990,

20 For instructions, see Tuning XL compiler applications. Steps in the optimization process Basic optimization When 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 improvements that optimization can provide. Learning about and experimenting with different optimization techniques can help you strike the right balance for your XL compiler applications while achieving 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 levels 0 and The Advanced optimization step exposes your application to more intense optimizations at levels 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 alternatives to compiler-driven optimization. The section Compiler-friendly programming techniques contains tips for writing more easily optimized source code. The XL compiler supports several levels of optimization, with each option level building on the levels below through increasingly aggressive transformations and consequently using more machine resources. Ensure that your application compiles and executes properly at low optimization levels before you try more aggressive optimizations. This topic discusses two optimizations levels, listed with complementary options in Table 4. The table also includes a column for compiler options that can have a performance benefit at that optimization level for some applications. Table 4. Basic optimizations Optimization level Additional options implied by default Complementary options -O0 None -qarch None -O2 -qmaxmem=8192 -qarch -qtune Other options with possible benefits -qmaxmem=-1 -qhot=level=0 2 XL Fortran: Optimization and Programming Guide for Little Endian Distributions

21 Note: Specifying -O without including a level implies -O2. Optimizing at level 0 Benefits at level 0 v Provides minimal performance improvement with minimal impact on machine resources v Exposes some source code problems that can be helpful in the debugging process Begin your optimization process at -O0, which the compiler already specifies by default. This level performs basic analytical optimization by removing obviously redundant code, and it can result in better compile time. It also ensures your code is algorithmically correct so you can move forward to more complex optimizations. -O0 also includes some redundant instruction elimination and constant folding. The -qfloat=nofold option can be used to suppress folding floating-point operations. Optimizing at this level accurately preserves all debugging information and can expose problems in existing code, such as uninitialized variables. Additionally, specifying -qarch at this level targets your application for a particular machine and can significantly improve performance by ensuring that your application takes advantage of all applicable architectural benefits. Note: For SMP programs, you need to add an additional option -qsmp=noopt. For more information about tuning, consult Tuning for Your Target Architecture. See "-O" in the XL Fortran Compiler Reference for information about the -O level syntax. Related information in the XL Fortran Compiler Reference -qarch Optimizing at level 2 Benefits at level 2 v Eliminates redundant code v Performs basic loop optimization v Structures code to take advantage of -qarch and -qtune settings After you successfully compile, execute, and debug your application using -O0, recompiling at -O2 opens your application to a set of comprehensive low-level transformations that apply to subprogram or compilation unit scopes and can include some inlining. Optimizations at -O2 attain a relative balance between increasing performance while limiting the impact on compilation time and system resources. You can increase the memory available to some of the optimizations in the -O2 portfolio by providing a larger value 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 level 2 Choosing the right hardware architecture target or family of targets becomes even more important at -O2 and higher. By targeting the proper hardware, the optimizer can make the best use of the available hardware facilities. If you choose a family of Chapter 1. Optimizing your applications 3

22 Advanced optimization hardware targets, the -qtune option can direct the compiler to emit code that is consistent with the architecture choice and that can execute optimally on the chosen tuning hardware target. With this option, you can compile for a general set of targets and have the code run best on a particular target. For details on the -qarch and -qtune options, see Chapter 2, Tuning XL compiler applications, on page 35. The -O2 option can perform a number of additional optimizations as follows: v Common subexpression elimination: Eliminates redundant instructions v Constant propagation: Evaluates constant expressions at compile time v Dead code elimination: Eliminates instructions that a particular control flow does not reach or that generate an unused result v Dead store elimination: Eliminates unnecessary variable assignments v Global register allocation: Globally assigns user variables to registers v Value numbering: Simplifies algebraic expressions by eliminating redundant computations v Instruction scheduling for the target machine v Loop unrolling and software pipelining v Moving loop-invariant code out of loops v Simplifying control flow v Strength reduction and effective use of addressing modes v Widening: Merges adjacent load/stores and other operations v Pointer aliasing improvements to enhance other optimizations Even with -O2 optimizations, some useful information about your source code is made available to the debugger if you specify -g. Using a higher -g level increases the information provided to the debugger but reduces the optimization that can be done. Conversely, higher optimization levels can transform code to an extent to which debugging information is no longer accurate. The section on Chapter 5, Debugging optimized code, on page 53 discusses other debugging strategies in detail. See "-O" in the XL Fortran Compiler Reference for information on the -O level syntax. Higher optimization levels can have 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 advanced optimization, and the transformations that your application undergoes are largely under your control. The discussion of each optimization level in Table 5 on page 5 includes information on the performance benefits and the possible trade-offs and information on how you can help guide the optimizer to find the best solutions for your application. 4 XL Fortran: Optimization and Programming Guide for Little Endian Distributions

23 Table 5. Advanced optimizations Optimization Level Additional options implied Complementary options Options with possible benefits -O3 -Ofast -qnostrict -qmaxmem=-1 -qhot -O4 All of -O3 -qipa -qarch=auto -qtune=auto -qcache=auto -O5 All of -O4 -qipa=level=2 -qarch -qtune -qarch -qtune -qcache -qarch -qtune -qcache -qpdf -qpdf -qsmp=auto -qpdf -qsmp=auto When you compile programs with any of the following sets of options: v -qhot -qnostrict v -Ofast v -O3 v -O4 v -O5 the compiler automatically attempts to vectorize calls to system math functions by calling the equivalent vector functions in the Mathematical Acceleration Subsystem libraries (MASS), with the exceptions of functions vatan2, vsatan2, vdnint, vdint, vcosisin, vscosisin, vqdrt, vsqdrt, vrqdrt, vsrqdrt, vpopcnt4, and vpopcnt8. If the compiler cannot vectorize, it automatically tries to call the equivalent MASS scalar functions. For automatic vectorization or scalarization, the compiler uses versions 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 vectorize, it tries to inline the MASS scalar functions before deciding to call them. Optimizing at level 3 Benefits at level 3 v In-depth Aliasing on page 43 analysis v Better loop scheduling v High-order loop analysis and transformations (-qhot) v Inlining of small procedures within a compilation unit by default v Eliminating implicit compile-time memory usage limits Specifying -O3 initiates more intense low-level transformations that remove many of the limitations present at -O2. For instance, the optimizer no longer checks for memory limits, by setting the default to -qmaxmem=-1. Additionally, optimizations encompass larger program regions and attempt more in-depth analysis. Although not all applications contain opportunities for the optimizer to provide a measurable increase in performance, most applications can benefit from this type of analysis. Specifying -O3 also implies -qhot, which performs the default set of high-order transformations. Chapter 1. Optimizing your applications 5

24 Potential trade-offs at level 3 With the in-depth analysis of -O3 comes a trade-off in terms of compilation time and memory resources. Also, because -O3 implies -qnostrict, the optimizer can alter certain floating-point semantics in your application to gain execution speed. This typically involves precision trade-offs as follows: v Reordering of floating-point computations v Reordering or elimination of possible exceptions, such as division by zero or overflow v Using alternative calculations that might give slightly less precise results or not handle infinities or NaNs in the same way You can still gain most of the -O3 benefits while preserving 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 sensitive to floating-point exceptions or the order of evaluation 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 individual 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-level operation is very 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 additive, most applications are not sensitive to the changes that can occur in floating-point semantics. For information about the -O level syntax, see "-O" in the XL Fortran Compiler Reference. An intermediate step: adding -qhot suboptions at level 3 At -O3, the optimization implies -qhot to increase performance. To further increase your performance benefit from -qhot, increase the optimization aggressiveness by increasing the optimization level of -qhot. The following -qhot suboption can also provide additional performance benefits, depending on the characteristics of your application: v -qhot=arraypad to enable array padding For more information about -qhot, see High-order transformation (HOT) on page 9. Conversely, if the application does not use loops processing arrays, which -qhot improves, you can improve compile speed significantly, usually with minimal performance loss by using -qnohot after -O3. 6 XL Fortran: Optimization and Programming Guide for Little Endian Distributions