Sun-OpenSolaris-Studio-x86_64.20080818.xml
Sun Microsystems SPEC CPU Flags: Sun-OpenSolaris-Studio-x86_64
Compilers: Sun Studio Express 11/08
Operating systems: OpenSolaris 2008.05
Last updated: 18-Aug-2008 cds
The text for many of the descriptions below was taken from the Sun Studio Compiler Documentation, which is
copyright © 2007 Sun Microsystems, Inc. The original documentation can be found at
docs.sun.com.
]]>
Platform settings
One or more of the following settings may have been applied to the testbed. If so, the "Platform Notes" section of the
report will say so; and you can read below to find out more about what these settings mean.
autoup=<n> (Unix)
When the file system flush daemon fsflush runs, it writes to disk all modified file buffers that are more
than n seconds old.
PARALLEL=<n> (Unix)
If programs have been compiled with -xautopar, this environment variable can be set to the number of
processors that programs should use.
OMP_NUM_THREADS=<n> (Unix)
If programs have been compiled with -xautopar, this environment variable can be set to the number of
processors that programs should use.
SUNW_MP_THR_IDLE=SPIN (Unix)
Controls the end-of-task status of each helper
thread executing the parallel part of a program.
You can set the value to spin, sleep ns, or sleep
nms. The default is SPIN -- the thread spins (or
busy-waits) after completing a parallel task until
a new parallel task arrives.
Choosing SLEEP time specifies the amount of time a
helper thread should spin-wait after completing a
parallel task. If, while a thread is spinning, a
new task arrives for the thread, the tread
executes the new task immediately. Otherwise, the
thread goes to sleep and is awakened when a new
task arrives. time may be specified in seconds,
(ns) or just (n), or milliseconds, (nms).
SLEEP with no argument puts the thread to sleep
immediately after completing a parallel task.
SLEEP, SLEEP (0), SLEEP (0s), and SLEEP (0ms) are
all equivalent.
STACKSIZE=<n> (Unix)
Set the size of the stack (temporary storage area) for each slave thread of a multithreaded program.
submit=echo 'pbind -b...' > dobmk; sh dobmk (SPEC tools, Unix)
When running multiple copies of benchmarks, the SPEC config file feature submit is sometimes used to
cause individual jobs to be bound to specific processors. If so, the specific command may be found in the config file; here
is a brief guide to understanding that command:
- submit= causes the SPEC tools to use this line when submitting jobs.
- echo ...> dobmk causes the generated commands to be written to a file, namely
dobmk.
- 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 submission 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, each core ends up with
exactly one copy of each benchmark. The pbind expression may include:
- $SPECUSERNUM: the SPEC tools-assigned number for this copy of the benchmark.
- psrinfo: find out what processors are available
- grep on-line: search the psrinfo output for information regarding on-line cpus
- expr: Calculate simple arithmetic expressions. For example, the effect of binding jobs to a
(quote-resolved) expression such as:
expr ( $SPECUSERNUM / 4 ) * 8 + ($SPECUSERNUM % 4 ) )
would be to send the jobs to processors whose numbers are:
0,1,2,3, 8,9,10,11, 16,17,18,19 ...
- awk...print \$1: Pick out the line corresponding to this copy of the benchmark and use the CPU
number mentioned at the start of this line.
- sh dobmk actually runs the benchmark.
tune_t_fsflushr=<n> (Unix)
Controls the number of seconds between runs of the file system flush daemon, fsflush.
ulimit -s <n> (Unix)
Sets the stack size to n kbytes, or "unlimited" to allow the stack size to grow without limit.
]]>
CC
Invoke the Sun Studio C++ Compiler
cc
Invoke the Sun Studio C Compiler.
f90
Invoke the Sun Studio Fortran 90 Compiler
Splitter rule for qoptions: -Qoption (cg|iropt|f90comp|ube) -switch[,-switch...]
Splitter rule for Wx: -W2,-switch[,-switch...] or -Wc,-switch[,-switch...]
Splitter rule for -Ainline
Splitter rule for -Apf
-W2,-Arestrict_g
[optimizer flag]
Assumes global pointers are not aliased (restricted).
]]>
-W2,-Adata_access
[optimizer flag]
Asked compiler folks for description TBD
]]>
Splitter rule for -Qlp
[optimizer flag]
Increase the probability that the compiler will perform memcpy/memset transformations.
]]>
-Wd,-iropt-prof , -Qoption CC -iropt-prof
[global optimizer flag]
Use iropt in the profile phase of the compiler iropt is the Global optimizer.
]]>
-Addint:ignore_parallel
[optimizer]
Ignore parallelization factors in loop interchange heuristics.
]]>
-Addint:sf=<n>
[optimizer]
When considering whether to interchange loops, set memory store operation weight to n. A higher value of
n indicates a greater performance cost for stores.
]]>
-Ainline:cp=<n>
[optimizer flag]
Control the optimizer's loop inliner; set the minimum call site frequency counter in order to consider a routine for
inlining.
]]>
-Ainline:cs=<n>
[optimizer flag]
Control the optimizer's loop inliner; Set inline callee size limit to n. The unit roughly corresponds to the
number of instructions.
]]>
-Ainline:inc=<n>
[optimizer flag]
Control the optimizer's loop inliner;
The inliner is allowed to increase the size of the program by up to n%.
]]>
-Ainline:irs=<n>
[optimizer flag]
Control the optimizer's loop inliner; Allow routines to increase by up to n. The unit roughly corresponds to
the number of instructions.
]]>
-Ainline:mi
[optimizer flag]
Control the optimizer's loop inliner; Perform maximum inlining (without considering code size increase).
]]>
-Ainline:recursion=1
[optimizer flag]
Control the optimizer's loop inliner; Allow routines that are called recursively to still be eligible for inlining.
]]>
-Ainline:rs=400
[optimizer flag]
Inliner only considers routines smaller than n pseudo instructions as possible inline candidates.
]]>
[optimizer flag]
Increase the probability that loop induction variables will replaced, so that some extraneous code can be eliminated from
loops.
]]>
-aligncommon=<n>
Controls the alignment of data in common blocks and standard numeric sequence types.
The value specified indicates the maximum alignment (in bytes) for data elements within common
blocks and standard numeric sequence types.
]]>
-Aloop_dist:ignore_parallel
[optimizer flag]
Ignore parallelization factors in loop distribution heuristics.
]]>
-Amemopt:arrayloc
[optimizer flag]
Reconstruct array subscripts during memory allocation merging and data layout program transformation.
]]>
-Apf:llist=<n>
[optimizer flag]
Do speculative prefetching for link-list data structures; perform prefetching n iterations ahead.
]]>
-Apf:noinnerllist
[optimizer flag]
Do speculative prefetching for link-list data structures; do not attempt prefetching for innermost loops.
]]>
-Apf:pdl=1
[optimizer flag]
Do prefetching for one-level indirect memory references.
]]>
-array_pad_rows,<n>
Enable padding of arrays by n.
]]>
[optimizer flag]
Convert multiple short memory load operations into single long load operations.
]]>
-Atile:skewp[:b<n>]
[optimizer flag]
Perform loop tiling which is enabled by loop skewing. Loop skewing is a transformation that transforms a non-fully
interchangeable loop nest to a fully interchangeable loop nest. The optional b<n> sets the tiling block
size to n.
]]>
-Aujam:inner=g
[optimizer flag]
Increase the probability that small-trip-count inner loops will be fully unrolled.
]]>
[optimizer flag]
Enable optimization of critical control paths
]]>
Assume data is naturally aligned.
-Dalloca=__builtin_alloca
Used for 403.gcc: allow use of compiler's internal builtin alloca.
Synonym for -xdepend.
Allows the compiler to assume that your code does not rely on setting of the errno variable.
]]>
-fast
A convenience option, this switch selects several other options that are described in this file.
-fast
A convenience option, this switch selects several other options that are described in this file.
-fast
A convenience option, this switch selects the following switches that are described in this file:
Selects faster (but nonstandard) handling of floating point arithmetic exceptions and gradual underflow.
compilers="sun_cc,sun_f90">
This option forces all floating-point expressions to the precision of the destination variable.
-Wu,-fsimple=3
Allow optimizer to use x87 hardware instructions for sine,
cosine, and rsqrt. The precision and rounding effects are
determined by the underlying hardware implementation, rather
than by standard IEEE754 semantics.
-Qoption ube -fsimple=3
Allow optimizer to use x87 hardware instructions for sine,
cosine, and rsqrt. The precision and rounding effects are
determined by the underlying hardware implementation, rather
than by standard IEEE754 semantics.
-Qoption ube -sched_first_pass=1
-sched_first_pass=0 turns off first pass of instruction scheduler (second pass if off by default).
-sched_first_pass=1 turns on first pass of instruction scheduler.
-fsimple=<n>
Controls simplifying assumptions for floating point arithmetic:
- -fsimple=0 permits no simplifying assumptions. Preserves strict IEEE 754 conformance.
- -fsimple=1 allows the optimizer to assume:
- The IEEE 754 default rounding/trapping modes do not change after process initialization.
- Computations producing no visible result other than potential floating-point exceptions may be deleted.
- Computations with Infinity or NaNs as operands need not propagate NaNs to their results. For example, x*0 may be
replaced by 0.
- Computations do not depend on sign of zero.
- -fsimple=2 permits more aggressive floating point optimizations that may cause programs to produce
different numeric results due to changes in rounding. Even with -fsimple=2, the optimizer still is not
permitted to introduce a floating point exception in a program that otherwise produces none.
For example, -fsimple=2 permits the optimizer to replace computations of x/y in a loop with x*z, where z=1/y.
]]>
Evaluate float expressions as single precision.
Sets the IEEE 754 trapping mode to common exceptions (invalid, division by zero, and overflow).
-ftrap=%none
Turns off all IEEE 754 trapping modes.
Includes symbols in the executable. If the optimization level is -xO3 or lower, some optimizations may be
disabled when -g is present. At -xO4 or higher, full optimization is performed, even when -g is present.
Includes symbols in the executable. If the optimization level is -xO3 or lower, some optimizations may be
disabled when -g0 is present. At -xO4 or higher, full optimization is performed, even when -g0 is present.
Links in a library of general purpose memory allocation routines which can be faster than those found in libc, at the expense
of more virtual memory consumed.
This library provides faster versions of some common functions, such as malloc/free and bcopy.
Link with multi-threaded memory allocator library. Functions in this library provide concurrent access to heap space.
Include a library containing chip-specific memory routines.
Include the optimized math library. This option usually generates faster code, but may produce slightly different
results. Usually these results will differ only in the last bit.
USe object-caching memory allocation library
Include a library with vectorized versions of some elementary mathematical functions.
This library is necessary to get functions used for accessing name services. As there are no network-enabled CPU2006
benchmarks, this flag should not be used.
Use STLport's Standard Library implementation instead of the default libCstd.
The libsunmath math library contains functions that are not specified by any standard but are useful in numerical software.
It also contains many of the functions that are in libm.so.2 but not in libm.so.1.
Specifies the memory model for the compiled binary object. Use -m64 to create 64-bit executables and shared libraries.
Specifies the memory model for the compiled binary object. Use -m32 to create 32-bit executables and shared libraries.
-L/export/SmartHeap_7.4/lib -lsmartheap
-L/export/home/SmartHeap_7.4/lib -lsmartheap ,
When used, results in linking with MicroQuill's SmartHeap 7.4 (32-bit)
library for Solaris. This is a library that optimizes calls to new, delete,
malloc and free.
]]>
-M /usr/lib/ld/map.bssalign
Reads mapfile as a text file of directives to ld.
]]>
Do not allow C++ exceptions. A throw specification on a function is accepted but ignored; the compiler does not generate
exception code.
Cancels forcing expressions to have the precision of the result.
A synomym for -xO3.
-Qoption ube -xcallee=yes
[optimizer flag]
Do not assume callee-save registers are saved. -xcallee=yes is the default.
]]>
-Qoption iropt -Aujam:noinner
[optimizer flag]
Increase the probability that small-trip-count inner loops will be fully unrolled.
]]>
-Qoption iropt -Rloop_dist
[optimizer flag]
Do not perform loop distribution transformations.
]]>
-Qdepgraph-early_cross_call=1
[code generator flag]
There are several scheduling passes in the compiler. This option allows early passes to move instructions across call
instructions.
]]>
-Qeps:do_spec_load=1
[code generator flag]
Allow the enhanced pipeline scheduler (EPS) to use speculative (non-faulting) loads.
]]>
-Qeps:enabled=1
[code generator flag]
Use enhanced pipeline scheduling (EPS) and selective scheduling algorithms for instruction scheduling.
]]>
-Qeps:rp_filtering_margin=<n>
[code generator flag]
The number of live variables allowed at any given point is n more than the number of physical registers. Setting n to a
significantly large number (e.g., 100) will disable register pressure heuristics in EPS.
]]>
-Qeps:ws=<n>
[code generator flag]
Set the EPS window size, that is, the number of instructions it will consider across all paths when trying to find
independent instructions to schedule a parallel group. Larger values may result in better run time, at the cost of increased
compile time.
]]>
-Qgsched-T<n>
[code generator flag]
Sets the aggressiveness of the trace formation, where n is 4, 5, or 6. The higher the value of n,
the lower the branch probability needed to include a basic block in a trace.
]]>
-Qicache-chbab=1
[code generator flag]
Turn on optimization to reduce branch after branch penalty: nops will be inserted to prevent one branch from occupying
the delay slot of another branch.
]]>
-Qipa:valueprediction
[code generator flag]
Use profile feedback data to predict values and attempt to generate faster code along these control paths, even at the
expense of possibly slower code along paths leading to different values. Correct code is generated for all paths.
]]>
-Qiselect-funcalign=<n>
[code generator flag]
Do function entry alignment at n-byte boundaries.
]]>
-Qiselect-sw_pf_tbl_th=<n>
[code generator flag]
Peels the most frequent test branches/cases off a switch until the branch probability reaches less than 1/n. This is
effective only when profile feedback is used
]]>
-Qlp=<n>
[code generator flag]
Control irregular loop prefetching; turns the module on (1) or off (0) (default is on for F90; off for C/C++)
]]>
-Qlp-av=<n>
[code generator flag]
Control irregular loop prefetching; sets the prefetch look ahead distance, in bytes. The default is 256.
]]>
-Qlp-fa=<n>
[code generator flag]
Control irregular loop prefetching; a setting of "1" means force user settings to override internally computed values.
]]>
-Qlp-fl=<n>
[code generator flag]
Control irregular loop prefetching; a setting of "1" means force the optimization to be turned on for all languages.
]]>
-Qlp-pt=weak
[code generator flag]
Turns on prefetching for outer loops
]]>
-Qlp-pt=weak
[code generator flag]
Control irregular loop prefetching; use weak prefetches in the general loop prefetch.
]]>
-Qlp-t=<n>
[code generator flag]
Control irregular loop prefetching; sets the number of attempts at prefetching. If not specified, t=2 if
-xprefetch_level=3 has been set; otherwise, defaults to t=1.
]]>
-Qms_pipe+alldoall
[code generator flag]
Specifies that all loops can be pipelined without needing to be concerned about loop-carried dependencies.
]]>
-Qms_pipe+intdivusefp
[code generator flag]
In pipelined loops, use floating point divide instructions for signed integer division.
]]>
-Qms_pipe+prefolim=<n>
[code generator flag]
Set number of outstanding prefetches in pipelined loops to <n>
]]>
-Qms_pipe-pref_prolog
[code generator flag]
Turn off prefetching in the prolog of modulo scheduled loops.
]]>
-Qms_pipe-prefst
[code generator flag]
Turn off prefetching for stores in the pipeliner.
]]>
-Qms_pipe-prefstrong=0
[code generator flag]
Turn off the use of strong prefetches in modulo scheduled loops.
]]>
-Qms_pipe+unoovf
[code generator flag]
Assert (to the pipeliner) that unsigned int computations will not overflow.
]]>
-Qpeep-Sh0
[code generator flag]
Reduce the probability that the compiler will hoist sethi insructions out of loops.
]]>
Allocate routine local variables on the stack.
-#
Turns on verbose mode, showing how command options expand. Shows each component as it is invoked.
-verbose=diags,version
Controls compiler verbosity. There are several values that can be used with this flag:
- [no%]diags
- [Do not] Print the command line for each compilation pass
- [no%]template
- [Do not] Turn on the template instantiation verbose mode (sometimes called the "verify" mode). The
verbose mode displays each phase of instantiation as it occurs during compilation.
- [no%]version
- [Do not] Direct the CC driver to print the names and version numbers of the programs it invokes.
- %all
- Invokes all of the above.
- %none
- -verbose=%none is the same as -verbose=no%template,no%diags,no%version.
The default is -verbose=%none.
]]>
-v
Same as -verbose=diags.
]]>
-v
This flag will cause the Fortran compiler to emit verbose messages.
-V
Directs the compiler to print the name and version ID of each component as the compiler executes.
-V
Same as -verbose=version.
]]>
-X[a|c]
Specifies the degree of conformance with the ISO C standard: -Xc indicates strict conformance, whereas -Xa indicates ISO C
plus some K&R compatibility extensions.
-xalias
Specify degree of aliasing to be assumed by the compiler. Specifying -xalias without a list gives the best performance for most programs that do not violate Fortran aliasing rules, and corresponds to: -xalias=no%dummy,no%craypointer,no%actual,no%overindex,no%ftnpointer
- no%dummy Usage of dummy parameters follows the Fortran standard and may not alias each other or global variables.
- craypointer Cray pointers can point at any global variable or a local variable whose address is taken by the LOC() function.
- no%actual Passing an argument does not result in further aliasing.
- no%overindex Array bounds are not violated. Array references do not reference other variables.
- no%ftnpointer Fortran pointers follow the rules of the standard.
]]>
-xalias_level=[basic|std|strong|strict]
Allows the compiler to perform type-based alias analysis at the specified alias level:
- basic assume that memory references that involve different C basic types do not alias each
other.
- std assume aliasing rules described in the ISO 1999 C standard.
- strong in addition to the restrictions at the std level, assume that pointers of type
char * are used only to access an object of type char; and assume that there are no interior pointers.
- strict assume that memory references that involve types such as structs or unions, that are the same when tags are removed, can alias each other. Conversely, the compiler assumes that memory references involving types that are not the same even after tags are removed do not alias each other.
]]>
-xalias_level[=any|simple|compatible]
Allows the compiler to perform type-based alias analysis:
- any assumes that any type can alias any other
- simple assumes that fundamental types are not aliased
- compatible assumes that layout-incompatible types are not aliased. If you specify -xalias_level without any values, the compiler sets it to -xalias_level=compatible.
]]>
-xarch=[sse|sse2|sse2a|amd64a|amd64|native|generic]
Specifies which instructions can be used. Among the choices are:
- sse Adds the SSE instruction set
- sse2 Adds the SSE2 instruction set
- sse2a Adds the AMD extensions to the SSE2 instruction set
- amd64 Compile 64-bit Solaris x86 applications. Is equivalent to -m64 -xarch=sse2
- amd64a Adds the AMD extensions to the AMD64 architecture and generates 64-bit ELF format binary file.
- native Use the instructions available on the current processor
- generic This option generates 32-bit applications. This is default.
]]>
Turn on automatic parallelization for multiple processors.
-xbuiltin=%all
Substitute intrinsic functions or inline system functions where profitable for performance.
-xbuiltin=%none
Specifies no functions from the standard libraries are substituted or inlined.
-xchip=[opteron|native|generic]
xchip determines timing properties that are assumed by the compiler. It does not limit which instructions are allowed
(see xtarget for that). Among the choices are:
- opteron Optimize for the AMD Opteron processor
- native Optimize for the current processor
- generic Optimize for the most x86 platforms
]]>
Analyze loops for inter-iteration data dependencies, and do loop restructuring.
-xinline=
Turn off inlining.
-xipo or -xipo=(0|1|2)
Perform optimizations across all object files in the link step:
- 0 = off
- 1 = on
- 2 = performs whole-program detection and analysis.
At -xipo=2, the compiler performs inter-procedural aliasing analysis as well as optimization of memory allocation and
layout to improve cache performance.
]]>
-xjobs=<n>
Specify the -xjobs option to set how many processes the compiler creates to complete its work. Currently,
-xjobs works only with the -xipo option. When you specify -xjobs=n, the interprocedural
optimizer uses n as the maximum number of code generator instances it can invoke to compile different files.
]]>
Use inline expansion for math library, libm.
Select the optimized math library.
Link with Sun supplied licensed sunperf library.
Perform link-time optimizations, such as branch optimization and cache coloring.
-xO<n>
Specify optimization level n:
- -xO1 does only basic local optimizations (peephole.)
- -xO2 Do basic local and global optimizations, such as induction variable elimination, common subexpression
elimination, constant propogation, register allocation, and basic block merging.
- -xO3 Add global optimizations at the function level, loop unrolling, and software pipelining.
- -xO4 Adds automatic inlining of functions in the same file.
- -xO5 Uses optmization algorithms that may take significantly more compilation time or that do not have as
high a probability of improving execution time, such as speculative code motion.
]]>
-xpad=common[:<n>]
If multiple arrays are placed in common, insert padding between them for better use of cache. n specifies the
amount of padding to apply, in units that are the same size as the array elements. If no parameter is specified then the
compiler selects one automatically.
]]>
Pad local variables, for better use of cache.
-xpagesize=<n>
Set the preferred page size for running the program.
-xpagesize_stack=<n>
Set the preferred stack page size for running the program.
-xpagesize_heap=<n>
Set the preferred heap page size for running the program.
Generates code for the Pentium processor.
-xprefetch[=val[,val]]
Enable generation of prefetch instructions on those architectures that support prefetch. val may be one of the following:
- auto - Enable automatic generation of prefetch instructions
- no%auto - Disable automatic generation of prefetch instructions
- explicit - Enable explicit prefetch macros (SPARC only)
- no%explicit - Disable explicit prefetch macros (SPARC only)
- latx:<n> - Adjust the compiler's assumptions about prefetch latency by the specified factor.
Typically values in the range of 0.5 to 2.0
will be useful. A lower number might
indicate that data will usually be cache
resident; a higher number might indicate a
relatively larger gap between the processor
speed and the memory speed (compared to the
assumptions built into the compiler).
If only -xprefetch is specified, -xprefetch=auto,explicit is assumed.
]]>
Generate indirect prefetches for data arrays accessed indirectly.
-xprefetch_level=<n>
Control the level of searching that the compiler does for prefetch opportunities by setting n to 1, 2, or 3,
where higher numbers mean to do more searching. The default for Fortran is 2. The default for C and C++ is 1.
]]>
-xprofile=collect[:directory]
Collect profile data for feedback-directed optimization (FDO). If an option directory is named, the feedback will be stored there.
When FDO is used, the training run gathers information
regarding execution paths. As of the Sun Studio 12 version
of the compiler suite, the training run gathers information
about data values on SPARC systems, but not on x86 systems.
Hardware performance counters are not used. FDO improves
existing optimizations but does not introduce new classes of
optimization.
-xprofile=use[:directory]
Use data collected for profile feedback. If an option directory is named, look for the feedback data there.
Analyze loops for reductions such as dot products, maximum and minimum finding.
-xregs=frameptr
Allow the compiler to use the frame-pointer register (%ebp on IA32, %rbp on AMD64)
as an unallocated callee-saves register.
Treat pointer-valued function parameters as restricted pointers.
Enables the use of non-faulting loads when used in conjunction with -xarch=v8plus. Assumes that no
memory based traps will occur.
]]>
-xtarget=native
Selects options appropriate for the system where the compile is taking place, including architecture, chip, and cache
sizes. (These can also be controlled separately, via -xarch, -xchip, and -xcache, respectively.)
-xunroll=<n>
Enable unrolling loops n times where possible.
Synonym for -unroll=n
]]>
-O<n>
Specify optimization level. If n is not specified, only a very basic level of optimization limited to local common subexpression elimination and dead code analysis is performed. -O2 does basic local and global optimization. This level usually gives minimum code size.
]]>
-unroll=<n>
Enable unrolling loops n times where possible.
-xcrossfile
Enable optimization and inlining across source files
-xvector, -xvector=yes, -xvector=lib, -xvector=simd
Allow the compiler to transform math library calls within loops into calls to the vector math library. Specifying
- -xvector is equivalent to -xvector=yes.
If you specify -xvector, but do not provide a flag, the compiler
assumes -xvector=lib.
- -xvector=lib Enables the compiler to transform math library calls within loops into single calls to the equivalent vector math routines when such transformations are possible.
- -xvector=simd Directs the compiler to use the native x86 SSE SIMD instructions to improve performance of certain loops.
]]>