The Intel® Fortran Compiler for Linux helps make your software 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 processors code-named "Prescott" 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 following components are included in the installation package:
<install-dir>/doc/fcompindex.htm 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/ .
The Intel Fortran compiler for IA-32 based applications contains the following components:
<install-dir>/doc/fcompindex.htm The Intel Fortran compiler for Itanium-based applications contains the following components:
<install-dir>/doc/fcompindex.htm You must recompile all Fortran sources that were compiled with earlier compilers, including those that create .mod files. Third-party libraries will also need to be rebuilt - if you are using third-party libraries, please let us know which ones through Intel Premier Support at https://premier.intel.com. A document describing Intel Fortran 7 porting considerations is available from http://developer.intel.com/software/products/compilers/flin/ or from Intel Premier Support.
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.
The Intel processors code-named "Prescott" are a new generation of IA-32 processors. These processors support a new "SSE3" instruction set, which can improve performance of vectorized loops containing complex data types, float-to-integer conversions, and horizontal adds.
The Intel Fortran Compiler 8.0 for Linux adds the ability to optimize
for this new processor generation. 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.
This release includes two new code generation options. -xB and -axB
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 optimizations in the Intel Fortran Compiler
User's Guide
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:
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.
ldconfig system utility. Note: this requires root user privileges to run.
<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.
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.
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.
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.
.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.
TRACEBACKQQ routine
to request a traceback from an application.ifort. In contrast,
earlier versions of Intel Fortran used a command name of ifc or efc.
Intel® Fortran 8.0 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. 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.0, 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.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.-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.0, 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.-assume byterecl.-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.)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.
If you are using some other versions of the Intel Fortran Compiler 8.0, we recommend you uninstall them prior to installing this version of the Intel Fortran Compiler 8.0. 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.
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.0 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.0 to compile and build programs.
Note: The license for your Intel Fortran Compiler for Linux 6.0.1 or 7.1 will work with the 8.0 compiler provided your support services have not expired.
Here is how to setup the license file before installation.
.lic". /opt/intel_fc_80/licenses/Perform the following steps to install the IA-32 compiler.
tar the compiler package in a directory to which you have
write access.> tar -xvf l_fc_p[c]_8.0.xxx.tar > tar -zxvf l_fc_p[c]_8.0.xxx.tar.gz
> source ./install.shrpm2cpio and
editing the ifortvars.sh (.csh) file to include the directory
where the compiler is installed. The install script automates this procedure.
*.lic)
above. The installation program will validate the license before installing
any Intel Fortran Compiler for Linux component.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 systemLinux Application Debugger for 32-bit applications or "accept" to accept this license agreement. -U --replacefiles are recommended to
force the update of existing files. /opt/intel_fc_80/ for
the Intel Fortran Compiler, and /opt/intel_idb_xx/ (xx: is the
idb version number, run "idb -V" for the version) for the Intel
Debugger.
'x' to exit the install
script. 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 optionsLIBRARY_PATH - specifies additional directories to be searched
for libraries by the linker; the driver translates these into -L optionsThe 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) > source <install-dir>/bin/idbvars.sh(.csh) 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.
Please register for support after you install this product. See Technical Support for registration instructions.
> 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
> source <debugger-install-dir>/bin/uninstall.sh or
if you've installed the debugger to the default directory, use> source /opt/intel_idb_73/bin/uninstall.sh 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.
When installing the Intel Debugger version 7.3 for IA-32 or Itanium-based applications from the Intel Fortran Compiler 8.0 package, if the Intel Debugger version 7.1 or 7.2 is already installed on the system, it will be upgraded to the Intel Debugger version 7.3.
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.
The FLEXlm license daemon is not currently supported on systems running Red Hat Linux 9. This daemon is only needed if floating licenses are in use; in this case, the license server should be installed on a system running some other supported operating system. There is no effect on typical users with single user licenses, which do not require a server.
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.
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, please use a version of glibc built with the FLOATING_STACKS parameter
defined, typically version 2.2.4 or later for both IA-32 and Itanium Processor
Family. Then use the ulimit -s .... command to set the maximum
shell stack size to an explicit large value (units of KBytes) and also set
the KMP_STACKSIZE environment variable to the needed thread stacksize
in bytes. A shell stacksize limit of unlimited does not work - it causes a
fixed hard limit to be imposed. Note, in the bash shell, ulimit -s can
be used to set a large maximum stack size only once. In the C shell (csh), ulimit
-stacksize can be used to reset the maximum stacksize repeatedly. The
default values for KMP_STACKSIZE have been increased to 2 MB for
IA-32 and 4 MB for Itanium-based systems.
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.
Use of Profile Guided Optimization along with OpenMP may substantially increase
the execution time for the generation of the profile (.dyn file).
This is a known issue which is being addressed. The use of profile guided optimization
in conjunction with OpenMP is not recommended for this version of the Intel
Fortran compiler.
Some threaded (including OpenMP) applications may encounter problems when
linked with the new NPTL-based pthreads library introduced in Red Hat Linux
9. In some cases, this may be worked around by setting the environment variable LD_ASSUME_KERNEL=2.4.19,
which results in the use of the previous pthreads library version without NPTL.
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.
The following features of the Intel Fortran Compiler 7.1 are not currently available in Intel Fortran 8.0:
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.
The -zero option to initialize local variables to zero is not yet implemented - it is expected to be available in an update to version 8.0. Please log into your Intel Premier Support account to see available updates.
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".
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/.
Submit" button.
I Accept" button.
Go" button next to the "Product" drop-down
list.
Submit Issue" link in the left navigation bar.
Development Environment (tools,SDV,EAP)" from the "Product
Type" drop-down list.
Intel(R) Fortran
Compiler for Linux*" from the "Product Name" drop-down
list.
> uname -a > rpm -qa | grep glibcrpm installed, use the command below: > ls /lib/libc*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.0.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.
Please review <package ID>_README (e.g. l_fc_p[c]_8.0.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.
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_xx/doc (xx: is the idb version
number, run "idb -V" for the version) ).
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:
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.
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.
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).
You can read the PDF files using the xpdf utility or install Adobe
Acrobat Reader. The xpdf utility is provided with most Linux
distributions and has a Search capability. If you choose to use Acrobat Reader,
it is recommended to view the PDF documentation with Acrobat running within
Netscape as this provides additional navigation features. To enable Netscape
to start Acrobat Reader, it needs to be installed in a directory searched
by your PATH environment variable and you need to edit the browser's preferences. Note: If
Acrobat Reader isn't configured correctly, you can overwrite the PDF files,
requiring you to reinstall them. If improperly configured, the browser
may prompt you to Save-As file, which if you click OK can overwrite the PDF
documentation files.
Perform these steps needed to update your preferences for Acrobat Reader:
Edit --> Preferences --> Navigator --> Applications
--> new
Description: Portable Document Format
MIMEType: application/pdf
Suffixes: pdf
Application: acroread %s
Another method to configure acroread is to add the following entry in the
file .mailcap in your home directory:
application/pdf; acroread %s
Depending on your version of the Netscape browser, you might need to disable
(turn OFF) the "Automatically load images" option or the browser
will freeze when you open the HTML documentation files, this means that you
will then need to click on the images in the documentation if you want to see
them while paging through the documentation with the browser. Turn OFF this
option by clicking on: Edit-->Preferences-->Advanced-->Automatically
load images and other data types.
Information on Intel software development products is available at http://www.intel.com/software/products. Some of the related products include:
Intel, Intel logo, Intel Xeon, Intel XScale, Itanium, MMX, MMX logo, Pentium, Pentium II Xeon, Pentium III Xeon, Pentium M, Intel Thread Checker, Celeron, 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 © 2001 ~ 2003 Intel Corporation. All Rights Reserved.