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 optimization options -[a]xi (optimize for Pentium Pro and
Pentium II), -[a]xM (optimize for MMX instruction set) and -[a]xW
(lower optimization level for Pentium 4) are still functional in this release
but will be removed in a future release of the Intel Fortran compiler. If you
use -[a]xi or -[a]xM, you should discontinue their
use. If you use -[a]xW, use -[a]xN as a replacement.
For more information, please refer to the sections on optimization 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.cfgIf 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 system
Linux 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
options
LIBRARY_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.
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.
> 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 either Red Hat Linux 9 or Red Hat Enterprise Linux 3.0. 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.
"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: ifort -shared -i_dynamic -nofor_main test.f90. In a future version of Intel Fortran, specifying -shared will automatically set -i_dynamic and -nofor_main.
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.