Intel(R) C Compiler 9.1 for Itanium(R)-based applications Intel(R) Fortran Compiler 9.1 for Itanium(R)-based applications --------------------------------------------------------------- Intel(R) 9.1 Linux64 IPF compiler options. NAME icc - invokes the Intel(R) C++ compiler ifort - invokes the Intel(R) Fortran Compiler Optimization Levels The Intel C++ and Intel Fortran Compilers apply the following optimizations when you invoke the -O1, -O2, or -O3 options: Constant propagation, copy propagation, dead- code elimination, global register allocation, instruction scheduling, lLoop unrolling (-O2, -O3 only), loop-invar- iant code movement, partial redundancy elimination, strength reduction/induction variable simplification, var- iable renaming, exception handling optimizations, tail recursions, peephole optimizations, structure assignment lowering and optimizations, dead store elimination, loop- invariant code motion. Depending on the Intel architecture, optimization options can have different effects. To specify optimizations for your target architecture, refer to the following: -O1 Optimizes to favor code size and code locality. Disables loop unrolling. -O1 may improve perfor- mance for applications with very large code size, many branches, and execution time not dominated by code within loops. In most cases, -O2 is recom- mended over -O1. Itanium architecture-based systems: Disables soft- ware pipelining and global code scheduling. -O2 (DEFAULT) Optimize for code speed. This is the generally rec- ommended optimization level. Itanium architecture-based systems: Turns software pipelining ON. -O3 Enable -O2 optimizations and in addition, enable more aggressive optimizations such as loop and mem- ory access transformation. The -O3 optimizations may slow down code in some cases compared to -O2 optimizations. Recommended for applications that have loops with heavy use of floating point calcu- lations and process large data sets. -fast Enhances speed across the entire program. Sets the following command options that can improve run-time performance: -O3, -ipo, and -static. The default is -nofast. Other enhancements include improvements related to data transpose, performance tuning of prefetch heuristics, more inlining and unroll & Jam. -O Same as -O2 -Ob Control inline expansion, where is one of the following values: 0 -- Disables inlining. 1 -- (DEFAULT) Enables inlining of functions declared with the __inline keyword. Also enables inlining according to the C++ language. 2 -- Inline any function, at the compiler's discre- tion. Enables interprocedural optimizations and has the same effect as -ip. -O0 Disables optimizations. Floating Point Optimization Options -mp Maintain floating-point precision (disables some optimizations). The -mp option restricts optimiza- tion to maintain declared precision and to ensure that floating-point arithmetic conforms more closely to the ANSI and IEEE standards. For most programs, specifying this option adversely affects performance. If you are not sure whether your application needs this option, try compiling and running your program both with and without it to evaluate the effects on both performance and preci- sion. -mp1 Improve floating-point precision. -mp1 disables fewer optimizations and has less impact on perfor- mance than -mp. -ftz Flush denormal results to zero. -[no-]IPF-fma Enable [disable] the combining of floating point multiplies and add/subtract operations. -IPF_fma[-] enables [disables] the contraction of float- ing-point multiply and add/subtract operations into a single operation. Unless -mp is specified, the compiler contracts these operations whenever possi- ble. The -mp option disables the contractions. -IPF_fma and -IPF_fma- can be used to override the default compiler behavior. -[no-]IPF-fp-relaxed Enables use of faster but slightly less accurate code sequences for math functions, such as divide and sqrt. When compared to strict IEEE* pre- cision, this option slightly reduces the accuracy of floating-point calculations performed by these functions, usually limited to the least signifi- cant digit. -IPF-fp-speculation Enable floating point speculations with the follow- ing conditions: fast -- Speculate floating point operations safe -- Speculate only when safe strict -- Same as off off -- Disables speculation of floating-point oper- ations -IPF-flt-eval-method0 Direct the compiler to evaluate the expressions involving floating-point operands in the precision indicated by the variable types declared in the pro- gram. -[no-]IPF-fltacc Enable [disable] optimizations that affect floating point accuracy. By default (-IPF-fltacc-) the com- piler may apply optimizations that reduce float- ing-point accuracy. You may use -IPF-fltacc or -mp to improve floating-point accuracy, but at the cost of disabling some optimizations. Optimizing Non-Exclusively for Specific Processors The -tpp options optimize your application's performance for a specific processor. The resulting binary will also run on other processors in the same architecture (IA-32 or Itanium architecture). The Intel C++ Compiler includes gcc-compatible versions of the -tpp options. These options are listed below, following the -tpp options. -tpp1 Target optimization to the Itanium processor. -tpp2 Target optimization to the Itanium 2 processor. (DEFAULT on Itanium architecture-based systems) The Intel C++ Compiler includes gcc-compatible versions of the -tpp options, listed as follows -mcpu= Optimize for a specific cpu, where is one of the following: itanium -- Optimize for Intel Itanium processor itanium2 -- Optimize for Intel Itanium 2 processor. Interprocedural Optimizations (IPO) Use -ip and -ipo[value] to enable interprocedural optimizations (IPO), which allow the compiler to analyze your code to deter- mine where to apply the following optimizations: inline function expansion, interprocedural constant propagation, monitoring mod- ule-level static variables, dead code elimination, propagation of function characteristics, and multifile optimization. For IA-32, IPO also passes arguments in registers. Inline function expansion is one of the main optimizations per- formed by the interprocedural optimizer. For function calls that the compiler believes are frequently executed, the compiler might decide to replace the instructions of the call with code for the function itself (inline the call). Enable and Specify the Scope of IPO -ip Enable single-file IP optimizations (within files). With this option, the compiler performs inline function expansion for calls to functions defined within the current source file. -ipo[value] Enables multifile IP optimizations (between files). When you specify this option, the compiler performs inline function expansion for calls to functions defined in separate files. The [value] argument is an optional integer that specifies the number of object files the compiler should create. Any integer greater than or equal to 0 is valid. If [value] is 0, the compiler decides whether to create one or more object files based on an estimate of the size of the object file. It generates one object file for small applications, and two or more object files for large applications. If [value] is positive, the compiler generates [value] object files, unless [value] exceeds the number of source files (m), in which case the com- piler generates only m object files. If you do not specify [value], the default is 1. -ipo_c Generate a multi-file object file (ipo_out.o) that can be used in further link steps. -ipo_S Generate a multi-file assembly file (ipo_out.s) that can be used in further link steps. Modify the Behavior of IPO -ip_no_inlining Disables inlining that would result from the -ip interprocedural optimization, but has no effect on other interprocedural optimizations. -ipo_obj Force the compiler to create real object files when used with -ipo (requires -ipo). -nolib_inline Disable inline expansion of intrinsic functions -auto_ilp32 Specifies that the application should run within a 32-bit address space. Also tells the compiler to use 32-bit pointers whenever possible. To use this option, you must specify -ipo. Profile-guided Optimizations (PGO) -prof_gen[x] Instructs the compiler to produce instrumented code in your object files in preparation for instru- mented execution. With the x qualifier, extra information is gathered. This option is used in Phase 1 of PGO to instruct the compiler to produce instrumented code in your object files in prepara- tion for instrumented execution. Parallel make is automatically supported for -prof_genx compila- tions. -prof_use Instruct the compiler to produce a profile-opti- mized executable and merge available dynamic infor- mation (.dyn) files into a pgopti.dpi file. Use the -prof_use option in Phase 3 of PGO. -prof_dir Specify directory for profiling output files (*.dyn and *.dpi). Use the -prof_dir option with -prof_gen as recommended for most programs, espe- cially if the application includes the source files located in multiple directories. -prof_dir ensures that the profile information is generated in one consistent place. -prof_file Specify file name for profiling summary file -fnsplit[-] Enable[disable] function splitting. Function split- ting is enabled by -prof_use in Phase 3 to improve code locality by splitting routines into different sections: one section to contain the cold or very infrequently executed code, and one section to con- tain the rest of the code (hot code). You can use -fnsplit to disable function splitting for the following reasons: Most importantly, to get improved debugging capa- bility. In the debug symbol table, it is difficult to represent a split routine, that is, a routine with some of its code in the hot code section and some of its code in the cold code section. The -fnsplit- option disables the splitting within a routine but enables function grouping, an optimization in which entire routines are placed either in the cold code section or the hot code section. Function grouping does not degrade debug- ging capability. Another reason can arise when the profile data does not represent the actual program behavior, that is, when the routine is actually used fre- quently rather than infrequently. High-level Language Optimizations (HLO) -O3 Turn on high-level optimizations. Enable -O2 plus more aggressive optimizations, such as loop trans- formation and prefetching. -O3 optimizes for maxi- mum speed, but may not improve performance for some programs. -unroll The only allowed value for n is 0. Disable loop unrolling. -ivdep_parallel For Itanium architecture-based applications, the -ivdep_parallel option indicates there is abso- lutely no loop-carried memory dependency in the loop where IVDEP directive is specified. This tech- nique is useful for some sparse matrix applica- tions. Auto Parallelization Options -parallel Enable the auto-parallelizer to generate multi-threaded code for loops that can be safely executed in parallel. The -parallel option enables the auto-parallelizer if either the -O2 or -O3 optimization option is also on (the default is -O2). The -parallel option detects parallel loops capable of being executed safely in parallel and automatically generates multithreaded code for these loops. -par_report[] Control the diagnostic messages from the auto-par- allelizer where is one of the following: 0 -- no diagnostic information is displayed. 1 -- indicates loops successfully auto-parallelized (DEFAULT). Issues a "LOOP AUTO-PARALLELIZED" mes- sage for parallel loops. 2 -- indicates successfully auto-parallelized loops as well as unsuccessful loops. 3 -- same as 2 plus additional information about any proven or assumed dependencies inhibiting auto-parallelization (reasons for not paralleliz- ing). -par_threshold[] Set a threshold for the auto-parallelization of loops based on the probability of profitable execu- tion of the loop in parallel. This option is used for loops whose computation work volume cannot be determined at compile-time. The threshold is usu- ally relevant when the loop trip count is unknown at compile-time. =0-100. (DEFAULT: =75) The compiler applies a heuristic that tries to bal- ance the overhead of creating multiple threads ver- sus the amount of work available to be shared amongst the threads. Conformance Options -ansi_alias directs the compiler to assume that the program adheres to the rules defined in the ISO C Standard. If your program adheres to these rules, then this option will allow the compiler to optimize more aggressively. If it doesn't adhere to these rules, then it can cause the compiler to generate incorrect code. -Xc, -ansi Select strict ANSI C/C++ conformance dialect -Xa (Itanium architecture-based systems) Select extended ANSI C dialect -c99[-] Enable(DEFAULT) [disable] C99 support for C pro- grams. -std=c99 Enable C99 support for C programs -mp This option is described above in Floating-point Optimizations. Miscellaneous Optimization Options -qp, -p Compile and link for function profiling with Linux gprof* tool -alias_args[-] This option implies arguments may be aliased [not aliased]. DEFAULT: -alias_args -mserialize-volatile (Itanium architecture-based systems) Enable strict memory access ordering for volatile data object references. -mno-serialize-volatile (Itanium architecture-based sys- tems) Memory access ordering for volatile data object references may be suppressed . -complex_limited_range This option causes the compiler to use the highest performance formulations of complex arithmetic operations, which may not produce acceptable results for input values near the top or bottom of the legal range. Without this option, the compiler users a better formulation of complex arithmetic operations, which produces acceptable results for the full range of input values, at some loss in performance. Output Options By default, the compiler converts source code directly to an executable file. Appropriate options allow you to con- trol the process by directing the compiler to produce pre- processed files (.i), assemblable files (.s) and object files (.o). -P, -F Preprocess to file (.i) only. See Preprocessing Options below for more information. -S Compile to assembly (.s) only, do not link (*I). -c Compile to object (.o) only, do not link. -use_asm Produce objects through assembler. -fcode-asm Produce assembly file with optional code annota- tions. -fsource-asm Produce assembly file with optional code annota- tions. -f[no]verbose-asm Produce assembly file with compiler comments (DEFAULT). -o Name output file. -inline_debug_info Preserve the source position of inlined code instead of assigning the call-site source position to inlined code. Preprocessing Options -A[] Associate a symbol with the specified sequence of . Equivalent to an #assert preprocessing directive. -A- Remove all predefined macros. Causes all predefined macros and assertions to be inactive. -C Preserve comments in preprocessed source output. Comments following preprocessing directives are not preserved. -D[=] Define the macro and associate it with the specified . Equivalent to a #define prepro- cessing directive. DEFAULT: -D defines a macro with a of 1. -E Direct the preprocessor to expand your source mod- ule and write the result to standard output. The preprocessed source contains #line directives, which the compiler uses to determine the source file and line number. Direct the preprocessor to expand your source module and write the result to standard output. Does not include #line directives in the output. -EP is equivalent to -E -P. -P Direct the preprocessor to expand your source mod- ule and store the result in a .i file in the cur- rent directory. Unlike the -E option, the output from -P does not include #line number directives. By default, the preprocessor creates the name of the output file using the prefix of the source file name with a .i extension. Caution: When you use the -P option, any existing files with the same name and extension are over- written. -I Add directory to include file search path. For mul- tiple search directories, multiple -I commands must be used. The compiler searches directories for include files in the following order: 1. Directory of the source file that contains the include. 2. Directories specified by the -I option. -idirafter Add directory to the second include file search path (after -I). -isystem Add directory to the start of the system include path. -U Remove predefined macro. Equivalent to a #undef preprocessing directive. -X Remove standard directories from include file search path. You can use the -X option with the -I option to prevent the compiler from searching the default path for include files and direct it to use an alternate path. -nostdinc Same as -X. -no-gcc Do not predefine the __GNUC__, __GNUC_MINOR__, and __GNUC_PATCHLEVEL__ macros. -H Print "include" file order and continue compila- tion. -M Generate makefile dependency lines for each source file, based on the #include lines found in the source file. -MD Preprocess and compile. Generate output file (.d extension) containing dependency information. -MF Generate makefile dependency information in . Must specify -M or -MM. -MG Similar to -M, but treats missing header files as generated files. -MM Similar to -M, but does not include system header files. -MMD Similar to -MD, but does not include system header files. -MX Generate dependency file (.o.dep extension) con- taining information used for the Intel wb tool. -dM Output macro definitions in effect after prepro- cessing (use with -E). -pch Automatic processing for precompiled headers. -pch_dir Directs the compiler to find and/or create a file for pre-compiled headers in . -create_pch Manual creation of precompiled header (file.pchi). -use_pch Manual use of precompiled header (file.pchi). Specifying Alternate Tools and Paths You can direct the compiler to specify alternate tools for preprocessing, compilation, assembly, and linking. Fur- ther, you can invoke options specific to your alternate tools on the command line. -Qoption,, Pass options to tool specified by . may be cpp, c, asm, or ld. Indi- cates one or more valid argument strings for the designated program. If the argument is a com- mand-line option, you must include the hyphen. If the argument contains a space or tab character, you must enclose the entire argument in quotation char- acters (""). You must separate multiple arguments with commas. -Qlocation,, Set as the location of the tool specified by . may be cpp, c, asm, or ld. is the complete path to the tool. -Qinstall Set as root of compiler installation. Precompiled Headers The Intel C++ Compiler supports precompiled header (PCH) files to significantly reduce compile times using the options described below. Caution: Depending on how you organize the header files listed in your sources, these options may increase compile times. -pch Direct the compiler to use appropriate PCH files. If none are available, they are created as source file.pchi. This option supports multiple source files. Note: The -pch option uses PCH files created from other sources if the headers files are the same. For example, if you compile source1.cpp using -pch, then source1.pchi is created. If you then compile source2.cpp using -pch, the compiler will use source1.pchi if it detects the same headers. -create_pch Manual creation of precompiled header . Use the -create_pch option if you want the compiler to create a PCH file called . The filename parameter must be specified. The filename parameter can be a full path name. The full path to filename must exist. The .pchi extension is not automatically appended to file name. This option cannot be used in the same compi- lation as -use_pch filename. The -create_pch file- name option is supported for single source file compilations only. -pch_dir Directs the compiler to find and/or create a file for pre-compiled headers in dirname. Use the -pch_dir option to specify the path (dirname) to the PCH file. You can use this option with -pch, -create_pch filename, and -use_pch file- name. -use_pch Manual use of precompiled header (filename.pchi). This option directs the compiler to use the PCH file specified by filename. It cannot be used in the same compilation as -create_pch . The -use_pch option supports full path names and supports multiple source files when all source files use the same .pchi file. Language Options -[no]restrict Enable [disable] the ´restrict´ keyword for disam biguating pointers. -Kc++ Compile all source or unrecognized file types as C++ source files. -fno-rtti Disable RTTI support. -[no]align (IA-32 systems only) Analyze and reorder memory layout for variables and arrays. -Zp[n] Specify alignment constraint for structure and union types, where n is one of the following: 1,2,4,8,16. -fshort-enums Allocate as many bytes as needed for enumerated types. -fsyntax-only Same as -syntax. -funsigned-char Change default char type to unsigned. -funsigned-bitfields Change default bitfield type to unsigned. Options for Controlling Compiler Diagnostics -w Disable all warnings. Displays error messages only. -w Control diagnostics, where is one of the fol- lowing: 0 -- Display errors (same as -w) 1 -- Display warnings and errors (DEFAULT) 2 -- Display remarks, warnings, and errors -wn Print a maximum of errors displayed before the compiler aborts. By default, if more than 100 errors are displayed, compilation aborts. Remarks and warnings do not count towards this limit. -wd[,,...] Disable diagnostics L1 through LN. -we[,,...] Change severity of diagnostics L1 through LN to error. -ww[,,...] Change severity of diagnostics L1 through LN to warning. -wr[,,...] Change severity of diagnostics L1 through LN to remark. -Wall Enable all warnings. -Werror Force warnings to be reported as errors. -Wbrief Print brief one-line diagnostics. When enabled, the original source line is not displayed and the error message text is not wrapped when too long to fit on a single line. -Wcheck Enable more strict diagnostics. Performs com- pile-time code checking for code that exhibits non-portable behavior, represents a possible unin- tended code sequence, or possibly affects operation of the program because of a quiet change in the ANSI C Standard. -Wp64 (Itanium architecture-based systems) Print diagnostics for 64-bit porting. Miscellaneous Options -help Print list of compiler options. -V Display compiler version information. -dryrun Show driver tool commands but do not execute tools. -v Show driver tool commands and execute tools. -x All source files found subsequent to -x will be recognized as one of the following types: c -- C source file c++ -- C++ source file c-header -- C header file cpp-output -- C pre-processed file assembler -- Assembly file assembler-with-cpp -- Assembly file that needs to be preprocessed none -- Disable recognition, and revert to file extension -falias Assume aliasing in program (DEFAULT). -fno-alias Assume no aliasing in program. -ffnalias Assume aliasing within functions (DEFAULT). -fno-fnalias Assume no aliasing within functions, but assume aliasing across calls. -fr32 (Itanium architecture-based systems only) Disable use of high floating point registers. Use only lower 32 floating-point registers. -Kpic, -KPIC Deprecated option. Use -fpic instead. -fpic, -fPIC Itanium architecture-based systems: This option generates code allowing full symbol preemption. -fvisibility=[extern|default|protected|hidden|internal] Global symbols (data and functions) will get the visibility attribute given by default. Symbol visi- bility attributes explicitly set in the source code or using the symbol visibility attribute file options will override the -fvisibility setting. -fvisibility-extern= Space separated symbols listed in the argu- ment will get visibility set to extern. -fvisibility-default= Space separated symbols listed in the argu- ment will get visibility set to default. -fvisibility-protected= Space separated symbols listed in the argu- ment will get visibility set to protected. -fvisibility-hidden= Space separated symbols listed in the argu- ment will get visibility set to hidden. -fvisibility-internal= Space separated symbols listed in the argu- ment will get visibility set to internal. -fminshared Compilation is for the main executable. Absolute addressing can be used and non-position independent code generated for symbols that are at least pro- tected. -fno-common Enables the compiler to treat common variables as if they were defined, allowing the use of gprel addressing of common data variables. -Knopic, -KNOPIC (Itanium architecture-based systems) Deprecated. Use fpic instead of this option. -nobss_init Place variables that are initialized with zeroes in the DATA section. Disable placement of zero-ini- tialized variables in BSS (use DATA). -tcheck Generate instrumentation to detect multi-threading bugs (requires Intel Threading Tools; cannot be used with compiler alone). Linker Options -L Instruct linker to search for libraries. -i_dynamic Link Intel provided libraries dynamically. -dynamic-linker Select a dynamic linker (filename) other than the default. -mrelax Pass -relax to the linker. -mnorelax Do not pass -relax to the linker. -no_cpprt Do not link in C++ runtime libraries. -cxxlib-gcc Use C++ header files provided by gcc during compi- lation, and use C++ libraries provided by gcc. Also, see gcc Interoperability above. -cxxlib-icc Use C++ libraries provided by Intel compiler. -gcc-name Use this option to specify the location of g++ when compiler cannot locate gcc C++ libraries. For use with -cxxlib-gcc configuration. -nodefaultlibs Do not use standard libraries when linking. -nostartfiles Do not use standard startup files when linking. -nostdlib Do not use standard libraries and startup files when linking. -static Prevent linking with shared libraries. Causes the executable to link all libraries statically, as opposed to dynamically. -shared Produce a shared object. -static-libcxa Link Intel libcxa C++ library statically. By default, the Intel-provided libcxa C++ library is linked in dynamically. Use -static-libcxa on the command line to link libcxa statically, while still allowing the standard libraries to be linked in by the default behavior. -shared-libcxa Link Intel libcxa C++ library dynamically, overrid- ing the default behavior when -static is used. This option has the opposite effect of -static-libcxa. When this option is used, the Intel-provided libcxa C++ library is linked in dynamically, allowing the user to override the static linking behavior when the -static option is used. -u Pretend the is undefined. -T Direct linker to read link commands from . -Xlinker Pass directly to the linker for processing. -Wl,[,,...] Pass options o1, o2, etc. to the linker for pro- cessing. ENVIRONMENT VARIABLES You can customize your environment by editing the follow- ing environment variables. You can specify paths where the compiler can search for special files such as libraries and include files. LD_LIBRARY_PATH Specifies the location for all Intel-provided libraries. The LD_LIBRARY_PATH environment variable contains a colon-separated list of directories in which the linker will search for library (.a) files. If you want the linker to search additional libraries, you can add their names to LD_LIBRARY_PATH, to the command line, to a response file, or to the configuration file. In each case, the names of these libraries are passed to the linker before the names of the Intel libraries that the driver always specifies. PATH Specifies the directories the system searches for binary executable files. ICCCFG Specifies the configuration file for customizing compilations with the icc compiler. ICPCCFG Specifies the configuration file for customizing compilations with the icpc compiler. TMP Specifies the directory in which to store temporary files. If the directory specified by TMP does not exist, the compiler places the temporary files in the current directory. IA32ROOT (IA32-based systems) Points to the directory containing the bin, lib, include and substitute header directories. IA64ROOT (Itanium architecture-based systems) Points to the directory containing the bin, lib, include and substitute header directories. GNU* Environment Variables The Intel C++ Compiler supports the following GNU environ­ ment variables: CPATH Specifies a list of directories to search following the directories specified by -I. C_INCLUDE Specifies a list of directories to search following the directories specified by -isystem. CPLUS_INCLUDE_PATH Same as C_INCLUDE. DEPENDENCIES_OUTPUT Specifies how to output dependencies for Make based on preprocessed, non-system header files. SUNPRO_DEPENDENCIES Same as DEPENDENCIES_OUTPUT, except that system header files are not ignored. Compilation Environment Options The Intel C++ Compiler installation includes shell scripts that you can use to set environment variables. See the Intel C++ User´s Guide for more information PGO Environment Variables The following environment values determine the directory in which to store dynamic information files or whether to overwrite pgopti.dpi. PROF_DIR Specifies the directory in which dynamic informa- tion files are created. This variable applies to all three phases of the profiling process. PROF_NO_CLOBBER Alters the feedback compilation phase slightly. By default, during the feedback compilation phase, the compiler merges the data from all dynamic informa- tion files and creates a new pgopti.dpi file if .dyn files are newer than an existing pgopti.dpi file. When this variable is set, the compiler does not overwrite the existing pgopti.dpi file. Instead, the compiler issues a warning and you must remove the pgopti.dpi file if you want to use addi- tional dynamic information files. PROF_DUMP_INTERVAL Initiate Interval Profile Dumping in an instru- mented application. The _PGOPTI_Set_Inter- val_Prof_Dump(int interval) function activates Interval Profile Dumping and sets the approximate frequency at which dumps will occur. The interval parameter is measured in milliseconds and specifies the time interval at which profile dumping will occur. An alternative method of initiating Interval Profile Dumping is by setting this environment variable. Set this environment variable to the desired interval value prior to starting the appli- cation. COPYRIGHT INFORMATION Copyright (C) 1985-2003, Intel Corporation. All rights reserved. * Other brands and names are the property of their respec- tive owners. Copyright(C) 1985-2003 Intel Corporation ICC(1) ------------------------------------------------------------------ Other annotations ------------------------------------------------------------------ dplace - a tool for controlling placement of processes onto cpus -c Cpu_number(s) Specified as a list of cpu ranges: Example: "-c1", "-c2-4", "-c1,4-8,3". Cpu numbers are NOT physical cpu numbers. They are logical cpu number that are relative to the cpus that are in the set of allowed cpus as specified by the current cpumemset or "runon" command. Cpu numbers start at 0. If this option is not specified, all cpus of the current cpumemset are available. taskset - retrieve or set a processes's CPU affinity (this tool performs the same basic function as dplace, and for the purposes of these benchmarks may be considered an alter- native to dplace) -c -c, --cpu-list specifiy a numerical list of processors instead of a bitmask. The list may contain multiple items, separated by comma, and ranges. For example, 0,5,7, 9-11. +FDO this is shorthand notation to indicate that feedback opti- mization was used in the build. The actual compiler flag used was -prof_gen for the first pass build, ie. before the training run, and -prof_use for the second pass build which is after the training run. Extra Libraries: libsmartheap64.a this denotes that the 64 bit version of MicroQuill SmartHeap Library 7.01 or later, from www.microquill.com, was used. The exact version used is documented under the Software section of each submission. ------------------------------------------------------------------ Portability flags for SPEC CPU2000 V1.3 on IPF Linux64: ------------------------------------------------------------------ -Dalloca=__builtin_alloca Replace occurrences of alloca() with __builtin_alloca. -DSPEC_CPU2000_LP64 Compile using LP64 programming model. -D_LIBC Don't include GNU C libraries -DLINUX_i386 Linux Intel system, use "long long" as 64bit variable. -DHAS_ERRLIST Prog env provides specification for "sys_errlist[]". -DSPEC_CPU2000_NEED_BOOL Use SPEC provided definition of the boolean type. -DSPEC_CPU2000_LINUX_IA64 Compile for an IA64 system running Linux. -DPSEC_CPU2000_GLIBC22 Compatibility with 2.2 & later versions of glibc -DSYS_IS_USG Specifies that the operating system is USG compliant. -DSYS_HAS_TIME_PROTO Do not explicitly declare time(). -DSYS_HAS_SIGNAL_PROTO Do not explicitly #include -DSYS_HAS_IOCTL_PROTO Do not explicitly declare ioctl(). -DSYS_HAS_ANSI System is ANSI compliant. -DSYS_HAS_CALLOC_PROTO Do not explicitly declare calloc(). -FI Fixed-format F90 source code.