This result has been formatted using multiple flags files. The "default header section" from each of them appears next.
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 C compiler.
Also used to invoke linker for C programs.
Invoke the Open64 C++ compiler.
Also used to invoke linker for C++ programs.
This macro specifies that the target system uses the LP64 data model; specifically, that integers are 32 bits, while longs and pointers are 64 bits.
This macro indicates that the benchmark is being compiled on an AMD64-compatible system running the Linux operating system.
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.
Portability changes for Linux
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 flag can be set for SPEC compilation for Linux using default compiler.
This macro specifies that the target system uses the LP64 data model; specifically, that integers are 32 bits, while longs and pointers are 64 bits.
This macro indicates that the benchmark is being compiled on an AMD64-compatible system running the Linux operating system.
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.
Portability changes for Linux
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 flag can be set for SPEC compilation for Linux using default compiler.
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 automatically transform sequential code into parallel code. The compiler will only transform blocks of code that will demonstrate a speed-up to the runtime (i.e. execute faster) on a multiprocessor target.
The default number of threads used at run-time is either the number of processors in the machine or is determined by the value of the OMP_NUM_THREADS environment variable.
-CG:local_sched_alg=(0|1|2): 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.
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. 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.
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:parallel_overhead=N : Specifying the auto-parallelizing option, "-apo", instructs the compiler to generate a serial and parallel instance of a loop. Specifying -LNO:parallel_overhead. in conjunction with "-apo" instructs the compiler to estimate the overhead involved when invoking the parallel instance of the loop taking into account the number of processors and loop iterations. The loop nest optimizer then uses N to determine if the overhead exceeds the performance benefit during execution time. Note using this flag with auto-parallelizer can be used to tune parallel performance across various platforms and programs. The default is "-LNO:parallel_overhead=4096"
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.
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.
-INLINE:aggressive=(on|off|0|1): Instructs the compiler to be very aggressive when performing inlining. The default is "-INLINE:aggressive=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".
-L<library directory> -lsmartheap ,
when used as an EXTRA_CXXLIB variable,
results in linking with MicroQuill's SmartHeap 8 (32-bit) library
for Linux. This is a library that optimizes calls to new, delete, malloc and free.
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.
-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: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"
-OPT:unroll_times_max=N
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".
-OPT:keep_ext=(on|off|0|1)
Instructs the compiler
to preserve external symbolic information. The default is "-OPT:keep_ext=OFF".
-WOPT:if_conv=(0|1|2):
"-WOPT:if_conv" instructs the compiler to transform simple IF
statements to conditional move instructions. "-WOPT:if_conv" has
three settings:
0 Disables this optimization.
1 Specifies conservative IF statement transformations.
The context surrounding the IF statement is used in
the transformation decision.
2 Use aggressive IF statement transformations. Perform
the IF statement transformation regardless of the surrounding
context.
The default is "-WOPT:if_conv=1".
-CG:local_sched_alg=(0|1|2): 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.
The default value for this option is determined by the Open64 compiler
during compilation.
-CG:unroll_fb_req=(on|off|0|1): The compiler is instructed to override cold code motion to keep the code generator from adding control flow in unrolled loops. The default is "-CG:unroll_fb_req=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. 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.
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".
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.
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.
-OPT:goto=(on|off|0|1)
Transforms GOTO into higher level structures e.g., FOR loops. Note if
"-O2" is specified "-OPT:goto=ON". The default is "-OPT:goto=OFF".
-CG:local_sched_alg=(0|1|2): 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.
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. 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.
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:trip_count,trip_count_assumed_when_unknown=N : The compiler is instructed to use the value in N for a presumed loop trip-count if at compile time a loop trip-count is not known. The loop trip-count, N, is used for loop transformations and prefetch optimizations and must be a positive integer. The default is "-LNO:trip_count_assumed_when_unknown,trip_count=1000".
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".
-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".
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 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. 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".
-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.
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".
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.
-INLINE:aggressive=(on|off|0|1): Instructs the compiler to be very aggressive when performing inlining. The default is "-INLINE:aggressive=OFF".
-CG:gcm=(on|off|0|1): "-CG:gcm=OFF" instructs the compiler to disable the instruction level global code motion optimization phase. The default is "-CG:gcm=ON".
-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".
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 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. 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.
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".
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.
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.
-OPT:unroll_times_max=N
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".
-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 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.
-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:min_hotness=N: The compiler is instructed not to inline a function to a call site (i.e. caller) unless the callee is invoked more than N times. The compiler examines the interprocedural feedback to determine if the threshold set by N is surpassed by a call site to a procedure and then proceeds to inline the procedure if the limit is exceeded. The default is "-IPA:min_hotness=10".
-IPA:pu_reorder=(0|1|2): The compiler is instructed to examine compilation feedback for invocation patterns to determine the process of reordering the layout of program procedures in order to minimize instruction cache misses. Possible settings are:
0 Suppress reordering of program procedures.
1 Use the frequent occurrence of procedure invocation to determine reordering.
2 Use the relationship between caller and callee to determine reordering.
The default is "-IPA:pu_reorder=1" for C++ programs and "-IPA:pu_reorder=0" for non-C++ programs.
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: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: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:unroll_fb_req=(on|off|0|1): The compiler is instructed to override cold code motion to keep the code generator from adding control flow in unrolled loops. The default is "-CG:unroll_fb_req=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. 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.
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: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".
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.
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.
-OPT:unroll_times_max=N
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".
-OPT:keep_ext=(on|off|0|1)
Instructs the compiler
to preserve external symbolic information. The default is "-OPT:keep_ext=OFF".
-CG:local_sched_alg=(0|1|2): 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.
The default value for this option is determined by the Open64 compiler
during compilation.
The Code Generation option group -CG: controls the optimizations and transformations of the instruction-level code generator.
-CG:cflow=(on|off|0|1): Specifying OFF disables control flow optimization in code generation. The default is ON.
-CG:push_pop_int_saved_regs=(on|off|0|1): When ON, the compiler generates push and pop instructions to save integer callee-saved registers at function prologues and epilogues. The push and pop instructions replace mov instructions to and from memory locations based off the stack pointer. The default is "-CG:push_pop_int_saved_regs=OFF". When the specified target is barcelona, default is "-CG:push_pop_int_saved_regs=ON".
-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".
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. 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.
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".
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.
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".
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".
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".
-IPA:pu_reorder=(0|1|2): The compiler is instructed to examine compilation feedback for invocation patterns to determine the process of reordering the layout of program procedures in order to minimize instruction cache misses. Possible settings are:
0 Suppress reordering of program procedures.
1 Use the frequent occurrence of procedure invocation to determine reordering.
2 Use the relationship between caller and callee to determine reordering.
The default is "-IPA:pu_reorder=1" for C++ programs and "-IPA:pu_reorder=0" for non-C++ programs.
-IPA:min_hotness=N: The compiler is instructed not to inline a function to a call site (i.e. caller) unless the callee is invoked more than N times. The compiler examines the interprocedural feedback to determine if the threshold set by N is surpassed by a call site to a procedure and then proceeds to inline the procedure if the limit is exceeded. The default is "-IPA:min_hotness=10".
-CG:ptr_load_use=N: The code generator increases the modeled latency between an instruction that loads a pointer and an instruction that uses the pointer by N cycles. Ordinarily, it is advantageous to load pointers as fast as possible so the dependent memory instructions can begin execution. However, the additional latency will force the instruction scheduler to schedule the load pointer even earlier. Note the load pointer instructions include load-execute instructions which compute pointer results. The default is "-CG:ptr_load_use=4".
-OPT:unroll_times_max=N
Instructs the compiler to limit the unrolling of inner loops to the
value specified by N. The default is "-OPT:unroll_times_max=4".
-INLINE:aggressive=(on|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. 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.
Instructs the compiler to automatically transform sequential code into parallel code. The compiler will only transform blocks of code that will demonstrate a speed-up to the runtime (i.e. execute faster) on a multiprocessor target.
The default number of threads used at run-time is either the number of processors in the machine or is determined by the value of the OMP_NUM_THREADS environment variable.
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.
-CG:gcm=(on|off|0|1): "-CG:gcm=OFF" instructs the compiler to disable the instruction level global code motion optimization phase. The default is "-CG:gcm=ON".
-CG:use_prefetchnta=(on|off|0|1): When enabled, prefetching is performed on non-temporal data at all levels of the cache hierarchy. Note this option is for data streaming situations when the data will not need to be reused soon. The default is "-CG:use_prefetchnta=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".
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".
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.
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.
-INLINE:aggressive=(on|off|0|1): Instructs the compiler to be very aggressive when performing inlining. The default is "-INLINE:aggressive=OFF".
-IPA:space=N: The compiler is instructed to perform inlining until the program code size expands by percentage specified by N. Therefore, to limit program code size growth to ~20%, due to inlining, specify "-IPA:space=20". The default is "-IPA:space=infinity".
-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 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.
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".
-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 "-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.
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: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".
-CG:ptr_load_use=N: The code generator increases the modeled latency between an instruction that loads a pointer and an instruction that uses the pointer by N cycles. Ordinarily, it is advantageous to load pointers as fast as possible so the dependent memory instructions can begin execution. However, the additional latency will force the instruction scheduler to schedule the load pointer even earlier. Note the load pointer instructions include load-execute instructions which compute pointer results. The default is "-CG:ptr_load_use=4".
-CG:push_pop_int_saved_regs=(on|off|0|1): When ON, the compiler generates push and pop instructions to save integer callee-saved registers at function prologues and epilogues. The push and pop instructions replace mov instructions to and from memory locations based off the stack pointer. The default is "-CG:push_pop_int_saved_regs=OFF". When the specified target is barcelona, default is "-CG:push_pop_int_saved_regs=ON".
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. 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.
-CG:gcm=(on|off|0|1): "-CG:gcm=OFF" instructs the compiler to disable the instruction level global code motion optimization phase. The default is "-CG:gcm=ON".
-INLINE:aggressive=(on|off|0|1): Instructs the compiler to be very aggressive when performing inlining. The default is "-INLINE:aggressive=OFF".
-WOPT:if_conv=(0|1|2):
"-WOPT:if_conv" instructs the compiler to transform simple IF
statements to conditional move instructions. "-WOPT:if_conv" has
three settings:
0 Disables this optimization.
1 Specifies conservative IF statement transformations.
The context surrounding the IF statement is used in
the transformation decision.
2 Use aggressive IF statement transformations. Perform
the IF statement transformation regardless of the surrounding
context.
The default is "-WOPT:if_conv=1".
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 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. 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.
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.
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.
-WOPT:if_conv=(0|1|2):
"-WOPT:if_conv" instructs the compiler to transform simple IF
statements to conditional move instructions. "-WOPT:if_conv" has
three settings:
0 Disables this optimization.
1 Specifies conservative IF statement transformations.
The context surrounding the IF statement is used in
the transformation decision.
2 Use aggressive IF statement transformations. Perform
the IF statement transformation regardless of the surrounding
context.
The default is "-WOPT:if_conv=1".
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".
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.
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.
-INLINE:aggressive=(on|off|0|1): Instructs the compiler to be very aggressive when performing inlining. The default is "-INLINE:aggressive=OFF".
-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".
-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".
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 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. 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.
-INLINE:aggressive=(on|off|0|1): Instructs the compiler to be very aggressive when performing inlining. The default is "-INLINE:aggressive=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.
-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".
-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".
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.
(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.
-L<library directory> -lsmartheap ,
when used as an EXTRA_CXXLIB variable,
results in linking with MicroQuill's SmartHeap 8 (32-bit) library
for Linux. This is a library that optimizes calls to new, delete, malloc and free.
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.
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".
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".
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"
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.
Flag description origin markings:
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.1.
Report generated on Wed Jul 23 15:21:40 2014 by SPEC CPU2006 flags formatter v6906.