Products

Percepio

Percepio’s Tracealyzer products give an unprecedented level of insight into the run-time world of embedded software. This allows you to solve complex software problems in a fraction of the time otherwise needed, develop more robust designs to prevent future problems and find new ways to improve your software’s performance.

When developing embedded software based on an operating system, a traditional debugger is often insufficient to fully understand the software’s run-time behavior. A debugger shows the current system state and allows you to step through individual functions, but this is a low-level perspective that is not suitable for studying real-time operating system behavior, such as scheduling, blocking and interactions between tasks.

imgget a quote

GET A QUOTE



 

The Tracealyzer Product Family

 


FreeRTOS

 


 µC/OS-III

VxWorks


 

On Time RTOS-32


SafeRTOS

Wind River Linux

 

Faster Troubleshooting Tracealyzer allows for capturing rare, sporadic errors which otherwise can be very hard to reproduce and analyze. Many embedded software problems can be solved in a fraction of the time otherwise required. Tracealyzer recording can be used in parallel with existing debuggers in the lab, or deployed in field systems to capture rare sporadic errors.

 

Better Software Quality Tracealyzer is not only a “fire extinguisher” to use on specific hard problems. You can also discover and avoid potential future problems, such as blocking system calls that are close to a timeout. Moreover, Tracealyzer gives you a better understanding of the current system run-time dynamics, so when designing new features, you can avoid unsuitable designs that could cause problems related to timing, CPU usage, scheduling or other task interactions.

 

Better Performance The improved insight also allows you to find new ways of improving the embedded software performance. There might be “low hanging fruits”, where small changes in task timing may give substantial performance improvements. Tracealyzer provides several ways of finding “hot-spots” where tasks are delayed by higher prioritized tasks, that possibly could run a bit earlier or later to reduce resource conflicts. Without suitable visualization, such optimizations are very hard to find. This way, you can get a more responsive software system, or fit more software functionality in the same hardware platform.

 

Control system tuning Control system developers can benefit from the support for plotting custom application data, what we call user events. Plots of e.g. control signals (sensor inputs and actuator outputs) can be correlated with the software timing in order to better understand anomalies in the control performance. Moreover, plots of task timing (e.g., periodicity) can be used to study software timing variations that affects control performance.

 

Other benefits The improved level of insight also allows for faster introduction of new developers and better possibilities to evaluate the performance of new third party software, such as embedded databases, touch screen drivers or communication stacks. Finally, since we support several common operating systems for embedded software, you can often keep the Tracealyzer support even if switching to another operating system.

 

Scheduling, Interrupts, System Calls and User Events
The main trace view shows you all recorded events visualized on a vertical time-line, including task execution timing, interrupts, system calls and custom user events. The task and interrupt trace are shown as colored rectangles. Events are shown as floating text labels. Zooming is very easy using a click-and-drag selection, which also works as a measurement tool. Tasks and events can be clicked and highlighted for additional information, including timing and event dependencies. The lower right corner contains a powerful filter, and the Finder dialog provides even more powerful filters. When zooming out, this view naturally transforms into an overview where patterns can be studied.

 

CPU Load
This view presents a horizontal time-line showing the total CPU usage, and also CPU usage per task/interrupt. The CPU Load Graph allows for navigating the main trace view, since a double click in the CPU Load Graph focuses the main trace view on the clicked interval. Zooming is allowed in this view as well, independently of other views, and filters are available for focusing on individual tasks or interrupts.

 

 

 

Timing Variations
This is an example of several Actor Instance Graphs, each showing the distributions of a specific timing property for an actor, i.e., a task or interrupt routine. This includes execution time, response time, fragmentation, and several others. Each data point represents one specific execution of a task or interrupt handler. This graph, Response Time, shows the variation in response times for two selected tasks. Tasks instances with high response times may reveal resource conflicts, e.g., where several tasks or interrupts compete for CPU time in a busy interval. This view makes it easier to spot such locations that may indicate problems or possibilities for optimization.

 

Multiple Views Synchronized
All views with horizontal orientation can be combined in a single parent window, with synchronized scrolling. This includes most views except the main trace view, but the task and interrupt trace is available as a horizontal view as well. In this example, a horizontal execution trace is shown together with an execution time plot and the CPU Load Graph. Combining views like this allows for spotting patterns that otherwise would be hard to see using individual views, e.g., how the response time depends on other events, and this also allows for greater customization of the user interface.

 

Communication Flow
Many system calls allow for communication or synchronization between tasks. Tracealyzer understand these dependencies and the Communication Flow graph is a summary of all such dependencies found in the trace, in the form of a directed graph. This is a high-level view of the communication dependencies between tasks and interrupts, including the kernel objects used such as semaphores and message queues. Like in all views, double-clicking on a node opens a related view focused on the particular object. Double-clicking on a kernel object (e.g., a semaphore) opens the Object History view (shown below), a list of all events on the specific kernel object. If double-clicking on a task or interrupt, the Actor History view is opened showing all executions of the actor.

Kernel Object History
This view shows all events on a particular kernel object, such as a message queue, semaphore or mutex. The events are presented as a list, and double-clicking on a list item shows the corresponding system call in the main trace view. For message queues and similar objects with send/receive operations, it is possible to follow a specific message from send to receive, or vice versa, and also to inspect the messages (by sequence number) in the queue at any given time.

 

 

User Events and Signal Plots
This view shows all events on a particular kernel object, such as a message queue, semaphore or mutex. The events are presented as a list, and double-clicking on a list item shows the corresponding system call in the main trace view. For message queues and similar objects with send/receive operations, it is possible to follow a specific message from send to receive, or vice versa, and also to inspect the messages (by sequence number) in the queue at any given time.

Tracealyzer for FreeRTOS Demo

Tracealyzer Data Sheet

 

FreeRTOS+Trace

Tracealyzer Intro