![[user]](http://www.spec.org/auto/cpu2006/flags/user.png)
Invoke the Open64 C compiler.
Also used to invoke linker for C programs.
Invoke the Open64 C++ compiler.
Also used to invoke linker for C++ programs.
Invoke the Open64 Fortran 77, 90 and 95 compilers.
Also used to invoke linker for Fortran programs and
for mixed C / Fortran. openf90 and openf95 are synonymous.
Invoke the Open64 C compiler.
Also used to invoke linker for C programs.
Invoke the Open64 C++ compiler.
Also used to invoke linker for C++ programs.
Invoke the Open64 Fortran 77, 90 and 95 compilers.
Also used to invoke linker for Fortran programs and
for mixed C / Fortran. openf90 and openf95 are synonymous.
![[suite]](http://www.spec.org/auto/cpu2006/flags/suite.png)
This option is used to indicate that the host system's integers are 32-bits wide, and longs and pointers are 64-bits wide. Not all benchmarks recognize this macro, but the preferred practice for data model selection applies the flags to all benchmarks; this flag description is a placeholder for those benchmarks that do not recognize this macro.
This option is used to indicate that the host system's integers are 32-bits wide, and longs and pointers are 64-bits wide. Not all benchmarks recognize this macro, but the preferred practice for data model selection applies the flags to all benchmarks; this flag description is a placeholder for those benchmarks that do not recognize this macro.
This option is used to indicate that the host system's integers are 32-bits wide, and longs and pointers are 64-bits wide. Not all benchmarks recognize this macro, but the preferred practice for data model selection applies the flags to all benchmarks; this flag description is a placeholder for those benchmarks that do not recognize this macro.
This option is used to indicate that the host system's integers are 32-bits wide, and longs and pointers are 64-bits wide. Not all benchmarks recognize this macro, but the preferred practice for data model selection applies the flags to all benchmarks; this flag description is a placeholder for those benchmarks that do not recognize this macro.
This option is used to indicate that the host system's integers are 32-bits wide, and longs and pointers are 64-bits wide. Not all benchmarks recognize this macro, but the preferred practice for data model selection applies the flags to all benchmarks; this flag description is a placeholder for those benchmarks that do not recognize this macro.
This option is used to indicate that the host system's integers are 32-bits wide, and longs and pointers are 64-bits wide. Not all benchmarks recognize this macro, but the preferred practice for data model selection applies the flags to all benchmarks; this flag description is a placeholder for those benchmarks that do not recognize this macro.
CFP2006:
If -funderscoring is in effect, and the original Fortran external identifier contained an underscore, -fsecond-underscore appends a second underscore to the one added by -funderscoring. -fno-second-underscore does not append a second underscore. The default is both -funderscoring and -fsecond-underscore, the same defaults as g77 uses. -fno-second-underscore corresponds to the default policies of PGI Fortran and Intel Fortran.
This option is used to indicate that the host system's integers are 32-bits wide, and longs and pointers are 64-bits wide. Not all benchmarks recognize this macro, but the preferred practice for data model selection applies the flags to all benchmarks; this flag description is a placeholder for those benchmarks that do not recognize this macro.
This option is used to indicate that the host system's integers are 32-bits wide, and longs and pointers are 64-bits wide. Not all benchmarks recognize this macro, but the preferred practice for data model selection applies the flags to all benchmarks; this flag description is a placeholder for those benchmarks that do not recognize this macro.
This option is used to indicate that the host system's integers are 32-bits wide, and longs and pointers are 64-bits wide. Not all benchmarks recognize this macro, but the preferred practice for data model selection applies the flags to all benchmarks; this flag description is a placeholder for those benchmarks that do not recognize this macro.
This option is used to indicate that the host system's integers are 32-bits wide, and longs and pointers are 64-bits wide. Not all benchmarks recognize this macro, but the preferred practice for data model selection applies the flags to all benchmarks; this flag description is a placeholder for those benchmarks that do not recognize this macro.
This option is used to indicate that the host system's integers are 32-bits wide, and longs and pointers are 64-bits wide. Not all benchmarks recognize this macro, but the preferred practice for data model selection applies the flags to all benchmarks; this flag description is a placeholder for those benchmarks that do not recognize this macro.
This option is used to indicate that the host system's integers are 32-bits wide, and longs and pointers are 64-bits wide. Not all benchmarks recognize this macro, but the preferred practice for data model selection applies the flags to all benchmarks; this flag description is a placeholder for those benchmarks that do not recognize this macro.
This option is used to indicate that the host system's integers are 32-bits wide, and longs and pointers are 64-bits wide. Not all benchmarks recognize this macro, but the preferred practice for data model selection applies the flags to all benchmarks; this flag description is a placeholder for those benchmarks that do not recognize this macro.
This option is used to indicate that the host system's integers are 32-bits wide, and longs and pointers are 64-bits wide. Not all benchmarks recognize this macro, but the preferred practice for data model selection applies the flags to all benchmarks; this flag description is a placeholder for those benchmarks that do not recognize this macro.
This option is used to indicate that the host system's integers are 32-bits wide, and longs and pointers are 64-bits wide. Not all benchmarks recognize this macro, but the preferred practice for data model selection applies the flags to all benchmarks; this flag description is a placeholder for those benchmarks that do not recognize this macro.
![[benchmark]](http://www.spec.org/auto/cpu2006/flags/benchmark.png)
This macro indicates that the benchmark is being compiled on a Linux system.
This macro indicates that Fortran functions called from C should have their names lower-cased.
This option is used to indicate that the host system's integers are 32-bits wide, and longs and pointers are 64-bits wide. Not all benchmarks recognize this macro, but the preferred practice for data model selection applies the flags to all benchmarks; this flag description is a placeholder for those benchmarks that do not recognize this macro.
CFP2006:
If -funderscoring is in effect, and the original Fortran external identifier contained an underscore, -fsecond-underscore appends a second underscore to the one added by -funderscoring. -fno-second-underscore does not append a second underscore. The default is both -funderscoring and -fsecond-underscore, the same defaults as g77 uses. -fno-second-underscore corresponds to the default policies of PGI Fortran and Intel Fortran.
This option is used to indicate that the host system's integers are 32-bits wide, and longs and pointers are 64-bits wide. Not all benchmarks recognize this macro, but the preferred practice for data model selection applies the flags to all benchmarks; this flag description is a placeholder for those benchmarks that do not recognize this macro.
This option is used to indicate that the host system's integers are 32-bits wide, and longs and pointers are 64-bits wide. Not all benchmarks recognize this macro, but the preferred practice for data model selection applies the flags to all benchmarks; this flag description is a placeholder for those benchmarks that do not recognize this macro.
This option is used to indicate that the host system's integers are 32-bits wide, and longs and pointers are 64-bits wide. Not all benchmarks recognize this macro, but the preferred practice for data model selection applies the flags to all benchmarks; this flag description is a placeholder for those benchmarks that do not recognize this macro.
This option is used to indicate that the host system's integers are 32-bits wide, and longs and pointers are 64-bits wide. Not all benchmarks recognize this macro, but the preferred practice for data model selection applies the flags to all benchmarks; this flag description is a placeholder for those benchmarks that do not recognize this macro.
This option is used to indicate that the host system's integers are 32-bits wide, and longs and pointers are 64-bits wide. Not all benchmarks recognize this macro, but the preferred practice for data model selection applies the flags to all benchmarks; this flag description is a placeholder for those benchmarks that do not recognize this macro.
This option is used to indicate that the host system's integers are 32-bits wide, and longs and pointers are 64-bits wide. Not all benchmarks recognize this macro, but the preferred practice for data model selection applies the flags to all benchmarks; this flag description is a placeholder for those benchmarks that do not recognize this macro.
This option is used to indicate that the host system's integers are 32-bits wide, and longs and pointers are 64-bits wide. Not all benchmarks recognize this macro, but the preferred practice for data model selection applies the flags to all benchmarks; this flag description is a placeholder for those benchmarks that do not recognize this macro.
CFP2006:
If -funderscoring is in effect, and the original Fortran external identifier contained an underscore, -fsecond-underscore appends a second underscore to the one added by -funderscoring. -fno-second-underscore does not append a second underscore. The default is both -funderscoring and -fsecond-underscore, the same defaults as g77 uses. -fno-second-underscore corresponds to the default policies of PGI Fortran and Intel Fortran.
This option is used to indicate that the host system's integers are 32-bits wide, and longs and pointers are 64-bits wide. Not all benchmarks recognize this macro, but the preferred practice for data model selection applies the flags to all benchmarks; this flag description is a placeholder for those benchmarks that do not recognize this macro.
This option is used to indicate that the host system's integers are 32-bits wide, and longs and pointers are 64-bits wide. Not all benchmarks recognize this macro, but the preferred practice for data model selection applies the flags to all benchmarks; this flag description is a placeholder for those benchmarks that do not recognize this macro.
This option is used to indicate that the host system's integers are 32-bits wide, and longs and pointers are 64-bits wide. Not all benchmarks recognize this macro, but the preferred practice for data model selection applies the flags to all benchmarks; this flag description is a placeholder for those benchmarks that do not recognize this macro.
This option is used to indicate that the host system's integers are 32-bits wide, and longs and pointers are 64-bits wide. Not all benchmarks recognize this macro, but the preferred practice for data model selection applies the flags to all benchmarks; this flag description is a placeholder for those benchmarks that do not recognize this macro.
This option is used to indicate that the host system's integers are 32-bits wide, and longs and pointers are 64-bits wide. Not all benchmarks recognize this macro, but the preferred practice for data model selection applies the flags to all benchmarks; this flag description is a placeholder for those benchmarks that do not recognize this macro.
This option is used to indicate that the host system's integers are 32-bits wide, and longs and pointers are 64-bits wide. Not all benchmarks recognize this macro, but the preferred practice for data model selection applies the flags to all benchmarks; this flag description is a placeholder for those benchmarks that do not recognize this macro.
This option is used to indicate that the host system's integers are 32-bits wide, and longs and pointers are 64-bits wide. Not all benchmarks recognize this macro, but the preferred practice for data model selection applies the flags to all benchmarks; this flag description is a placeholder for those benchmarks that do not recognize this macro.
This macro indicates that the benchmark is being compiled on a Linux system.
This macro indicates that Fortran functions called from C should have their names lower-cased.
This option is used to indicate that the host system's integers are 32-bits wide, and longs and pointers are 64-bits wide. Not all benchmarks recognize this macro, but the preferred practice for data model selection applies the flags to all benchmarks; this flag description is a placeholder for those benchmarks that do not recognize this macro.
CFP2006:
If -funderscoring is in effect, and the original Fortran external identifier contained an underscore, -fsecond-underscore appends a second underscore to the one added by -funderscoring. -fno-second-underscore does not append a second underscore. The default is both -funderscoring and -fsecond-underscore, the same defaults as g77 uses. -fno-second-underscore corresponds to the default policies of PGI Fortran and Intel Fortran.
Uses a selection of optimizations in order to maximize performance.
Specifying "-Ofast" is equivalent to -O3 -ipa -OPT:Ofast -fno-math-errno -ffast-math.
These optimization options are generally safe. Floating-point accuracy may
be affected due to the transformation of the computational code. Note the
interprocedural analysis option, -ipa, specifies limitations on how libraries
and object files (.o files) are built.
-OPT:malloc_algorithm,malloc_alg=(0|1|2)
To improve runtime speed the compiler will select an optimal malloc
algorithm. To enable the selected algorithm, setup code is included
in the C/C++ and Fortran main function.
The two parameters, M_MMAP_MAX and M_TRIM_THRESHOLD, are described below.
Function: int mallopt (int param, int value) When calling mallopt, the param argument specifies the parameter to be set, and value the new value to be set. Possible choices for param, as defined in malloc.h, are:
Instructs the compiler to use 2MB hugepages for bss, data and text segments (i.e. bdt), and/or for heap allocation. Mixed usage of huge and small pages is not supported for bdt, but is supported for heap allocation. When the -HP:bd option is specified, the text segment is not mapped to huge pages while the bss and data segments still get mapped to 2MB hugepages. The limit option specifies a combined limit on the number of hugepages that may be used by the compiled program. If no limit is set, the number of hugepages that can be used by the program is effectively limited by the system configuration.
-IPA:plimit=N: The compiler is instructed to halt inlining within a program once the intermediate representation indicates that the code size of the program has surpassed the limit set by N. The default is "-IPA:plimit=2500".
-IPA:small_pu=N: The compiler is instructed not to restrict a procedure from inlining with a code size smaller than N when invoking the "-IPA:plimit" flag. The default is "-IPA:small_pu=30".
Instructs the compiler to perform aggressive optimizations that are likely to improve the scalability of an application running on a system with multi-core processors. In particular, these optimizations may target machine resources that are shared among the multiple cores of a processor, e.g. memory bandwidth, shared L3 cache, etc.
Compiler will generate instructions and schedule them appropriately for the selected processor type. The default value, auto, means to optimize for the platform on which the compiler is running, as determined by reading /proc/cpuinfo. anyx86 means a generic 32-bit x86 processor without SSE2 support.
Uses a selection of optimizations in order to maximize performance.
Specifying "-Ofast" is equivalent to -O3 -ipa -OPT:Ofast -fno-math-errno -ffast-math.
These optimization options are generally safe. Floating-point accuracy may
be affected due to the transformation of the computational code. Note the
interprocedural analysis option, -ipa, specifies limitations on how libraries
and object files (.o files) are built.
-static
On systems that support dynamic linking, this prevents linking with shared
libraries. On other systems, this option has no effect.
-CG:load_exe=N : The parameter N must be a non-negative integer which specifies the threshold for the compiler to consider folding a memory load operation directly into its subsequent use in an arithmetic instruction (thereby eliminating the memory load operation). If N=0 this folding optimization is not performed (in other words, the optimization is turned off). If the number of times the result of the memory load is used exceeds the value of N, then the folding optimization is not performed. For example, if N=1 this optimization is performed only when the result of the memory load has only one use. The default value of N varies with target processor and source language.
-OPT:malloc_algorithm,malloc_alg=(0|1|2)
To improve runtime speed the compiler will select an optimal malloc
algorithm. To enable the selected algorithm, setup code is included
in the C/C++ and Fortran main function.
The two parameters, M_MMAP_MAX and M_TRIM_THRESHOLD, are described below.
Function: int mallopt (int param, int value) When calling mallopt, the param argument specifies the parameter to be set, and value the new value to be set. Possible choices for param, as defined in malloc.h, are:
-INLINE:aggressive=(ON|On|on|OFF|Off|off|0|1): Instructs the compiler to be very aggressive when performing inlining. The default is "-INLINE:aggressive=OFF".
Instructs the compiler to use 2MB hugepages for bss, data and text segments (i.e. bdt), and/or for heap allocation. Mixed usage of huge and small pages is not supported for bdt, but is supported for heap allocation. When the -HP:bd option is specified, the text segment is not mapped to huge pages while the bss and data segments still get mapped to 2MB hugepages. The limit option specifies a combined limit on the number of hugepages that may be used by the compiled program. If no limit is set, the number of hugepages that can be used by the program is effectively limited by the system configuration.
Instructs the compiler to use a more efficient STL set map implementation. This allows faster iterations over sets and maps. This option is currently available only on open64 compilers downloaded from AMD.
Compiler will generate instructions and schedule them appropriately for the selected processor type. The default value, auto, means to optimize for the platform on which the compiler is running, as determined by reading /proc/cpuinfo. anyx86 means a generic 32-bit x86 processor without SSE2 support.
Uses a selection of optimizations in order to maximize performance.
Specifying "-Ofast" is equivalent to -O3 -ipa -OPT:Ofast -fno-math-errno -ffast-math.
These optimization options are generally safe. Floating-point accuracy may
be affected due to the transformation of the computational code. Note the
interprocedural analysis option, -ipa, specifies limitations on how libraries
and object files (.o files) are built.
This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".
-LNO:blocking=(on|off|0|1): Instructs the compiler to perform cache blocking transformation. The default is "-LNO:blocking=ON".
Instrucuts the compiler to create multiple copies of loops with different alignment assumptions. The compiler adds a runtime test to branch to particular loop when alignment assumptions are met. As necessary, the compiler will peel one or more iterations to improve alignment in alternate loop copies. The default is "-LNO:simd_peel_align=OFF".
-OPT:rsqrt=(0|1|2)
Instructs the compiler to use the reciprocal square root instruction
when calculating the square root. This transformation may vary
the accuracy slightly.
0 Restrain from using the reciprocal square root instruction.
1 Use the reciprocal square root instruction followed by
operations that will improve the accuracy of the results.
2 Use the reciprocal square root instruction without improving
the result accuracy.
Note "-OPT:rsqrt=1" if "-OPT:roundoff=2" or "-OPT:roundoff=3".
The default is "-OPT:rsqrt=0".
-OPT:unroll_size=N
Instructs the compiler to limit the number of instructions produced
when unrolling inner loops. When N=0 the ceiling is disregarded.
Note by specifying "-O3" sets "-OPT:unroll_size=128". The default
is "-OPT:unroll_size=40".
Instructs the compiler to use 2MB hugepages for bss, data and text segments (i.e. bdt), and/or for heap allocation. Mixed usage of huge and small pages is not supported for bdt, but is supported for heap allocation. When the -HP:bd option is specified, the text segment is not mapped to huge pages while the bss and data segments still get mapped to 2MB hugepages. The limit option specifies a combined limit on the number of hugepages that may be used by the compiled program. If no limit is set, the number of hugepages that can be used by the program is effectively limited by the system configuration.
Instructs the compiler to perform aggressive optimizations that are likely to improve the scalability of an application running on a system with multi-core processors. In particular, these optimizations may target machine resources that are shared among the multiple cores of a processor, e.g. memory bandwidth, shared L3 cache, etc.
Compiler will generate instructions and schedule them appropriately for the selected processor type. The default value, auto, means to optimize for the platform on which the compiler is running, as determined by reading /proc/cpuinfo. anyx86 means a generic 32-bit x86 processor without SSE2 support.
Uses a selection of optimizations in order to maximize performance.
Specifying "-Ofast" is equivalent to -O3 -ipa -OPT:Ofast -fno-math-errno -ffast-math.
These optimization options are generally safe. Floating-point accuracy may
be affected due to the transformation of the computational code. Note the
interprocedural analysis option, -ipa, specifies limitations on how libraries
and object files (.o files) are built.
-OPT:malloc_algorithm,malloc_alg=(0|1|2)
To improve runtime speed the compiler will select an optimal malloc
algorithm. To enable the selected algorithm, setup code is included
in the C/C++ and Fortran main function.
The two parameters, M_MMAP_MAX and M_TRIM_THRESHOLD, are described below.
Function: int mallopt (int param, int value) When calling mallopt, the param argument specifies the parameter to be set, and value the new value to be set. Possible choices for param, as defined in malloc.h, are:
Instructs the compiler to use 2MB hugepages for bss, data and text segments (i.e. bdt), and/or for heap allocation. Mixed usage of huge and small pages is not supported for bdt, but is supported for heap allocation. When the -HP:bd option is specified, the text segment is not mapped to huge pages while the bss and data segments still get mapped to 2MB hugepages. The limit option specifies a combined limit on the number of hugepages that may be used by the compiled program. If no limit is set, the number of hugepages that can be used by the program is effectively limited by the system configuration.
-IPA:plimit=N: The compiler is instructed to halt inlining within a program once the intermediate representation indicates that the code size of the program has surpassed the limit set by N. The default is "-IPA:plimit=2500".
-IPA:small_pu=N: The compiler is instructed not to restrict a procedure from inlining with a code size smaller than N when invoking the "-IPA:plimit" flag. The default is "-IPA:small_pu=30".
Instructs the compiler to perform aggressive optimizations that are likely to improve the scalability of an application running on a system with multi-core processors. In particular, these optimizations may target machine resources that are shared among the multiple cores of a processor, e.g. memory bandwidth, shared L3 cache, etc.
Compiler will generate instructions and schedule them appropriately for the selected processor type. The default value, auto, means to optimize for the platform on which the compiler is running, as determined by reading /proc/cpuinfo. anyx86 means a generic 32-bit x86 processor without SSE2 support.
This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".
-LNO:blocking=(on|off|0|1): Instructs the compiler to perform cache blocking transformation. The default is "-LNO:blocking=ON".
Instrucuts the compiler to create multiple copies of loops with different alignment assumptions. The compiler adds a runtime test to branch to particular loop when alignment assumptions are met. As necessary, the compiler will peel one or more iterations to improve alignment in alternate loop copies. The default is "-LNO:simd_peel_align=OFF".
-OPT:rsqrt=(0|1|2)
Instructs the compiler to use the reciprocal square root instruction
when calculating the square root. This transformation may vary
the accuracy slightly.
0 Restrain from using the reciprocal square root instruction.
1 Use the reciprocal square root instruction followed by
operations that will improve the accuracy of the results.
2 Use the reciprocal square root instruction without improving
the result accuracy.
Note "-OPT:rsqrt=1" if "-OPT:roundoff=2" or "-OPT:roundoff=3".
The default is "-OPT:rsqrt=0".
-OPT:unroll_size=N
Instructs the compiler to limit the number of instructions produced
when unrolling inner loops. When N=0 the ceiling is disregarded.
Note by specifying "-O3" sets "-OPT:unroll_size=128". The default
is "-OPT:unroll_size=40".
Uses a selection of optimizations in order to maximize performance.
Specifying "-Ofast" is equivalent to -O3 -ipa -OPT:Ofast -fno-math-errno -ffast-math.
These optimization options are generally safe. Floating-point accuracy may
be affected due to the transformation of the computational code. Note the
interprocedural analysis option, -ipa, specifies limitations on how libraries
and object files (.o files) are built.
-CG:movnti=N : When writing memory blocks of size larger than N KB ordinary stores will be transformed into non-temporal stores. The default is N=1000.
When enabled the local instruction scheduler is run several times using different heuristics. The optimal schedule generated is selected. Note this option supersedes options which control local instruction scheduling, e.g. "-CG:local_sched_alg" and "-CG:locs_shallow_depth". The default is "-CG:locs_best=off".
Instructs the compiler to use 2MB hugepages for bss, data and text segments (i.e. bdt), and/or for heap allocation. Mixed usage of huge and small pages is not supported for bdt, but is supported for heap allocation. When the -HP:bd option is specified, the text segment is not mapped to huge pages while the bss and data segments still get mapped to 2MB hugepages. The limit option specifies a combined limit on the number of hugepages that may be used by the compiled program. If no limit is set, the number of hugepages that can be used by the program is effectively limited by the system configuration.
-IPA:plimit=N: The compiler is instructed to halt inlining within a program once the intermediate representation indicates that the code size of the program has surpassed the limit set by N. The default is "-IPA:plimit=2500".
The inter-procedural analyzer option group -IPA: controls application of inter-procedural analysis and optimization.
-IPA:callee_limit=N: The compiler is instructed not to allow inlining of functions with a code size larger the limit set by N. The default is "-IPA:callee_limit=500."
Instructs the compiler to perform array copying to improve data cache utilization. The flag can be set to: 0 Instructs the compiler to suppress array copying. 1 Instructs the compiler to perform limited array copying. 2 Instructs the compiler to aggressively perform array copying. The default is "-OPT:struct_array_copy=1".
The "-OPT:" option group controls various optimizations. The "-OPT:" options supersede the defaults that are based on the main optimization level.
-OPT:alias=<model>
Identify which pointer aliasing model to use. The compiler will
make assumptions during compilation when one or more of the
following <model> is specified:
typed
Assumes that two pointers of different types will not
point to the same location in memory (i.e. the code
adheres to the ANSI/ISO C standards). Note when
specifying "-OPT:Ofast" turns this option ON.
(restricted|restrict)
Assumes that distinct pointers are pointing to distinct
non-overlapping objects. The default is that this optimization
is disabled.
disjoint
Assumes that any two pointer expressions are pointing
to distinct non-overlapping objects. This default is that this
optimization is disabled.
^M
field_sensitive
^M
Replaces the alias algorithm with an alternate
implementation that tracks fields of individual pointers,
i.e. it is field sensitive. This alternate implementation is
also designed to be flow-insensitive, scalable and
context-sensitive to heap allocations.
no_f90_pointer_alias
Assumes that any two different Fortran 90 pointers are
pointing to distinct non-overlapping objects. The default
is that this optimization is disabled.
Instructs the compiler to perform aggressive optimizations that are likely to improve the scalability of an application running on a system with multi-core processors. In particular, these optimizations may target machine resources that are shared among the multiple cores of a processor, e.g. memory bandwidth, shared L3 cache, etc.
Compiler will generate instructions and schedule them appropriately for the selected processor type. The default value, auto, means to optimize for the platform on which the compiler is running, as determined by reading /proc/cpuinfo. anyx86 means a generic 32-bit x86 processor without SSE2 support.
Uses a selection of optimizations in order to maximize performance.
Specifying "-Ofast" is equivalent to -O3 -ipa -OPT:Ofast -fno-math-errno -ffast-math.
These optimization options are generally safe. Floating-point accuracy may
be affected due to the transformation of the computational code. Note the
interprocedural analysis option, -ipa, specifies limitations on how libraries
and object files (.o files) are built.
-CG:cmp_peep=(on|off|0|1): Instructs the compiler to perform aggressive peephole optimization on compare operations involving memory operands. The default is "CG:cmp_peep=OFF".
-OPT:keep_ext=(on|off|0|1)
Instructs the compiler
to preserve external symbolic information. The default is "-OPT:keep_ext=OFF".
Instructs the compiler to use 2MB hugepages for bss, data and text segments (i.e. bdt), and/or for heap allocation. Mixed usage of huge and small pages is not supported for bdt, but is supported for heap allocation. When the -HP:bd option is specified, the text segment is not mapped to huge pages while the bss and data segments still get mapped to 2MB hugepages. The limit option specifies a combined limit on the number of hugepages that may be used by the compiled program. If no limit is set, the number of hugepages that can be used by the program is effectively limited by the system configuration.
-IPA:plimit=N: The compiler is instructed to halt inlining within a program once the intermediate representation indicates that the code size of the program has surpassed the limit set by N. The default is "-IPA:plimit=2500".
-IPA:small_pu=N: The compiler is instructed not to restrict a procedure from inlining with a code size smaller than N when invoking the "-IPA:plimit" flag. The default is "-IPA:small_pu=30".
Compiler will generate instructions and schedule them appropriately for the selected processor type. The default value, auto, means to optimize for the platform on which the compiler is running, as determined by reading /proc/cpuinfo. anyx86 means a generic 32-bit x86 processor without SSE2 support.
Instructs the compiler to perform aggressive optimizations that are likely to improve the scalability of an application running on a system with multi-core processors. In particular, these optimizations may target machine resources that are shared among the multiple cores of a processor, e.g. memory bandwidth, shared L3 cache, etc.
Instructs the compiler to generate an instrumented executable program from
the source code under development. The instrumented executable produces
feedback data files at runtime using an example dataset. filename specifies the
name of the feedback data file generated by the instrumented executable.
opencc -O2 -ipa -fb_create fbdata -o foo foo.c
"fbdata" will contain the instrumented feedback data from the instrumented
executable "foo". The default is "-fb_create" is disabled.
When feedback directed optimization (FDO) is used, an instrumented executable is used for a training run that produces information regarding execution paths and data values. Hardware performance counters are not used. This information is then provided to the optimizer during a second compilation pass to produce an optimized executable. FDO enables the optimizer to perform some optimizations which are not available without feedback data. The safety level of optimizations is unchanged with FDO, i.e. the safety level is the same as determined by the other (non-FDO) optimization flags specified on the compile and link lines.
Instructs the compiler to perform a feedback directed compilation using the
instrumented feedback data produced by the -fb_create option.
opencc -O2 -ipa -fb-opt fbdata -o foo foo.c
The new executable, foo, will be optimized to execute faster, and will not
include any instrumentation library calls. Note the same optimization flags
specified when creating the instrumented data file with the -fb_create must
be specified when invoking the compiler with the -fb_opt option. Otherwise,
the compiler will emit checksum errors. The default is "-fb_opt" disabled.
Uses a selection of optimizations in order to maximize performance.
Specifying "-Ofast" is equivalent to -O3 -ipa -OPT:Ofast -fno-math-errno -ffast-math.
These optimization options are generally safe. Floating-point accuracy may
be affected due to the transformation of the computational code. Note the
interprocedural analysis option, -ipa, specifies limitations on how libraries
and object files (.o files) are built.
Generate code for a 32-bit environment. The 32-bit environment sets int, long and pointer to 32 bits and generates code that runs on any i386 system. The compiler generates x86 or IA32 32-bit ABI. The default on a 32-bit host is 32-bit ABI. The default on a 64-bit host is 64-bit ABI if the target platform specified is 64-bit, otherwise the default is 32-bit.
-IPA:plimit=N: The compiler is instructed to halt inlining within a program once the intermediate representation indicates that the code size of the program has surpassed the limit set by N. The default is "-IPA:plimit=2500".
-OPT:malloc_algorithm,malloc_alg=(0|1|2)
To improve runtime speed the compiler will select an optimal malloc
algorithm. To enable the selected algorithm, setup code is included
in the C/C++ and Fortran main function.
The two parameters, M_MMAP_MAX and M_TRIM_THRESHOLD, are described below.
Function: int mallopt (int param, int value) When calling mallopt, the param argument specifies the parameter to be set, and value the new value to be set. Possible choices for param, as defined in malloc.h, are:
-CG:cmp_peep=(on|off|0|1): Instructs the compiler to perform aggressive peephole optimization on compare operations involving memory operands. The default is "CG:cmp_peep=OFF".
-CG:p2align=(on|off|0|1): When ON instructs the compiler to align loop heads to 64-byte boundaries. The default is "-CG:p2align=OFF".
-CG:load_exe=N : The parameter N must be a non-negative integer which specifies the threshold for the compiler to consider folding a memory load operation directly into its subsequent use in an arithmetic instruction (thereby eliminating the memory load operation). If N=0 this folding optimization is not performed (in other words, the optimization is turned off). If the number of times the result of the memory load is used exceeds the value of N, then the folding optimization is not performed. For example, if N=1 this optimization is performed only when the result of the memory load has only one use. The default value of N varies with target processor and source language.
-CG:dsched=(on|off|0|1): Instructs the compiler to aggressively schedule operations to maximize throughput during the decode stage of family 15h processors. This flag implies 32-byte alignment by default unless -CG:p2align is set to a value other than 2. The default is "CG:dsched=OFF".
-INLINE:aggressive=(ON|On|on|OFF|Off|off|0|1): Instructs the compiler to be very aggressive when performing inlining. The default is "-INLINE:aggressive=OFF".
This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".
-LNO:prefetch=(0|1|2|3) : Instructs the compiler to perform prefetching optimizations at a
specified level. The flag can be set to:
0 Instructs the compiler to suppress prefetching.
1 The compiler is instructed to allow prefetching only for
arrays that are always referenced in every loop iteration.
2 The compiler is instructed to implement prefetching
disregarding the restrictions in the above setting.
3 The compiler is instructed to implement aggressive prefetching.
The default is "-LNO:prefetch=2".
This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".
-LNO:prefetch_ahead=N : The compiler is instructed to prefetch ahead N cache line(s). The default is "-LNO:prefetch_ahead=2".
Instructs the compiler to perform aggressive optimizations that are likely to improve the scalability of an application running on a system with multi-core processors. In particular, these optimizations may target machine resources that are shared among the multiple cores of a processor, e.g. memory bandwidth, shared L3 cache, etc.
Compiler will generate instructions and schedule them appropriately for the selected processor type. The default value, auto, means to optimize for the platform on which the compiler is running, as determined by reading /proc/cpuinfo. anyx86 means a generic 32-bit x86 processor without SSE2 support.
Uses a selection of optimizations in order to maximize performance.
Specifying "-Ofast" is equivalent to -O3 -ipa -OPT:Ofast -fno-math-errno -ffast-math.
These optimization options are generally safe. Floating-point accuracy may
be affected due to the transformation of the computational code. Note the
interprocedural analysis option, -ipa, specifies limitations on how libraries
and object files (.o files) are built.
-IPA:plimit=N: The compiler is instructed to halt inlining within a program once the intermediate representation indicates that the code size of the program has surpassed the limit set by N. The default is "-IPA:plimit=2500".
This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".
-LNO:ignore_feedback=(on|off|0|1): The compiler is instructed to ignore feedback information generated by loop annotations during loop nest optimizations. The default is "-LNO:ignore_feedback=OFF".
-CG:local_sched_alg=(0|1|2|3): This option selects the basic block instruction scheduling algorithm.
To perform backward scheduling (i.e. where instructions are
scheduled from the bottom to the top of the basic block) select 0.
To perform forward scheduling select 1.
To schedule the instruction twice (i.e. once in the forward
direction and once in the backward direction) and take the
optimal of the two schedules select 2.
To perform forward or backward scheduling on per basic block basis, select 3.
The default value for this option is determined by the Open64 compiler
during compilation.
-CG:load_exe=N : The parameter N must be a non-negative integer which specifies the threshold for the compiler to consider folding a memory load operation directly into its subsequent use in an arithmetic instruction (thereby eliminating the memory load operation). If N=0 this folding optimization is not performed (in other words, the optimization is turned off). If the number of times the result of the memory load is used exceeds the value of N, then the folding optimization is not performed. For example, if N=1 this optimization is performed only when the result of the memory load has only one use. The default value of N varies with target processor and source language.
-OPT:unroll_size=N
Instructs the compiler to limit the number of instructions produced
when unrolling inner loops. When N=0 the ceiling is disregarded.
Note by specifying "-O3" sets "-OPT:unroll_size=128". The default
is "-OPT:unroll_size=40".
(For C++ only) -fexceptions enables exception handling and thus generates extra code needed to propagate exceptions. -fno-exceptions disables exception handling. Exception handling is enabled by default.
Instructs the compiler to use 2MB hugepages for bss, data and text segments (i.e. bdt), and/or for heap allocation. Mixed usage of huge and small pages is not supported for bdt, but is supported for heap allocation. When the -HP:bd option is specified, the text segment is not mapped to huge pages while the bss and data segments still get mapped to 2MB hugepages. The limit option specifies a combined limit on the number of hugepages that may be used by the compiled program. If no limit is set, the number of hugepages that can be used by the program is effectively limited by the system configuration.
Instructs the compiler to convert simple if-conditions with direct/indirect stores within loops to "Select" statements, thereby removing control flow and enabling vectorization. This feature is off by default.
The "-OPT:" option group controls various optimizations. The "-OPT:" options supersede the defaults that are based on the main optimization level.
-OPT:alias=<model>
Identify which pointer aliasing model to use. The compiler will
make assumptions during compilation when one or more of the
following <model> is specified:
typed
Assumes that two pointers of different types will not
point to the same location in memory (i.e. the code
adheres to the ANSI/ISO C standards). Note when
specifying "-OPT:Ofast" turns this option ON.
(restricted|restrict)
Assumes that distinct pointers are pointing to distinct
non-overlapping objects. The default is that this optimization
is disabled.
disjoint
Assumes that any two pointer expressions are pointing
to distinct non-overlapping objects. This default is that this
optimization is disabled.
^M
field_sensitive
^M
Replaces the alias algorithm with an alternate
implementation that tracks fields of individual pointers,
i.e. it is field sensitive. This alternate implementation is
also designed to be flow-insensitive, scalable and
context-sensitive to heap allocations.
no_f90_pointer_alias
Assumes that any two different Fortran 90 pointers are
pointing to distinct non-overlapping objects. The default
is that this optimization is disabled.
Instructs the compiler to enable 128-bit AVX/SSE partial vectorization for loop bodies. In scenarios where there is no loop carried dependence in the input functions, use the option "-LNO:psimd iso unroll=ON" for improved performance. The default is "-LNO:psimd_iso_unroll=OFF".
Compiler will generate instructions and schedule them appropriately for the selected processor type. The default value, auto, means to optimize for the platform on which the compiler is running, as determined by reading /proc/cpuinfo. anyx86 means a generic 32-bit x86 processor without SSE2 support.
Uses a selection of optimizations in order to maximize performance.
Specifying "-Ofast" is equivalent to -O3 -ipa -OPT:Ofast -fno-math-errno -ffast-math.
These optimization options are generally safe. Floating-point accuracy may
be affected due to the transformation of the computational code. Note the
interprocedural analysis option, -ipa, specifies limitations on how libraries
and object files (.o files) are built.
Instructs the compiler to use a more efficient STL set map implementation. This allows faster iterations over sets and maps. This option is currently available only on open64 compilers downloaded from AMD.
-static
On systems that support dynamic linking, this prevents linking with shared
libraries. On other systems, this option has no effect.
-INLINE:aggressive=(ON|On|on|OFF|Off|off|0|1): Instructs the compiler to be very aggressive when performing inlining. The default is "-INLINE:aggressive=OFF".
This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".
-LNO:opt=(0|1): Instructs the compiler at which level to perform loop nest optimizations.
The flag can be set to:
0 The compiler is restricted to suppress nearly all loop nest optimizations.
1 The compiler performs full loop nest optimizations.
The default is "-LNO:opt=1"
This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".
-LNO:simd=(0|1|2|3) : The compiler is instructed to use single instruction multiple data
(SIMD) instructions, supported by the target processor, when vectorizing
the inner loop. The flag can be set to:
0 The compiler is instructed to suppress vectorization.
1 The compiler is instructed to vectorize only if there is
no performance degradation due to sub-optimal alignment
and does not induce floating-point operation inaccuracies.
2 Instructs the compiler to aggressively vectorize with no
constraints in place.
3 Instructs the compiler to use advanced vectorization techniques such as
partial vectorization. This option enables the compiler to vectorize in
situations where all parts of a loop may not be vectorizable.
The default is "LNO:simd=1".
(For C++ only) Enables exception handling, but does not generate code needed to raise/catch exceptions. This option allows the compiler to accept exceptions as part of the C++ dialect but in effect asserts that these exceptions will not actually be raised at runtime.
Generate code for a 32-bit environment. The 32-bit environment sets int, long and pointer to 32 bits and generates code that runs on any i386 system. The compiler generates x86 or IA32 32-bit ABI. The default on a 32-bit host is 32-bit ABI. The default on a 64-bit host is 64-bit ABI if the target platform specified is 64-bit, otherwise the default is 32-bit.
Instructs the compiler to limit the unrolling of inner loops to the value specified by N. The default is "-OPT:unroll_times_max=4".
-OPT:unroll_size=N
Instructs the compiler to limit the number of instructions produced
when unrolling inner loops. When N=0 the ceiling is disregarded.
Note by specifying "-O3" sets "-OPT:unroll_size=128". The default
is "-OPT:unroll_size=40".
-OPT:unroll_level=(1|2)
Controls the level at which
the compiler will perform unrolling optimizations. When "-OPT:unroll_level=2"
the compiler is instructed to aggressively unroll loops in the
presence of control flow. The default is "-OPT:unroll_level=1".
Instructs the compiler to use 2MB hugepages for bss, data and text segments (i.e. bdt), and/or for heap allocation. Mixed usage of huge and small pages is not supported for bdt, but is supported for heap allocation. When the -HP:bd option is specified, the text segment is not mapped to huge pages while the bss and data segments still get mapped to 2MB hugepages. The limit option specifies a combined limit on the number of hugepages that may be used by the compiled program. If no limit is set, the number of hugepages that can be used by the program is effectively limited by the system configuration.
-GRA:unspill=(on|off|0|1)
Instructs the compiler's Global Register Allocator (GRA) to aggressively
remove redundant register spills that occur in the boundary region between
GRA and LRA (Local Register Allocator). The default is "-GRA:unspill=off".
-CG:cmp_peep=(on|off|0|1): Instructs the compiler to perform aggressive peephole optimization on compare operations involving memory operands. The default is "CG:cmp_peep=OFF".
The compiler is instructed to optimize move extend or load extend instructions when followed by compare instructions. The default is "-CG:movext_icmp=on".
These -TENV: options control the target environment assumed and/or produced by the compiler.
-TENV:frame_pointer=(on|off)
Setting this option to ON tells the compiler to use the frame pointer
register to address local variables in the function stack frame. Generally,
if the compiler determines that the stack pointer is fixed it
will use the stack pointer to address local variables throughout the
function invocation in place of the frame pointer. This frees up the
frame pointer for other purposes.
The default is ON for C/C++ and OFF for Fortran. This flag defaults
to ON for C/C++ because the exception handling mechanism
relies on the frame pointer register being used to address local variables.
This flag can be turned OFF for C/C++ programs that do
not generate exceptions.
Compiler will generate instructions and schedule them appropriately for the selected processor type. The default value, auto, means to optimize for the platform on which the compiler is running, as determined by reading /proc/cpuinfo. anyx86 means a generic 32-bit x86 processor without SSE2 support.
Instructs the compiler to generate an instrumented executable program from
the source code under development. The instrumented executable produces
feedback data files at runtime using an example dataset. filename specifies the
name of the feedback data file generated by the instrumented executable.
opencc -O2 -ipa -fb_create fbdata -o foo foo.c
"fbdata" will contain the instrumented feedback data from the instrumented
executable "foo". The default is "-fb_create" is disabled.
When feedback directed optimization (FDO) is used, an instrumented executable is used for a training run that produces information regarding execution paths and data values. Hardware performance counters are not used. This information is then provided to the optimizer during a second compilation pass to produce an optimized executable. FDO enables the optimizer to perform some optimizations which are not available without feedback data. The safety level of optimizations is unchanged with FDO, i.e. the safety level is the same as determined by the other (non-FDO) optimization flags specified on the compile and link lines.
Instructs the compiler to perform a feedback directed compilation using the
instrumented feedback data produced by the -fb_create option.
opencc -O2 -ipa -fb-opt fbdata -o foo foo.c
The new executable, foo, will be optimized to execute faster, and will not
include any instrumentation library calls. Note the same optimization flags
specified when creating the instrumented data file with the -fb_create must
be specified when invoking the compiler with the -fb_opt option. Otherwise,
the compiler will emit checksum errors. The default is "-fb_opt" disabled.
Perform all the optimizations at the -O2 level as well as many more aggressive optimizations. Examples of such aggressive optimizations are loop nest optimizations and generation of prefetch instructions. Although these more aggressive optimizations can significantly speed up the run time execution of the compiled program, in rare cases they may not be profitable and may instead lead to a slow down. Also, some of these more aggressive optimizations may affect the accuracy of some floating point computations.
If multiple "O" options are used, with or without level numbers, the last such option is the one that is effective. Level 2 is assumed if no value is specified (i.e. "-O". The default is "-O2".
This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".
-LNO:ignore_feedback=(on|off|0|1): The compiler is instructed to ignore feedback information generated by loop annotations during loop nest optimizations. The default is "-LNO:ignore_feedback=OFF".
-INLINE:aggressive=(ON|On|on|OFF|Off|off|0|1): Instructs the compiler to be very aggressive when performing inlining. The default is "-INLINE:aggressive=OFF".
-OPT:roundoff=(0|1|2|3)
"-OPT:roundoff" specifies acceptable levels of divergence for
both accuracy and overflow/underflow behavior of floating-point
results relative to the source language rules. The roundoff
value has a value in the range 0 to 3 and are described in the
following table:
0
Do *no* transformations which could affect floating-point
results. The is the default for optimization levels "-O0",
"-O1", and "-O2".
1
Allow all transformations which have a limited affect on
floating-point results. For roundoff, limited is defined as
only the last bit or two of the mantissa is affected. For
overflow or underflow, limited is defined as intermediate
results of the transformed calculation may overflow or
underflow within a factor of two where the original
expression may have overflowed or underflowed. Note that
effects may be less limited when compounded by multiple
transformations. This is the default when "-O3" is specified.
2
Specifies transformations with extensive effects on
floating-point results. For example, allow associative
rearrangement (i.e. even across loop iterations) and the
distribution of multiplication over addition or subtraction.
Do *not* specify transformations known to cause:
* - cumulative roundoff errors.
* - overflow/underflow of operands in a large range of
valid floating-point values.
This is the default when specifying "-OPT:Ofast" or "-O3"
3
Specify any mathematically valid transformation of
floating-point expressions. For example, floating point
induction variables in loops are permitted (even if known to
cause cumulative roundoff errors). Also permitted are fast
algorithms for complex absolute value and divide (which will
overflow/underflow for operands beyond the square root of
the representable extremes).
-OPT:IEEE_arithmetic,IEEE_arith,IEEE_a=(1|2|3)
This flag regulates the level of conformance to ANSI/IEEE 754-
1985 floating point roundoff and overflow. The levels of conformance:
1 Adhere to IEEE 754 accuracy. Specifying "-O0", "-O1",
and "-O2" will set "-OPT:IEEE_arithmetic=1".
2 Inexact results that do not conform to IEEE 754 may be calculated.
Specifying "-O3" will set "-OPT:IEEE_arithmetic=2".
3 All mathematically valid transformations (possibly non-IEEE standard ones) are allowed.
-OPT:IEEE_NaN_Inf=(on|off|0|1)
-OPT:IEEE_NaN_inf=ON instructs the compiler to conform to ANSI/IEEE 754-1985 for all
operations which produce a NaN or infinity result. Note NaN and
infinity are typically handled as special cases in floating-point representations
of real numbers and are defined by the IEEE 754 Standards for Binary Floating-point
Arithmetic. The default is "-OPT:IEEE_NaN_Inf=ON".
-OPT:IEEE_NaN_inf=OFF instructs the compiler to calculate various operations that do not
produce IEEE-754 results. For example, x/x is set to the value 1
without performing a divide operation and x=x is set to TRUE with
out executing a test operation. "-OPT:IEEE_NaN_inf=OFF"
specifies multiple optimizations that increase performance.
-OPT:fold_unsigned_relops=(on|off|0|1)
Instructs the compiler to fold relational operators involving
unsigned integers that may be simplified at compile time, which
may cause fewer overflows to be seen at run time. The default is
"-OPT:fold_unsigned_relops=ON".
(For C++ only) -fexceptions enables exception handling and thus generates extra code needed to propagate exceptions. -fno-exceptions disables exception handling. Exception handling is enabled by default.
-CG:p2align=(on|off|0|1): When ON instructs the compiler to align loop heads to 64-byte boundaries. The default is "-CG:p2align=OFF".
Generate code for a 32-bit environment. The 32-bit environment sets int, long and pointer to 32 bits and generates code that runs on any i386 system. The compiler generates x86 or IA32 32-bit ABI. The default on a 32-bit host is 32-bit ABI. The default on a 64-bit host is 64-bit ABI if the target platform specified is 64-bit, otherwise the default is 32-bit.
Enables/disables the use of FMA4 instructions on targets which support them. Specifying "-march=bdver1" enables this option, else the default is "-mno-fma4". Note specifying option "-mno-avx" implies option "-mno-fma4"
Instructs the compiler to use 2MB hugepages for bss, data and text segments (i.e. bdt), and/or for heap allocation. Mixed usage of huge and small pages is not supported for bdt, but is supported for heap allocation. When the -HP:bd option is specified, the text segment is not mapped to huge pages while the bss and data segments still get mapped to 2MB hugepages. The limit option specifies a combined limit on the number of hugepages that may be used by the compiled program. If no limit is set, the number of hugepages that can be used by the program is effectively limited by the system configuration.
The compiler's scalar optimizer is instructed to take advantage of scaled-index addressing mode. For example if "-WOPT:sib" is set, strength reduction will be performed less aggressively. The default is "-WOPT:sib=OFF".
Compiler will generate instructions and schedule them appropriately for the selected processor type. The default value, auto, means to optimize for the platform on which the compiler is running, as determined by reading /proc/cpuinfo. anyx86 means a generic 32-bit x86 processor without SSE2 support.
Instructs the compiler to generate an instrumented executable program from
the source code under development. The instrumented executable produces
feedback data files at runtime using an example dataset. filename specifies the
name of the feedback data file generated by the instrumented executable.
opencc -O2 -ipa -fb_create fbdata -o foo foo.c
"fbdata" will contain the instrumented feedback data from the instrumented
executable "foo". The default is "-fb_create" is disabled.
When feedback directed optimization (FDO) is used, an instrumented executable is used for a training run that produces information regarding execution paths and data values. Hardware performance counters are not used. This information is then provided to the optimizer during a second compilation pass to produce an optimized executable. FDO enables the optimizer to perform some optimizations which are not available without feedback data. The safety level of optimizations is unchanged with FDO, i.e. the safety level is the same as determined by the other (non-FDO) optimization flags specified on the compile and link lines.
Instructs the compiler to perform a feedback directed compilation using the
instrumented feedback data produced by the -fb_create option.
opencc -O2 -ipa -fb-opt fbdata -o foo foo.c
The new executable, foo, will be optimized to execute faster, and will not
include any instrumentation library calls. Note the same optimization flags
specified when creating the instrumented data file with the -fb_create must
be specified when invoking the compiler with the -fb_opt option. Otherwise,
the compiler will emit checksum errors. The default is "-fb_opt" disabled.
Uses a selection of optimizations in order to maximize performance.
Specifying "-Ofast" is equivalent to -O3 -ipa -OPT:Ofast -fno-math-errno -ffast-math.
These optimization options are generally safe. Floating-point accuracy may
be affected due to the transformation of the computational code. Note the
interprocedural analysis option, -ipa, specifies limitations on how libraries
and object files (.o files) are built.
When on, enables the local scheduler phase before register allocation. The default is "-CG:pre_local_sched=on".
-CG:p2align=(on|off|0|1): When ON instructs the compiler to align loop heads to 64-byte boundaries. The default is "-CG:p2align=OFF".
-CG:p2align=(on|off|0|1): When ON forces the compiler to emit multiple nops if alignment needs to be adjusted by more than 8 bytes. The default is "-CG:p2align_split=OFF".
-CG:dsched=(on|off|0|1): Instructs the compiler to aggressively schedule operations to maximize throughput during the decode stage of family 15h processors. This flag implies 32-byte alignment by default unless -CG:p2align is set to a value other than 2. The default is "CG:dsched=OFF".
-INLINE:aggressive=(ON|On|on|OFF|Off|off|0|1): Instructs the compiler to be very aggressive when performing inlining. The default is "-INLINE:aggressive=OFF".
Instructs the compiler to use 2MB hugepages for bss, data and text segments (i.e. bdt), and/or for heap allocation. Mixed usage of huge and small pages is not supported for bdt, but is supported for heap allocation. When the -HP:bd option is specified, the text segment is not mapped to huge pages while the bss and data segments still get mapped to 2MB hugepages. The limit option specifies a combined limit on the number of hugepages that may be used by the compiled program. If no limit is set, the number of hugepages that can be used by the program is effectively limited by the system configuration.
Instructs the compiler to perform loop transformations by using library function calls to |memcpy| or |memset|. The default is "-OPT:transform=1".
The "-OPT:" option group controls various optimizations. The "-OPT:" options supersede the defaults that are based on the main optimization level.
-OPT:alias=<model>
Identify which pointer aliasing model to use. The compiler will
make assumptions during compilation when one or more of the
following <model> is specified:
typed
Assumes that two pointers of different types will not
point to the same location in memory (i.e. the code
adheres to the ANSI/ISO C standards). Note when
specifying "-OPT:Ofast" turns this option ON.
(restricted|restrict)
Assumes that distinct pointers are pointing to distinct
non-overlapping objects. The default is that this optimization
is disabled.
disjoint
Assumes that any two pointer expressions are pointing
to distinct non-overlapping objects. This default is that this
optimization is disabled.
^M
field_sensitive
^M
Replaces the alias algorithm with an alternate
implementation that tracks fields of individual pointers,
i.e. it is field sensitive. This alternate implementation is
also designed to be flow-insensitive, scalable and
context-sensitive to heap allocations.
no_f90_pointer_alias
Assumes that any two different Fortran 90 pointers are
pointing to distinct non-overlapping objects. The default
is that this optimization is disabled.
Instructs the compiler to throttle the aggressiveness of speculative code motion optimization. This flag has the following three settings: 0 Disable speculative code motion. 1 Allow speculative code motion, but only in situations where it is deemed profitable (i.e., in cases where register pressure is not too high). 2 Allow speculative code motion even in cases where the register pressure may be too high. The default is "-WOPT:aggcm=1".
Compiler will generate instructions and schedule them appropriately for the selected processor type. The default value, auto, means to optimize for the platform on which the compiler is running, as determined by reading /proc/cpuinfo. anyx86 means a generic 32-bit x86 processor without SSE2 support.
Instructs the compiler to generate an instrumented executable program from
the source code under development. The instrumented executable produces
feedback data files at runtime using an example dataset. filename specifies the
name of the feedback data file generated by the instrumented executable.
opencc -O2 -ipa -fb_create fbdata -o foo foo.c
"fbdata" will contain the instrumented feedback data from the instrumented
executable "foo". The default is "-fb_create" is disabled.
When feedback directed optimization (FDO) is used, an instrumented executable is used for a training run that produces information regarding execution paths and data values. Hardware performance counters are not used. This information is then provided to the optimizer during a second compilation pass to produce an optimized executable. FDO enables the optimizer to perform some optimizations which are not available without feedback data. The safety level of optimizations is unchanged with FDO, i.e. the safety level is the same as determined by the other (non-FDO) optimization flags specified on the compile and link lines.
Instructs the compiler to perform a feedback directed compilation using the
instrumented feedback data produced by the -fb_create option.
opencc -O2 -ipa -fb-opt fbdata -o foo foo.c
The new executable, foo, will be optimized to execute faster, and will not
include any instrumentation library calls. Note the same optimization flags
specified when creating the instrumented data file with the -fb_create must
be specified when invoking the compiler with the -fb_opt option. Otherwise,
the compiler will emit checksum errors. The default is "-fb_opt" disabled.
Uses a selection of optimizations in order to maximize performance.
Specifying "-Ofast" is equivalent to -O3 -ipa -OPT:Ofast -fno-math-errno -ffast-math.
These optimization options are generally safe. Floating-point accuracy may
be affected due to the transformation of the computational code. Note the
interprocedural analysis option, -ipa, specifies limitations on how libraries
and object files (.o files) are built.
-OPT:Ofast
Maximizes performance for a given platform using the selected optimizations.
"-OPT:Ofast" specifies four optimizations; "-OPT:ro=2",
"-OPT:Olimit=0", "-OPT:div_split=ON", and "-OPT:alias=typed".
Note the specified optimizations are ordinarily safe but floating
point accuracy due to transformations may be diminished.
-OPT:treeheight=(on|off|0|1)
Instructs the compiler to perform a global reassociation of expressions
which reduces the tree height of the expressions. The reassociation
process determines the optimum order of combining terms
in a sum so as to produce loop invariant subcomputations
or to refine common subexpressions among several essential computations.
The default is "-OPT:treeheight=OFF".
This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".
-LNO:blocking=(on|off|0|1): Instructs the compiler to perform cache blocking transformation. The default is "-LNO:blocking=ON".
This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".
-LNO:ignore_feedback=(on|off|0|1): The compiler is instructed to ignore feedback information generated by loop annotations during loop nest optimizations. The default is "-LNO:ignore_feedback=OFF".
This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".
-LNO:full_unroll,fu=N: The compiler is instructed to fully unroll loops after examining the loop, within the loop nest optimizer, to determine if the loop can be fully unrolled in N or less iterations. Argument "fu=N" specifies the maximum number of unrolls that can be performed to fully unroll the loop. Note that setting N=0 suppresses full unrolling of loops inside the loop nest optimizer. The default is "-LNO:full_unroll=5".
The compiler is instructed to perform outer loop vectorization by moving vectorizable loop into the innermost position. The default is "-LNO:loop_model_simd=off".
The compiler is instructed to remove the remainder loop construct for the vectorized loops. The default is "-LNO:simd_rm_unity_remainder=off".
This group of options controls the affect the global optimizer has on the program. "-WOPT:" only influences global optimizations specified by "-O2" or above.
-WOPT:aggstr=N
-WOPT:aggstr regulates the aggressiveness of the compilers
scalar optimizer when performing strength reduction optimizations.
Strength reduction is the substitution of induction expressions
within a loop with temporaries that are incremented together
with the loop variable. The value N specifies the maximum
number of induction expressions being replaced. Select positive
integers only for variable N. Setting N=0 tells the scalar optimizer
to use strength reduction for non-trivial induction expressions.
Note specifying very aggressive strength reductions may prompt
additional temporaries increasing register pressure and resulting
in excessive register spills that decrease performance. The default
is "-WOPT:aggstr=11".
Instructs the compiler to use 2MB hugepages for bss, data and text segments (i.e. bdt), and/or for heap allocation. Mixed usage of huge and small pages is not supported for bdt, but is supported for heap allocation. When the -HP:bd option is specified, the text segment is not mapped to huge pages while the bss and data segments still get mapped to 2MB hugepages. The limit option specifies a combined limit on the number of hugepages that may be used by the compiled program. If no limit is set, the number of hugepages that can be used by the program is effectively limited by the system configuration.
-CG:cmp_peep=(on|off|0|1): Instructs the compiler to perform aggressive peephole optimization on compare operations involving memory operands. The default is "CG:cmp_peep=OFF".
Compiler will generate instructions and schedule them appropriately for the selected processor type. The default value, auto, means to optimize for the platform on which the compiler is running, as determined by reading /proc/cpuinfo. anyx86 means a generic 32-bit x86 processor without SSE2 support.
Instructs the compiler to generate an instrumented executable program from
the source code under development. The instrumented executable produces
feedback data files at runtime using an example dataset. filename specifies the
name of the feedback data file generated by the instrumented executable.
opencc -O2 -ipa -fb_create fbdata -o foo foo.c
"fbdata" will contain the instrumented feedback data from the instrumented
executable "foo". The default is "-fb_create" is disabled.
When feedback directed optimization (FDO) is used, an instrumented executable is used for a training run that produces information regarding execution paths and data values. Hardware performance counters are not used. This information is then provided to the optimizer during a second compilation pass to produce an optimized executable. FDO enables the optimizer to perform some optimizations which are not available without feedback data. The safety level of optimizations is unchanged with FDO, i.e. the safety level is the same as determined by the other (non-FDO) optimization flags specified on the compile and link lines.
Instructs the compiler to perform a feedback directed compilation using the
instrumented feedback data produced by the -fb_create option.
opencc -O2 -ipa -fb-opt fbdata -o foo foo.c
The new executable, foo, will be optimized to execute faster, and will not
include any instrumentation library calls. Note the same optimization flags
specified when creating the instrumented data file with the -fb_create must
be specified when invoking the compiler with the -fb_opt option. Otherwise,
the compiler will emit checksum errors. The default is "-fb_opt" disabled.
Uses a selection of optimizations in order to maximize performance.
Specifying "-Ofast" is equivalent to -O3 -ipa -OPT:Ofast -fno-math-errno -ffast-math.
These optimization options are generally safe. Floating-point accuracy may
be affected due to the transformation of the computational code. Note the
interprocedural analysis option, -ipa, specifies limitations on how libraries
and object files (.o files) are built.
This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".
-LNO:full_unroll,fu=N: The compiler is instructed to fully unroll loops after examining the loop, within the loop nest optimizer, to determine if the loop can be fully unrolled in N or less iterations. Argument "fu=N" specifies the maximum number of unrolls that can be performed to fully unroll the loop. Note that setting N=0 suppresses full unrolling of loops inside the loop nest optimizer. The default is "-LNO:full_unroll=5".
This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".
-LNO:blocking=(on|off|0|1): Instructs the compiler to perform cache blocking transformation. The default is "-LNO:blocking=ON".
This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".
-LNO:simd=(0|1|2|3) : The compiler is instructed to use single instruction multiple data
(SIMD) instructions, supported by the target processor, when vectorizing
the inner loop. The flag can be set to:
0 The compiler is instructed to suppress vectorization.
1 The compiler is instructed to vectorize only if there is
no performance degradation due to sub-optimal alignment
and does not induce floating-point operation inaccuracies.
2 Instructs the compiler to aggressively vectorize with no
constraints in place.
3 Instructs the compiler to use advanced vectorization techniques such as
partial vectorization. This option enables the compiler to vectorize in
situations where all parts of a loop may not be vectorizable.
The default is "LNO:simd=1".
-OPT:roundoff,ro=(0|1|2|3)
"-OPT:roundoff" specifies acceptable levels of divergence for both
accuracy and overflow/underflow behavior of floating-point results
relative to the source language rules. The roundoff value is
in the range 0-3 with each value described as follows:
0 Do no transformations which could affect floating-point
results. The default for optimization levels "-O0", "-O1",
and "-O2".
1 Allow all transformations which have a limited affect
on floating-point results. For roundoff, limited is defined
as only the last bit or two of the mantissa is affected.
For overflow or underflow, limited is defined as
intermediate results of the transformed calculation may
overflow or underflow within a factor of two of where
the original expression may have overflowed or underflowed.
Note that effects may be less limited when
compounded by multiple transformations. This is the
default when "-O3" is specified.
2 Specifies transformations with extensive effects on
floating-point results. For example, allow associative
rearrangement (i.e. even across loop iterations) and the
distribution of multiplication over addition or
subtraction. Do not specify transformations known to
cause: a. cumulative roundoff errors, or b. overflow/underflow
of operands in a large range of valid floating-point values.
This is the default when specifying "-OPT:Ofast".
3 Specify any mathematically valid transformation of
floating-point expressions. For example, floating point
induction variables in loops are permitted (even if
known to cause cumulative roundoff errors). Also
permitted are fast algorithms for complex absolute
value and divide (which will overflow/underflow for
operands beyond the square root of the representable extremes).
Allows expressions of the form 1/X to be changed to use the reciprocal instruction of the computer. This may be faster, but is inherently less accurate than a division.
-CG:local_sched_alg=(0|1|2|3): This option selects the basic block instruction scheduling algorithm.
To perform backward scheduling (i.e. where instructions are
scheduled from the bottom to the top of the basic block) select 0.
To perform forward scheduling select 1.
To schedule the instruction twice (i.e. once in the forward
direction and once in the backward direction) and take the
optimal of the two schedules select 2.
To perform forward or backward scheduling on per basic block basis, select 3.
The default value for this option is determined by the Open64 compiler
during compilation.
Instructs the compiler to use 2MB hugepages for bss, data and text segments (i.e. bdt), and/or for heap allocation. Mixed usage of huge and small pages is not supported for bdt, but is supported for heap allocation. When the -HP:bd option is specified, the text segment is not mapped to huge pages while the bss and data segments still get mapped to 2MB hugepages. The limit option specifies a combined limit on the number of hugepages that may be used by the compiled program. If no limit is set, the number of hugepages that can be used by the program is effectively limited by the system configuration.
The compiler's scalar optimizer is instructed to take advantage of scaled-index addressing mode. For example if "-WOPT:sib" is set, strength reduction will be performed less aggressively. The default is "-WOPT:sib=OFF".
Compiler will generate instructions and schedule them appropriately for the selected processor type. The default value, auto, means to optimize for the platform on which the compiler is running, as determined by reading /proc/cpuinfo. anyx86 means a generic 32-bit x86 processor without SSE2 support.
Instructs the compiler to generate an instrumented executable program from
the source code under development. The instrumented executable produces
feedback data files at runtime using an example dataset. filename specifies the
name of the feedback data file generated by the instrumented executable.
opencc -O2 -ipa -fb_create fbdata -o foo foo.c
"fbdata" will contain the instrumented feedback data from the instrumented
executable "foo". The default is "-fb_create" is disabled.
When feedback directed optimization (FDO) is used, an instrumented executable is used for a training run that produces information regarding execution paths and data values. Hardware performance counters are not used. This information is then provided to the optimizer during a second compilation pass to produce an optimized executable. FDO enables the optimizer to perform some optimizations which are not available without feedback data. The safety level of optimizations is unchanged with FDO, i.e. the safety level is the same as determined by the other (non-FDO) optimization flags specified on the compile and link lines.
Instructs the compiler to perform a feedback directed compilation using the
instrumented feedback data produced by the -fb_create option.
opencc -O2 -ipa -fb-opt fbdata -o foo foo.c
The new executable, foo, will be optimized to execute faster, and will not
include any instrumentation library calls. Note the same optimization flags
specified when creating the instrumented data file with the -fb_create must
be specified when invoking the compiler with the -fb_opt option. Otherwise,
the compiler will emit checksum errors. The default is "-fb_opt" disabled.
Uses a selection of optimizations in order to maximize performance.
Specifying "-Ofast" is equivalent to -O3 -ipa -OPT:Ofast -fno-math-errno -ffast-math.
These optimization options are generally safe. Floating-point accuracy may
be affected due to the transformation of the computational code. Note the
interprocedural analysis option, -ipa, specifies limitations on how libraries
and object files (.o files) are built.
This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".
-LNO:blocking=(on|off|0|1): Instructs the compiler to perform cache blocking transformation. The default is "-LNO:blocking=ON".
This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".
-LNO:interchange=(on|off|0|1): The compiler is instructed to perform loop interchange optimizations. The default is "-LNO:interchange=ON".
-IPA:plimit=N: The compiler is instructed to halt inlining within a program once the intermediate representation indicates that the code size of the program has surpassed the limit set by N. The default is "-IPA:plimit=2500".
Instructs the compiler to use 2MB hugepages for bss, data and text segments (i.e. bdt), and/or for heap allocation. Mixed usage of huge and small pages is not supported for bdt, but is supported for heap allocation. When the -HP:bd option is specified, the text segment is not mapped to huge pages while the bss and data segments still get mapped to 2MB hugepages. The limit option specifies a combined limit on the number of hugepages that may be used by the compiled program. If no limit is set, the number of hugepages that can be used by the program is effectively limited by the system configuration.
Compiler will generate instructions and schedule them appropriately for the selected processor type. The default value, auto, means to optimize for the platform on which the compiler is running, as determined by reading /proc/cpuinfo. anyx86 means a generic 32-bit x86 processor without SSE2 support.
Uses a selection of optimizations in order to maximize performance.
Specifying "-Ofast" is equivalent to -O3 -ipa -OPT:Ofast -fno-math-errno -ffast-math.
These optimization options are generally safe. Floating-point accuracy may
be affected due to the transformation of the computational code. Note the
interprocedural analysis option, -ipa, specifies limitations on how libraries
and object files (.o files) are built.
When enabled, the code generator uses an additional prescheduling algorithm for minimizing register pressure. With "-CG:pre_minreg_level=1" the prescheduling algorithm is applied globally to all basic blocks and will apply only when more registers are requested than the maximum physical registers. With "-CG:pre_minreg_level=" the prescheduling algorithm is also invoked, but only to unrolled loops. The default is to not use either heuristic.
This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".
-LNO:simd=(0|1|2|3) : The compiler is instructed to use single instruction multiple data
(SIMD) instructions, supported by the target processor, when vectorizing
the inner loop. The flag can be set to:
0 The compiler is instructed to suppress vectorization.
1 The compiler is instructed to vectorize only if there is
no performance degradation due to sub-optimal alignment
and does not induce floating-point operation inaccuracies.
2 Instructs the compiler to aggressively vectorize with no
constraints in place.
3 Instructs the compiler to use advanced vectorization techniques such as
partial vectorization. This option enables the compiler to vectorize in
situations where all parts of a loop may not be vectorizable.
The default is "LNO:simd=1".
This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".
-LNO:fusion=N: The compiler is instructed to perform loop fusion. The flag can be
set to:
0 Suppress loop fusion.
1 The compiler performs traditional loop fusion.
2 The compiler performs aggressive loop fusion.
The default is "-LNO:fusion=0".
Instructs the compiler to use 2MB hugepages for bss, data and text segments (i.e. bdt), and/or for heap allocation. Mixed usage of huge and small pages is not supported for bdt, but is supported for heap allocation. When the -HP:bd option is specified, the text segment is not mapped to huge pages while the bss and data segments still get mapped to 2MB hugepages. The limit option specifies a combined limit on the number of hugepages that may be used by the compiled program. If no limit is set, the number of hugepages that can be used by the program is effectively limited by the system configuration.
Instructs the compiler to perform aggressive optimizations that are likely to improve the scalability of an application running on a system with multi-core processors. In particular, these optimizations may target machine resources that are shared among the multiple cores of a processor, e.g. memory bandwidth, shared L3 cache, etc.
Compiler will generate instructions and schedule them appropriately for the selected processor type. The default value, auto, means to optimize for the platform on which the compiler is running, as determined by reading /proc/cpuinfo. anyx86 means a generic 32-bit x86 processor without SSE2 support.
Uses a selection of optimizations in order to maximize performance.
Specifying "-Ofast" is equivalent to -O3 -ipa -OPT:Ofast -fno-math-errno -ffast-math.
These optimization options are generally safe. Floating-point accuracy may
be affected due to the transformation of the computational code. Note the
interprocedural analysis option, -ipa, specifies limitations on how libraries
and object files (.o files) are built.
-IPA:plimit=N: The compiler is instructed to halt inlining within a program once the intermediate representation indicates that the code size of the program has surpassed the limit set by N. The default is "-IPA:plimit=2500".
-OPT:unroll_size=N
Instructs the compiler to limit the number of instructions produced
when unrolling inner loops. When N=0 the ceiling is disregarded.
Note by specifying "-O3" sets "-OPT:unroll_size=128". The default
is "-OPT:unroll_size=40".
Instructs the compiler to limit the unrolling of inner loops to the value specified by N. The default is "-OPT:unroll_times_max=4".
This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".
-LNO:fission=N: Instructs the compiler to perform loop fission. This option can be
set to:
0 Suppress loop fission.
1 The compiler performs normal loop fission as necessary.
2 The compiler performs loop fission prior to loop fusion.
Note loop fusion is usually applied before loop fission, therefore
if "-LNO:fission=ON" and "-LNO:fusion=ON" when the compiler is
invoked a reverse effect may be induced. To counter this effect
specify "-LNO:fission=2" to instruct the compiler to perform loop
fission prior to loop fusion. The default is "-LNO:fission=0".
-CG:local_sched_alg=(0|1|2|3): This option selects the basic block instruction scheduling algorithm.
To perform backward scheduling (i.e. where instructions are
scheduled from the bottom to the top of the basic block) select 0.
To perform forward scheduling select 1.
To schedule the instruction twice (i.e. once in the forward
direction and once in the backward direction) and take the
optimal of the two schedules select 2.
To perform forward or backward scheduling on per basic block basis, select 3.
The default value for this option is determined by the Open64 compiler
during compilation.
Instructs the compiler to use 2MB hugepages for bss, data and text segments (i.e. bdt), and/or for heap allocation. Mixed usage of huge and small pages is not supported for bdt, but is supported for heap allocation. When the -HP:bd option is specified, the text segment is not mapped to huge pages while the bss and data segments still get mapped to 2MB hugepages. The limit option specifies a combined limit on the number of hugepages that may be used by the compiled program. If no limit is set, the number of hugepages that can be used by the program is effectively limited by the system configuration.
Compiler will generate instructions and schedule them appropriately for the selected processor type. The default value, auto, means to optimize for the platform on which the compiler is running, as determined by reading /proc/cpuinfo. anyx86 means a generic 32-bit x86 processor without SSE2 support.
Uses a selection of optimizations in order to maximize performance.
Specifying "-Ofast" is equivalent to -O3 -ipa -OPT:Ofast -fno-math-errno -ffast-math.
These optimization options are generally safe. Floating-point accuracy may
be affected due to the transformation of the computational code. Note the
interprocedural analysis option, -ipa, specifies limitations on how libraries
and object files (.o files) are built.
The "-OPT:" option group controls various optimizations. The "-OPT:" options supersede the defaults that are based on the main optimization level.
-OPT:alias=<model>
Identify which pointer aliasing model to use. The compiler will
make assumptions during compilation when one or more of the
following <model> is specified:
typed
Assumes that two pointers of different types will not
point to the same location in memory (i.e. the code
adheres to the ANSI/ISO C standards). Note when
specifying "-OPT:Ofast" turns this option ON.
(restricted|restrict)
Assumes that distinct pointers are pointing to distinct
non-overlapping objects. The default is that this optimization
is disabled.
disjoint
Assumes that any two pointer expressions are pointing
to distinct non-overlapping objects. This default is that this
optimization is disabled.
^M
field_sensitive
^M
Replaces the alias algorithm with an alternate
implementation that tracks fields of individual pointers,
i.e. it is field sensitive. This alternate implementation is
also designed to be flow-insensitive, scalable and
context-sensitive to heap allocations.
no_f90_pointer_alias
Assumes that any two different Fortran 90 pointers are
pointing to distinct non-overlapping objects. The default
is that this optimization is disabled.
This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".
-LNO:blocking=(on|off|0|1): Instructs the compiler to perform cache blocking transformation. The default is "-LNO:blocking=ON".
-CG:load_exe=N : The parameter N must be a non-negative integer which specifies the threshold for the compiler to consider folding a memory load operation directly into its subsequent use in an arithmetic instruction (thereby eliminating the memory load operation). If N=0 this folding optimization is not performed (in other words, the optimization is turned off). If the number of times the result of the memory load is used exceeds the value of N, then the folding optimization is not performed. For example, if N=1 this optimization is performed only when the result of the memory load has only one use. The default value of N varies with target processor and source language.
-CG:local_sched_alg=(0|1|2|3): This option selects the basic block instruction scheduling algorithm.
To perform backward scheduling (i.e. where instructions are
scheduled from the bottom to the top of the basic block) select 0.
To perform forward scheduling select 1.
To schedule the instruction twice (i.e. once in the forward
direction and once in the backward direction) and take the
optimal of the two schedules select 2.
To perform forward or backward scheduling on per basic block basis, select 3.
The default value for this option is determined by the Open64 compiler
during compilation.
-IPA:plimit=N: The compiler is instructed to halt inlining within a program once the intermediate representation indicates that the code size of the program has surpassed the limit set by N. The default is "-IPA:plimit=2500".
Instructs the compiler to use 2MB hugepages for bss, data and text segments (i.e. bdt), and/or for heap allocation. Mixed usage of huge and small pages is not supported for bdt, but is supported for heap allocation. When the -HP:bd option is specified, the text segment is not mapped to huge pages while the bss and data segments still get mapped to 2MB hugepages. The limit option specifies a combined limit on the number of hugepages that may be used by the compiled program. If no limit is set, the number of hugepages that can be used by the program is effectively limited by the system configuration.
Compiler will generate instructions and schedule them appropriately for the selected processor type. The default value, auto, means to optimize for the platform on which the compiler is running, as determined by reading /proc/cpuinfo. anyx86 means a generic 32-bit x86 processor without SSE2 support.
Uses a selection of optimizations in order to maximize performance.
Specifying "-Ofast" is equivalent to -O3 -ipa -OPT:Ofast -fno-math-errno -ffast-math.
These optimization options are generally safe. Floating-point accuracy may
be affected due to the transformation of the computational code. Note the
interprocedural analysis option, -ipa, specifies limitations on how libraries
and object files (.o files) are built.
-OPT:rsqrt=(0|1|2)
Instructs the compiler to use the reciprocal square root instruction
when calculating the square root. This transformation may vary
the accuracy slightly.
0 Restrain from using the reciprocal square root instruction.
1 Use the reciprocal square root instruction followed by
operations that will improve the accuracy of the results.
2 Use the reciprocal square root instruction without improving
the result accuracy.
Note "-OPT:rsqrt=1" if "-OPT:roundoff=2" or "-OPT:roundoff=3".
The default is "-OPT:rsqrt=0".
Instructs the compiler to use 2MB hugepages for bss, data and text segments (i.e. bdt), and/or for heap allocation. Mixed usage of huge and small pages is not supported for bdt, but is supported for heap allocation. When the -HP:bd option is specified, the text segment is not mapped to huge pages while the bss and data segments still get mapped to 2MB hugepages. The limit option specifies a combined limit on the number of hugepages that may be used by the compiled program. If no limit is set, the number of hugepages that can be used by the program is effectively limited by the system configuration.
-CG:local_sched_alg=(0|1|2|3): This option selects the basic block instruction scheduling algorithm.
To perform backward scheduling (i.e. where instructions are
scheduled from the bottom to the top of the basic block) select 0.
To perform forward scheduling select 1.
To schedule the instruction twice (i.e. once in the forward
direction and once in the backward direction) and take the
optimal of the two schedules select 2.
To perform forward or backward scheduling on per basic block basis, select 3.
The default value for this option is determined by the Open64 compiler
during compilation.
-CG:load_exe=N : The parameter N must be a non-negative integer which specifies the threshold for the compiler to consider folding a memory load operation directly into its subsequent use in an arithmetic instruction (thereby eliminating the memory load operation). If N=0 this folding optimization is not performed (in other words, the optimization is turned off). If the number of times the result of the memory load is used exceeds the value of N, then the folding optimization is not performed. For example, if N=1 this optimization is performed only when the result of the memory load has only one use. The default value of N varies with target processor and source language.
-GRA:unspill=(on|off|0|1)
Instructs the compiler's Global Register Allocator (GRA) to aggressively
remove redundant register spills that occur in the boundary region between
GRA and LRA (Local Register Allocator). The default is "-GRA:unspill=off".
Compiler will generate instructions and schedule them appropriately for the selected processor type. The default value, auto, means to optimize for the platform on which the compiler is running, as determined by reading /proc/cpuinfo. anyx86 means a generic 32-bit x86 processor without SSE2 support.
This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".
-LNO:simd=(0|1|2|3) : The compiler is instructed to use single instruction multiple data
(SIMD) instructions, supported by the target processor, when vectorizing
the inner loop. The flag can be set to:
0 The compiler is instructed to suppress vectorization.
1 The compiler is instructed to vectorize only if there is
no performance degradation due to sub-optimal alignment
and does not induce floating-point operation inaccuracies.
2 Instructs the compiler to aggressively vectorize with no
constraints in place.
3 Instructs the compiler to use advanced vectorization techniques such as
partial vectorization. This option enables the compiler to vectorize in
situations where all parts of a loop may not be vectorizable.
The default is "LNO:simd=1".
Instructs the compiler to generate an instrumented executable program from
the source code under development. The instrumented executable produces
feedback data files at runtime using an example dataset. filename specifies the
name of the feedback data file generated by the instrumented executable.
opencc -O2 -ipa -fb_create fbdata -o foo foo.c
"fbdata" will contain the instrumented feedback data from the instrumented
executable "foo". The default is "-fb_create" is disabled.
When feedback directed optimization (FDO) is used, an instrumented executable is used for a training run that produces information regarding execution paths and data values. Hardware performance counters are not used. This information is then provided to the optimizer during a second compilation pass to produce an optimized executable. FDO enables the optimizer to perform some optimizations which are not available without feedback data. The safety level of optimizations is unchanged with FDO, i.e. the safety level is the same as determined by the other (non-FDO) optimization flags specified on the compile and link lines.
Instructs the compiler to perform a feedback directed compilation using the
instrumented feedback data produced by the -fb_create option.
opencc -O2 -ipa -fb-opt fbdata -o foo foo.c
The new executable, foo, will be optimized to execute faster, and will not
include any instrumentation library calls. Note the same optimization flags
specified when creating the instrumented data file with the -fb_create must
be specified when invoking the compiler with the -fb_opt option. Otherwise,
the compiler will emit checksum errors. The default is "-fb_opt" disabled.
Uses a selection of optimizations in order to maximize performance.
Specifying "-Ofast" is equivalent to -O3 -ipa -OPT:Ofast -fno-math-errno -ffast-math.
These optimization options are generally safe. Floating-point accuracy may
be affected due to the transformation of the computational code. Note the
interprocedural analysis option, -ipa, specifies limitations on how libraries
and object files (.o files) are built.
This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".
-LNO:blocking=(on|off|0|1): Instructs the compiler to perform cache blocking transformation. The default is "-LNO:blocking=ON".
This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".
-LNO:prefetch=(0|1|2|3) : Instructs the compiler to perform prefetching optimizations at a
specified level. The flag can be set to:
0 Instructs the compiler to suppress prefetching.
1 The compiler is instructed to allow prefetching only for
arrays that are always referenced in every loop iteration.
2 The compiler is instructed to implement prefetching
disregarding the restrictions in the above setting.
3 The compiler is instructed to implement aggressive prefetching.
The default is "-LNO:prefetch=2".
This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".
-LNO:pf2=(on|off|0|1): The compiler is instructed to turn ON/OFF prefetching for specified cache levels. "pf2" specifies the level 2 cache.
This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".
-LNO:prefetch_ahead=N : The compiler is instructed to prefetch ahead N cache line(s). The default is "-LNO:prefetch_ahead=2".
Instructs the compiler to use 2MB hugepages for bss, data and text segments (i.e. bdt), and/or for heap allocation. Mixed usage of huge and small pages is not supported for bdt, but is supported for heap allocation. When the -HP:bd option is specified, the text segment is not mapped to huge pages while the bss and data segments still get mapped to 2MB hugepages. The limit option specifies a combined limit on the number of hugepages that may be used by the compiled program. If no limit is set, the number of hugepages that can be used by the program is effectively limited by the system configuration.
-CG:locs_shallow_depth=(on|off|0|1): ON instructs the compiler to give priority to instructions that have shallow depths in the dependence graph when performing local instruction scheduling to reduce register usage. The default is "-CG:locs_shallow_depth=OFF".
-CG:load_exe=N : The parameter N must be a non-negative integer which specifies the threshold for the compiler to consider folding a memory load operation directly into its subsequent use in an arithmetic instruction (thereby eliminating the memory load operation). If N=0 this folding optimization is not performed (in other words, the optimization is turned off). If the number of times the result of the memory load is used exceeds the value of N, then the folding optimization is not performed. For example, if N=1 this optimization is performed only when the result of the memory load has only one use. The default value of N varies with target processor and source language.
-CG:dsched=(on|off|0|1): Instructs the compiler to aggressively schedule operations to maximize throughput during the decode stage of family 15h processors. This flag implies 32-byte alignment by default unless -CG:p2align is set to a value other than 2. The default is "CG:dsched=OFF".
The compiler's scalar optimizer is instructed to take advantage of scaled-index addressing mode. For example if "-WOPT:sib" is set, strength reduction will be performed less aggressively. The default is "-WOPT:sib=OFF".
Compiler will generate instructions and schedule them appropriately for the selected processor type. The default value, auto, means to optimize for the platform on which the compiler is running, as determined by reading /proc/cpuinfo. anyx86 means a generic 32-bit x86 processor without SSE2 support.
Uses a selection of optimizations in order to maximize performance.
Specifying "-Ofast" is equivalent to -O3 -ipa -OPT:Ofast -fno-math-errno -ffast-math.
These optimization options are generally safe. Floating-point accuracy may
be affected due to the transformation of the computational code. Note the
interprocedural analysis option, -ipa, specifies limitations on how libraries
and object files (.o files) are built.
-OPT:unroll_size=N
Instructs the compiler to limit the number of instructions produced
when unrolling inner loops. When N=0 the ceiling is disregarded.
Note by specifying "-O3" sets "-OPT:unroll_size=128". The default
is "-OPT:unroll_size=40".
The "-OPT:" option group controls various optimizations. The "-OPT:" options supersede the defaults that are based on the main optimization level.
-OPT:alias=<model>
Identify which pointer aliasing model to use. The compiler will
make assumptions during compilation when one or more of the
following <model> is specified:
typed
Assumes that two pointers of different types will not
point to the same location in memory (i.e. the code
adheres to the ANSI/ISO C standards). Note when
specifying "-OPT:Ofast" turns this option ON.
(restricted|restrict)
Assumes that distinct pointers are pointing to distinct
non-overlapping objects. The default is that this optimization
is disabled.
disjoint
Assumes that any two pointer expressions are pointing
to distinct non-overlapping objects. This default is that this
optimization is disabled.
^M
field_sensitive
^M
Replaces the alias algorithm with an alternate
implementation that tracks fields of individual pointers,
i.e. it is field sensitive. This alternate implementation is
also designed to be flow-insensitive, scalable and
context-sensitive to heap allocations.
no_f90_pointer_alias
Assumes that any two different Fortran 90 pointers are
pointing to distinct non-overlapping objects. The default
is that this optimization is disabled.
Global register allocation (GRA) is the process of multiplexing a large number of target program variables onto a small number of CPU registers. The code generator implements global register allocation when certain optimization levels are specified.
-GRA:optimize_boundary=(on|off|0|1)
Instructs the compiler to permit the register allocator to assign the
same register to different variables in the same basic-block. The
default is "-GRA:optimize_boundary=OFF".
-CG:dsched=(on|off|0|1): Instructs the compiler to aggressively schedule operations to maximize throughput during the decode stage of family 15h processors. This flag implies 32-byte alignment by default unless -CG:p2align is set to a value other than 2. The default is "CG:dsched=OFF".
Instructs the compiler to use 2MB hugepages for bss, data and text segments (i.e. bdt), and/or for heap allocation. Mixed usage of huge and small pages is not supported for bdt, but is supported for heap allocation. When the -HP:bd option is specified, the text segment is not mapped to huge pages while the bss and data segments still get mapped to 2MB hugepages. The limit option specifies a combined limit on the number of hugepages that may be used by the compiled program. If no limit is set, the number of hugepages that can be used by the program is effectively limited by the system configuration.
Compiler will generate instructions and schedule them appropriately for the selected processor type. The default value, auto, means to optimize for the platform on which the compiler is running, as determined by reading /proc/cpuinfo. anyx86 means a generic 32-bit x86 processor without SSE2 support.
Uses a selection of optimizations in order to maximize performance.
Specifying "-Ofast" is equivalent to -O3 -ipa -OPT:Ofast -fno-math-errno -ffast-math.
These optimization options are generally safe. Floating-point accuracy may
be affected due to the transformation of the computational code. Note the
interprocedural analysis option, -ipa, specifies limitations on how libraries
and object files (.o files) are built.
This option group commands the compiler loop nest optimizer to perform nested loop analysis and transformations. Note an optimization level of "-O3" or higher must be specified in order to enable the "-LNO:" options. To verify the LNO options that were invoked during compilation use the option "-LIST:all_options=ON".
-LNO:blocking=(on|off|0|1): Instructs the compiler to perform cache blocking transformation. The default is "-LNO:blocking=ON".
Options in the -LANG: group can be used to control the set of features that are supported. For example, to compile code that does not conform with the standard in one way or another. Note it may not always be possible, however, to link together object files, some of which have been compiled with a feature enabled and others with it disabled.
-LANG:copyinout=(on|off)
If an array section is passed as an argument in a call, the compiler
is instructed to copy the array section into a temporary array that
will be passed as the argument in the call. -LANG:copyinout
optimizes the accessing of array arguments by improving argument
locality. Note the flag helps regulate the aggressiveness of this
optimization and is mainly suited to Fortran code. When specifying
global optimization -O2 or higher -LANG:copyinout=ON. The
default is "-LANG:copyinout=OFF".
The inter-procedural analyzer option group -IPA: controls application of inter-procedural analysis and optimization.
-IPA:callee_limit=N: The compiler is instructed not to allow inlining of functions with a code size larger the limit set by N. The default is "-IPA:callee_limit=500."
-GRA:prioritize_by_density=(on|off|0|1)
Instructs the compiler's Global Register Allocator (GRA) to prioritize
register assignments to variables based on the variables' reference count
density (number of times the variables are referenced in a local region of
interest) and not on their global reference count.
The default is "-GRA:prioritize_by_density=OFF".
Instructs the compiler to use 2MB hugepages for bss, data and text segments (i.e. bdt), and/or for heap allocation. Mixed usage of huge and small pages is not supported for bdt, but is supported for heap allocation. When the -HP:bd option is specified, the text segment is not mapped to huge pages while the bss and data segments still get mapped to 2MB hugepages. The limit option specifies a combined limit on the number of hugepages that may be used by the compiled program. If no limit is set, the number of hugepages that can be used by the program is effectively limited by the system configuration.
The compiler's scalar optimizer is instructed to take advantage of scaled-index addressing mode. For example if "-WOPT:sib" is set, strength reduction will be performed less aggressively. The default is "-WOPT:sib=OFF".
Compiler will generate instructions and schedule them appropriately for the selected processor type. The default value, auto, means to optimize for the platform on which the compiler is running, as determined by reading /proc/cpuinfo. anyx86 means a generic 32-bit x86 processor without SSE2 support.
This section contains descriptions of flags that were included implicitly by other flags, but which do not have a permanent home at SPEC.
Perform all the optimizations at the -O2 level as well as many more aggressive optimizations. Examples of such aggressive optimizations are loop nest optimizations and generation of prefetch instructions. Although these more aggressive optimizations can significantly speed up the run time execution of the compiled program, in rare cases they may not be profitable and may instead lead to a slow down. Also, some of these more aggressive optimizations may affect the accuracy of some floating point computations.
If multiple "O" options are used, with or without level numbers, the last such option is the one that is effective. Level 2 is assumed if no value is specified (i.e. "-O". The default is "-O2".
Perform extensive global optimizations. Examples of such optimizations are control flow optimizations, partial redundancy elimination, and strength reduction. These optimizations can very often reduce the execution time of the compiled program significantly, but they may do so at the expense of increased compilation time. This is the default level of optimization.
If multiple "O" options are used, with or without level numbers, the last such option is the one that is effective. Level 2 is assumed if no value is specified (i.e. "-O". The default is "-O2".
Perform minimal local optimizations on sections of straight-line code (basic blocks) only. Examples of such optimizations are instruction scheduling and some peephole optimizations. These optimizations do not usually have any noticeable impact on compilation time.
If multiple "O" options are used, with or without level numbers, the last such option is the one that is effective. Level 2 is assumed if no value is specified (i.e. "-O". The default is "-O2".
Instructs the compiler to invoke inter-procedural analysis. Specifying "-ipa" is equivalent to "-IPA" and "-IPA:" with no suboptions, thus the default settings for the individual IPA suboptions are used.
-OPT:Ofast
Maximizes performance for a given platform using the selected optimizations.
"-OPT:Ofast" specifies four optimizations; "-OPT:ro=2",
"-OPT:Olimit=0", "-OPT:div_split=ON", and "-OPT:alias=typed".
Note the specified optimizations are ordinarily safe but floating
point accuracy due to transformations may be diminished.
-OPT:roundoff,ro=(0|1|2|3)
"-OPT:roundoff" specifies acceptable levels of divergence for both
accuracy and overflow/underflow behavior of floating-point results
relative to the source language rules. The roundoff value is
in the range 0-3 with each value described as follows:
0 Do no transformations which could affect floating-point
results. The default for optimization levels "-O0", "-O1",
and "-O2".
1 Allow all transformations which have a limited affect
on floating-point results. For roundoff, limited is defined
as only the last bit or two of the mantissa is affected.
For overflow or underflow, limited is defined as
intermediate results of the transformed calculation may
overflow or underflow within a factor of two of where
the original expression may have overflowed or underflowed.
Note that effects may be less limited when
compounded by multiple transformations. This is the
default when "-O3" is specified.
2 Specifies transformations with extensive effects on
floating-point results. For example, allow associative
rearrangement (i.e. even across loop iterations) and the
distribution of multiplication over addition or
subtraction. Do not specify transformations known to
cause: a. cumulative roundoff errors, or b. overflow/underflow
of operands in a large range of valid floating-point values.
This is the default when specifying "-OPT:Ofast".
3 Specify any mathematically valid transformation of
floating-point expressions. For example, floating point
induction variables in loops are permitted (even if
known to cause cumulative roundoff errors). Also
permitted are fast algorithms for complex absolute
value and divide (which will overflow/underflow for
operands beyond the square root of the representable extremes).
-OPT:Olimit=N
Controls the size of procedures to be optimized. Procedures above
the specified cutoff limit, N, are not optimized. N=0 means
"infinite Olimit", which causes all procedures to be optimized
with no consideration regarding compilation times. Note if
"-OPT:Ofast" is enabled then "-OPT:Olimit=0" or when "-O3" is
enabled "-OPT:Olimit=9000". The default is "-OPT:Olimit=6000".
-OPT:div_split=(on|off|0|1)
Instruct the compiler to transform x/y into x*(recip(y)). Flags
-OPT:Ofast or -OPT:IEEE_arithmetic=3 will enable this optimization.
Note this transform generates fairly accurate code. The default
is "-OPT:div_split=OFF".
The "-OPT:" option group controls various optimizations. The "-OPT:" options supersede the defaults that are based on the main optimization level.
-OPT:alias=<model>
Identify which pointer aliasing model to use. The compiler will
make assumptions during compilation when one or more of the
following <model> is specified:
typed
Assumes that two pointers of different types will not
point to the same location in memory (i.e. the code
adheres to the ANSI/ISO C standards). Note when
specifying "-OPT:Ofast" turns this option ON.
(restricted|restrict)
Assumes that distinct pointers are pointing to distinct
non-overlapping objects. The default is that this optimization
is disabled.
disjoint
Assumes that any two pointer expressions are pointing
to distinct non-overlapping objects. This default is that this
optimization is disabled.
^M
field_sensitive
^M
Replaces the alias algorithm with an alternate
implementation that tracks fields of individual pointers,
i.e. it is field sensitive. This alternate implementation is
also designed to be flow-insensitive, scalable and
context-sensitive to heap allocations.
no_f90_pointer_alias
Assumes that any two different Fortran 90 pointers are
pointing to distinct non-overlapping objects. The default
is that this optimization is disabled.
Do not set ERRNO after calling math functions that are executed with a single instruction, e.g. sqrt. A program that relies on IEEE exceptions for math error handling may want to use this flag for speed while maintaining IEEE arithmetic compatibility. Note specifying "-Ofast" implies "-fno-math-errno". The default is "-fmath-errno".
"-fast-math" instructs the compiler to relax ANSI/ISO or IEEE
rules/specifications for math functions in order to optimize
floating-point computations to improve runtime.
"-fno-fast-math" instructs the compiler to conform to ANSI and
IEEE math rules. This option causes the preprocessor macro
__FAST_MATH__ to be defined.
Note:
"-Ofast" implies "-ffast-math".
"-ffast-math" sets options "-fno-math-errno" and "-OPT:IEEE_arithmetic=2".
"-fno-fast-math" sets options "-fmath-errno" and "-OPT:IEEE arithmetic=1".
Using numactl to bind processes and memory to cores
For multi-copy runs or single copy runs on systems with multiple sockets, it is advantageous to bind a process to a particular core. Otherwise, the OS may arbitrarily move your process from one core to another. This can effect performance. To help, SPEC allows the use of a "submit" command where users can specify a utility to use to bind processes. We have found the utility 'numactl' to be the best choice.
numactl runs processes with a specific NUMA scheduling or memory placement policy. The policy is set for a command and inherited by all of its children. The numactl flag "--physcpubind" specifies which core(s) to bind the process. "-l" instructs numactl to keep a process memory on the local node while "-m" specifies which node(s) to place a process memory. For full details on using numactl, please refer to your Linux documentation, 'man numactl'
Note that some versions of numactl, particularly the version found on SLES 10, we have found that the utility incorrectly interprets application arguments as it's own. For example, with the command "numactl --physcpubind=0 -l a.out -m a", numactl will interpret a.out's "-m" option as it's own "-m" option. To work around this problem, a user can put the command to be run in a shell script and then run the shell script using numactl. For example: "echo 'a.out -m a' > run.sh ; numactl --physcpubind=0 bash run.sh"
Linux Huge Page settings
In order to take full advantage of using x86 Open64's huge page runtime library, your system must be configured to use huge pages. It is safe to run binaries compiled with "-HP" on systems not configured to use huge pages, however, you will not benefit from the performance improvements huge pages offer. To configure your system for huge pages perform the following steps:
Note that further information about huge pages may be found in your Linux documentation file: /usr/src/linux/Documentation/vm/hugetlbpage.txt
HUGETLB_LIMIT
For the x86 Open64 compiler, the maximum number of huge pages an application is allowed to use can be set at run time via the environment variable HUGETLB_LIMIT. If not set, then the process may use all available huge pages when compiled with "-HP (or -HUGEPAGE)" or a maximum of n pages where the value of n is set via the compile time flag "-HP:limit=n".
ulimit -s <n>
Sets the stack size to n kbytes, or unlimited to allow the stack size to grow without limit.
ulimit -l <n>
Sets the maximum size of memory that may be locked into physical memory.
OMP_NUM_THREADS
Sets the maximum number of OpenMP parallel threads auto-parallelized (-apo) applications may use.
O64_OMP_AFFINITY_MAP
Specifies the thread-CPU relationship when the operating system's affinity mechanism is used to assign OpenMP threads to CPUs.
O64_OMP_SPIN_USER_LOCK
Specifies whether or not to use the user-level spin mechanism for OpenMP locks. If the variable is set to TRUE then user-level spin mechanisms are used. If the variable is set to FALSE then pthread mutexes are used. The default if the variable is not set is the same as FALSE.
powersave -f (on SuSE)
Makes the powersave daemon set the CPUs to the highest supported frequency.
/etc/init.d/cpuspeed stop (on Red Hat)
Disables the cpu frequency scaling program in order to set the CPUs to the highest supported frequency.
LD_LIBRARY_PATH
An environment variable set to include the x86 Open64 and SmartHeap libraries used during compilation of the binaries. This environment variable setting is not needed when building the binaries on the system under test.
kernel/randomize_va_space
This option can be used to select the type of process address space randomization that is used in the system, for architectures that support this feature. 0 - Turn the process address space randomization off. This is the default for architectures that do not support this feature anyways, and kernels that are booted with the "norandmaps" parameter. 1 - Make the addresses of mmap base, stack and VDSO page randomized. This, among other things, implies that shared libraries will be loaded to random addresses. Also for PIE-linked binaries, the location of code start is randomized. This is the default if the CONFIG_COMPAT_BRK option is enabled. 2 - Additionally enable heap randomization. This is the default if CONFIG_COMPAT_BRK is disabled.
O64_OMP_SPIN_COUNT
Specify the number of times the spin loops will spin at user-level before falling back to operating system schedule/reschedule mechanisms. The default value is 20000.
Flag description origin markings:
|
Indicates that the flag description came from the user flags file. |
|
Indicates that the flag description came from the suite-wide flags file. |
|
Indicates that the flag description came from a per-benchmark flags file. |
For questions about the meanings of these flags, please contact the tester.
For other inquiries, please contact webmaster@spec.org
Copyright 2006-2014 Standard Performance Evaluation Corporation
Tested with SPEC CPU2006 v1.2.
Report generated on Thu Jul 24 14:19:37 2014 by SPEC CPU2006 flags formatter v6906.