Unlocking Zephyr Debugging

If you’ve been working with Zephyr RTOS, you know how powerful and flexible it is for embedded development. At Percepio, we appreciate Zephyr’s hardware abstraction and kernel architecture, which make it easy to get up and running on a wide range of hardware. Now, we have exciting news for developers looking to improve their Zephyr debugging and performance analysis: we’ve validated that Percepio Tracealyzer works on over 600 Zephyr-supported development boards!

Zephyr’s well-structured build system and configuration framework make it easier to enable debugging and tracing across a broad range of hardware platforms. Our latest tests show that Tracealyzer is compatible with 617 out of 649 boards we tested. The remaining boards mostly had memory constraints (less than 32 KB RAM available for tracing) or were simulation targets that required additional host compiler configuration.

Here’s a link to the list of boards: https://docs.zephyrproject.org/latest/boards/index.html#

What does this mean for Zephyr developers? If you’re using one of these supported boards, you can now visualize your system’s behavior in unprecedented detail with Tracealyzer—whether it’s thread execution, CPU usage, or kernel events—in a timeline-based, intuitive interface.

Getting Started with Tracealyzer on Zephyr

Setting up Tracealyzer for Zephyr is straightforward. If you have Zephyr running on your target board, you’re already halfway there. Here’s how to enable snapshot tracing:

• Ensure your board has enough RAM. At least 32 KB is recommended for effective tracing.
• Modify your Zephyr configuration (add the following to prj.conf):

CONFIG_TRACING=y CONFIG_PERCEPIO_TRACERECORDER=y CONFIG_PERCEPIO_TRC_CFG_STREAM_PORT_RINGBUFFER=y CONFIG_PERCEPIO_TRC_START_MODE_START=y

• If memory is tight, reduce the RingBuffer size:

CONFIG_PERCEPIO_TRC_CFG_STREAM_PORT_RINGBUFFER_SIZE=5120

• Build and run your application—Tracealyzer will now collect data that you can analyze for insights.

For a more detailed guide, check out our Zephyr setup documentation.

Debugging Priority Inversion in Zephyr with Tracealyzer

One of the common issues in real-time systems like Zephyr is priority inversion, where a high-priority task is blocked because a lower-priority task is holding a resource it needs. Without visibility into task scheduling and synchronization, this can be difficult to detect.

Example: Diagnosing Priority Inversion

Imagine a Zephyr-based application where a high-priority DataProcessingTask is supposed to run immediately but is unexpectedly delayed. A lower-priority SensorTask is holding a mutex, preventing DataProcessingTask from proceeding.

In principle, a high-priority task (‘H’ above) should never be blocked by lower-priority tasks. In practice, certain design decisions can result in this happening anyway, a condition known as Priority Inversion.

Step-by-Step Debugging with Tracealyzer

1. Capture a trace: Run the application with Tracealyzer enabled and collect a snapshot of the system’s execution.
2. Analyze the execution timeline: Open the trace file in Tracealyzer and look at the task execution graph.
3. Identify blocking dependencies: Use the Tracealyzer visualization tools to find where DataProcessingTask is waiting and see which lower-priority task is holding the resource.
4. Confirm priority inversion: If a lower-priority task (SensorTask) is blocking a higher-priority task (DataProcessingTask), check if priority inheritance is enabled.
5. Fix the issue
   • Enable priority inheritance for the mutex (CONFIG_PRIORITY_CEILING=y in prj.conf).
   • Optimize task scheduling to reduce blocking time.
   • Consider breaking up long-running lower-priority tasks.

With Tracealyzer, this type of analysis becomes straightforward, allowing you to pinpoint and resolve priority inversions quickly.

Tracealyzer visualization of priority inversion: A high-priority task is blocked while a medium-priority task preempts the low-priority task holding the mutex.

Try It Yourself!

With Zephyr’s robust architecture and our newly validated board support, now is a great time to try Tracealyzer for Zephyr. If you’re using Zephyr on a supported board, give it a spin and see how it transforms your debugging and optimization process.

Got questions? We’ll be at Embedded World, in the Zephyr Pavilion, so please stop by and talk to us about your Zephyr application. And of course you can always visit us at percepio.com.