Base Compiler Invocation
C benchmarks
-
- gcc
![[user]](https://www.spec.org/auto/cpu2017/images/user.png)
- CC, LD
-
Invokes the GNU C compiler.
C++ benchmarks
-
- g++
- CXX, LD
-
Invokes the GNU C++ compiler.
Fortran benchmarks
-
- gfortran
- FC, LD
-
Invokes the GNU Fortran compiler.
Note: The GNU Compiler Collection provides a wide array of compiler options, described in detail and readily available at https://gcc.gnu.org/onlinedocs/gcc/Option-Index.html#Option-Index and https://gcc.gnu.org/onlinedocs/gfortran/. This SPEC CPU flags file contains excerpts from and brief summaries of portions of that documentation.
SPEC's modifications are:
Copyright (C) 2006-2020 Standard Performance Evaluation Corporation
Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with the Invariant Sections being "Funding Free Software", the Front-Cover Texts being (a) (see below), and with the Back-Cover Texts being (b) (see below). A copy of the license is included in your SPEC CPU kit at $SPEC/Docs/licenses/FDL.v1.3.txt and on the web at https://www.spec.org/cpu2017/Docs/licenses/FDL.v1.3.txt. A copy of "Funding Free Software" is on your SPEC CPU kit at $SPEC/Docs/licenses/FundingFreeSW.txt and on the web at https://www.spec.org/cpu2017/Docs/licenses/FundingFreeSW.txt.
(a) The FSF's Front-Cover Text is:
A GNU Manual
(b) The FSF's Back-Cover Text is:
You have freedom to copy and modify this GNU Manual, like GNU software. Copies published by the Free Software Foundation raise funds for GNU development.
Invokes the GNU C compiler.
Invokes the GNU C++ compiler.
Invokes the GNU Fortran compiler.
Invokes the GNU C compiler.
Invokes the GNU C++ compiler.
Invokes the GNU Fortran compiler.
![[suite]](https://www.spec.org/auto/cpu2017/images/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.
![[benchmark]](https://www.spec.org/auto/cpu2017/images/benchmark.png)
This macro indicates that Fortran functions called from C should have their names lower-cased.
Use big-endian representation for unformatted files. This is important when reading 521.wrf_r, 621.wrf_s, and 628.pop2_s data files that were originally generated in big-endian format.
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.
Let the type "char" be unsigned, like "unsigned char".
Note: this particular portability flag is included for 526.blender_r per the recommendation in its documentation - see https://www.spec.org/cpu2017/Docs/benchmarks/526.blender_r.html.
Linux portability
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.
Fortran to C symbol naming. C symbol names are lower case with one underscore. _symbol
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.
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 Fortran functions called from C should have their names lower-cased.
Use big-endian representation for unformatted files. This is important when reading 521.wrf_r, 621.wrf_s, and 628.pop2_s data files that were originally generated in big-endian format.
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.
Let the type "char" be unsigned, like "unsigned char".
Note: this particular portability flag is included for 526.blender_r per the recommendation in its documentation - see https://www.spec.org/cpu2017/Docs/benchmarks/526.blender_r.html.
Linux portability
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.
Fortran to C symbol naming. C symbol names are lower case with one underscore. _symbol
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.
Generate code for lp64. With ilp32, int, long int and pointer are 32-bit; with lp64, int is 32-bit, but long int and pointer are 64-bit.
Sets the language dialect to include syntax from the C99 standard, such as bool and other features used in CPU 2017 benchmarks.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Produce debugging information.
Disregard strict standards compliance. -Ofast enables all -O3 optimizations. It also enables optimizations that are not valid for all standard-compliant programs. It turns on -ffast-math, -fallow-store-data-races (as of GCC 10), and the Fortran-specific -fstack-arrays unless -fmax-stack-var-size is specified, and -fno-protect-parens.
On aarch64 systems, mcpu sets the what kind of instructions can be used (as if by -march) and how to
tune for performance (as if by -mtune).
On x86 systems, mcpu is a deprecated synonym for mtune.
On SPARC systems, mcpu sets the available instruction set.
Enable Link Time Optimization When invoked with source code, it generates GIMPLE (one of GCC's internal representations) and writes it to special ELF sections in the object file. When the object files are linked together, all the function bodies are read from these ELF sections and instantiated as if they had been part of the same translation unit.
The language standards set aliasing requirements: programmers are expected to follow conventions so that the compiler can keep track of memory. If a program violates the requirements (for example, using pointer arithmetic), programs may crash, or (worse) wrong answers may be silently produced.
Unfortunately, the aliasing requirements from the standards are not always well understood.
Sometimes, the aliasing requirements are understood and nevertheless intentionally violated by smart programmers who know what they are doing, such as the programmer responsible for the inner workings of Perl storage allocation and variable handling.
The -fno-strict-aliasing switch instructs the optimizer that it must not assume that the aliasing requirements from the standard are met by the current program. You will probably need it for 500.perlbench_r and 600.perlbench_s. Note that this is an optimization switch, not a portability switch. When running SPECint2017_rate_base or SPECint2017_speed_base, you must use the same optimization switches for all the C modules in base; see https://www.spec.org/cpu2017/Docs/runrules.html#BaseFlags and https://www.spec.org/cpu2017/Docs/runrules.html#MustValidate.
Link with libjemalloc, a fast, arena-based memory allocator.
Generate code for lp64. With ilp32, int, long int and pointer are 32-bit; with lp64, int is 32-bit, but long int and pointer are 64-bit.
Sets the language dialect to include syntax from the 1998 ISO C++ standard plus the 2003 technical corrigendum.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Produce debugging information.
Disregard strict standards compliance. -Ofast enables all -O3 optimizations. It also enables optimizations that are not valid for all standard-compliant programs. It turns on -ffast-math, -fallow-store-data-races (as of GCC 10), and the Fortran-specific -fstack-arrays unless -fmax-stack-var-size is specified, and -fno-protect-parens.
On aarch64 systems, mcpu sets the what kind of instructions can be used (as if by -march) and how to
tune for performance (as if by -mtune).
On x86 systems, mcpu is a deprecated synonym for mtune.
On SPARC systems, mcpu sets the available instruction set.
Enable Link Time Optimization When invoked with source code, it generates GIMPLE (one of GCC's internal representations) and writes it to special ELF sections in the object file. When the object files are linked together, all the function bodies are read from these ELF sections and instantiated as if they had been part of the same translation unit.
Link with libjemalloc, a fast, arena-based memory allocator.
Generate code for lp64. With ilp32, int, long int and pointer are 32-bit; with lp64, int is 32-bit, but long int and pointer are 64-bit.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Produce debugging information.
Disregard strict standards compliance. -Ofast enables all -O3 optimizations. It also enables optimizations that are not valid for all standard-compliant programs. It turns on -ffast-math, -fallow-store-data-races (as of GCC 10), and the Fortran-specific -fstack-arrays unless -fmax-stack-var-size is specified, and -fno-protect-parens.
On aarch64 systems, mcpu sets the what kind of instructions can be used (as if by -march) and how to
tune for performance (as if by -mtune).
On x86 systems, mcpu is a deprecated synonym for mtune.
On SPARC systems, mcpu sets the available instruction set.
Enable Link Time Optimization When invoked with source code, it generates GIMPLE (one of GCC's internal representations) and writes it to special ELF sections in the object file. When the object files are linked together, all the function bodies are read from these ELF sections and instantiated as if they had been part of the same translation unit.
Enabled: Put all local arrays, even those of unknown size onto stack memory.
The -fno- form disables the behavior.
Link with libjemalloc, a fast, arena-based memory allocator.
Generate code for lp64. With ilp32, int, long int and pointer are 32-bit; with lp64, int is 32-bit, but long int and pointer are 64-bit.
Sets the language dialect to include syntax from the C99 standard, such as bool and other features used in CPU 2017 benchmarks.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Produce debugging information.
Disregard strict standards compliance. -Ofast enables all -O3 optimizations. It also enables optimizations that are not valid for all standard-compliant programs. It turns on -ffast-math, -fallow-store-data-races (as of GCC 10), and the Fortran-specific -fstack-arrays unless -fmax-stack-var-size is specified, and -fno-protect-parens.
On aarch64 systems, mcpu sets the what kind of instructions can be used (as if by -march) and how to
tune for performance (as if by -mtune).
On x86 systems, mcpu is a deprecated synonym for mtune.
On SPARC systems, mcpu sets the available instruction set.
Enable Link Time Optimization When invoked with source code, it generates GIMPLE (one of GCC's internal representations) and writes it to special ELF sections in the object file. When the object files are linked together, all the function bodies are read from these ELF sections and instantiated as if they had been part of the same translation unit.
Enabled: Put all local arrays, even those of unknown size onto stack memory.
The -fno- form disables the behavior.
The language standards set aliasing requirements: programmers are expected to follow conventions so that the compiler can keep track of memory. If a program violates the requirements (for example, using pointer arithmetic), programs may crash, or (worse) wrong answers may be silently produced.
Unfortunately, the aliasing requirements from the standards are not always well understood.
Sometimes, the aliasing requirements are understood and nevertheless intentionally violated by smart programmers who know what they are doing, such as the programmer responsible for the inner workings of Perl storage allocation and variable handling.
The -fno-strict-aliasing switch instructs the optimizer that it must not assume that the aliasing requirements from the standard are met by the current program. You will probably need it for 500.perlbench_r and 600.perlbench_s. Note that this is an optimization switch, not a portability switch. When running SPECint2017_rate_base or SPECint2017_speed_base, you must use the same optimization switches for all the C modules in base; see https://www.spec.org/cpu2017/Docs/runrules.html#BaseFlags and https://www.spec.org/cpu2017/Docs/runrules.html#MustValidate.
Link with libjemalloc, a fast, arena-based memory allocator.
Generate code for lp64. With ilp32, int, long int and pointer are 32-bit; with lp64, int is 32-bit, but long int and pointer are 64-bit.
Sets the language dialect to include syntax from the 1998 ISO C++ standard plus the 2003 technical corrigendum.
Sets the language dialect to include syntax from the C99 standard, such as bool and other features used in CPU 2017 benchmarks.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Produce debugging information.
Disregard strict standards compliance. -Ofast enables all -O3 optimizations. It also enables optimizations that are not valid for all standard-compliant programs. It turns on -ffast-math, -fallow-store-data-races (as of GCC 10), and the Fortran-specific -fstack-arrays unless -fmax-stack-var-size is specified, and -fno-protect-parens.
On aarch64 systems, mcpu sets the what kind of instructions can be used (as if by -march) and how to
tune for performance (as if by -mtune).
On x86 systems, mcpu is a deprecated synonym for mtune.
On SPARC systems, mcpu sets the available instruction set.
Enable Link Time Optimization When invoked with source code, it generates GIMPLE (one of GCC's internal representations) and writes it to special ELF sections in the object file. When the object files are linked together, all the function bodies are read from these ELF sections and instantiated as if they had been part of the same translation unit.
The language standards set aliasing requirements: programmers are expected to follow conventions so that the compiler can keep track of memory. If a program violates the requirements (for example, using pointer arithmetic), programs may crash, or (worse) wrong answers may be silently produced.
Unfortunately, the aliasing requirements from the standards are not always well understood.
Sometimes, the aliasing requirements are understood and nevertheless intentionally violated by smart programmers who know what they are doing, such as the programmer responsible for the inner workings of Perl storage allocation and variable handling.
The -fno-strict-aliasing switch instructs the optimizer that it must not assume that the aliasing requirements from the standard are met by the current program. You will probably need it for 500.perlbench_r and 600.perlbench_s. Note that this is an optimization switch, not a portability switch. When running SPECint2017_rate_base or SPECint2017_speed_base, you must use the same optimization switches for all the C modules in base; see https://www.spec.org/cpu2017/Docs/runrules.html#BaseFlags and https://www.spec.org/cpu2017/Docs/runrules.html#MustValidate.
Link with libjemalloc, a fast, arena-based memory allocator.
Generate code for lp64. With ilp32, int, long int and pointer are 32-bit; with lp64, int is 32-bit, but long int and pointer are 64-bit.
Sets the language dialect to include syntax from the 1998 ISO C++ standard plus the 2003 technical corrigendum.
Sets the language dialect to include syntax from the C99 standard, such as bool and other features used in CPU 2017 benchmarks.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Produce debugging information.
Disregard strict standards compliance. -Ofast enables all -O3 optimizations. It also enables optimizations that are not valid for all standard-compliant programs. It turns on -ffast-math, -fallow-store-data-races (as of GCC 10), and the Fortran-specific -fstack-arrays unless -fmax-stack-var-size is specified, and -fno-protect-parens.
On aarch64 systems, mcpu sets the what kind of instructions can be used (as if by -march) and how to
tune for performance (as if by -mtune).
On x86 systems, mcpu is a deprecated synonym for mtune.
On SPARC systems, mcpu sets the available instruction set.
Enable Link Time Optimization When invoked with source code, it generates GIMPLE (one of GCC's internal representations) and writes it to special ELF sections in the object file. When the object files are linked together, all the function bodies are read from these ELF sections and instantiated as if they had been part of the same translation unit.
Enabled: Put all local arrays, even those of unknown size onto stack memory.
The -fno- form disables the behavior.
The language standards set aliasing requirements: programmers are expected to follow conventions so that the compiler can keep track of memory. If a program violates the requirements (for example, using pointer arithmetic), programs may crash, or (worse) wrong answers may be silently produced.
Unfortunately, the aliasing requirements from the standards are not always well understood.
Sometimes, the aliasing requirements are understood and nevertheless intentionally violated by smart programmers who know what they are doing, such as the programmer responsible for the inner workings of Perl storage allocation and variable handling.
The -fno-strict-aliasing switch instructs the optimizer that it must not assume that the aliasing requirements from the standard are met by the current program. You will probably need it for 500.perlbench_r and 600.perlbench_s. Note that this is an optimization switch, not a portability switch. When running SPECint2017_rate_base or SPECint2017_speed_base, you must use the same optimization switches for all the C modules in base; see https://www.spec.org/cpu2017/Docs/runrules.html#BaseFlags and https://www.spec.org/cpu2017/Docs/runrules.html#MustValidate.
Link with libjemalloc, a fast, arena-based memory allocator.
Generate code for lp64. With ilp32, int, long int and pointer are 32-bit; with lp64, int is 32-bit, but long int and pointer are 64-bit.
Sets the language dialect to include syntax from the C99 standard, such as bool and other features used in CPU 2017 benchmarks.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Instruments code to collect information for profile-driven feedback. Information is collected regarding both code paths and data values.
Applies information from a profile run in order to improve optimization. Several optimizations are improved when profile data is available, including branch probabilities, loop peeling, and loop unrolling.
Produce debugging information.
Disregard strict standards compliance. -Ofast enables all -O3 optimizations. It also enables optimizations that are not valid for all standard-compliant programs. It turns on -ffast-math, -fallow-store-data-races (as of GCC 10), and the Fortran-specific -fstack-arrays unless -fmax-stack-var-size is specified, and -fno-protect-parens.
On aarch64 systems, mcpu sets the what kind of instructions can be used (as if by -march) and how to
tune for performance (as if by -mtune).
On x86 systems, mcpu is a deprecated synonym for mtune.
On SPARC systems, mcpu sets the available instruction set.
Tells the optimizer to unroll loops whose number of iterations can be determined at compile time or upon entry to the loop.
Enable Link Time Optimization When invoked with source code, it generates GIMPLE (one of GCC's internal representations) and writes it to special ELF sections in the object file. When the object files are linked together, all the function bodies are read from these ELF sections and instantiated as if they had been part of the same translation unit.
Specify growth that the early inliner can make. In effect it increases the amount of inlining for code having a large abstraction penalty.
When you use -finline-functions (included in -O3), a lot of functions that would otherwise not be considered for inlining by the compiler are investigated. To those functions, a different (more restrictive) limit compared to functions declared inline can be applied.
Specifies maximal overall growth of the compilation unit caused by inlining. For example, parameter value 20 limits unit growth to 1.2 times the original size. Cold functions (either marked cold via an attribute or by profile feedback) are not accounted into the unit size.
Link with libjemalloc, a fast, arena-based memory allocator.
Generate code for lp64. With ilp32, int, long int and pointer are 32-bit; with lp64, int is 32-bit, but long int and pointer are 64-bit.
Sets the language dialect to include syntax from the 1998 ISO C++ standard plus the 2003 technical corrigendum.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Instruments code to collect information for profile-driven feedback. Information is collected regarding both code paths and data values.
Applies information from a profile run in order to improve optimization. Several optimizations are improved when profile data is available, including branch probabilities, loop peeling, and loop unrolling.
Produce debugging information.
Disregard strict standards compliance. -Ofast enables all -O3 optimizations. It also enables optimizations that are not valid for all standard-compliant programs. It turns on -ffast-math, -fallow-store-data-races (as of GCC 10), and the Fortran-specific -fstack-arrays unless -fmax-stack-var-size is specified, and -fno-protect-parens.
On aarch64 systems, mcpu sets the what kind of instructions can be used (as if by -march) and how to
tune for performance (as if by -mtune).
On x86 systems, mcpu is a deprecated synonym for mtune.
On SPARC systems, mcpu sets the available instruction set.
Tells the optimizer to unroll loops whose number of iterations can be determined at compile time or upon entry to the loop.
Enable Link Time Optimization When invoked with source code, it generates GIMPLE (one of GCC's internal representations) and writes it to special ELF sections in the object file. When the object files are linked together, all the function bodies are read from these ELF sections and instantiated as if they had been part of the same translation unit.
Specify growth that the early inliner can make. In effect it increases the amount of inlining for code having a large abstraction penalty.
When you use -finline-functions (included in -O3), a lot of functions that would otherwise not be considered for inlining by the compiler are investigated. To those functions, a different (more restrictive) limit compared to functions declared inline can be applied.
Specifies maximal overall growth of the compilation unit caused by inlining. For example, parameter value 20 limits unit growth to 1.2 times the original size. Cold functions (either marked cold via an attribute or by profile feedback) are not accounted into the unit size.
Assume that a loop with an exit will eventually take the exit and not loop indefinitely. This allows the compiler to remove loops that otherwise have no side-effects, not considering eventual endless looping as such.
Link with libjemalloc, a fast, arena-based memory allocator.
Generate code for lp64. With ilp32, int, long int and pointer are 32-bit; with lp64, int is 32-bit, but long int and pointer are 64-bit.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Instruments code to collect information for profile-driven feedback. Information is collected regarding both code paths and data values.
Applies information from a profile run in order to improve optimization. Several optimizations are improved when profile data is available, including branch probabilities, loop peeling, and loop unrolling.
Produce debugging information.
Disregard strict standards compliance. -Ofast enables all -O3 optimizations. It also enables optimizations that are not valid for all standard-compliant programs. It turns on -ffast-math, -fallow-store-data-races (as of GCC 10), and the Fortran-specific -fstack-arrays unless -fmax-stack-var-size is specified, and -fno-protect-parens.
On aarch64 systems, mcpu sets the what kind of instructions can be used (as if by -march) and how to
tune for performance (as if by -mtune).
On x86 systems, mcpu is a deprecated synonym for mtune.
On SPARC systems, mcpu sets the available instruction set.
Tells the optimizer to unroll loops whose number of iterations can be determined at compile time or upon entry to the loop.
Enable Link Time Optimization When invoked with source code, it generates GIMPLE (one of GCC's internal representations) and writes it to special ELF sections in the object file. When the object files are linked together, all the function bodies are read from these ELF sections and instantiated as if they had been part of the same translation unit.
Enabled: Put all local arrays, even those of unknown size onto stack memory.
The -fno- form disables the behavior.
Link with libjemalloc, a fast, arena-based memory allocator.
Generate code for lp64. With ilp32, int, long int and pointer are 32-bit; with lp64, int is 32-bit, but long int and pointer are 64-bit.
Sets the language dialect to include syntax from the C99 standard, such as bool and other features used in CPU 2017 benchmarks.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Instruments code to collect information for profile-driven feedback. Information is collected regarding both code paths and data values.
Applies information from a profile run in order to improve optimization. Several optimizations are improved when profile data is available, including branch probabilities, loop peeling, and loop unrolling.
Produce debugging information.
Disregard strict standards compliance. -Ofast enables all -O3 optimizations. It also enables optimizations that are not valid for all standard-compliant programs. It turns on -ffast-math, -fallow-store-data-races (as of GCC 10), and the Fortran-specific -fstack-arrays unless -fmax-stack-var-size is specified, and -fno-protect-parens.
On aarch64 systems, mcpu sets the what kind of instructions can be used (as if by -march) and how to
tune for performance (as if by -mtune).
On x86 systems, mcpu is a deprecated synonym for mtune.
On SPARC systems, mcpu sets the available instruction set.
Tells the optimizer to unroll loops whose number of iterations can be determined at compile time or upon entry to the loop.
Enable Link Time Optimization When invoked with source code, it generates GIMPLE (one of GCC's internal representations) and writes it to special ELF sections in the object file. When the object files are linked together, all the function bodies are read from these ELF sections and instantiated as if they had been part of the same translation unit.
Specify growth that the early inliner can make. In effect it increases the amount of inlining for code having a large abstraction penalty.
When you use -finline-functions (included in -O3), a lot of functions that would otherwise not be considered for inlining by the compiler are investigated. To those functions, a different (more restrictive) limit compared to functions declared inline can be applied.
Specifies maximal overall growth of the compilation unit caused by inlining. For example, parameter value 20 limits unit growth to 1.2 times the original size. Cold functions (either marked cold via an attribute or by profile feedback) are not accounted into the unit size.
Enabled: Put all local arrays, even those of unknown size onto stack memory.
The -fno- form disables the behavior.
Link with libjemalloc, a fast, arena-based memory allocator.
Generate code for lp64. With ilp32, int, long int and pointer are 32-bit; with lp64, int is 32-bit, but long int and pointer are 64-bit.
Sets the language dialect to include syntax from the C99 standard, such as bool and other features used in CPU 2017 benchmarks.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Instruments code to collect information for profile-driven feedback. Information is collected regarding both code paths and data values.
Applies information from a profile run in order to improve optimization. Several optimizations are improved when profile data is available, including branch probabilities, loop peeling, and loop unrolling.
Produce debugging information.
Disregard strict standards compliance. -Ofast enables all -O3 optimizations. It also enables optimizations that are not valid for all standard-compliant programs. It turns on -ffast-math, -fallow-store-data-races (as of GCC 10), and the Fortran-specific -fstack-arrays unless -fmax-stack-var-size is specified, and -fno-protect-parens.
On aarch64 systems, mcpu sets the what kind of instructions can be used (as if by -march) and how to
tune for performance (as if by -mtune).
On x86 systems, mcpu is a deprecated synonym for mtune.
On SPARC systems, mcpu sets the available instruction set.
Tells the optimizer to unroll loops whose number of iterations can be determined at compile time or upon entry to the loop.
Enable Link Time Optimization When invoked with source code, it generates GIMPLE (one of GCC's internal representations) and writes it to special ELF sections in the object file. When the object files are linked together, all the function bodies are read from these ELF sections and instantiated as if they had been part of the same translation unit.
Specify growth that the early inliner can make. In effect it increases the amount of inlining for code having a large abstraction penalty.
When you use -finline-functions (included in -O3), a lot of functions that would otherwise not be considered for inlining by the compiler are investigated. To those functions, a different (more restrictive) limit compared to functions declared inline can be applied.
Specifies maximal overall growth of the compilation unit caused by inlining. For example, parameter value 20 limits unit growth to 1.2 times the original size. Cold functions (either marked cold via an attribute or by profile feedback) are not accounted into the unit size.
Enabled: Put all local arrays, even those of unknown size onto stack memory.
The -fno- form disables the behavior.
The language standards set aliasing requirements: programmers are expected to follow conventions so that the compiler can keep track of memory. If a program violates the requirements (for example, using pointer arithmetic), programs may crash, or (worse) wrong answers may be silently produced.
Unfortunately, the aliasing requirements from the standards are not always well understood.
Sometimes, the aliasing requirements are understood and nevertheless intentionally violated by smart programmers who know what they are doing, such as the programmer responsible for the inner workings of Perl storage allocation and variable handling.
The -fno-strict-aliasing switch instructs the optimizer that it must not assume that the aliasing requirements from the standard are met by the current program. You will probably need it for 500.perlbench_r and 600.perlbench_s. Note that this is an optimization switch, not a portability switch. When running SPECint2017_rate_base or SPECint2017_speed_base, you must use the same optimization switches for all the C modules in base; see https://www.spec.org/cpu2017/Docs/runrules.html#BaseFlags and https://www.spec.org/cpu2017/Docs/runrules.html#MustValidate.
Link with libjemalloc, a fast, arena-based memory allocator.
Generate code for lp64. With ilp32, int, long int and pointer are 32-bit; with lp64, int is 32-bit, but long int and pointer are 64-bit.
Sets the language dialect to include syntax from the 1998 ISO C++ standard plus the 2003 technical corrigendum.
Sets the language dialect to include syntax from the C99 standard, such as bool and other features used in CPU 2017 benchmarks.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Add the specified path to the list of paths that the linker will search for archive libraries and control scripts.
Instruments code to collect information for profile-driven feedback. Information is collected regarding both code paths and data values.
Applies information from a profile run in order to improve optimization. Several optimizations are improved when profile data is available, including branch probabilities, loop peeling, and loop unrolling.
Produce debugging information.
Disregard strict standards compliance. -Ofast enables all -O3 optimizations. It also enables optimizations that are not valid for all standard-compliant programs. It turns on -ffast-math, -fallow-store-data-races (as of GCC 10), and the Fortran-specific -fstack-arrays unless -fmax-stack-var-size is specified, and -fno-protect-parens.
On aarch64 systems, mcpu sets the what kind of instructions can be used (as if by -march) and how to
tune for performance (as if by -mtune).
On x86 systems, mcpu is a deprecated synonym for mtune.
On SPARC systems, mcpu sets the available instruction set.
Tells the optimizer to unroll loops whose number of iterations can be determined at compile time or upon entry to the loop.
Enable Link Time Optimization When invoked with source code, it generates GIMPLE (one of GCC's internal representations) and writes it to special ELF sections in the object file. When the object files are linked together, all the function bodies are read from these ELF sections and instantiated as if they had been part of the same translation unit.
Specify growth that the early inliner can make. In effect it increases the amount of inlining for code having a large abstraction penalty.
When you use -finline-functions (included in -O3), a lot of functions that would otherwise not be considered for inlining by the compiler are investigated. To those functions, a different (more restrictive) limit compared to functions declared inline can be applied.
Specifies maximal overall growth of the compilation unit caused by inlining. For example, parameter value 20 limits unit growth to 1.2 times the original size. Cold functions (either marked cold via an attribute or by profile feedback) are not accounted into the unit size.
Specify growth that the early inliner can make. In effect it increases the amount of inlining for code having a large abstraction penalty.
When you use -finline-functions (included in -O3), a lot of functions that would otherwise not be considered for inlining by the compiler are investigated. To those functions, a different (more restrictive) limit compared to functions declared inline can be applied.
Specifies maximal overall growth of the compilation unit caused by inlining. For example, parameter value 20 limits unit growth to 1.2 times the original size. Cold functions (either marked cold via an attribute or by profile feedback) are not accounted into the unit size.
Assume that a loop with an exit will eventually take the exit and not loop indefinitely. This allows the compiler to remove loops that otherwise have no side-effects, not considering eventual endless looping as such.
The language standards set aliasing requirements: programmers are expected to follow conventions so that the compiler can keep track of memory. If a program violates the requirements (for example, using pointer arithmetic), programs may crash, or (worse) wrong answers may be silently produced.
Unfortunately, the aliasing requirements from the standards are not always well understood.
Sometimes, the aliasing requirements are understood and nevertheless intentionally violated by smart programmers who know what they are doing, such as the programmer responsible for the inner workings of Perl storage allocation and variable handling.
The -fno-strict-aliasing switch instructs the optimizer that it must not assume that the aliasing requirements from the standard are met by the current program. You will probably need it for 500.perlbench_r and 600.perlbench_s. Note that this is an optimization switch, not a portability switch. When running SPECint2017_rate_base or SPECint2017_speed_base, you must use the same optimization switches for all the C modules in base; see https://www.spec.org/cpu2017/Docs/runrules.html#BaseFlags and https://www.spec.org/cpu2017/Docs/runrules.html#MustValidate.
Link with libjemalloc, a fast, arena-based memory allocator.
Write a linker map to the named file.
Write a linker map to the named file.
Warn, rather than generating a fatal error, when calls to external procedures have mismatches vs. the procedure definition. See also https://gcc.gnu.org/gcc-10/porting_to.html.
Write a linker map to the named file.
Warn, rather than generating a fatal error, when calls to external procedures have mismatches vs. the procedure definition. See also https://gcc.gnu.org/gcc-10/porting_to.html.
Write a linker map to the named file.
Write a linker map to the named file.
Warn, rather than generating a fatal error, when calls to external procedures have mismatches vs. the procedure definition. See also https://gcc.gnu.org/gcc-10/porting_to.html.
Write a linker map to the named file.
Inhibit all warning messages.
Write a linker map to the named file.
Write a linker map to the named file.
Write a linker map to the named file.
Warn, rather than generating a fatal error, when calls to external procedures have mismatches vs. the procedure definition. See also https://gcc.gnu.org/gcc-10/porting_to.html.
Write a linker map to the named file.
Inhibit all warning messages.
Warn, rather than generating a fatal error, when calls to external procedures have mismatches vs. the procedure definition. See also https://gcc.gnu.org/gcc-10/porting_to.html.
Write a linker map to the named file.
Warn, rather than generating a fatal error, when calls to external procedures have mismatches vs. the procedure definition. See also https://gcc.gnu.org/gcc-10/porting_to.html.
Write a linker map to the named file.
Write a linker map to the named file.
Warn, rather than generating a fatal error, when calls to external procedures have mismatches vs. the procedure definition. See also https://gcc.gnu.org/gcc-10/porting_to.html.
Write a linker map to the named file.
SPECrate runs might use one of these methods to bind processes to specific processors, depending on the config file.
Linux systems: the numactl command is commonly used. Here is a brief guide to understanding the specific command which will be found in the config file:
Solaris systems: The pbind command is commonly used, via
submit=echo 'pbind -b...' > dobmk; sh dobmk
The specific command may be found in the config file; here is a brief guide to understanding that command:
pbind -b causes this copy's processes to be bound to the CPU specified by the expression that follows it. See the config file used in the run for the exact syntax, which tends to be cumbersome because of the need to carefully quote parts of the expression. When all expressions are evaluated, the jobs are typically distributed evenly across the system, with each chip running the same number of jobs as all other chips, and each core running the same number of jobs as all other cores.
The pbind expression may include various elements from the SPEC toolset and from standard Unix commands, such as:
No special commands are needed for feedback-directed optimization, other than the compiler profile flags.
One or more of the following may have been used in the run. If so, it will be listed in the notes sections. Here is a brief guide to understanding them:
LD_LIBRARY_PATH=<directories> (set via config file preENV)
LD_LIBRARY_PATH controls the search order for libraries. Often, it can be defaulted. Sometimes, it is
explicitly set (as documented in the notes in the submission), in order to ensure that the correct versions of
libraries are picked up.
OMP_STACKSIZE=N (set via config file preENV)
Set the stack size for subordinate threads.
ulimit -s N
ulimit -s unlimited
'ulimit' is a Unix commands, entered prior to the run. It sets the stack size for the main process, either
to N kbytes or to no limit.
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 info@spec.org
Copyright 2017-2022 Standard Performance Evaluation Corporation
Tested with SPEC CPU2017 v1.1.8.
Report generated on 2022-12-20 15:10:17 by SPEC CPU2017 flags formatter v5178.