This result has been formatted using multiple flags files. The "default header section" from each of them appears next.
![[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.
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.
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 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.
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.
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.
-mso <path>
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 band-
width, shared L3 cache, etc.
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. 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.
-mso <path>
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 band-
width, shared L3 cache, etc.
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.
-INLINE:aggressive=(on|off|0|1): Instructs the compiler to be very aggressive when performing inlining. The default is "-INLINE:aggressive=OFF".
-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. 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.
-mso <path>
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 band-
width, shared L3 cache, etc.
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 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.
-mso <path>
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 band-
width, shared L3 cache, etc.
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. 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 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.
-mso <path>
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 band-
width, shared L3 cache, etc.
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.
-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: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".
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: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".
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.
-mso <path>
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 band-
width, shared L3 cache, etc.
-fb_create <path>
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.
-fb_opt <prefix for feedback data files>
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: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:sse_cse_regs=N : When performing common subexpression elimination, instructs the compiler code generator that there are N extra SSE registers available (i.e. in excess of the number provided by the processor). N can be positive, negative, or zero. The default is positive infinity. See also -CG:cse_regs=N.
-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:cmp_peep=(on|off|0|1): Instructs the compiler to perform aggressive load execution peeps on compare operations. Note for 32-bit environments the default is "-CG:cmp_peep=ON". The default is "CG:cmp_peep=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.
-INLINE:aggressive=(on|off|0|1): Instructs the compiler to be very aggressive when performing inlining. The default is "-INLINE:aggressive=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.
-mso <path>
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 band-
width, shared L3 cache, etc.
-fb_create <path>
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.
-fb_opt <prefix for feedback data files>
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: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): 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: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:compute_to=(on|off|0|1): Instructs the compiler to allow local code motion to take advantage of pipeline optimizations. For example: specify in conjunction with option "-march=barcelona", i.e.when targeting versions of the Quad-Core AMD Opteron and greater. The default is "CG:compute_to=OFF"
-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. 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.
-mso <path>
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 band-
width, shared L3 cache, etc.
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.
-INLINE:aggressive=(on|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"
(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.
-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".
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".
-CG:cmp_peep=(on|off|0|1): Instructs the compiler to perform aggressive load execution peeps on compare operations. Note for 32-bit environments the default is "-CG:cmp_peep=ON". The default is "CG:cmp_peep=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.
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.
-mso <path>
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 band-
width, shared L3 cache, etc.
-fb_create <path>
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.
-fb_opt <prefix for feedback data files>
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".
-INLINE:aggressive=(on|off|0|1): Instructs the compiler to be very aggressive when performing inlining. The default is "-INLINE:aggressive=OFF".
-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".
-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: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.
(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.
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.
-mso <path>
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 band-
width, shared L3 cache, etc.
-fb_create <path>
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.
-fb_opt <prefix for feedback data files>
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.
-INLINE:aggressive=(on|off|0|1): Instructs the compiler to be very aggressive when performing inlining. The default is "-INLINE:aggressive=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.
-mso <path>
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 band-
width, shared L3 cache, etc.
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".
-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:prefetch_ahead=N : The compiler is instructed to prefetch ahead N cache line(s). The default is "-LNO:prefetch_ahead=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".
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. 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 load execution peeps on compare operations. Note for 32-bit environments the default is "-CG:cmp_peep=ON". 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.
-mso <path>
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 band-
width, shared L3 cache, etc.
-fb_create <path>
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.
-fb_opt <prefix for feedback data files>
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: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: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".
-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: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. 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.
-mso <path>
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 band-
width, shared L3 cache, etc.
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".
-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".
-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".
-CG:cmp_peep=(on|off|0|1): Instructs the compiler to perform aggressive load execution peeps on compare operations. Note for 32-bit environments the default is "-CG:cmp_peep=ON". The default is "CG:cmp_peep=OFF".
-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. 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.
-mso <path>
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 band-
width, shared L3 cache, etc.
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 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.
-mso <path>
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 band-
width, shared L3 cache, etc.
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: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".
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: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): 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.
-mso <path>
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 band-
width, shared L3 cache, etc.
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.
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: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.
-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. 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.
-mso <path>
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 band-
width, shared L3 cache, etc.
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. 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.
-mso <path>
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 band-
width, shared L3 cache, etc.
-fb_create <path>
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.
-fb_opt <prefix for feedback data files>
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.
-apo <path>
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: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. 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.
-LANG:heap_allocation_threshold=N
Specifies the threshold when determining whether to allocate an automatic
array or compiler temporary on the heap rather than on
the stack. Parameter size is in bytes and sets the threshold. Setting
size to -1 implies all objects are placed on the stack. Setting
size to 0 implies all objects are placed on the heap. The default
is "-LANG:heap_allocation_threshold=-1" for maximum performance.
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.
-mso <path>
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 band-
width, shared L3 cache, etc.
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: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: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: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:compute_to=(on|off|0|1): Instructs the compiler to allow local code motion to take advantage of pipeline optimizations. For example: specify in conjunction with option "-march=barcelona", i.e.when targeting versions of the Quad-Core AMD Opteron and greater. The default is "CG:compute_to=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_ahead=N : The compiler is instructed to prefetch ahead N cache line(s). The default is "-LNO:prefetch_ahead=2".
-WOPT:unroll=(0|1|2) : Specifying "WOPT:unroll" helps regulate the compiler's scalar optimizer
when unrolling of innermost loops. The available settings
are:
0 Innermost loop unrolling is suppressed.
1 Instructs the compilers scalar optimizer to unroll the
innermost loops which contain IF statements. Selecting
this setting compliments the loop unrolling performed
in the code generator.
2 Instructs the compiler's scalar optimized to unroll the
innermost loops which contain straight line code plus
the loops containing IF statements. Selecting this setting
duplicates the unrolling performed in the code generator
(i.e. unrolling straight line code in the body of
a loop).
Note "-WOPT:unroll" and the unrolling options in the "-OPT" group
are mutually exclusive. The default is "-WOPT:unroll=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".
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.
-mso <path>
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 band-
width, shared L3 cache, etc.
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_ahead=N : The compiler is instructed to prefetch ahead N cache line(s). The default is "-LNO:prefetch_ahead=2".
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".
Enables the use of 3DNow instructions.
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 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.
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.
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:
|
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.1.
Report generated on Wed Jul 23 08:48:55 2014 by SPEC CPU2006 flags formatter v6906.