CPU2006 Flag Description
Sun Microsystems Sun Blade 6000

Implicitly Included Flags

This section contains descriptions of flags that were included implicitly by other flags, but which do not have a permanent home at SPEC.

• • -D__MATHERR_ERRNO_DONTCARE
  • 
  • sun_studio_cc,sun_studio_CC

  • Allows the compiler to assume that your code does not rely on setting of the errno variable.

• • -dalign
  • 

  • Assume data is naturally aligned.

• • -fns
  • 

  • Selects faster (but nonstandard) handling of floating point arithmetic exceptions and gradual underflow.

• • -fsimple=2
  • 

  • 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.
• • -fsingle
  • 
  • sun_studio_cc

  • Evaluate float expressions as single precision.

• • -ftrap=%none
  • 

  • Turns off all IEEE 754 trapping modes.

• • -xalias_level=basic
  • 
  • sun_studio_cc,gcc,g-plus-plus

  • 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.
• • -xbuiltin=%all
  • 

  • Substitute intrinsic functions or inline system functions where profitable for performance.

• • -xdepend
  • 

  • Analyze loops for inter-iteration data dependencies, and do loop restructuring.

• • -xlibmil
  • 

  • Use inline expansion for math library, libm.

• • -xO5
  • 

  • 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.
• • -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.)

• • -xtarget=native
  • 

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

  • Includes:
    • -xarch=...
    • -xcache=...
    • -xchip=...
• • -xarch=...
  • 

  • Specifies which instructions can be used. Among the choices are:

    • native Use the instructions available on the current processor
    • generic Use instructions that are compatible with most SPARC processors
    • ultra3cu Use instructions compatible with the UltraSPARC IIIcu processor
    • v8plusa Use instructions that are available on the UltraSPARC processors
    • v8plusb Use instructions that are available on the UltraSPARC III/IV processors
    • sparcfmaf Allows use of the v8plusb set plus extensions for floating-point multiply-add
• • -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:

    • si is the size of the cache, in kb
    • li is the line size, in bytes
    • ai is the associativity
• • -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:

    • ultra3 Optimize for the UltraSPARC III processor
    • ultra3cu Optimize for the UltraSPARC IIIcu processor
    • sparc64vi Optimize for the SPARC64 VI processor
    • native Optimize for the current processor
    • generic Use timing properties for good performance on most SPARC processors
• • -xlibmopt
  • 

  • Select the optimized math library.

• • -depend
  • 
  • sun_studio_f90

  • Synonym for -xdepend.

  • Includes:
    • -xdepend
• • -ftrap_common
  • 

  • Sets the IEEE 754 trapping mode to common exceptions (invalid, division by zero, and overflow).

• • -xpad=local
  • 
  • sun_studio_f90

  • Pad local variables, for better use of cache.

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

System and Other Tuning Information

Platform Settings

These platform notes are in two sections: a generic section about system tuning and a section which is specific to the Sun Blade 6000 test of March, 2008.

System and process tuning

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. Alternatively, the units can be expressed as a percent of total memory, by setting bufhw_pct.

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.

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.

tsb_rss_factor=<1> (Unix /etc/system)
Suggests that the the size of the TSB (Translation Storage Buffer) may be increased if it is more than 25% (128/512) full. Doing so may reduce TSB traps, at the cost of additional kernel memory.

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

Submit on the Sun Blade 6000

For the testing of the Sun Blade 6000 System, jobs are submitted to processors using

submit = $[top]/config/blade-submit.pl $SPECCOPYNUM "$command" 

In this line, the SPEC tools invoke a perl procedure which does arithmetic to derive processor numbers from the SPEC copy number. The procedure receives as input the copy number and the command that actually runs the benchmark, and produces as output a file that assigns the job to the correct location, and starts that file with ssh. Here is the complete text of the procedure:

#!/bin/perl

use strict;
use Cwd;

# Particular testbed used today:
my @nodes = qw ( sys115 sys114 sys113
                 sys112 sys111 sys110 
                 sys109 sys108 sys107
                 sys106 );

# Processor description: 
# UltraSPARC T2 has 8 cores, each with 2 integer units, each with 4 threads
my @cores                = qw ( 7 6 5 4 3 2 1 0);  # When assigning,
my @int_units            = qw ( 1 0 );             # ...fill resources from top
my @threads              = qw ( 3 2 1 0);          # ...to bottom.
my $threads_per_int_unit = $#threads + 1;
my $threads_per_core     = $threads_per_int_unit * ($#int_units + 1);
# end of processor description section

my $rundir        = getcwd;
my $copynum       = shift @ARGV;

my $node          =     $copynum % ($#nodes+1);     
my $copy_on_node  = int($copynum / ($#nodes+1)); 

my $core          =     $copy_on_node % ($#cores+1);         
my $copy_on_core  = int($copy_on_node / ($#cores+1));         

my $int_unit         =     $copy_on_core % ($#int_units+1);    
my $copy_on_int_unit = int($copy_on_core / ($#int_units+1));    

my $processor_num = ($cores[$core] * $threads_per_core) + 
                    ($int_units[$int_unit] * $threads_per_int_unit) +
                    $threads[$copy_on_int_unit];

open DOBMK, "> dobmk" or die "Eh?";
print DOBMK "cd $rundir\n";
print DOBMK '/usr/ucb/echo -n "`hostname` " >> pbind.out' , "\n";
print DOBMK "/usr/sbin/pbind -b $processor_num \$\$ >> pbind.out\n"; 
print DOBMK 'sh -c "' . join(' ', @ARGV) . '"' . "\n";
close DOBMK;
system '/usr/bin/ssh', '-n', $nodes[$node], 'sh', "$rundir/dobmk";

The effect of the above procedure is to use ssh (Secure Shell) to submit jobs to the nodes listed at the top, binding a copy of the benchmark to a virtual processor on that node with pbind. (Note: the above arithmetic could have been accomplished more efficiently using more traditional 'awk' and 'expr' methods, but the tester felt that a slight loss of efficiency was balanced by the potential improvement in clarity from the above procedure.)

Flag description origin markings:

	Indicates that the flag description came from the user flags file.
	Indicates that the flag description came from the suite-wide flags file.
	Indicates that the flag description came from a per-benchmark flags file.

For questions about the meanings of these flags, please contact the tester.
For other inquiries, please contact webmaster@spec.org
Copyright 2006-2014 Standard Performance Evaluation Corporation
Tested with SPEC CPU2006 v1.0.1.
Report generated on Tue Jul 22 16:47:43 2014 by SPEC CPU2006 flags formatter v6906.