Manipulating Experiments

Oracle^® Solaris Studio 12.4: Performance Analyzer

Document Information

Using This Documentation

Product Documentation Library

Feedback

Chapter 1 Overview of Performance Analyzer

Tools of Performance Analysis

Collector Tool

Performance Analyzer Tool

er_print Utility

Performance Analyzer Window

Chapter 2 Performance Data

Data the Collector Collects

Clock Profiling Data

Clock Profiling Under Oracle Solaris

Clock Profiling Under Linux

Clock Profiling for OpenMP Programs

Clock Profiling for the Oracle Solaris Kernel

Clock Profiling for MPI Programs

Hardware Counter Profiling Data

Hardware Counter Lists

Format of the Aliased Hardware Counter List

Format of the Raw Hardware Counter List

Synchronization Wait Tracing Data

Heap Tracing (Memory Allocation) Data

I/O Tracing Data

Sample Data

MPI Tracing Data

How Metrics Are Assigned to Program Structure

Function-Level Metrics: Exclusive, Inclusive, and Attributed

Interpreting Attributed Metrics: An Example

How Recursion Affects Function-Level Metrics

Chapter 3 Collecting Performance Data

Compiling and Linking Your Program

Compiling to Analyze Source Code

Compiling for Dataspace and Memoryspace Profiling

Static Linking

Shared Object Handling

Optimization at Compile Time

Compiling Java Programs

Preparing Your Program for Data Collection and Analysis

Using Dynamically Allocated Memory

Using System Libraries

Data Collection and Signals

Sample and Pause-Resume Signals

Using setuid and setgid

Program Control of Data Collection Using libcollector Library

C and C++ Interface

Fortran Interface

Java Interface

C, C++, Fortran, and Java API Functions

Dynamic Functions and Modules

collector_func_load() Function

collector_func_unload() Function

Limitations on Data Collection

Limitations on Clock Profiling

Runtime Distortion and Dilation With Clock Profiling

Limitations on Collection of Tracing Data

Runtime Distortion and Dilation With Tracing

Limitations on Hardware Counter Profiling

Runtime Distortion and Dilation With Hardware Counter Profiling

Limitations on Data Collection for Descendant Processes

Limitations on OpenMP Profiling

Limitations on Java Profiling

Runtime Performance Distortion and Dilation for Applications Written in the Java Programming Language

Where the Data Is Stored

Experiment Names

Experiment Groups

Experiments for Descendant Processes

Experiments for MPI Programs

Experiments on the Kernel and User Processes

Moving Experiments

Estimating Storage Requirements

Collecting Data

Collecting Data Using the collect Command

Data Collection Options

Clock Profiling with the -p option

Hardware Counter Profiling with collect -h

Synchronization Wait Tracing with -s option

Heap Tracing Data with -H option

I/O Tracing with i option

Count Data with c option

Specify Count Data Instrumentation Directory with I directory

Specify Excluded Libraries with N library-name

Sample Data with -S option

Data Race and Deadlock Detection with r option

MPI Profiling with M option

MPI Tracing with m option

Experiment Control Options

Limit the Experiment Size with -L size

Follow Processes with the -F option

Profile Java with -j option

Pass Java Options with -J java-argument

Specify a Signal for Sampling with -l signal

Set a Time Range with t duration

Stop Profiled Target to Allow dbx attach with -x

Signal Pause and Resume State with -y signal [ ,r]

Output Options

Set Experiment Name with -o experiment-name

Set Directory of Experiment with -d directory-name

Create Experiment in a Group with -g group-name

Archive Load Objects in Experiment with the -A option

Save the Command Output to a File with -O file

Other Options

Attach to a Process with P process-id

Add a Comment to the Experiment with -C comment

Try Out a Command with -n

Display the collect Version with -V

Display Verbose Output with -v

Collecting Data From a Running Process Using the collect Utility

To Collect Data From a Running Process Using the collect Utility

Collecting Data Using the dbx collector Subcommands

To Run the Collector From dbx

Data Collection Subcommands

dbxsample { on | off }

Experiment Control Subcommands

sample record name Subcommand

Output Subcommands

archive mode Subcommand

limit value Subcommand

