Intel® Fortran Compiler 8.1 for Linux*
Release Notes

For Intel IA-32 and Itanium® Processors

Contents

Overview

This product provides tools for Linux* software developers to create applications that run at top speeds on all Intel® IA-32 processors and the Intel Itanium® processors. Optimizations include support for Streaming SIMD Extensions 2 (SSE2) in the Intel Pentium® 4 and Pentium M processors, Streaming SIMD Extensions 3 (SSE3) in the Intel Pentium 4 processors with SSE3 support, and software pipelining in the Intel Itanium® 2 processor. Inter-procedural optimization (IPO) and profile-guided optimization (PGO) can provide greater application performance. Intel Compilers support multi-threaded code development through autoparallelism and OpenMP* support.

The paper, Optimizing Applications with the Intel® C++ and Fortran Compilers for Windows* and Linux, explains how to use the Intel compilers to optimize for the Pentium 4 and Itanium processors and is available at http://www.intel.com/software/products/compilers/ . Additional information on the Intel Software Development Products is available at http://www.intel.com/software/products/ .

Product Contents

Intel® Fortran Compiler for IA-32 Based Applications

The Intel® Fortran compiler for IA-32 based applications contains the following components:

• Intel® Fortran Compiler for Linux for IA-32 applications, version 8.1
• Intel® Debugger for IA-32 applications, version 8.1
• Intel® Compilers code-coverage tool
• Intel® Compilers test-prioritization tool
• The product documentation, version 8.1
  • The documentation index is provided for easy access of all the documents. It is located at <install-dir>/doc/fcompindex.htm
  • A training tutorial Enhancing Performance with Intel Compilers is also included

Intel® Fortran Compiler for Itanium-Based Applications

The Intel® Fortran compiler for Itanium-based applications contains the following components:

• Intel® Fortran compiler for Itanium-based applications, version 8.1
• Intel® Debugger for Itanium-based applications, version 8.1
• Intel® Itanium Assembler to produce Itanium-based applications, version 7.0
• Intel® Compilers code-coverage tool
• Intel® Compilers test-prioritization tool
• The product documentation, version 8.1
  • The documentation index is provided for easy access of all the documents. It is located at <install-dir>/doc/fcompindex.htm
  • A training tutorial Enhancing Performance with Intel Compilers is also included

Compatibility

You must recompile all Fortran sources that were compiled with compilers earlier than version 8.0, including those that create .mod files. Third-party libraries built with versions earlier than 8.0 will also need to be rebuilt - if you are using third-party libraries that do not support Intel Fortran 8.0, please let us know which ones through Intel® Premier Support at https://premier.intel.com. Fortran sources built with Intel Fortran 8.0 do not need to be recompiled for use with version 8.1.

Changes in Version 8.1

Version 8.1 is a minor update to Intel Fortran. The primary focus of this release is improvement in compiler stability and run-time performance.

New Predefined Preprocessor Symbol

The following new predefined preprocessor symbol is now available:

• __INTEL_COMPILER_BUILD_DATE specifies the build date of the compiler in YYYYMMDD format. It matches the build date shown on the version banner. You can use this predefined macro if you have a need to conditionalize code based on a specific Intel Compiler update. The YYYYMMDD string is guaranteed to be an increasing integral value with each new release.

-zero Now Implemented

The -zero option is now implemented - this causes the compiler to initialize the value of local (not in COMMON nor a MODULE), static (not allocatable nor automatic), scalar (not array nor derived type) variables to zero when the program is run. It is the same is if the variables had been named in a DATA statement with an initial value of zero

Duplicate Unnamed BLOCK DATA Subprograms No Longer Permitted

The compiler now gives an error for more than one unnamed BLOCK DATA subprogram in a compilation, in accordance with the Fortran standard.

Change in Meaning of -fast

As of the 8.1 release, specifying -fast implies the following options: -O3 -ipo -static -xP

New -ipoN Option to Create Multiple Objects

In previous versions, when -ipo was specified to perform multifile interprocedural optimization, one object file was generated as input to the linker; this is still the default for version 8.1. New in version 8.1 is the ability to request that the compiler create multiple object files for input to the linker; this can, in some cases, reduce link time for large applications. To specify the maximum number of object files to be produced, use the -ipoN form of the option where N is the maximum number of object files to be created. For example, -ipo4 specifies a maximum of 4 object files. The compiler may choose to create fewer files than the maximum depending on the application size. If -ipo0 is specified, the compiler will choose an appropriate number of object files based on the total application size.

KMP_SCHEDULE Environment Variable for OpenMP Scheduling Control

