cvperf(1)

NAME
     cvperf - WorkShop Performance View

SYNOPSIS
     cvperf {<experiment-record> | <pixie-counts-file>}

DESCRIPTION
     cvperf presents a graphical display of the performance data gathered in a
     WorkShop Performance experiment whose experiment directory is given by
     <experiment-record>.

     cvperf can also present the display of performance information from a
     pixie counts file given by <pixie-counts-file>.  To use this feature, you
     will need to install a patch with a later version of pixie than is on the
     current released system.  Contact Customer Support to obtain the patch.

EXPERIMENT TYPES
     The WorkShop Performance tools can record a number of different
     experiments, each of which provides one or more metrics of performance.
     Each has its strengths and weaknesses;  the experiment types are
     described in the CASEVision/WorkShop User's Guide, and are briefly
     described below.

     A ``Bottleneck'' experiment measures the performance of the program by
     sampling the active process' callstack every 100 milliseconds, and using
     the callstack data to attribute exclusive total time to the function at
     the bottom of each callstack (i.e., the function being executed at the
     time of the sample), and to attribute inclusive total time to all the
     functions above the one currently being executed.  In addition, this
     experiment takes a caliper-sample every second, so that the user can
     examine the data for any interval of execution.

     A ``Total Time'' experiment uses the same statistical callstack sampling
     to compute performance metrics, but does not take caliper-samples, except
     as the user specifies them.

     A ``CPU Time'' experiment instruments the program to count function calls
     (both direct, and through function pointers), as well as do statistical
     PC sampling on the resultant instrumented executable.  The PC sample data
     is used to compute exclusive CPU time for each function, and the call
     information is used to propagate the exclusive time to the callers of
     each routine.

     An ``Ideal Time'' experiment generates the same data as a a pixie-fied
     executable.  It instruments the program to maintain precise basic block
     counts, and uses a machine model to convert the block execution counts
     into an idealized exclusive time.  This time will be less than the real
     time that any run would take, as it excludes any pipeline delays across
     basic blocks, and does not take any cache or memory latencies into
     account.  Inclusive time is propagated to callers based on the call
     information, just as it is for ``CPU Time'' experiments.

     An ``I/O Trace'' experiment traces each of the I/O calls made by the
     executable, and computes inclusive and exclusive read and write counts,
     and can show a time-based event chart for all calls with a given file-
     descriptor.

     A ``System Call Trace'' experiment traces all calls, and can show a
     time-based event chart for all calls, as well as compute read and write
     counts.  This experiment is a super-set of the ``I/O Trace'' experiment.

     A ``Page Fault Trace'' experiment computes inclusive and exclusive page
     fault counts, and also shows an event line with the time-based sequence
     of page faults.

     A ``Find Memory Leaks'' experiment traces all calls to malloc, free,
     etc., and computes inclusive and exclusive memory allocations and leaks,
     and will also show any errors in calling these routines.  For more
     information, see the malloc_cv(3) man page for more information.

     A ``Floating Point Exception'' trace experiment traces all such
     exceptions, and computes inclusive and exclusive counts of these
     exceptions, as well as an event line showing the time sequence of the
     exceptions.

     A ``PC Sampling Time'' experiment uses a statistical counting of where
     the process PC is as a function of time, and computes exclusive time from
     that data.  There is no information in the data that allows computing of
     inclusive times.

     A ``Custom Task'' can be run by choosing the particular instrumentation
     and data desired.  Its use is discouraged, because not all combinations
     will give meaningful results.  If there is a custom task that you desire,
     please tell us, and we will endeavor to make a standard one for it.

USER INTERFACE
     The Performance Analyzer main window has a Task component, a Function
     List component, a per thread User Time/System Time State Chart component,
     and a TimeLine component.

     The Task Component- simply states the task or objective that the user
     selected for this experiment.

     The Function List Component- is an annotated list of all the functions in
     the program. The annotations available depend on the experiment task;
     annotations can be enabled or disabled by bringing up the Preferences
     Dialog from the Config menu.

     The State Chart Component- allows the user to quickly guess at the
     bottleneck resources in the different phases of the run, and also to see
     thread balance information.  For some experiments, the State Chart is
     replaced by an event line for the primary events being traced.  For
     ``Find Memory Leaks'' experiment, it is replaced by a plot of process
     address space and resident size as a function of time.
     The TimeLine Component- displays the experiment as a set of events over
     time, and provides calipers to allow the user to specify an interval of
     interest.

     There are also a number additional views, some of which are applicable to
     all experiments, and some of which are meaningful only for some
     experiment types.  The additional views are:

     Usage View (Graphs)- presents a graphical display of the process resource
     usage data in the form of stripcharts and event charts.

     Usage View (Numerical)- presents a textual display of the process and
     system wide resource usage data.

     IO View- presents a per file descriptor chart of the number of bytes
     transferred.  This view is available only for I/O tracing or System call
     tracing experiments.

     Call Graph View- presents the target program as nodes and arcs.

     Butterfly View- shows the caller and callee relationships for any
     selected function.

     Leak View- presents a list of all of the memory leaks in the target
     program.  A leak is any region that is malloc'd, but not free'd.  The
     leaks are aggregated by common callstack.  This view is available only
     for Memory Leak experiments.

     Malloc View- presents a list of all of the memory allocation in the
     target program, aggregated by common callstack.  This view is available
     only for Memory Leak experiments.

     Malloc Error View- presents a list of all of the memory allocation errors
     in the target program, aggregated by common callstack.  This view is
     available only for Memory Leak experiments.

     Heap View- presents a graphical display of use of the heap by the target
     program.  This view is available only for Memory Leak experiments.

     Call Stack View- presents the callstack at the event currently selected
     in the TimeLine component, or in any event chart for tracing experiments.

     Working Set View- presents a list of all of the DSO's in the program,
     with information on the efficiency of use of the text (instruction)
     pages.  This view is available only for Ideal time experiments.

     Source View- presents an annotated Source View, and is brought up by
     double clicking on any function in the function list, on any node in the
     Call Graph View, or on any frame in the Call Stack View.  If cvperf is
     being run in a session with the debugger, cvd, also running, the
     annotations will appear in the debugger's main source window.  If there
     is no debugger window running, a separate Source View will be used.
     Disassembly View- presents an annotated Disassembled View of the
     currently selected function.

SEE ALSO
     cvd(1), cvmeter(1), on-line help for cvperf.