Percepio Tracealyzer

Stop Guessing with Visual Trace Diagnostics

Tracealyzer is the premier solution for visual trace diagnostics, giving embedded software developers amazing insight into the runtime world. This allows for easier debugging of system-level issues, and for improving the software design and performance. Ensure your code is reliable, efficient and responsive. If not, learn why.

Tracealyzer can be used side-by-side with traditional debuggers, such as IAR, Keil or Eclipse tools, and complements the detailed debugger view with several additional views on system level, ideal for understanding real-time issues where a classic debugger is not sufficient.

Supported Platforms

  • Wittenstein SafeRTOS

Tracealyzer provides over 30 views of the run-time behavior, including task scheduling and interrupt handler/ISR execution, task timing (execution time and other metrics), task priority, CPU load, memory usage, as well as interactions between tasks and interrupt handlers/ISRs via e.g., message queue, semaphore and mutex objects. This way, you can see if your task priorities, execution times and timeouts are suitable, to avoid timeout errors from task preemption or blocking. For example, perhaps the USB task must be allowed to preempt the TCP/IP task, to reduce its response time and avoid a semaphore timeout? Perhaps some mutex is used by many tasks, and thereby frequently block the execution and cause delays?

You can also do custom logging of “User Events” from your application code to see states and variables over time, in parallel with the other views. This can be used to analyze and debug the real-time behavior of your algorithms, such as motor control loops. Both the software logic itself, and its performance. For instance, how much execution time is needed? Can I run my control loop at a higher rate? Is the task timing steady?

The profiling views allows you to see what parts of the system that uses most resources (e.g. processor time and heap memory). Perhaps some part is using much more CPU cycles than motivated, due to inefficient code? The memory usage views also allow you to locate possible memory leaks. You can filter out all “malloc” events that have matching “free” events using the “Show remaining only” option, showing all events that could be a memory leak.

All views are interconnected in clever ways, so you can click on a data point in one view and see the corresponding location in another related view. Moreover, all timeline views can be synchronized, so you can scroll and zoom them side-by-side. This way, you can benefit from multiple perspectives at the same time and better understand the trace.

The trace can be streamed in real-time, either using a supported debug probe or by using a custom target-host interface, such as a USB or TCP/IP.

No special trace hardware is required, as Tracealyzer relies on efficient software instrumentation with minimal overhead. This way, it works on essentially any processor or microcontroller, assuming you have a few kilobytes available for the trace recorder module. It is designed for 32-bit target processors and upwards, including ARM Cortex-M MCUs such as STMicroelectronics STM32, NXP LPC and Kinetis series, Renesas Synergy, Silicon labs EFM32, Cypress PSoC, Atmel SAM, TI MSP432, TI TMC4 and Infineon XMC4. We also support Renesas RX, Renesas RZ, Microchip PIC32, Atmel AVR32, ARM Cortex-R, ARM Cortex-A, Xilinx Zynq, Xilinx Microblaze, Altera Nios II and Synopsys ARC processors. And even if your processor family is not yet directly supported, you can easily develop your own port. You just need to define a few macros, mainly for reading the current time.

You can even use it in deployed IoT systems via Percepio DevAlert, to become aware of customer errors and get traces for remote diagnostics.

Tracealyzer can be used with most IDEs and several leading IDEs are directly supported, such as IAR Embedded Workbench, Keil µVision (MDK), Microchip MPLAB X IDE, Wind River Workbench and STM32CubeIDE.

Unlike some other trace tools, multiple RTOS and Linux platforms are supported, including FreeRTOS, Zephyr, Azure RTOS ThreadX, Keil RTX5 and VxWorks. So there is a good chance you can keep using Tracealyzer on your next project.