Sun-Solaris-Studio12-and-gccfss4.2 Sun Microsystems SPEC CPU Flags
Compilers

Sun Studio 12

GCC for SPARC Systems V4.2.0 (gccfss).

Note: these compilers are described together because gccfss uses the same optimizing code generator as Studio 12.

Operating systems: Solaris 10 Copyright:

The text for many of the descriptions below was excerpted from the Sun Studio Compiler Documentation, which is copyright © 2005 Sun Microsystems, Inc. The original documentation can be found at docs.sun.com.

Some material below is quoted from the gccfss website, http://cooltools.sunsource.net/gcc/. Additional information about GCC options may be found at the The GNU C documentation website.

Last updated: 5-Feb-2008 jh ]]>
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 /etc/system)
When the file system flush daemon fsflush runs, it writes to disk all modified file buffers that are more than n seconds old.

bufhwm=<n> (Unix /etc/system)
Sets the upper limit of the file system buffer cache. The units for bufhwm are in kilobytes.

cpu_bringup_set=<n> (Unix /etc/system)
Specifies which processors are enabled at boot time. <n> represents a bitmap of the processors to be brought online.

disablecomponent (System Management Services)
This command can be used prior to booting the system for a 1-cpu test. The tester uses disablecomponent to add all other CPUs to the "blacklist", which is a list of components that cannot be used at boot time.

LD_LIBRARY_PATH=<directories> (linker)
LD_LIBRARY_PATH controls the search order for both the compile-time and run-time linkers. Usually, it can be defaulted; but testers may sometimes choose to explicitly set it (as documented in the notes in the submission), in order to ensure that the correct versions of libraries are picked up.

LD_PRELOAD=<shared object> (Unix environment variable)
Adds the named shared object to the runtime environment.

MADV=access_lwp and LD_PRELOAD=madv.so.1 (Unix environment variables)
When the madv.so.1 shared object is present in the LD_PRELOAD list, it is possible to provide advice to the system about how memory is likely to be accessed. The advice present in MADV applies to all processes and their descendants. A commonly used value is access_lwp, which means that when memory is allocated, the next process to touch it will be the primary user. Examples of other possible values include sequential, for memory that is used only once and then no longer needed and acces_many when many processes will be sharing data.

MPSSHEAP=<size>, MPSSSTACK=<size>, and LD_PRELOAD=mpss.so.1 (Unix environment variables)
When these variables are set, the mpss.so.1 shared object will set the preferred page size for new processes, and their descendants, to the requested sizes for the heap and stack.

PARALLEL=<n> (Unix environment variable)
If programs have been compiled with -xautopar, this environment variable can be set to the number of processors that programs should use.

segmap_percent=<n> (Unix /etc/system)
This value controls the size of the segmap cache as a percent of total memory. Set this value to help keep the file system cache from consuming memory unnecessarily.

STACKSIZE=<n> (Unix environment variable)
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 shell)
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:

svcadm disable webconsole (Unix, superuser commands)
Turns off the Sun Web Console, a browser-based interface that performs systems management. If it is enabled, system administrators can manage systems, devices and services from remote systems.

ts_dispatch_extended=<n> (Unix /etc/system)
Controls which dispatch table is loaded upon boot. A value of 1 loads the large system table, a value of 0 loads the regular system table.

tune_t_fsflushr=<n> (Unix /etc/system)
Controls the number of seconds between runs of the file system flush daemon, fsflush.

ulimit -s <n> (Unix shell)
Sets the stack size to n kbytes, or "unlimited" to allow the stack size to grow without limit.
Note that the "heap" and the "stack" share space; if your application allocates large amounts of memory on the heap, then you may find that the stack limit should not be set to "unlimited". A commonly used setting for SPEC CPU2006 purposes is a stack size of 128MB (131072K).

]]> CC Invoke the Sun Studio C++ Compiler gcc http://cooltools.sunsource.net/gcc/ for more information. ]]> cc Invoke the Sun Studio C Compiler. f90 Invoke the Sun Studio Fortran 90 Compiler g-plus-plus Invoke GCC for SPARC Systems, targetting C++ programs, and automatically adding the C++ library. See http://cooltools.sunsource.net/gcc/ for more information.

Note: this compiler is sometimes referenced below as "g-plus-plus" due to a limitation in how SPEC reports flags (it uses the XML name, and under the XML specification, such names are not allowed to use plus signs). The actual spelling used on the command line is "g++".

]]> Splitter rule for qoptions: -Qoption (cg|iropt|f90comp) -switch[,-switch...] Splitter rule for Wx: -W2,-switch[,-switch...] or -Wc,-switch[,-switch...] Splitter rule for -Ainline Splitter rule for -Apf Splitter rule for -Qlp [optimizer flag]

Increase the probability that the compiler will perform memcpy/memset transformations.

]]> -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.

]]> -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]

Allow prefetching through up to n levels of indirect memory references.

]]> -array_pad_rows,<n> Enable padding of arrays by n.

]]> [optimizer flag]