A new environment variable, KMP_SCHEDULE, can be used to fine tune the load balancing of parallel loops that are statically scheduled under OpenMP with no chunk size specification. The default value is KMP_SCHEDULE="static,greedy". This results in (#iterations/#threads) iterations, rounded to the next higher integer, being allocated to most threads, but the final thread(s) may be allocated much fewer, or even zero, iterations. This corresponds to previous compiler behavior. The alternative, KMP_SCHEDULE="static,balanced", results in (#iterations/#threads) iterations, rounded to the next lower integer, being allocated to most threads, with at most one additional iteration being allocated to some threads. Although the largest number of iterations assigned to any thread remains the same, this results in a more even sharing of iterations between threads, which may sometimes lead to a performance improvement.

For example, consider a loop of 9 iterations running on 4 threads:

Additional New Options

For information on these options, please see the New Options section of the on-disk Compiler Options Quick Reference Guide.

• -debug variable_locations
• -IPF_fp_relaxed
• -ipo_separate
• -openmp_profile
• -tcheck

Changes in Version 8.0

This is a new generation of Intel Fortran that combines the best technology from both Intel Fortran and Compaq* Visual Fortran. The "front-end" of the compiler, which provides Fortran language features and Fortran-specific optimizations, is now derived from that of Compaq Visual Fortran. The Fortran run-time library (I/O and non-math intrinsics) also derives from Compaq Visual Fortran. The "back-end" is from the latest generation of Intel's high-performance code generation and optimization technology to achieve the best performance on Intel processors.

Optimization support for Intel Pentium 4 Processors with SSE3 Instruction Set

A new generation of Intel Pentium 4 processors supports the Streaming SIMD Extensions 3 (SSE3) instruction set, which can improve performance of vectorized loops containing complex data types, float-to-integer conversions, and horizontal adds.

Version 8.0 adds the ability to optimize for Intel processors that support SSE3. To do so, specify the -xP or -axP options. For further details, please consult the sections on optimizations in the Intel Fortran Compiler User's Guide.

New IA-32 Optimization Options

This release includes two new code generation options. -xB and /QaxB direct the compiler to generate code for best performance on the Intel Pentium M processor. The new -xN and -axN options enable additional optimizations for all Intel Pentium 4 processors. Intel recommends the use of -xN and -axN for best performance with Pentium 4 processors, and suggests trying -xB or -axB to see if it helps your application on the Pentium M processor. For more information, please refer to the sections on optimization in the Intel Fortran Compiler User's Guide

Obsolete and Obsolescent Optimization Options

The optimization options -[a]xi (optimize for Pentium Pro and Pentium II) and -[a]xM (optimize for MMX instruction set) are no longer supported by the Intel Fortran compiler. If these options are present on the compile command line, an informational message is displayed and the options are ignored. If you use -[a]xi or -[a]xM, you should discontinue their use. The default is to generate generic code that will run on Pentium processor as well as newer IA-32 processors.

The-[a]xW (lower optimization level for Pentium 4) may be removed in a future compiler version. If you use -[a]xW, use -[a]xN as a replacement when generating code for Intel Pentium 4 processors.

For more information, please refer to the sections on optimization in the Intel Fortran Compiler User's Guide.

Changes to Default Linking Behavior

The compiler configuration files, <install-dir>/bin/ifort.cfg and <install-dir>/bin/icpc.cfg, have been modified to remove the RPATH command to the linker. This was used in previous releases to set the location of the Intel shared libraries in the executable. The disadvantage of putting the RPATH directive in the configuration file is that just typing the compiler, ifort, would result in a cryptic error:

/usr/lib/crt1.o: In function `_start': /usr/lib/crt1.o(.text+0x18): undefined reference to `main'

Which would confuse users, thinking that there is a problem with their compiler or installation. The current release removes the RPATH directive, and typing ifort gives a more informative error:

ifort: Command line error: no files specified; for help type "ifort -help"

However, as executables no longer contain the location of the Intel shared libraries, you need to specify the location of the shared libraries. Any of the following techniques can be used to do this:

1. Modify the LD_LIBRARY_PATH environment variable to contain the location of the Intel shared libraries. For sh type shells, enter: export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:<install-dir>/lib.
2. Use the ldconfig system utility. Note: this requires root user privileges to run.
3. Modify the compiler configuration files, <install-dir>/bin/ifort.cfg

If you see an error message such as this:

error while loading shared libraries: libcprts.so.5: cannot open shared object file: No such file or directory

you need to apply one of the three methods listed above to set the location of the Intel shared libraries.

Intel® Compilers code-coverage tool

The Intel Compilers code-coverage tool leverages the Intel Compilers profile-guided optimization technology to present developers a complete picture of the coverage of their application code on a particular workload. To find the application's code coverage the tool combines static profile information generated by the compiler with dynamic profile information generated by running the user's instrumented binaries on the workload. The coverage tool uses this information together with the application sources to create HTML pages with color annotations that highlight the coverage of the code. Navigation is through frames that make it particularly easy to sort the application's files and functions and see the least-covered modules and functions. Developers can then use their favorite browser to display the coverage of their code.

The Intel Compilers code coverage tool can be used in a number of ways to improve development efficiency, reduce defects, and improve application performance. When applied to the profile of the application on its test space, the tool can be used to measure the overall quality of testing based on the coverage information. Similarly, when applied to the profile of a performance workload, the code-coverage information indicates how well the workload exercises the application's critical code. High coverage of performance-critical modules is essential to taking full advantage of the profile-guided optimizations that Intel Compilers offer. The tool also provides an option, useful for both coverage and performance tuning, through which the users can display the dynamic execution count of each basic block of the application. Lastly, the coverage tool provides the ability to compare the profile of two different runs of the application. This feature can be used to find the portion of the application's code that is not covered by the application's tests but is exercised when the application is used outside the test space, such as by a customer.

The Intel Compilers code-coverage tool is supported on Intel Architecture IA-32 and the Itanium Processor Family on both Windows and Linux and seamlessly supports C, C++, and Fortran.

Intel® Compilers test-prioritization tool

The Intel Compilers test-prioritization tool leverages the Intel Compilers profile-guided optimizations technology to select and prioritize application tests based on prior execution profiles of the application. Using this tool, users can select and prioritize the tests that are more relevant for any subset of the application's code. When certain modules of an application are changed, the Intel Compilers test-prioritization tool suggests the tests that are most probably affected by the given change set. The tool mines the profile data from previous runs of the application, discovers the dependency between the application's components and its tests, and uses this information to guide the process of testing. The tool can be used for devising an effective hierarchical testing based on the application's code coverage. For instance, the tool may be used to find the smallest subset of the application tests that achieve exactly the same code coverage as the entire set of tests. The tool can also be used to dramatically reduce the turn-around time of testing. Instead of spending a large amount of time and finding a possibly-large number of failures, the tool may enable the users to quickly find a small number of tests that expose the defects associated with the regressions caused by a change set. The tool offers the potential of significant time saving in testing and development of large-scale applications where testing is major bottleneck. The tool can be used to minimize the number of tests that are required to achieve a given overall coverage for any subset of the application. Moreover, when the execution times of the tests are available, the tool may also be used to select and prioritize the tests to achieve certain level of code coverage in a minimum amount of time.

The Intel Compilers test-prioritization tool is supported on Intel Architecture IA-32 and the Itanium Processor Family on both Windows and Linux and seamlessly supports C, C++, and Fortran.

Please refer to the following link for additional details: http://www.intel.com/software/products/compilers/techtopics/pgt.htm.

Intel Debugger Graphical User Interface

The Intel Debugger idb now offers an optional graphical user interface. For more information, including known problems and restrictions, please see the Intel Debugger Release Notes.

Versioned Intermediate files (.il) during interprocedural optimization (IPO)

Each .il file generated by IPO will have a version number. The compiler will only accept .il files with matching versions. The version numbers will be automatically generated and updated as part of the build process.

The following additional features are new in version 8.0

• Full language compatibility with Compaq Visual Fortran 6.6
• Support for the Fortran 2003 feature Allocatable Components of Derived Types
• Traceback option to help you locate the source of run-time errors and the TRACEBACKQQ routine to request a traceback from an application.
• More complete documentation, including:
  • The Intel Fortran User's Guide now has separate parts for Building Applications and Optimizing Applications.
  • Intel Fortran language information previously described in the Intel Fortran Programmer's Reference is now described in the Intel Fortran Language Reference (PDF file), including all intrinsics procedures and directives.

The following behavior changes are new in version 8.0

• The Intel Fortran command name is now ifort. In contrast, earlier versions of Intel Fortran used a command name of ifc or efc. Intel® Fortran 8.1 will accept and process the ifc and efc command name. However, in a future Intel Fortran release, only the ifort command name will be processed.
• The numeric representation of true and false in LOGICAL expressions has changed from that used in earlier versions of Intel Fortran. In previous versions of Intel Fortran, when an integer expression was interpreted as LOGICAL, zero was considered .FALSE. and non-zero values considered .TRUE. In Intel Fortran Compiler 8.1, even integer values are considered .FALSE. and odd values are considered .TRUE. Furthermore, the logical constant .TRUE. has the value -1 rather than 1 as in previous versions of Intel Fortran. This behavior matches that of Compaq Visual Fortran and can be changed by using the -fpscomp logicals compiler option.
• The command line inquiry routines GETARG, IARGC and NARGS, which were formerly library routines, are now treated as intrinsic procedures by the compiler, and are documented in the Language Reference Manual. If your application contains declarations of these routines as EXTERNAL, or provides an explicit interface for them, you will need to remove those declarations in order to build successfully.
• The -vms compiler option, which specifies compatibility with HP* OpenVMS* Fortran compilers, has additional effects in this release as compared to Intel Fortran 7.1. In previous versions of Intel Fortran, the option disabled the recognition of \n in character literals as a newline and set the default unit size for RECL of unformatted files to four bytes. In version 8.1, these options have separate switches (-assume [no]bscc and -assume [no]byterecl). Please consult the description of -vms in the Intel Fortran Compiler User's Guide for details on the new effects of -vms.
• In previous versions of Intel Fortran, the default RECL= unit for UNFORMATTED files was bytes. Version 8.1 adopts the Compaq Fortran default unit of four bytes (a numeric storage unit.) You can specify one-byte units by adding the compiler option -assume byterecl.
• Previous versions of Intel Fortran inserted up to seven bytes of padding between variables in COMMON to ensure that 8-byte numeric variables were aligned on natural boundaries. However, this violated the Fortran standard's rules on common association. The default behavior in version 8.1 is to not insert padding between variables in a COMMON block. The compiler will issue warning messages (unless suppressed by -warn noalign) if an unaligned numeric variable is seen. This change should be invisible to most applications, except for those that access variables in COMMON other than by their names; for example, if the COMMON is shared with a C extern. If you wish to have variables in COMMON padded, specify -align commons to align on up to four-byte boundaries, or -align dcommons to align on up to eight-byte boundaries (same as version 7.1.)
• The implementation of the RANDOM_NUMBER intrinsic has changed; the new implementation uses a key length of 2. Properly written programs which set the seed using RANDOM_SEED should not notice a difference.
• A call to RANDOM_SEED with no arguments sets the seed to a value based on the current time-of-day, so that multiple runs of a program that calls RANDOM_NUMBER will see a different sequence of values. If you require the same set of values on each run, use RANDOM_SEED to set the seed(s) to a fixed value.
• If you are building a mixed-language application where the main program is not in Fortran, you may need to add the -nofor_main switch to the Fortran build commands in order to avoid an ld error message about "doubly defined symbol main".

System Requirements

IA-32 Processor System Requirements

• A computer based on an Intel Pentium processor or subsequent IA-32 based processor. (Intel Pentium 4 processor recommended).
• 128 MB (256MB recommended).
• 100 MB of disk space, plus an additional 200 MB during installation for the download and temporary files.
• Linux system with glibc 2.2.4, 2.2.5, 2.2.93 or 2.3.2 and the 2.4.X or 2.6.X Linux kernel as represented by the following distributions. Note: Not all distributions listed are validated and not all distributions are listed.
  • Red Hat* Linux 7.3, 8, 9
  • Red Hat Enterprise Linux* 2.1, 3
  • SUSE* Linux 8.2, 9.1
  • SUSE Linux Enterprise Server* 8 or 9
• Linux Developer tools component installed, including gcc, g++ and related tools.

Itanium Processor System Requirements

• A computer with an Intel Itanium or Itanium 2 processor.
• 512 MB (1GB recommended).
• 150 MB of disk space, plus an additional 200 MB. during installation for the download and temporary files.
• Linux system with glibc 2.2.4, 2.2.5 or 2.3.2 and the 2.4.X or 2.6.X Linux kernel as represented by the following distributions. Note: Not all distributions listed are validated and not all distributions are listed.
  • Red Hat Linux 7.2
  • Red Hat Enterprise Linux AS 2.1, AS 3, WS 3
  • SUSE Linux Professional* 9.1
  • SUSE Linux Enterprise Server 8, 9
  • United Linux* 1.0
• Linux Developer tools component installed, including gcc, g++ and related tools.

We recommend using binutils 2.14 or later, especially if using shared libraries as there are a known issues with binutils 2.11.

Note: Compiling very large source files (several thousands of lines) using advanced optimizations such as -O3, -ipo and -openmp, may require substantially larger amounts of RAM.

Installation

If you have Intel Fortran Compiler 8.0 or 8.1 installed, you must uninstall it prior to installing Intel Fortran Compiler 8.1. Please refer to the Uninstalling the Compiler and Debugger below for details on uninstallation.

The installation script of the Intel Fortran Compiler uses the system utility RPM to install files. But RPM 4.0.2 and RPM 4.1 have a limitation, please see Known Limitations below for details.

Installing the license

The Intel Fortran Compiler uses Macrovision Corporation's FLEXlm* electronic licensing technology. License management is transparent. The installation program of the Intel Fortran Compiler 8.1 checks for a valid license before installing any component of the product. Also, the license must remain in place on the system in order to use the Intel Fortran Compiler 8.1 to compile and build programs.

The FLEXlm license server for Intel software, used for floating and node-locked licenses only, is available for many popular platforms. The server may be installed on any supported platform accessible on your local network. The compiler CD contains license server for several Linux distributions. If you do not have the CD, or need a license server for an additional platform, you can find all available license servers in the Downloads section of your Intel® Premier Support account.

Note: Your existing license for Intel Fortran Compiler for Linux will work with the 8.1 compiler provided your support services have not expired.

Here is how to setup the license file before installation.

• If you have an electronically downloaded version of the Intel Fortran Compiler 8.1, the license will be sent to you via email. Please follow the instructions in the email to install the license file.
• If you have a CD version of the Intel Fortran Compiler 8.1, a valid license is included on the CD and the installation program can locate it automatically. But, in order to obtain access to technical support and to be able to download and execute product updates, as a CD-ROM user you must do the following:
  1. Register your product: First, locate the serial number found on the inside flap of the product box. Then, visit the web site http://www.intel.com/software/products/registrationcenter/ and follow the instructions. After the registration you will receive an email within 24 hours containing a new license.
  2. Install the new license: The new license in the email entitles you to one year of support services that allow you to download and execute product updates and obtain full technical support. The email also contains the instructions on how to install the license. Please follow the instructions to finish the new license installation.
  Note:
  The license file must have an extension ".lic".
  The default license directory is /opt/intel_fc_80/licenses/ .

For details about the support service license, please see http://www.intel.com/software/products/compilers/flin/pricelist.htm .

Installing the Intel License Server on SGI* Altix* Systems Running SGI ProPack* 3

If you will be installing the Intel License Server on an SGI* Altix* system running SGI ProPack* 3, please follow these alternate instructions to ensure correct operation in the partitioned cluster environment:

• Obtain the appropriate license server from Intel® Premier Support File Downloads at https://premier.intel.com/. On the File Downloads page, select product Intel SW Development License Servers. The file to use is flexlm.Linux.ia64.EL3_SGIAltix.tar.Z.

• Install the license server following the instructions in the flexlm_ug.pdf documentation file in the compiler package.

• To determine the host ID, required to retrieve the license file, log in to the partition from which the license server is to be run and perform the following commands:

  cd /opt/intel/flexlm
./lmhostid

  If you installed the license server into a path other than /opt/intel/flexlm, use the correct path instead.

• If you do not already have your license, go to the Intel Registration Center and register your product as described in the section above. If you already have a license with an incorrect host ID, submit an issue to Intel® Premier Support, providing the serial number of the license file, the results of running lmhostid, an indicator of whether this is a floating license or a node-locked license, and a request that a new license be generated for the new host ID. Be sure to specify that this is for an Altix system system by selecting SGI* Altix* ProPack* 3.0 in the Linux* Operating System dropdown list . The Intel customer support team will generate a new license for you with the corrected host ID.

Installing the Intel Fortran Compiler

Perform the following steps to install the compiler.

1. Download the compiler package.
2. Unpack the compiler package in a directory to which you have write access.
   > tar -xvf l_fc_p[c]_8.1.xxx.tar
   or
   > tar -zxvf l_fc_p[c]_8.1.xxx.tar.gz
3. Run the installation script
   Become the root user, needed to run the rpm command, and execute the install script in the directory where the tar file was extracted.
   > source ./install.sh
   If you do not have access to the root account, it is possible to install the compiler without root access by manually unpacking the RPM files with rpm2cpio and editing the ifortvars.sh (.csh) file to include the directory where the compiler is installed. The install script automates this procedure.
4. Enter the directory for the license file
   It is the directory where you saved the license file (*.lic) above. The installation program will validate the license before installing any Intel Fortran Compiler for Linux component.
5. After the license checking, the installation program will display the Intel software products that are already installed, and the following menu items for you to install:
   • Intel Compiler for 32-bit applications if you're installing on an IA-32 system or
     Intel Compiler for Itanium architecture if you're installing on an Itanium-based system
   • Linux Application Debugger for 32-bit applications or
     Linux Application Debugger for Itanium®-based applications
6. Select a package to install.
   The suggested order is to
   • install the Intel Fortran Compiler first
   • then install the Linux Application Debugger (Intel Debugger, idb)
   Before installation begins, the End-User License Agreement (EULA) is displayed. Type "accept" to accept this license agreement.
   All necessary packages needed to use the product will also be installed. If an RPM package has already been installed, the install script will report this and ask you to verify that you want to overwrite the existing installation. It will then continue to the next RPM package that needs to be installed to use the product. The default RPM options -U --replacefiles --force are recommended to force the update of existing files.
   The default installation directory is /opt/intel_fc_80/ for the Intel Fortran Compiler, and /opt/intel_idb_80/ for the Intel Debugger.
7. After installation, the Intel packages installed will be redisplayed, followed by a redisplay of the install menu. Enter 'x' to exit the install script.

Environment Variables

The Intel Fortran compiler now supports the following environment variables, if defined:

• FPATH - specifies additional directories to be searched for INCLUDE and USE (compiled .mod) files; the driver translates these into -I options
• LIBRARY_PATH - specifies additional directories to be searched for libraries by the linker; the driver translates these into -L options

Setting Up The Compiler Environment

The installation script (install.sh) creates compiler environment script files (ifortvars.sh/ idbvars.sh) that set some environment variables such as PATH, LD_LIBRARY_PATH and MANPATH. It is strongly recommended that you add those script files into your login script (.login file). So once the variables are set in the ".login" file there is no need to run the script files for each session.

Source the script to setup the compiler environment:

• > source <install-dir>/bin/ifortvars.sh(.csh)
  to use ifort on either an IA32 system or an Itanium-based system
• > source <install-dir>/bin/idbvars.sh(.csh)
  to use idb on an IA32 system or Itanium-based system

The installation program also creates compiler configuration files named <install-dir>/bin/ifort.cfg that contain common settings for all compilations. You can edit these files to add additional default options. Note, if you install a compiler update package, you need to rename the configuration file to another filename if you have modified it so that the installation doesn't overwrite your modified file.

If you want to use both Intel Fortran and Intel C++, you must also run the Intel C++ environment script iccvars.sh from its installed location.

Please register for support after you install this product. See Technical Support for registration instructions.

Uninstalling the Compiler and Debugger

1. become the root user
2. to uninstall the compiler:
   > source <compiler-install-dir>/bin/uninstall.sh
or if you've installed the compiler to the default directory, use
   > source /opt/intel_fc_80/bin/uninstall.sh
3. to uninstall the debugger:
   > source <debugger-install-dir>/bin/uninstall.sh
or if you've installed the debugger to the default directory, use
   > source /opt/intel_idb_80/bin/uninstall.sh

Known Limitations

Installation Warning for RPM 4.0.2 and RPM 4.1

RPM 4.0.2 cannot install to a non-default directory. This has been resolved in RPM 4.0.3. RPM 4.1 cannot install to a non-default directory. This has been resolved in RPM 4.11 to 4.2.

Note about installing the Intel Debugger

When installing the Intel Debugger version 8.1 for IA-32 or Itanium-based applications from the Intel Fortran Compiler 8.1 package, if an earlier version of the Intel Debugger is already installed on the system, it will be upgraded to the Intel Debugger version 8.1.

Segmentation Violation with static link to libpthreads

Applications built with libpthreads.a statically linked, (libpthreads.a is used by default when -static is used), may fail with a segmentation violation on some versions of Linux when the applications use more than 2MB of stack space. This is a known limitation of Linuxthreads. If you encounter this problem, link libpthreads dynamically. As an alternative, on Red Hat Linux 9 and Red Hat Enterprise Linux 3.0, you can install the nptl-devel package and pass "-I/usr/include/nptl -L/usr/lib/nptl" on the ifort command line. This will create a statically-linked binary which will run under nptl only, but which does not have the stack size limitation.

Dynamic Shared Objects on Itanium Systems

On Itanium systems, when the -shared switch is used to specify that a Dynamic Shared Object (.so) is to be created, ld may issue diagnostic messages referring to "@gprel relocation against dynamic symbol". To correct this problem, add the -i_dynamic and -nofor_main switches to the command line used to build the .so. A future version of Intel Fortran may set these options automatically when -shared is specified.

OpenMP Limitations

POSIX threaded programs that require a large stack size may not run correctly on some versions of Linux because of hard-coded stack size limits in some versions of the Linux POSIX threads libraries. These limits also apply to OpenMP programs (-openmp) and automatically generated parallel programs (-parallel) with the Intel compilers, because the Intel compilers use the POSIX threads library to implement OpenMP based and automatically generated parallelism. Threaded programs that exceed the stack space limit usually experience segmentation violations or addressing errors.

To avoid these limitations, use a version of glibc built with the FLOATING_STACKS parameter defined. For some distributions, this implies using the shared rather than the static version of the pthreads library. Then use the ulimit -s or limit stacksize command to set the maximum shell stack size to an explicit large value, in units of KBytes, (not unlimited), and also set the KMP_STACKSIZE environment variable to the needed thread stacksize in bytes. Note, in the bash shell, ulimit -s can be used to set a large maximum stack size only once. In the C shell (csh), limit stacksize , with no dash before the argument, can be used to reset the maximum stacksize repeatedly.

This solution has been tested on glibc version 2.2.4-13 for IA-32 and glibc 2.2.4-19 for Itanium Processor Family as found in the RedHat 7.2 Linux distribution. For glibc 2.2.4-13 on IA-32, the shared version of the POSIX threads library must be used, (there should not be a -static flag in the compiler .cfg file or on the command line).

In addition, if a common block is declared as THREADPRIVATE with an OpenMP directive, the common block must have the same length in all the source files in which it is declared.

Itanium Floating Point Software Assistance Handler 1.12 Error on Red Hat Linux 7.2

On Itanium-based systems, the Floating Point Software Assistance handler (FPSWA), part of the system BIOS, performs software completion of floating point operations that generate exceptional values such as NaNs and Infinities. Version 1.12 of the FPSWA has an error which can be revealed on Red Hat Linux 7.2 systems as an unexpected segmentation violation fault when an application runs. Intel is not aware that this issue affects other distributions or versions of Linux on Itanium systems.

To correct this problem, upgrade the system BIOS to one that includes FPSWA version 1.18 or later. Please contact your system manufacturer for BIOS update information.

gprel relocation Error Messages on Itanium-based Linux Systems

On Itanium-based systems running Linux, when the -shared switch is used to create a Dynamic Shared Object (.so), there may be some "relocation against dynamic symbol" messages generated during the ld phase, similar to:

/usr/bin/ld: for_init.o: @gprel relocation against dynamic symbol for__segv_default_msg
/usr/bin/ld: for_init.o: @gprel relocation against dynamic symbol for__l_fpe_mask
/usr/bin/ld: for_init.o: @gprel relocation against dynamic symbol for__l_undcnt
...

To fix this problem, add the switches -i_dynamic and -nofor_main to the command line. As of version 8.1, specifying -shared will automatically set -i_dynamic and -nofor_main.

Issues relating to Multiple Object File Interprocedural Optimization

The following issues are expected to be resolved in a future update:

-ipo1 doesn't guarantee only one object file

Specifying an explicit number of files object files to be generated with -ipoN doesn't turn off the compiler heuristic for dividing and object file into two object files when it gets too big.

Because of this, you cannot currently turn off IPO multiple objects by explicitly specifying one object file using -ipo1.

-qipo_separate is not recognised by xild

The -qipo_separate option is not recognized by xild. This causes IPO compilations using this option to fail.

Explicit naming of .o and .s files ignored with -ipo multiple objects

When using -ipo_c or -ipo_S (explicit .o or .s files, respectively), options to explcitly name these files are ignored by the compiler for when generating multiple objects.

s files generated by -ipo_S fail to assemble with multiple object IPO

There are two classes of errors:

• The assembler complains that routines being called haven't been defined.
• The assembler complains that constant data (e.g. strings in WRITE statements) hasn't been defined. This issue affects Itanium-based Linux systems only.

Limited Debug Information with Automatic CPU Dispatching (-ax*)

Compilation using -ax{W|N|B|P} results in two copies of generated code for each function. One for IA-32 generic code and one for CPU specific code. The symbol for each function then refers to an Auto CPU Dispatch routine that decides at run-time which one of the generated code sections to execute. Debugger breakpoints that are set on these functions by name cause the application to stop in the dispatch routine. This may cause unexpected behavior when debugging. This issue may be addressed in a future version of the Intel Debugger and Compilers.

Cannot Debug or View Traceback for IA-32 Programs Built Without -fp

Compilation using -fp specifies that the IA-32 EBP register be used as a frame pointer rather than a general purpose register. Debuggers and traceback handlers may not be able to properly unwind through a stack that contains a call to a function that is compiled without -fp in effect. If you compile with -g or -O0, -fp is implicitly enabled, but not if you specify a higher optimization level explicitly (such as -O2). If you intend to use the debugger or traceback on an application, and are using some level of optimization higher than -O0, you should also specify -fp to ensure that the debugger and traceback handler can use frame pointers.

GNU* Assembler May Not Recognize -xP Generated Code

Older versions of the GNU Assembler may not be able to process assembly code generated by compiling with the -[a]xP option. Use binutils version 2.14.90.0.4.1 or later, or FSFbinutils 2.15 or later if this is an issue for you.

Stack Usage Increases Compared to Version 7.x

Version 8.x of the Intel Fortran compiler can generate code that uses more stack space than did earlier versions. You may find that it is necessary to increase the stacksize limit using the appropriate limit, unlimit or ulimit shell command.

!DEC$ ATTRIBUTES ALIGN Not Supported for ALLOCATABLE/POINTER Variables

The !DEC$ ATTRIBUTES ALIGN directive is currently ignored for variables with the ALLOCATABLE or POINTER attributes.

-auto_ilp32 Option Not Supported

The -auto_ilp32 option which specifies that that an application cannot exceed a 32-bit address space, and which is mentioned in the documentation, is not supported.

Missing Features

The following features of the Intel Fortran Compiler 7.1 are not currently available in Intel Fortran 8.1:

• The -CA, -CS, -CU and -CV options to perform run-time checking for run-time correctness checks (-CB for array and string bounds checking is available.)

• The -WB option, which enables compile-time array bounds warnings, is accepted but ignored.

Technical Support

Your feedback is very important to us. To receive technical support for the tools provided in this product and technical information including FAQ's and product updates, you need to be registered for an Intel® Premier Support account on our secure web site, https://premier.intel.com. Please register at http://support.intel.com/support/performancetools/support.htm and click on "Registration Center".

Note:
• Registering for support varies for release products or pre-release products (alpha, beta, etc) - only released products have support web pages on http://support.intel.com.
• If you are having trouble registering or are unable to access your Premier Support account, contact developer.support@intel.com. Please do not email your technical issue to developer.support@intel.com as it is not a secure medium.
• If you have forgotten your password, please email a request to: quad.support@intel.com. Please do not email your technical issue to this email address as it is not a secure medium.

For information about the Intel Fortran Compiler's Users Forums, FAQ's, tips and tricks, and other support information, please visit: http://support.intel.com/support/performancetools/fortran/linux/. For general support information please visit http://www.intel.com/software/products/support/.

Submitting Issues

Steps to submit an issue:

1. Go to https://premier.intel.com/.
2. Type in your Login and Password. Both are case-sensitive.
3. Click the "Submit" button.
4. Read the Confidentiality Statement and click the "I Accept" button.
5. Click on the "Go" button next to the "Product" drop-down list.
6. Click on the "Submit Issue" link in the left navigation bar.
7. Choose "Development Environment (tools,SDV,EAP)" from the "Product Type" drop-down list.
8. If this is a software or license-related issue, choose "Intel® Fortran Compiler for Linux*" from the "Product Name" drop-down list.
9. Enter your question and complete the fields in the windows that follow to successfully submit the issue.

Guidelines for problem report or product suggestion:

1. Describe your difficulty or suggestion.
   For problem reports please be as specific as possible, so that we may reproduce the problem. For compiler problem reports, please include the compiler options and a small test case if possible.
2. Describe your system configuration information.
   Get the version of glibc and kernel with following commands:
       > uname -a
    > rpm -qa | grep glibc
   If you don't have rpm installed, use the command below:
       > ls /lib/libc*
   And copy the information into the corresponding Premier Support fields.

   Get the Intel Fortran Compiler's Package ID with the following commands:
       > ifort -V
   And copy the "Package ID" (e.g. l_fc_p[c]_8.1.xxx) from the output into the corresponding Premier Support field. Please include any other specific information that may be relevant to helping us to reproduce and address your concern.

3. If you were not able to install the compiler or cannot get the Package ID, enter the filename you downloaded as the package ID.

Resolved Issues

Please review <package ID>_README (e.g. l_fc_p[c]_8.1.xxx_README), available for download from Intel® Premier Support, https://premier.intel.com, to see which issues have been resolved in the latest version of the compiler.

Documentation

You can view the Intel compiler and related HTML-based documentation with your Web browser, which provide full navigation, index look-up, search, and hyperlink capabilities. The documents also have PDF versions for easier printing via Adobe Acrobat Reader*.

The documentation is installed in the <install-dir>/doc (default /opt/intel_fc_80/doc) directory. An HTML index document can be found at <install-dir>/doc/fcompindex.htm (default /opt/intel_fc_80/doc/fcompindex.htm). A training tutorial Enhancing Performance with Intel Compilers is also available from links in the documentation index. The Intel® Debugger Manual is provided in HTML form in the Intel® Debugger doc directory (default /opt/intel_idb_80/doc).

The document Intel® Fortran Compiler User's Guide is provided as HTML-based documentation you can view in your Web browser. It is now organized into separate parts:

• An Options Quick Reference Guide
• User's Guide for Building Applications
• User's Guide for Optimizing Applications

• The Intel Fortran Language Reference describes the Intel Fortran programming language, including intrinsics. This document visually identifies Intel Fortran extensions to the Fortran 95 standard. This document applies to both Intel Fortran for Linux* Systems and Intel Visual Fortran for Windows* Systems. This document is also available separately in printed form.
• The Intel Fortran Libraries Reference describes the library procedures in the various Intel Fortran libraries and provides an alphabetic listing of the library routines. This document applies to both Intel Fortran for Linux Systems and Intel Visual Fortran for Windows Systems.
• The Intel Fortran Compiler for Linux* Systems User's Guide consists of three separate PDF files for Volume I: Building Applications, Volume II: Optimizing Applications, and the Options Quick Reference Guide. These documents are provided in PDF form for printing purposes; use the HTML-based versions of these documents for viewing in your browser.
• Using the Intel® License Manager for FLEXlm* describes how to install and use the Intel® License Manager for FLEXlm* to configure a license server for systems using counted licenses.

The Enhancing Performance with Intel Compilers provides an interactive HTML-based tutorial on using compiler options that help you optimize your application for IA-32 and Itanium-based systems. Documents that describe the Itanium Assembler are also provided.

Viewing Manpages

The ifort(1) manpage provides a list of command-line options and related information for the ifort compiler command. To display the ifort(1) manpage, type the following command after you set up your environment by using a source command to execute the <install-dir>/bin/ifortvars.*sh file:

$ man ifort

The man command provides single keys or key combinations that let you scroll through the displayed content, search for a string, jump to a location, and perform other functions. For example, type the z to view the next screen or w to view the previous screen. To obtain help about the man command, type the h key; when you are done viewing help, type the q key to return to the displayed manpage. To search, type / character followed by the search string (/string) and press Enter. After viewing the man command text, type q to return to the shell command prompt.

Viewing HTML Documentation

To view the compiler User's Guide HTML-based documentation, you no longer need to use a Java*-enabled or Javascript-enabled Web browser. The documentation format has been tested to work with Web browsers shipped on standard Red Hat* distributions. To allow the HTML-based User's Guide help to be browser-neutral and not require java support, the Search capability has been removed. If you need to search the User's Guide, please use the supplied User's Guide PDF files (same content as HTML-based User's Guide).

Viewing PDF Documentation Files

You can read the PDF files using the xpdf utility (provides search capability), or use the gv or ghostview command. On some Linux distributions, using mozilla will display PDF files using a PDF helper.

Additional Information

Related Products and Services

Information on Intel software development products is available at http://www.intel.com/software/products.

Some of the related products include:

• The Intel® Software College provides training for developers on leading-edge software development technologies. Training consists of online and instructor-led courses covering all Intel architectures, platforms, tools, and technologies.
• The VTune™ Performance Analyzer enables you to evaluate how your application is utilizing the CPU and helps you determine if there are modifications you can make to improve your application's performance.
• The Intel® C++ and Fortran Compilers are an important part of making software run at top speeds with full support for the latest Intel IA-32 and Itanium® processors.
• The Intel® Performance Library Suite provides a set of routines optimized for various Intel processors. The Intel® Math Kernel Library, which provides developers of scientific and engineering software with a set of linear algebra, fast Fourier transforms and vector math functions optimized for the latest Intel Pentium® and Intel Itanium processors. The Intel® Integrated Performance Primitives consists of cross-platform tools to build high performance software for several Intel architectures and several operating systems.

Copyright and Legal Information

INFORMATION IN THIS DOCUMENT IS PROVIDED IN CONNECTION WITH INTEL® PRODUCTS. NO LICENSE, EXPRESS OR IMPLIED, BY ESTOPPEL OR OTHERWISE, TO ANY INTELLECTUAL PROPERTY RIGHTS IS GRANTED BY THIS DOCUMENT. EXCEPT AS PROVIDED IN INTEL'S TERMS AND CONDITIONS OF SALE FOR SUCH PRODUCTS, INTEL ASSUMES NO LIABILITY WHATSOEVER, AND INTEL DISCLAIMS ANY EXPRESS OR IMPLIED WARRANTY, RELATING TO SALE AND/OR USE OF INTEL PRODUCTS INCLUDING LIABILITY OR WARRANTIES RELATING TO FITNESS FOR A PARTICULAR PURPOSE, MERCHANTABILITY, OR INFRINGEMENT OF ANY PATENT, COPYRIGHT OR OTHER INTELLECTUAL PROPERTY RIGHT. Intel products are not intended for use in medical, life saving, life sustaining, critical control or safety systems, or in nuclear facility applications. Intel may make changes to specifications and product descriptions at any time, without notice.

This Release Note, as well as the software described in it, is furnished under license and may only be used or copied in accordance with the terms of the license. The information in this manual is furnished for informational use only, is subject to change without notice, and should not be construed as a commitment by Intel Corporation. Intel Corporation assumes no responsibility or liability for any errors or inaccuracies that may appear in this document or any software that may be provided in association with this document.

Designers must not rely on the absence or characteristics of any features or instructions marked "reserved" or "undefined." Intel reserves these for future definition and shall have no responsibility whatsoever for conflicts or incompatibilities arising from future changes to them.

The software described in this Release Note may contain software defects which may cause the product to deviate from published specifications. Current characterized software defects are available on request.

Intel SpeedStep, Intel Thread Checker, Celeron, Dialogic, i386, i486, iCOMP, Intel, Intel logo, Intel386, Intel486, Intel740, IntelDX2, IntelDX4, IntelSX2, Intel Inside, Intel Inside logo, Intel NetBurst, Intel NetStructure, Intel Xeon, Intel XScale, Itanium, MMX, MMX logo, Pentium, Pentium II Xeon, Pentium III Xeon, Pentium M, and VTune are trademarks or registered trademarks of Intel Corporation or its subsidiaries in the United States and other countries.

* Other names and brands may be claimed as the property of others.

Copyright © 2005, Intel Corporation. All rights reserved.