store option Subcommand

Information Subcommands

show Subcommand

status Subcommand

Collecting Data From a Running Process With dbx on Oracle Solaris Platforms

To Collect Data From a Running Process That Is Not Under the Control of dbx

Collecting Tracing Data From a Running Program

Collecting Data From Scripts

Using collect With ppgsz

Collecting Data From MPI Programs

Running the collect Command for MPI

Storing MPI Experiments

Chapter 4 Performance Analyzer Tool

About Performance Analyzer

Starting Performance Analyzer

analyzer Command Options

Experiment Options

-c base-group compare-group

Java Options for analyzer Command

-j | --jdkhome jvm-path

-Jjvm-option

Control Options for analyzer Command

-f | --fontsize size

-v | --verbose

Information Options for analyzer Command

-V | --version

-? | -h | --help

Performance Analyzer User Interface

Menu Bar

Tool Bar

Navigation Panel

Selection Details Window

Called-By/Calls Panel

Performance Analyzer Views

OpenMP Parallel Region View

Source/Disassembly View

MPI Timeline Controls

MPI Chart View

MPI Chart Controls

Setting Library and Class Visibility

Filtering Data

Using Filters

Using Advanced Custom Filters

Using Labels for Filtering

Profiling Applications From Performance Analyzer

Profiling a Running Process

Comparing Experiments

Setting Comparison Style

Using Performance Analyzer Remotely

Using Performance Analyzer on a Desktop Client

How to Use the Remote Performance Analyzer on a Client

Connecting to a Remote Host in Performance Analyzer

Configuration Settings

Views Settings

Metrics Settings

Timeline Settings

Source/Disassembly Settings

Performance Analyzer Configuration File

Chapter 5 er_print Command-Line Performance Analysis Tool

About er_print

er_print Syntax

Metric Lists

Commands That Control the Function List

fsingle function-name [N]

Commands That Control the Callers-Callees List

callers-callees

csingle function-name [N]

cprepend function-name [N | ADDR]

cappend function-name [N | ADDR]

crmfirst

crmlast

Commands That Control the Call Tree List

calltree

Commands Common to Tracing Data

datasize

duration

Commands That Control the Leak and Allocation Lists

Commands That Control the I/O Activity Report

Commands That Control the Source and Disassembly Listings

source|src { filename | function-name } [ N]

disasm|dis { filename | function-name } [ N]

Commands That Control PCs and Lines

Commands That Control Searching For Source Files

setpath path-list

addpath path-list

pathmap old-prefix new-prefix

Commands That Control the Dataspace List

data_objects

data_single name [N]

data_layout

Commands That Control Index Object Lists

indxobj indxobj-type

indxobj_list

indxobj_define indxobj-type index-exp

Commands That Control Memory Object Lists

memobj mobj-type

mobj_list

mobj_define mobj-type index-exp

memobj_drop mobj_type

machinemodel model_name

Commands for the OpenMP Index Objects

OMP_preg

OMP_task

Commands That Support Thread Analyzer

Commands That List Experiments, Samples, Threads, and LWPs

Commands That Control Filtering of Experiment Data

Specifying a Filter Expression

filters filter-exp

Listing Keywords for a Filter Expression

describe

Selecting Samples, Threads, LWPs, and CPUs for Filtering

Selection Lists

Selection Commands

sample_select sample-spec

lwp_select lwp-spec

thread_select thread-spec

cpu_select cpu-spec

Commands That Control Load Object Expansion and Collapse

object_list

object_show object1,object2,...

object_hide object1,object2,...

object_api object1,object2,...

objects_default

object_select object1,object2,...

Commands That List Metrics

Commands That Control Output

outfile {filename|-|--}

appendfile filename

limit n

name { long | short } [ :{ shared-object-name | no-shared-object-name } ]

viewmode { user| expert | machine }

compare { on | off | delta | ratio }

printmode string

Commands That Print Other Information

sample_detail [ exp_id ]

statistics exp_id

Commands for Experiments

add_exp exp_name

drop_exp exp_name

open_exp exp_name

Setting Defaults in .er.rc Files

dmetrics metric-spec

dsort metric-spec

en_desc { on | off | =regexp}