Convert multiple short memory operations into single long memory 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 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: -ffast-math Allow faster math operations:

Programs that depend upon strict IEEE 754 conformance should not use this option.

]]> Enables the use of the fused multiply-add instruction. For the production release of Sun Studio 12, the recommended spelling of this switch is "-fma=fused". For pre-release versions, the same effect can be achieved via the spelling "-Wc,-fma=fused" (C) or "-Qoption cg -fma=fused" (C++, Fortran).

]]> Enables the use of the fused multiply-add instruction.

]]> Selects faster (but nonstandard) handling of floating point arithmetic exceptions and gradual underflow. -fsimple=<n> Controls simplifying assumptions for floating point arithmetic:

]]> 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 is necessary to get full implementation of _Complex data types on Solaris 8 and Solaris 9. It is not necessary (and should not be used) on Solaris 10. This library provides faster versions of some common functions, such as malloc/free and bcopy. 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. 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. Links in a library of "object caching" memory allocation routines which can be faster than those found in libc. Do not allow C++ exceptions. A throw specification on a function is accepted but ignored; the compiler does not generate exception code. -O1 With -O1, also spelled "-O", optimizations include: basic local and global optimizations, such as induction variable elimination, common subexpression elimination, constant propogation, register allocation, and basic block merging.

]]> -O2 In addition to the optimizations at -O1, add global optimizations at the function level, loop unrolling, and software pipelining.

]]> -O3 In addition to the optimizations at -O2: add automatic inlining of functions in the same file, and use 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.

]]> A synomym for -xO3. -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-imb=1 [code generator flag]

Insert indirect prefetches when the indirect access chain spans across basic blocks.

]]> -Qlp-it=3 [code generator flag]

Indicates to the compiler to insert n extra prefetches for each indirect access in outer loops

]]> -Qlp-ol=1 [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 Sun Studio Fortran compiler to emit verbose messages. -v Shows each component as it is invoked. -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_level=[basic|std|strong] Allows the compiler to perform type-based alias analysis at the specified alias level:

]]> -xalias_level[=any|simple|compatible] Allows the compiler to perform type-based alias analysis:

]]> -xarch=... Specifies which instructions can be used. Among the choices are:

]]> Turn on automatic parallelization for multiple processors. -xbuiltin=%all Substitute intrinsic functions or inline system functions where profitable for performance. -xcache=... xcache defines the cache properties for use by the optimizer. It can specify use of default assumptions ("generic"); use of whatever the compiler can assume about the current platform ("native"); or an explicit description of up to three levels of cache, using colon-separated specifiers of the form si/li/ai, where:

]]> -xchip=... 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:

]]> 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:

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. Set maximum assumed data alignment to be at a 4 byte boundary and raise signal SIGBUS in the case of misaligned data accesses. -xO<n> Specify optimization level n:

]]> -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_heap=<n> Set the preferred heap page size for running the program. -xpagesize_stack=<n> Set the preferred stack page size for running the program. -xprefetch=auto,explicit Allow generation of prefetch instructions. -xprefetch=yes and -xprefetch are synonyms for -xprefetch=auto,explicit. -xprefetch=no is a synonym for -xprefetch=no%auto,no%explicit. (Explicit prefetch macros are not used in the source code of the SPEC CPU2006 benchmarks; therefore, in the context of CPU2006, -xprefetch=yes is effectively a synonym for -xprefetch=auto.)

]]> Generate indirect prefetches for data arrays accessed indirectly. -xprefetch=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). -xprefetch=no%auto Turn off prefetch instruction generation. -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 Sun Studio C and Sun Studio C++ is 1. The default for Sun Studio Fortran and for gccfss is 2.

]]> -xprofile=collect[:directory] Collect profile data for feedback-directed optimization. If an option directory is named, the feedback will be stored there.

When FDO is used, the training run gathers information regarding execution paths and data values. Hardware performance counters are not used. FDO improves existing optimizations but does not introduce new classes of optimization.

For gccfss, profile collection works the same as Sun Studio on SPARC.

]]> -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. 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, or -xtarget=(some specific target) Selects options for architecture, chip timing, and cache sizes. These can also be controlled separately, via -xarch, -xchip, and -xcache, respectively. A wide variety of targets can be selected, including ultra3, ultra3cu, ultra3i, ultra3iplus, ultra4, ultra4plus, ultraT1, ultraT2, sparc64vi. In each case, appropriate options are selected for architecture, chip timing, and cache size to match that target.

If -xtarget=native is selected, options that are appropriate for the system where the compile is being done.

The default is -xtarget=generic, which sets the parameters for the best performance over most 32-bit platform architectures.

On Solaris SPARC systems, the default pointer size with -xtarget=native is 32-bit.

]]> -xunroll=<n> Enable unrolling loops n times where possible. -xvector, -xvector=yes Allow the compiler to transform math library calls within loops into calls to the vector math library. Specifying -xvector is equivalent to -xvector=yes.

]]>