Newsletter in June 2026

                                      - Uncontrolled Timing Effects
                             - X-ray View into the Development Process
                                  - Optimizing System Performance
                              - How it works: From Events to Insights
                                        - 100% Software Solution

---

As every developer repeatedly experiences in their daily work, conventional verification methods are insufficient for fully verifying multithreaded systems. Most embedded systems today run multithreaded software on Linux or real-time operating systems (RTOS). While multithreading offers advantages over single-threaded designs, it increases software complexity and the challenges of verification. Conventional verification methods such as code review, static analysis, and functional testing are necessary but insufficient for multithreaded systems. These systems exhibit complex dependencies between threads caused by explicit and implicit interactions and are often influenced by runtime fluctuations - that is, by emergent behaviors that are not visible in the code itself.

Uncontrolled Timing Effects Timing effects on thread interactions are typically not controlled during testing, meaning that even extensive tests may uncover only a fraction of the potential execution scenarios, and latent bugs are often discovered only after deployment. Embedded software often must meet real-time requirements. For example, a control system is expected to output signals every 5 milliseconds, with any delay constituting a failure. These requirements depend not only on the execution time of individual threads but also on dependencies with other threads. Verifying real-time requirements therefore involves more than just measuring timing metrics - it requires identifying potential risks from thread interactions that could compromise compliance with timing requirements. The de facto solution is runtime monitoring via software tracing. Percepio Tracealyzer provides visual analysis capabilities for software design analysis and the verification of real-time requirements. By using system tracing with Tracealyzer, developers can: Capture detailed runtime data on thread execution, interactions, and timing across long test runs without specialized hardware. Identify anomalies using high-level overviews such as CPU utilization charts or statistical reports, and then investigate details in the execution trace view. Analyze software timing variations using the “Actor Instance Graph,” which displays timing metrics for each thread over time. Visualize thread dependencies using the “Communication Flow Graph,” which depicts thread interactions via IPC objects. Tracealyzer relies on efficient software instrumentation rather than specialized hardware. Trace data is transmitted to the host via real-time Ethernet streaming or supported debug probes.

X-Ray View into the Development Process Visual trace transparency gives you an “X-ray view” into your embedded software development. Tracealyzer helps speed up daily debugging, resolve issues, and ultimately deliver better products on time. What speaks louder than our customers’ experiences: “Tracealyzer has doubled our development speed. Problems that would otherwise take days to solve are immediately visible with this tool and can be quickly resolved. We use it all the time.” — Alex Pabouctisids, Lead Firmware Engineer, Flyability If you’re tired of spending endless hours debugging embedded C/C++ code, say goodbye to tedious troubleshooting and benefit from accelerated development with Percepio Tracealyzer. Conventional debugging is often ineffective with today’s complex RTOS or Linux systems and can take up 40–50% of development time. With visual trace transparency, you can speed up your daily debugging and solve problems where traditional debugging reaches its limits.

Optimizing System Performance   “In less than five days after deploying the tool, we tripled the performance of our graphics rendering engine” – Terry West, CEO, Serious Integrated, Inc. Tracealyzer offers advanced profiling capabilities that reveal the events behind the numbers. Identify performance bottlenecks and unlock the full potential of your hardware. Ensure you meet your product’s performance goals and deliver a responsive user experience. Optimization is a challenge for multithreaded RTOS or Linux systems. When a thread is slow, it’s often due to factors that aren’t apparent in the source code. Visual trace transparency provides the complete picture and simplifies optimization.

How it works: From Events to Insights   Percepio Tracealyzer visualizes the behavior and timing of embedded software based on a software tracing library added to the target system. This library extends your RTOS kernel with lightweight instrumentation that is added to existing hooks to capture key events such as task switches, kernel API calls, deadlocks, timeouts, and more. There is also a C API for custom logging (“user events”) that allows you to extend the tracing capabilities to log variable values and other debug events. Traces can be visually examined in Tracealyzer using various graphical views and analyses for debugging, profiling, and anomaly detection, including CPU utilization charts, stack and heap memory usage, and time charts. The tracing feature can be run as continuous live streaming or as in-memory snapshots to capture critical moments leading up to a problem.

100% Software Solution   Tracealyzer is a 100% software-based solution and does not require a trace port on your device; however, it can still benefit from high-speed debug probes such as IAR I-Jet and SEGGER J-Link as high-speed interfaces for continuous trace streaming.

Interested? Let me know. I’d be happy to suggest a solution using Percepio Tracealyzer. If you haven’t tried Tracealyzer yet, you can do so here for free. The free tutorial videos are the perfect way to get started with Tracealyzer. They’ll help you get familiar with the tool. Sincerely Yours, Marian A. Wosnitza „If you’re not curious, you’ll never discover anything." (Zora Neale Hurston, American Writer)