Miscellaneous Commands

Example Filter Expressions

er_print Command Examples

Chapter 6 Understanding Performance Analyzer and Its Data

How Data Collection Works

Recording Experiments

collect Experiments

dbx Experiments That Create a Process

dbx Experiments on a Running Process

Interpreting Performance Metrics

Clock Profiling

Accuracy of Timing Metrics

Comparisons of Timing Metrics

Hardware Counter Overflow Profiling

Dataspace Profiling and Memoryspace Profiling

Synchronization Wait Tracing

Heap Tracing

I/O Tracing

MPI Tracing

Call Stacks and Program Execution

Single-Threaded Execution and Function Calls

Function Calls Between Shared Objects

Signals

Traps

Tail-Call Optimization

Explicit Multithreading

Overview of Java Technology-Based Software Execution

Java Call Stacks and Machine Call Stacks

Clock Profiling and Hardware Counter Overflow Profiling

Java Profiling View Modes

User View Mode of Java Profiling Data

Expert View Mode of Java Profiling Data

Machine View Mode of Java Profiling Data

Overview of OpenMP Software Execution

User View Mode of OpenMP Profile Data

Artificial Functions

User Mode Call Stacks

OpenMP Metrics

Expert View Mode of OpenMP Profiling Data

Machine View Mode of OpenMP Profiling Data

Incomplete Stack Unwinds

Intermediate Files

Mapping Addresses to Program Structure

Process Image

Load Objects and Functions

Aliased Functions

Non-Unique Function Names

Static Functions From Stripped Shared Libraries

Fortran Alternate Entry Points

Cloned Functions

Inlined Functions

Compiler-Generated Body Functions

Outline Functions

Dynamically Compiled Functions

<Unknown> Function

OpenMP Special Functions

<JVM-System> Function

<no Java callstack recorded> Function

<Truncated-stack> Function

<Total> Function

Functions Related to Hardware Counter Overflow Profiling

Mapping Performance Data to Index Objects

Mapping Performance Data to Memory Objects

Mapping Data Addresses to Program Data Objects

Data Object Descriptors

<Total> Data Object

<Scalars> Data Object

<Unknown> Data Object and Its Elements

Chapter 7 Understanding Annotated Source and Disassembly Data

How the Tools Find Source Code

Annotated Source Code

Performance Analyzer Source View Layout

Identifying the Original Source Lines

Index Lines in the Source View

Compiler Commentary

Common Subexpression Elimination

Loop Optimizations

Inlining of Functions

Parallelization

Special Lines in the Annotated Source

Source Line Metrics

Interpreting Source Line Metrics

Metric Formats

Annotated Disassembly Code

Interpreting Annotated Disassembly

Instruction Issue Grouping

Instruction Issue Delay

Attribution of Hardware Counter Overflows

Special Lines in the Source, Disassembly and PCs Tabs

Outline Functions

Compiler-Generated Body Functions

Dynamically Compiled Functions

Java Native Functions

Cloned Functions

Static Functions

Inclusive Metrics

Annotations for Store and Load Instructions

Branch Target

Viewing Source/Disassembly Without an Experiment

-func

-{source,src} item tag

-{disasm,dis} item tag

-{cc,scc,dcc} com-spec

-outfile filename

-V

Chapter 8 Manipulating Experiments

Manipulating Experiments

Copying Experiments With the er_cp Utility

Moving Experiments With the er_mv Utility

Deleting Experiments With the er_rm Utility

Labeling Experiments

er_label Command Syntax

er_label Examples

Using er_label in Scripts

Chapter 9 Kernel Profiling

Kernel Experiments

Setting Up Your System for Kernel Profiling

Running the er_kernel Utility

To Profile the Kernel with er_kernel

To Profile Under Load with er_kernel

Profiling the Kernel for Hardware Counter Overflows

Profiling Kernel and User Processes

Alternative Method for Profiling Kernel and Load Together

To Profile the Kernel and Load Together

Analyzing a Kernel Profile

Index

Index Numbers and Symbols

Language:

Chapter 8

This chapter describes the utilities which are available for use with the Collector and Performance Analyzer.

This chapter covers the following topics: