General Ref R

General Commands Reference Guide R
TRACE32 Online Help

TRACE32 Directory
TRACE32 Index
TRACE32 Documents ......................................................................................................................
General Commands ......................................................................................................................
General Commands Reference Guide R ..................................................................................
REFresh ....................................................................................................................................
Function
REFresh.Address
REFresh.CYcle
REFresh.Inc
REFresh.OFF
REFresh.RESet
Refresh address range
Access mode
Address distance
Switch off
Reset command
REFresh.StandBy
Standby mode
REFresh.state
Status display
REFresh.Time
Refresh rate
Register ....................................................................................................................................
Register
Register.Init
Register.LOG
Register.REFRESH
Processor registers
Initialize the processor registers
Log registers
13
Refresh register window
14
Reload the compiler register settings
14
Modify register contents
15
Define stack top address
16
Display registers
17
RESet ........................................................................................................................................
20
Register.RELOAD
Register.Set
Register.StackTop
Register.view
RESet
Reset all commands
20
RTP ...........................................................................................................................................
21
RTP.CLEAR
Clear tracebuffer
21
tbd.
21
Direct data mode read/write
21
Halt system on RTP FIFO overflow
21
Selects the trace mode
21
RTP.OFF
Disables the RTP module
21
RTP.ON
Activates the RTP module
21
Configure RTPCLK
22
Size of RTP data port
22
RTP.DirectDataMode
RTP.DirectDataMode.Mode
RTP.HaltOnOverflow
RTP.Mode
RTP.PortClock
RTP.PortSize
1989-2015 Lauterbach GmbH
RTP.Register
Display the RTP register
RTP.RESet
RTP.state
RTP.TraceMode
RTP.TraceMode.RAM<x>.SECTion<y>
RTP.TraceMode.TraceExclude
Resets RTP settings
22
Display RTP setup
22
tbd.
22
Configures a trace region
22
Invert all trace regions
22
RTS ...........................................................................................................................................
RTS
RTS.FileCompression
24
Real-time profiling (RTS)
24
Code coverage
25
Set the name for the RTS file
26
RTS.COVerage
RTS.FILE
22
Set compression level for the RTS file
26
Set size limit for the RTS file
27
Select the data to write to the RTS file
28
Initialize RTS
29
Statistics regarding instruction execution
29
List recorded trace data
31
RTS.ListNesting
Display function call nesting
32
RTS.LOAD
Mount a file as trace source
33
RTS.FileLimit
RTS.FileMode
RTS.Init
RTS.ISTATistic
RTS.List
RTS.NestingMode
Set type of program flow analysis
34
Deactivate real-time profiling
35
Activate real-time profiling
35
RTS.PROfile
Display performance characteristics charts
36
RTS.RESet
Restore default settings and initialize RTS
37
Open status and control window
37
Statistics regarding function invocations
39
Configure behavior regarding minor errors
40
RTS.OFF
RTS.ON
RTS.state
RTS.STATistic
RTS.StopOnError
RTS.StopOnFifofull
Configure behavior regarding FIFO overflows
40
Configure task analysis
41
Configure analysis of program execution timing
42
RunTime ...................................................................................................................................
43
RTS.TASKMode
RTS.TImeMode
RunTime
Runtime measurement
43
Runtime Measurements Using the Debugger
43
Runtime Measurements Using TRACE32-ICE / TRACE32-FIRE
45
Functions related to RunTime
46
RunTime.Init
Clear timers
46
RunTime.refA
Set reference
47
RunTime.refB
Set reference
47
Reset values to zero
47
Display results
48
RunTime.RESet
RunTime.state
Usage:
(B) command only available for ICD
(E) command only available for ICE
(F) command only available for FIRE

Version 06-Nov-2015
REFresh
Function
The refresh function has to be activated, when a dynamic RAM is on the target system and is refreshed by
the CPU. The refresh function uses burst read cycles for refreshing target memory. Address range and
storage class may be defined.
StandBy
On StandBy mode the refresh burst is forced while no emulation is running.
ref.burst
NOTE:
ref.burst
//////////////////
realtime emulation
ref.burst
ref.burst
This command is for refreshing target DRAMs only, when having dynamic
emulation memory, it is automatically refreshed by dual-port access.
REFresh
REFresh.Address
Format:
Refresh address range
REFresh.Address <address_range>
Defines the address range, which is touched by refresh cycles.

ref.inc 0x1
ref.a ud:0x10000--0x100ff
; Refresh on USERDATA area
ref.inc 0x0
ref.c
word
ref.a
sd:0x1000++0x0ff
; Refresh burst with 128 words on

; address 1000h
If the REF.Inc value is set to zero, the address range will be define the length of the refresh burst to a single
memory address.
See also
REFresh.state
Refresh Generator in ICE Users Guide
REFresh.CYcle
Access mode
ICE only
Format:
REFresh.CYcle <width>
<width>:
Byte
Word
Long
If on 16 bit CPUs the access type is LONG, refresh is made by 2 refresh cycles. If on 8 bit CPUs the option
WORD or LONG is selected, 2 or 4 cycles are used for one refresh cycle.
See also
REFresh.state
REFresh
REFresh.Inc
Address distance
ICE only
Format:
REFresh.Inc <inc>
<inc>:
1.
Defines the address increment used in the refresh access loop.

; force refresh with 256 cycles
ref.t 4.ms
ref.a ud:0x0--0x03ff
ref.c long
ref.i 0x4
ref.on
;
;
;
;
;
cycle time 4 ms
address range 0 to 03ffh
long word
increment 4
switch on refresh operation
; standby refresh on address 1000H

ref.a ud:0x1000++0x0
ref.c b
ref.standby
; address 1000H
; byte access
; switch refresh on
See also
REFresh.state
REFresh.OFF
Switch off
ICE only
Format:
REFresh.OFF
Refresh function is switched to OFF automatically, when the refresh parameters don't fit e.g. an odd address
range together with word size.
See also
REFresh.state
REFresh
REFresh.RESet
Reset command
ICE only
Format:
REFresh.RESet
The refresh system is switched to OFF and all refresh parameters are initialized.
See also
REFresh.state
REFresh.StandBy
Standby mode
ICE only
Format:
REFresh.StandBy
Refresh cycles will be executed, if real-time emulation is not active. Refresh command may be activated only
when all refresh parameters are correct.
See also
REFresh.state
REFresh
REFresh.state
Status display
ICE only
Format:
REFresh.state
Displays the current setup of the refresh function.

E68::w.ref
mode
OFF
ON
StandBy
Address
UD:
000000
0000FF
Cycle
BYTE
Inc
000001
See also
REFresh.Address
REFresh.RESet
REFresh.CYcle
REFresh.StandBy
REFresh.Inc
REFresh.Time
REFresh.OFF
REFresh.Time
Refresh rate
ICE only
Format:
REFresh.Time <time>
<time>:
1.0ms 1.0s
Will define the refresh time, if cyclic refresh is selected. This field has no effect on standby-refresh.
ref.t 4.0ms
; refresh burst every 4 ms
See also
REFresh.state
REFresh
Register
Register
Processor registers
The Register command group is used to control the processor registers. In case of subprocessors (e.g.,
FPU) extra commands are provided.
Register values can be returned by the function Register(<register name>)
PRINT Register(D0)
; print the contents of the

; register D0 in the message line
Register.Set D1 Register(D0)
; set register D1 to the contents

; of register D0
See also
Register.Init
Register.REFRESH
Register.Set
Register.view
Register()
Register.LOG
Register.RELOAD
Register.StackTop
PP()
Register.LIST()
Release Information in Release History
Register.Init
Format:
Initialize the processor registers
Register.Init
Register.RESet (deprecated)
Sets the registers to the same state as after the processor reset. Registers which are undefined after
RESET are set to zero.
B::
; example for the debugger
SYStem.Up
; establish the communication between the

; processor and the debugger
Register.Init
; initialize the general purpose registers
Register
CPU
Behavior of Register.Init
ARC
STATUS
STATUS32
DEBUG
IRQ_LV12
IENABLE
SEMAPHORE
<=
<=
<=
<=
<=
<=
0x02000000
0x00000001
0x11000000
0x00000002 (Resets any interrupt flags)
0xffffffff
0x00000000
All other registers are set to zero.

If SYStem.Option ResetDetection is used with a semaphore bit
(Sem0...Sem3), Register.Init sets the corresponding semaphore
bit in the SEMAPHORE register.
ARM, Cortex, XScale
ARM7/9/10/11, Cortex-A/R, XScale:

Rx = 0
SPSRx = 0x10
CPSR = 0xd3 (ARM7/9/10, XScale), 0x1d3 (ARM11, Cortex-A/R)
R15 (PC) = 0, 0xffff0000 if high exception vectors selected
Cortex-M:
Rx = 0
R15 (PC) = [vector table base + 4]
xPSR = 0x01000000
MSP = [vector table base + 0]
PSP = 0
R13 (SP) = MSP or PSP depending on the mode
C166
The CP is set to 0xFC00. The sixteen registers R0 - R15 are set to

0x0. DPP0 = 0x0, DPP1 = 0x1, DPP2 = 0x2 and DPP3 = 0x3.
Stack registers STKUN is set to 0xFC00 and STKOV is set to
0xFA00.
The Stack Pointer SP is set to 0xFC00
The Instruction Pointer IP is set to zero.
The Code Segment Pointer CSP and the VECSEG are set to the
initial value after SYStem.Up.
CEVA-X
MODA and MODA shadow register are set to 0x1E.

10
Register
CPU
DSP56K
Family 56000 and 56100

The eight 16-bit modifier registers M[0-7] are set to 0xFFFF. This
specifies linear arithmetic as the default type for address register
update calculations.The Operating Mode Register (OMR) is set to
the initial value after SYStem.Up. Values of bits MA, MB and MC of
the OMR register are preserved.The program counter is set to
zero. All interrupts are masked by setting the Status Register (SR)
to 0x300.
Family 56300 and 56720 Dualcore
The eight 24-bit modifier registers M[0-7] are set to 0xFFFFFF.
This specifies linear arithmetic as the default type for address
register update calculations. The Operating Mode Register (OMR)
is set to the initial value after SYStem.Up. Values of bits MA, MB,
MC and MD of the OMR register are preserved. All interrupts are
masked by setting Status Register (SR) to 0x300. The program
counter is set to zero.
Family 56800 and 56800E
The eight 16-bit modifier registers M[0-7] are set to 0xFFFF. This
specifies linear arithmetic as the default type for address register
update calculations. The Operating Mode Register (OMR) is set to
the initial value after SYStem.Up. Values of bits MA and MB of the
OMR register are preserved. All interrupts are masked by setting
Status Register (SR) to 0x300. The program counter is set to zero.
HCS08
The Program Counter is set to the value read at 0xFFFE. The

Stack Pointer SP is set to 0xFF and the CCR is set to 0x68. All
other registers are set to zero.
HC11
The Program Counter is set to the value read at 0xFFFE. The

Stack Pointer SP is set to a default value dependent on the
derivative. The CCR is set to 0xD8. All other registers are set to
zero.
HC12/S12/S12X
The Program Counter is set to the value read at 0xFFFE. The CCR
is set to 0xD8. All other registers are set to zero.
MIPS32/MIPS64/NEC-VR
Program Counter, Status register and Config register are set to

their initial values after reset (read during SYStem.Up). PRID and
Cause register are updated, all other registers are set to zero.
MMDSP
Sets all registers to their initial value after a reset. This is done via
a soft reset of the core.
NOTE: This may have effects besides updating the contents of
architectural registers.
PowerPC
Program counter and MSR are set to their initial values after reset
(read during SYStem.Up). GPRs and SPR appearing in the
Register window are set to zero.
11
Register
CPU
Microblaze
All registers are set to zero.
PCP
Teak
MOD0 and MOD0S registers SATA bit is set. MOD1 and MOD1S
regsiters CMD bit is set. MOD3 and MOD3S registers CREP, CPC
and CCNTA bits are set.
Teaklite/Teaklite-II/Oak
Teaklite-III
MOD2 register SATA and SATP bits are set.

x86
EDX is set to a cpu specific value defining the family/model/

stepping of the core if a SYStem.Up has been executed at some
point before, otherwise EDX is set to 0.
EAX,EBX,ECX,ESI,EDI,ESP,EBP are set to 0.
EIP is set to 0xFFF0 and EFLAGS to 2.
CR0 is set to 0x60000010 and CR2-4 to 0.
DR0-3 are set to 0. DR6 to 0xFFFF0FF0 and DR7 to 0x400.
IDT and GDT: Base = 0 and Limit = 0xFFFF.
LDT and TR: Selector = 0, Base = 0, Limit = 0xFFFF, Access =
0x82.
CS: Selector = 0xF000, Base = 0xFFFF0000, Limit = 0xFFFF,
Access = 0x93.
DS,ES,FS,GS,SS: Selector = 0, Base = 0, Limit = 0xFFFF, Access
= 0x93.
NOTE: In a multicore system the above holds for the main
bootstrap processor. For the other processors the following
differences apply: EIP is set to 0x10000 and CR0 to 0x10.
TMS320
All registers except SSR, IER and TSR are set to zero.
TriCore
All registers are set to zero with the following exceptions:

The initial values for registers PC, PSW, ISP and BTV are read
from the CPU at SYStem.Up.
If this is not possible the following default values are assumed:
PC=0xA0000020 (AURIX and later), 0xA0000000 (otherwise)
PSW=0x00000B80
BTV=0xA0000100
ISP=0x00000100
XTENSA
ZSP
12
Register
See also
Register
Register.view
Register and Peripherals in ICE Users Guide
Register.LOG
Log registers
Format:
Register.LOG [<set>] [/<option>]
<set>:
ALL
<option>:
AREA <name>
Writes the selected registers to the AREA window whenever the program execution stops. The output can
be redirected to any named AREA window. The output of any AREA windows can also be redirected to a
file.
AREA.Create REG_LOG
; set-up an AREA window named

; REG_LOG
AREA.OPEN REG_LOG regfile.log
; write all outputs to the

; AREA window REG_LOG also to the
; file regfile.log
AREA.view REG_LOG
; display the AREA window REG_LOG

; in TRACE32
Register.LOG ALL /AREA REG_LOG
; log the contents of all registers

; at every program stop to the
; AREA window REG_LOG
Register.LOG
; end the register logging
AREA.CLOSE REG_LOG
; close the file regfile.log
See also
Register
Register.view
13
Register
Register.REFRESH
Format:
Refresh register window
Register.REFRESH
Forces the debugger to re-read all processor registers from the target and refresh the Register window.
Use this command, if your registers might have changed. The timebase registers of the PowerPC
processors for example change permanently even when the program execution is stopped.
NOTE:
Whenever the program execution is stopped, the Register window gets refreshed
automatically.
See also
Register
Register.view
Register.RELOAD
Format:
Reload the compiler register settings
Register.RELOAD
Re-write the initialization values of the last Data.LOAD command into the appropriate processor registers.
See also
Register
Register.view
14
Register
Register.Set
Modify register contents
Format:
Register.Set <register> [<value>] [/Task <task>]
<register>:
D0 | D1 | D2 | D3 |
Sets <register> to the specified <value>.

The Register.Set command is also invoked by a double click to the register contents or by choosing Set
in the Register pull-down menu.
Register.Set PC start
; set the Program Counter to the label

; start
Register.Set D0 Register(D0)+1
; increment register contents
See also
Register
Register()
Register.view

Registers in Debugger Basics - Training
Registers in Training FIRE Basics
Registers in Training ICE Basics
15
Register
Register.StackTop
Format:
Define stack top address
Register.StackTop <address>
Limits the display of the stack in the register window. When the stack is below or equal to this address its
contents will not be displayed.
Register.StackTop 0x14000
; limit the stack display in the

; register window to address
; 0x14000
See also
Register
Register()
Register.view
16
Register
Register.view
Display registers
Format:
Register.view [/<option>]
<option>:
SpotLight
Stack
ForeGroundSet | BackGroundSet | SystemSet | TemporarySet
CORE <number>
REGSET <number> | Current | Previous
TASK <taskmagic> | <taskid>. | "<taskname>"
Display the general purpose registers. For some CPUs additional information is displayed if the
Register.view window is dragged to its full size.
Default display
Full display
SpotLight
Highlight changed registers.

Registers changed by the last program run/single step are marked
in dark red. Registers changed by the second to last program run/
single step are marked a little bit lighter. This works up to a level of
4.
Register.view /SpotLight
17
Register
Stack
With Stack: The stack display (A) is shown.

Without Stack: The stack display is hidden.
A
B
C
B. Toggle between:
S = Addresses relative to the stack pointer
F = Addresses relative to the frame pointer
C = Addresses relative to the canonical frame address

C. Clicking the Stack button in the Register.view window lets you
show/hide the stack display on the fly.
ForeGroundSet
(TRACE32-ICE only)
Display the registers of the application program.
TRACE32-ICE allows to run a background program. The
background program is always executed, when the execution of
the application program stopped. The purpose of the background
program can be to maintain interrupts, refresh memory or trigger
watchdogs in the target.
BackGroundSet
(TRACE32-ICE only)
Display the registers of the background program.
SystemSet
The TRACE32-internal register set is a temporary buffer within

TRACE32. This buffer is used to hold a copy of the CPU registers.
Commands like Register.Copy, Register.SWAP are using this
TRACE32-internal register set.
TemporarySet
(diagnosis purpose only)
Register.COPY
; copy general purpose registers into the

; TRACE32-internal register set
Go
; start program execution
Break
; stop program execution
Register.view /SystemSet
; display TRACE32-internal register set
18
Register
CORE <number>
(SMP debugging only)

The TRACE32 GUI displays the context (registers, cache,
memory ) of the currently selected core if SMP debugging is
performed. The option CORE allows to display the register set of
another core.
CORE.select CORE 1
; advise TRACE32 to display the

; context of core 1
Register.view
; display the registers of the

; current context
Register.view /CORE 0
; display the registers for core 0
REGSET <number>
(processor-specific)
MIPS architecture: Display the specified shadow register set.
SH2A architecture: Display the specified register bank.
TASK <taskmagic> | <taskid>. | "<taskname>"
Display the register set of the specified task.
Register.view /TASK 0x41498
; <magic>
; <task_id>
Register.view /TASK "thread 0"
; <name>
See also
Go.direct
Register.Init
Register.REFRESH
Register.Set
PP()
Register.LIST()
Register
Register.LOG
Register.RELOAD
Register.StackTop
Register()
CPU specific Implementations in MIPS Debugger and Trace

19
Register
RESet
Resets all commands.
RESet
Format:
Reset all commands
RESet
(E) All commands of the emulator are reset to their default state.
(B) (BDM Debugger) All commands of the BDM-debugger are reset to their default state.
(B) (ROM Monitor) Switches off the EPROM simulator and resets the mapping system to its default state.
The target CPU is reset only if the RES pin of one adapter is connected and adapted to the target CPU.
See also
SYStem.RESet
RESET in EPROM/FLASH Simulator
20
RESet
RTP
RTP.CLEAR
Clear tracebuffer
see command RTP.CLEAR in 'RAM Trace Port' (trace_rtp.pdf, page 7)
RTP.DirectDataMode
tbd.
see command RTP.DirectDataMode in 'RAM Trace Port' (trace_rtp.pdf, page 8)
RTP.DirectDataMode.Mode
Direct data mode read/write
see command RTP.DirectDataMode.Mode in 'RAM Trace Port' (trace_rtp.pdf, page 8)
RTP.HaltOnOverflow
Halt system on RTP FIFO overflow
see command RTP.HaltOnOverflow in 'RAM Trace Port' (trace_rtp.pdf, page 9)
RTP.Mode
Selects the trace mode
see command RTP.Mode in 'RAM Trace Port' (trace_rtp.pdf, page 9)
RTP.OFF
Disables the RTP module
see command RTP.OFF in 'RAM Trace Port' (trace_rtp.pdf, page 9)
RTP.ON
Activates the RTP module
see command RTP.ON in 'RAM Trace Port' (trace_rtp.pdf, page 10)
21
RTP
RTP.PortClock
Configure RTPCLK
see command RTP.PortClock in 'RAM Trace Port' (trace_rtp.pdf, page 11)
RTP.PortSize
Size of RTP data port
see command RTP.PortSize in 'RAM Trace Port' (trace_rtp.pdf, page 10)
RTP.Register
Display the RTP register
see command RTP.Register in 'RAM Trace Port' (trace_rtp.pdf, page 10)
RTP.RESet
Resets RTP settings
see command RTP.RESet in 'RAM Trace Port' (trace_rtp.pdf, page 11)
RTP.state
Display RTP setup
see command RTP.state in 'RAM Trace Port' (trace_rtp.pdf, page 12)
RTP.TraceMode
tbd.
see command RTP.TraceMode in 'RAM Trace Port' (trace_rtp.pdf, page 13)
RTP.TraceMode.RAM<x>.SECTion<y>
Configures a trace region
see command RTP.TraceMode.RAM<x>.SECTion<y> in 'RAM Trace Port' (trace_rtp.pdf, page 13)
RTP.TraceMode.TraceExclude
Invert all trace regions
see command RTP.TraceMode.TraceExclude in 'RAM Trace Port' (trace_rtp.pdf, page 14)
22
RTP
23
RTP
RTS
RTS
Real-time profiling (RTS)
Real-time profiling (RTS) is a trace mode that processes the trace data being recorded from the target
while the target is running. This is in contrast to the classical flow trace (accessed via the <trace>
command) which uploads and processes the trace data only after the target stopped.
The operation mode of RTS is controlled by the commands RTS.ON (enabled), RTS.OFF (disabled), and
RTS.LOAD. The states enabled / disabled control which source of trace data is analyzed by the commands
COVerage and ISTATistic.
If RTS is enabled, the trace data is taken from the RTS database.
If RTS is disabled, the trace data is taken from the FIFO memory of the POWER TRACE module.
The following figure provides an overview of the sources of trace data accessed by various commands.
POWER TRACE
module*
RTS
enabled?
NO
YES
COVerage
ISTATistic
<trace>.List
<trace>.STATistic
(...)
RTS
Database**
RTS.List
RTS.ListNesting
RTS.STATistic
* With a FIFO memory of up to 4GB.

** The maximum database size depends on the disk size of the host computer.
RTS.LOAD mounts an RTS file, so that the above commands operate on the file data instead of on live
recorded data. To create an RTS file, enable one of the options of RTS.FileMode while recording trace data
in mode RTS.ON.
For more information on host system requirements, system setup and for a quick start guide, see ARMETM RTS Users Guide (rts_user.pdf).
See also
COVerage
RTS.FileLimit
RTS.List
RTS.OFF
RTS.state
RTS.TASKMode
RTS.COVerage
RTS.FileMode
RTS.ListNesting
RTS.ON
RTS.STATistic
RTS.TImeMode
RTS.FILE
RTS.Init
RTS.LOAD
RTS.PROfile
RTS.StopOnError
RTS.ERROR()
RTS.FileCompression
RTS.ISTATistic
RTS.NestingMode
RTS.RESet
RTS.StopOnFifofull
RTS.RECORDS()
24
RTS
RTS.COVerage
Format:
Code coverage
RTS.COVerage
The (deprecated) RTS.COVerage command is an alias for the command COVerage for code coverage
analysis. RTS supports the subset of the COVerage commands listed below:
List
obsolete - use COVerage.List instead.
ListModule
obsolete - use COVerage.ListModule instead.
ListFunc
obsolete - use COVerage.ListFunc instead.
ListLine
obsolete - use COVerage.ListLine instead.
Set
obsolete - use COVerage.Set instead.
Delete
obsolete - use COVerage.Delete instead.
NOTE:
Another option for displaying the coverage information is the command

Data.List /COV
When using this command, it is necessary to have some RTS.COVerage window
open to keep the contents of the Data.List window updated.
See also
RTS
RTS.state
25
RTS
RTS.FILE
Format:
Set the name for the RTS file
RTS.FILE <file>
RTS.FILE sets the name of the RTS <file> used in the modes RTS.ON and RTS.LOAD. The default
name is t32.rts. The current file name is displayed in the RTS.state window.
In mode RTS.ON, the file name is used for creating the file in which trace data and analysis results are
stored. This feature is controlled by the options of RTS.FileMode.
In mode RTS.LOAD, the file is mounted as source of trace data and analysis results.
See also
RTS
RTS.state
RTS.FileCompression
Format:
Set compression level for the RTS file
RTS.FileCompression OFF | LOW | MID | HIGH
RTS.FileCompression sets the compression level for writing the RTS file. When choosing the
compression level, consider that a higher level requires more processing resources and therefore may
cause that processing on the host cannot keep up with the data recorded. You may want to experiment
to find the best compression rate for your application.
Refer to the ARM-ETM RTS Users Guide (rts_user.pdf) for additional performance considerations.
OFF
No compression
LOW
Uses a fast compression algorithm
MID
Uses an algorithm with a good trade-off between speed and space reduction.
HIGH
Uses an algorithm with a high best compression rate and high requirements
regarding processing resources
See also
RTS
RTS.state
26
RTS
RTS.FileLimit
Format:
Set size limit for the RTS file
RTS.FileLimit <+/- limit in bytes>
The command sets the maximum size allowed for an RTS file. If the maximum size is reached, streaming is
stopped. When setting the file limit consider that the file still can grow in size and thus exceed the set limit,
when closing streaming with RTS.OFF because the streaming data base is written to the file.
The limit value is given in bytes and can have a positive or negative sign:
Positive value: the maximum size of the RTS file in bytes
Negative value: specifies the amount of space to leave on the disk before stopping streaming.
The maximum file size is calculated based on the amount of available disk space at the time of
starting streaming.
The default setting is -1.000.000.000 i.e. stops streaming when less than a GB of space is left on the mass
storage medium.
NOTE:
The file limit and the name of the RTS file must be set before starting streaming.
Later changes are not taken into account.
See also
RTS
RTS.state
27
RTS
RTS.FileMode
Format:
Select the data to write to the RTS file
RTS.FileMode OFF | Summary | Tasks | FULL
RTS is able to write the recorded trace data and processing results to an RTS file. RTS.FileMode
specifies which types of data are written to the RTS file.
The desired file mode must be set before invoking RTS.ON because at this point the RTS file is created. The
file is closed by RTS.OFF after writing all pending data.
The following table list the options in ascending order of saved detail and required space:
OFF
No RTS file is created.
Summary
The results of the program flow analysis and the contents of the virtual
memory are saved after the analysis.
Tasks
Task switch information is saved in addition to the data saved for summary.
FULL
The complete trace data is saved in addition to the data stored for the previous
modes. With the option FULL, trace files can reach various GBs of size and are
only limited by the space available on the hard disk.
The commands RTS.List and RTS.ListNesting only work with RTS.FileMode.FULL. Also other
commands depend on the level of detail in the RTS file. The following table lists the RTS command
families and the respective RTS.FileMode option required.
Command Group
Required RTS.FileMode
RTS.STAT.*,
RTS.ISTAT.*,
Data.List /ISTAT
With RTS.ON
: always available, also with RTS.FileMode.OFF
With RTS.LOAD : requires RTS.FileMode.Summary or higher
RTS.Chart
With RTS.ON and RTS.LOAD : requires RTS.FileMode.Tasks or higher

tbd.
RTS.List,
RTS.ListNesting
With RTS.ON and RTS.LOAD : requires RTS.FileMode.FULL
NOTE:
When writing trace data to the RTS file, the RTS session needs to be closed with
RTS.OFF to flush pending data to disk.
See also
RTS
RTS.state
28
RTS
RTS.Init
Format:
Initialize RTS
RTS.Init
Initializes RTS by clearing the result data base and internal data structures. In particular the command
also clears the data bases for ISTATistic and COVerage.
RTS.Init does not reset the processing options like RTS.RESet.
See also
RTS
RTS.state
RTS.ISTATistic
Statistics regarding instruction execution
Format:
RTS.ISTATistic <view_option> | <modification_option>
<view
_option>:
List
ListModule
ListFunc
ListLine
<modification
_option>:
Delete
Set
RTS.ISTATistic implements the ISTATistic functionality for RTS.

The <trace>.ISTATistic commands work on a data base of coverage information concerning individual
machine instructions. This is in contrast to the RTS.STATistic command working on the results of the
analysis of the function call patterns.
While RTS is active (mode RTS.ON), the ISTAT result data base and all dependent ISTATistic views
are updated when new trace data becomes available because the target is executing code.
The command RTS.ISTATistic.List creates a view on the data base with the granularity of sequentially
executed code blocks (the code blocks defined by waypoints) and is agnostic of symbols or lines of source
code. For each code block, a number of metrics like execution time, code coverage in percent, clock cycles
used are shown.
29
RTS
The commands RTS.ISTATistic.ListModule, RTS.ISTATistic.ListFunc, RTS.ISTATistic.ListLine each

create a tree view on the data base accumulating the respective values for the following source code
entities:
Modules (usually a compilation unit like an object file or a library),
Functions or
Source lines.
This forms a hierarchical structure that can be displayed in a tree because a source line is part of a function
which in turn is member of a module. Accordingly the only difference between these functions is, which
branches of the tree are initially open.
The following table lists the view options.
List
Creates a view with the granularity of executed code blocks.
ListModule
Creates a view showing statistics data for modules, with the option to open the
tree to inspect functions and source lines. The values shown for modules are
those accumulated from all its functions (and consequently all its source lines).
ListFunc
Creates a view showing statistics data for functions
ListLine
Creates a view showing statistics data for source lines
The options Delete and Set allow to manually modify the contents of the ISTAT data base:
Delete
Delete the coverage information for an address or address range from the
ISTAT data base, therefore essentially marking the area as not executed.
Set
Marks an address or address range as executed in the ISTAT data base.
For further information please refer to <trace>.ISTATistic.
NOTE:
Another option for displaying the coverage information is the command

Data.List /ISTAT
When using this command, it is necessary to have some RTS.ISTAT window open
to keep the contents of the Data.List window updated.
See also
RTS
RTS.state
30
RTS
RTS.List
List recorded trace data
Format:
RTS.List <option>
<option>:
formats
options
DEFault
ALL
cpu
lines
List
MARK
SPARE
STREAM
DIAG
<range>
<record>
RTS.List shows the recorded trace data.

In contrast to the other trace modes, in mode RTS.ON, the contents is updated while the target is running.
As well in mode RTS.ON as in mode RTS.LOAD, the command RTS.List works on the data read from an
RTS file (rather than the analyzer buffer). As the size of the file is only limited by the hard disk, RTS.List
works on virtually unlimited amounts of trace data.
Therefore RTS.List requires the option RTS.FileMode.FULL.
For a description of the options please refer to the command <trace>.List.
CAVEAT:
This feature is not yet supported with the PTM trace protocol.
Note:
The Trace.List command is available also in mode RTS.ON. However, it will only
display data, when the target is stopped and after RTS has processed all pending
data. The difference is that the command Trace.List shows the data available in
the analyzer's buffer (a maximum of 4GB) while RTS.List works on the trace data
in the RTS file.
The command RTS.List is not designed to work with data that contains errors. For
localizing errors in the trace data stream use Trace.List instead. For details, see
the section Avoiding and Fixing Processing Errors in ARM-ETM RTS
Users Guide (rts_user.pdf).
See also
RTS
RTS.state
31
RTS
RTS.ListNesting
Display function call nesting
Format:
RTS.ListNesting <option>
<option>:
formats
options
DEFault
ALL
cpu
lines
List
MARK
SPARE
STREAM
DIAG
<range>
<record>
Displays the recorded trace data in a way that the nesting of function calls is outlined.
RTS.ListNesting requires the options RTS.FileMode.FULL and RTS.NestingMode.TREE.
See <trace>.ListNesting for more details and a description of the options.
CAVEAT:
This feature is not yet supported with the PTM trace protocol.
See also
RTS
RTS.state
32
RTS
RTS.LOAD
Mount a file as trace source
Format:
RTS.LOAD [<file name>]
<file name>
name of the file to mount as trace source and to set as default name
Configures the debugger to use the trace data from a pre-recorded RTS file (rather than from the analyzer).
Therefore all analysis commands (RTS.ISTATistic, RTS.STATistic, RTS.List, ... ) operate on the data from
the file.
Using a file for supplying trace data is possible because conceptually all trace commands work on socalled trace sources i.e. on entities providing trace data. Examples for trace sources are a POWERTRACE
device providing live trace data, a RAM area (see RTP) or a file containing previously stored trace data.
If RTS.LOAD is executed with a file name parameter, it is set as default file name (as with RTS.FILE) and
then mounted. Without a parameter, the current file name is used.
In mode RTS.LOAD some or all of the analysis features are available, depending on the data stored in the
RTS file (see RTS.FileMode for details). However note, that only the final result is shown e.g. the code
coverage at the end of program execution.
The options like RTS.FunctionMode, RTS.TImeMode, ... are taken from the RTS file and cannot be set
manually. Also the radio button for RTS.ON is disabled while in load mode in order to prevent accidentally
overwriting the existing RTS file. For leaving load mode, switch to RTS.OFF which will enable all options.
For a usage example see the ARM-ETM RTS Users Guide (rts_user.pdf)
NOTE:
For using RTS.LOAD it is necessary to load the programs symbols (e.g. via
Data.LOAD.ELF ... /NoCODE).
See also
RTS
RTS.state
33
RTS
RTS.NestingMode
Format:
Set type of program flow analysis
RTS.NestingMode FLAT | TREE
Defines the type of program flow analysis the debugger performs:

FLAT
Only generates program coverage information regarding individual machine

instructions. As FLAT mode does not analyze the call graph it requires less
processing resources than nested mode.
The results of the analysis are displayed via the RTS.ISTATistic command.
TREE
Analyzes the programs call graph in addition to the coverage information as

done in mode FLAT.
The results of the analysis are displayed via the RTS.STATistic command.
See also
RTS
RTS.state
34
RTS
RTS.OFF
Format:
Deactivate real-time profiling
RTS.OFF
Ends an RTS session and stops recording new data.

If used with an RTS file (see RTS.FileMode), flushes pending data and processing results to disk. This may
require some time to complete.
NOTE:
When the RTS file does not contain sensible data (e.g. in the case of an RTS.ON
followed immediately by RTS.OFF without processing any data), RTS.OFF deletes
the superfluous RTS file. This avoids overwriting an older, potentially important
*.bak file at the next RTS.ON.
Generally for important data, it is advisable to make a copy of the last RTS file or
rename it immediately after ending the RTS sessions.
See also
RTS
RTS.state
RTS.ON
Format:
Activate real-time profiling
RTS.ON
Enables real-time profiling and prepares the debugger for processing trace data. The command RTS.ON
should be invoked before starting the target so the debugger can synchronize to the beginning of the trace
data stream.
If the option RTS.FileMode is enable, the command creates the RTS file. The name of the RTS file is set
using RTS.FILE. By convention the file name should end with the extension .RTS.
If necessary, RTS.ON creates a backup of a previous file with the same name by changing the extension to
*.bak.
Regarding information how to use the file, see RTS.LOAD and theARM-ETM RTS Users Guide
(rts_user.pdf).
See also
RTS
RTS.state
35
RTS
RTS.PROfile
Display performance characteristics charts
Format:
RTS.PROfile <event option> [{<event option>}] <time>
<event
option>:
MIPS
READS
WRITES
TaskSwitches
Displays a window charting the occurrence of events on the vertical axis versus the elapsed time on the
horizontal axis.
Multiple events (up to three) can be displayed in a single window. In this case the events are displayed using
the base colors red, green and blue, including mixed colors where ranges overlap. The events are
assigned colors according to their position in the command line:
1st parameter : red
2nd parameter : green
3rd parameter : blue
The following table explains the event options:

MIPS
Number of instructions executed; the term MIPS is slightly misleading.
READS
Number of memory read operations executed by the core
WRITES
Number of memory write operations executed by the core
TaskSwitches
Number of task switches performed.
<time>
Use the <time> parameter to define the update interval (e.g. 0.5s for two updates
per second).
See also
RTS
RTS.state
36
RTS
RTS.RESet
Format:
Restore default settings and initialize RTS
RTS.RESet
RTS.RESet restores the default settings (like RTS.TImeMode.OFF, RTS.FileMode.OFF, ...), and similar
to RTS.Init clears the result data base and re-initializes RTS by resetting all internal data structures.
See also
RTS
RTS.state
RTS.state
Format:
Open status and control window
RTS
RTS.state
The command RTS.state (short form RTS) opens the RTS status and control window:
This window displays the current status of the RTS system, allows to configure the most important
options and gives access to various analysis options through the buttons at the left side. In the following
we only describe the fields of the box utilization. For a description of the other elements please refer to
the documentation of the respective commands (e.g. for the box NestingMode refer to the command
RTS.NestingMode).
The fields under utilization have the following meaning:
The colored bar represents the fill level of the buffer holding of data awaiting processing. When
the buffer overflows, processing will fail. The number is the amount of pending data in MBs.
state: the state of RTS (yellow: waiting for synchronization pattern in the trace data stream;
green: recording and analyzing trace data; red: an error occurred; blue: not tracing)
data size: the amount of processed trace data

37
RTS
The field errors displays type of the latest error in plain text and the total accumulated number of
errors of any type. The following errors are handled:
no access to code : the decoder failed to read the opcodes necessary for decoding the trace
data. Usually this is caused by not copying a range of program code to the debuggers VM.
out of memory
stack overflow, stack underflow : when tracking the programs calling hierarchy (using
RTS.NestingMode.TREE), the debugger maintains information about invocations on an internal
stack. The error message is output, when this stack overflows or underflows.
illegal cancel : a cancel message was found in the trace data stream that should not be
there. Applicable only for the ETMV3 protocol.
flow error : the trace data does not match the executed program. This can be caused by
physical transmission errors of the trace data (bad signal quality on the trace port) or because
some executed code is missing in the debuggers VM. Even a single missing or incorrect opcode
can cause this problem.
vtrace error :
fatal error :
See also
RTS
RTS.FileLimit
RTS.List
RTS.OFF
RTS.STATistic
RTS.TImeMode
RTS.COVerage
RTS.FileMode
RTS.ListNesting
RTS.ON
RTS.StopOnError
RTS.ERROR()
RTS.FILE
RTS.Init
RTS.LOAD
RTS.PROfile
RTS.StopOnFifofull
RTS.RECORDS()
RTS.FileCompression
RTS.ISTATistic
RTS.NestingMode
RTS.RESet
RTS.TASKMode
38
RTS
RTS.STATistic
Statistics regarding function invocations
Format:
RTS.STATistic <option>
<option>:
sYmbol
Address
Line
GROUP
AddressGROUP
Var
DatasYmbol
Func
TREE
ChildTREE
ParentTREE
LINKage
TASK
TASKKernel
TASKState
RTS.STATistic implements the <trace>.STATistic functionality for RTS.

The <trace>.STATistic commands work on a data base recording functions calls and function execution
time values (min, max). This is in contrast to the <trace>.ISTATistic commands working on the coverage
information regarding individual machine instructions.
See also
RTS
RTS.state
39
RTS
RTS.StopOnError
Format:
Configure behavior regarding minor errors
RTS.StopOnError [ON | OFF]
The option StopOnError (read stop on minor errors) controls the behavior of RTS in case of minor
errors like Flow Errors or no access to code errors. For more serious errors (out of memory, ...) the RTS
decoder always stops processing.
NOTE:
The analysis mode RTS.NestingMode.TREE is rather delicate regarding errors

in the trace data stream as missing calls or return-from-subroutine-operations
can disrupt the analysis of the program flow in a way that cannot be recovered
from. Therefore it is important to calibrate the preprocessor using the autofocus
feature.
See also
RTS
RTS.state
RTS.StopOnFifofull
Format:
Configure behavior regarding FIFO overflows
RTS.StopOnFifofull [ON | OFF]
The option StopOnFifoFull controls the behavior of RTS in case of overflows of the targets FIFOs.
NOTE:
The analysis mode RTS.NestingMode.TREE is rather delicate regarding gaps

in the trace data stream as missing calls or return-from-subroutine-operations
can disrupt the analysis of the program flow in a way that cannot be recovered
from. Therefore it is important to calibrate the preprocessor using the autofocus
feature.
See also
RTS
RTS.state
40
RTS
RTS.TASKMode
Format:
Configure task analysis
RTS.TASKMode OFF | STATIC | DYNAMIC
Defines if the analysis considers task information or not.
OFF
The debugger ignores information about task switches in the trace stream.
STATIC
The information regarding (all relevant) tasks is retrieved at the beginning of the
analysis from the RTOS awareness. Tasks that are created later are not
included in the analysis.
The feature is under development.
DYNAMIC
The information regarding newly created and terminated tasks is retrieved

dynamically from the RTOS awareness while the system runs.
The feature is under development.
In the modes STATIC and DYNAMIC, the task switch information in the trace data stream is used to
attribute executed opcodes to the correct task.
See also
RTS
RTS.state
41
RTS
RTS.TImeMode
Format:
Configure analysis of program execution timing
RTS.TImeMode OFF | Sampling | CycleAccurate
Defines the type of real-time (wall-clock time) information that is gathered and analyzed:
OFF
no real-time information is generated. Use this for plain code coverage and
trace functions.
Sampling
Activates a coarse timestamp that is created by the Autofocus preprocessor.

It generates very little overhead of trace data at the cost of a lower resolution
than cycle-accurate tracing. The timestamp is created approximately every
1000 cycles of the trace clock.
CycleAccurate
Uses the cycle-accurate mode of the chip (e.g. ETMV3 cycle accurate
mode). If the amount of generated trace in cycle-accurate mode is too big,
Sampling may be an alternative.
For using cycle accurate mode, it is necessary to inform the debugger about the
targets CPU clock using the command <trace>.CLOCK.
CAVEAT:
Currently sampling mode is not supported for Coresight systems.
See also
RTS
RTS.state
42
RTS
RunTime
RunTime
Runtime measurement
The RunTime command group and the RunTime() functions allow to measure the time that the target
executed code i.e. the so-called runtime. The runtime starts with the target reset and increments while the
target executes program code. The target runtime is frozen, while the target is stopped.
There are different methods of measuring the runtime with different accuracies. The available methods
depend on the target hardware and the debug interface (debugger-based vs. trace-based or emulatorbased).
See also
RunTime.Init
RunTime.state
RunTime.LASTRUN()
RunTime.refA
RunTime.ACCURACY()
RunTime.REFA()
RunTime.refB
RunTime.ACTUAL()
RunTime.REFB()
RunTime.RESet
RunTime.LAST()
Runtime Measurements Using the Debugger

The RunTime counter allows to measure the program execution times between two breakpoints. The
accuracy of the measurement depends on the features provided by the debug interface. The measurement
error is displayed as tooltip text.
Or by the function
RunTime.ACCURACY()
43
RunTime
There is a number of different CPU and debugger features related to measuring runtime. The following table
gives an overview. For details, see further down.
Feature
RunTime counter
is started...
Runtime counter is
stopped...
Accuracy
CPU running
signal
...after detecting the

CPU running signal
... after deassertion of the

CPU running signal
High
NEXUS Debug
Status Message
... after receiving the

Debug Mode Left
message
... after receiving the

Debug Mode Entered
message
High
CPU stopped
signal
...by TRACE32 after

starting the CPU
...with the activation of the

CPU stopped signal
RunTime counter
start is imprecise
Polling the PC
...by TRACE32 after

starting the CPU
...by TRACE32 after CPU is

stopped
RunTime counter
start and stop are
imprecise
CPU running signal

Some processor architectures provide a CPU running signal within the debug interface (e.g. DBACK for
ARM7/ARM9). This feature allows an exact measurement by the RunTime counter.
Debug Status Messages
Most NEXUS interfaces provide Debug Status Messages which indicate the start/stop of the program
execution. The maximum measurement error is calculated as follows:
SizeOfMessageFifo 2 MCKOFactor clock cycles

While MCKOFactor is the value entered via the command SYStem.Option MCKO <factor>.
Hardware signal indicating CPU stopped
Some processor architectures provide a CPU stopped signal within the debug interface (e.g. DE for the
DSP56K). This feature allows an exact stop of the RunTime counter, but the start of the RunTime counter
cant be synchronized exactly with the start of the program execution.
Polling
For most processor architectures the RunTime counter is started/stopped by TRACE32. Thus the
measurement cant be exactly synchronized with the CPU start/stop.
The polling rate can be set with the SYStem.POLLING command. Any polling interval smaller than 1 ms is
ignored.
44
RunTime
Runtime Measurements Using TRACE32-ICE / TRACE32-FIRE

The runtime analyzer allows to check program execution times between two breakpoints. Therefore a
independent timing analyzer is available to the user. The resolution of runtime measurement is 100 ns. Two
reference points may be set in order to evaluate time differences. Total time, as well as the previous
emulation command execution time, is automatically recorded. The differences between the individual
reference points are displayed in tabular form. Only the execution time of the foreground program is
measured. The execution time of the background program is not taken into consideration (only TRACE32ICE).
Measurement errors due to break sequence
As a result of the break sequence of each individual emulator an absolute timing error of approximately
0.5 5 s occurs. This timing error is dependent upon the CPU's clock frequency and the type of the
emulation adapter used. The timing error can only precisely be determined by using time-stamp unit of the
logic analyzer. For complex CPUs, additional timing errors in single-step operation can occur during cache
memory fill. The timing error can be determined to some extent once a program has been executed by
executing first one, and then a set of NOP commands.
Timing errors due to dual-port access
In Wait mode, dual-port access requires up to 1% of total computing time; in Request mode, this can be
increased up to 3%. These values are valid for average clock frequencies and when using dynamic memory.
By using static memory only, these values will be reduced to one-third. If operating in Denied or Nodelay
(GAP, Refresh, Prefetch) mode, no computing will be needed for dual-port access.
45
RunTime
Functions related to RunTime

The following functions can be used to obtain various runtime-related values. All the functions return the
absolute time the target executed (the runtime) since the latest SYStem.Up or RunTime.Init command.
RunTime.ACTUAL() returns the runtime elapsed until the current moment.
RunTime.LAST() returns the time of the latest start of program execution e.g. caused by a single
Step or Go command.
RunTime.REFA() returns the reference value A. There is a homonymous command to set the
value.
RunTime.REFB() returns the reference value B. There is a homonymous command to set the
value.
RunTime.LASTRUN() returns the length of the last execution period (e.g. of a single step or the
time between a Go and a Break). The value is calculated by:
&difftime=CONV.TIMEUSTOINT(RUNTIME.ACTUAL()-RUNTIME.LAST())
RunTime.ACCURACY() returns a measure of the inaccuracy of the runtime values (depends on

the measurement method used).
RunTime.Init
Format:
Clear timers
RunTime.Init
Sets all timers and reference values to zero.
See also
RunTime
RunTime.state
Emulator Functions in FIRE Users Guide

Execution Time Measurement in ICE Users Guide
46
RunTime
RunTime.refA
Format:
Set reference
RunTime.refA
Sets the reference value A to the current runtime. Typically the feature is used to record the moment of an
important event like entering an interrupt handler etc.
The value can also be set by double-clicking the appropriate field in the RunTime.state window.
See also
RunTime
RunTime.state

RunTime.refB
Format:
Set reference
RunTime.refB
Sets the reference value B to the current runtime.

The value can also be set by double-clicking the appropriate field in the RunTime.state window.
See also
RunTime
RunTime.state

RunTime.RESet
Format:
Reset values to zero
RunTime.RESet
Sets all counters and reference values to zero.
See also
RunTime
RunTime.state

47
RunTime
RunTime.state
Format:
Display results
RunTime.state
RunTime.view (deprecated)
Displays the RunTime counter window with a matrix of values related to runtime measurements.
Each cell of the matrix shows the difference between the value denoted by the column header and the value
denoted by the row header. As the first lines row header is zero, the line shows the effective values e.g.
(refA - 0), (refB - 0), ... The cell at (column refB / row ref A) shows refB - refA i.e. the runtime between both
values.
Reference values can be set to the current runtime (actual) by double-clicking the appropriate element.
Time since the latest program start

Total time since the last
SYStem.Up or RunTime.Init
See also
RunTime
RunTime.RESet
RunTime.LASTRUN()
RunTime.Init
RunTime.ACCURACY()
RunTime.REFA()
RunTime.refA
RunTime.ACTUAL()
RunTime.REFB()
RunTime.refB
RunTime.LAST()

48
RunTime

General Ref R

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

General Ref R

Uploaded by

Copyright:

Available Formats

General Commands Reference Guide R

TRACE32 Online Help

General Commands ......................................................................................................................

General Commands Reference Guide R ..................................................................................

Refresh address range

Initialize the processor registers

Refresh register window

Reload the compiler register settings

Modify register contents

Define stack top address

Reset all commands

Direct data mode read/write

Halt system on RTP FIFO overflow

Selects the trace mode

Disables the RTP module

Activates the RTP module

Size of RTP data port

General Commands Reference Guide R

Display the RTP register

Resets RTP settings

Display RTP setup

Configures a trace region

Invert all trace regions

Real-time profiling (RTS)

Set the name for the RTS file

Set compression level for the RTS file

Set size limit for the RTS file

Select the data to write to the RTS file

Statistics regarding instruction execution

List recorded trace data

Display function call nesting

Mount a file as trace source

Set type of program flow analysis

Deactivate real-time profiling

Activate real-time profiling

Display performance characteristics charts

Restore default settings and initialize RTS

Open status and control window

Statistics regarding function invocations

Configure behavior regarding minor errors

Configure behavior regarding FIFO overflows

Configure task analysis

Configure analysis of program execution timing

Runtime Measurements Using the Debugger

Runtime Measurements Using TRACE32-ICE / TRACE32-FIRE

Functions related to RunTime

Reset values to zero

1989-2015 Lauterbach GmbH

General Commands Reference Guide R

1989-2015 Lauterbach GmbH

General Commands Reference Guide R

General Commands Reference Guide R

1989-2015 Lauterbach GmbH

General Commands Reference Guide R

Refresh address range

Defines the address range, which is touched by refresh cycles.

; Refresh on USERDATA area

; Refresh burst with 128 words on

1989-2015 Lauterbach GmbH

General Commands Reference Guide R

Defines the address increment used in the refresh access loop.

; standby refresh on address 1000H

1989-2015 Lauterbach GmbH