What is Percepio Tracealyzer?
Tracealyzer is the best solution for visual hint diagnostics, providing embedded applications programmers amazing insight into their runtime systems. This allows for easier debugging of system-level problems, discovering application design defects, and quantifying the application's time and resource utilization. Make sure your code is dependable, responsive, and efficient. Otherwise, find out why.
Tracealyzer provides state-of-the-art applications tracing and follow visualization, developed since 2004. The visualization was made to create traces simpler to review and comprehend. This makes it a lot easier to identify and understand bugs, find answers and confirm them. Attempt Tracealyzer now and boost your own development.
Tracealyzer may be utilized side-by-side using conventional debuggers, like IAR, Keil, or even Eclipse tools, and matches the in-depth debugger perspective with different additional viewpoints on the platform level, perfect for comprehending real-time issues in which a timeless debugger isn't adequate. For example, in real-time systems like motor control, it's frequently not feasible to halt the method for debugging. By employing program tracing, you may record your embedded applications and some other interest factors in real-time as the system executes.
Tracealyzer supplies over 30 perspectives of the run-time behavior, such as job scheduling and interrupt handler/ISR implementation, task time (implementation time and other metrics), action priority, CPU load, memory utilization, in addition to interactions between activities and disrupt handlers/ISRs through, e.g., message queue, semaphore and mutex objects. In this manner, you can see if your job priorities, implementation times, and timeouts are appropriate to prevent timeout errors from job preemption or to obstruct. By way of instance, maybe the USB job has to be permitted to preempt the TCP/IP job to decrease its response time and prevent a semaphore timeout? Maybe some mutex is utilized by several tasks and thus often blocks the implementation and leads to delays?
It is also possible to conduct custom logging of"User Occasions" from the application code to find countries and factors with time, parallel with all the other viewpoints. This may be utilized to test and debug the real-time behavior of your calculations, such as engine control loops: the application's logic itself and its own performance. For example, just how much implementation time is necessary? Can I conduct my control loop at a greater speed? Is the job timing stable?
The profiling views permit you to determine exactly what regions of the system utilize most funds (e.g., chip time and heap memory). Maybe some part is utilizing more CPU cycles than moved as a result of inefficient code? The memory utilization views also let you find potential memory leaks. You can filter out all"malloc" events which have fitting"free" events with the"Show staying only" alternative, revealing all events which might be a memory leak.
All viewpoints are interconnected in smart ways, which means that you can click a data point in 1 perspective and see the corresponding place in another related perspective. Moreover, all timeline viewpoints could be synchronized, meaning you may scroll and scroll them side-by-side. In this manner, you may benefit from several viewpoints at precisely the same time and better comprehend the trace.
The trace may be streamed in real-time, either with a supported debug probe or a custom target-host port, like a USB or TCP/IP. Thus far, this is encouraged for FreeRTOS, Micrium, and SAFERTOS, but added streaming service is intended.
No exceptional trace hardware is necessary, as Tracealyzer is based on effective application instrumentation with minimal overhead. In this manner, it functions on basically any chip or microcontroller, presuming you have a couple of kilobytes out there to your trace recorder module. It's designed for 32-bit target chips and upward, such as ARM Cortex-M MCUs for example, STMicroelectronics STM32, NXP LPC, and Kinetis Collection, Renesas Synergy, Silicon labs EFM32, Cypress PSoC, Atmel SAM, TI MSP432, TI TMC4, and Infineon XMC4. We also encourage Renesas RX, Renesas RZ, Microchip PIC32, Atmel AVR32, ARM Cortex-R, ARM Cortex-A, Xilinx Zynq, Xilinx Microblaze, Altera Nios II, along with Synopsys ARC chips. And even if your chip family isn't yet completely supported, it is easy to create your own interface. You have to specify a few macros, chiefly for studying the present moment.
Percepio Tracealyzer Great Features:
Tracealyzer permits for capturing infrequent, intermittent mistakes, which can be extremely tough to replicate and examine. Many embedded application issues can be solved at a fraction of the time required. Tracealyzer recording may be utilized in parallel with existing debuggers from the laboratory or deployed in area systems to catch rare sporadic mistakes.
Better Software Quality
Tracealyzer isn't merely a"fire extinguisher" to utilize on particular hard issues. You might even find and prevent possible future problems, like blocking system calls that are near some timeout. Additionally, Tracealyzer provides you a better knowledge of the present system run-time dynamics; therefore, when designing new attributes, you can stay away from unsuitable designs that might result in issues associated with time, CPU utilization, scheduling, or other job interactions.
The enhanced insight also lets you discover new methods of enhancing the functionality of the embedded application. There could be"low hanging fruits", in which little changes in activity timing may provide significant performance improvements. Tracealyzer provides several methods of discovering"hot-spots" where jobs are delayed by greater prioritized jobs that may run somewhat sooner or later to decrease resource conflicts. Without proper visualization, such optimizations are extremely tough to discover. In this manner, you can find a more reactive software program or match more application functionality in precisely the same hardware platform.
Control program tuning
Control system programmers may benefit from plotting custom program information, which we call user occasions. Plots of, e.g., control signs (sensor inputs and actuator outputs) may be connected with the application's timing to better comprehend anomalies in the management functionality. Additionally, plots of job time (e.g., periodicity) may be utilized to examine software timing variants that impact control functionality.
The enhanced penetration level also allows for the quicker introduction of new programmers and improved chances to assess the operation of new third-party applications, including embedded databases, touch display drivers, or communicating stacks. Ultimately, because we encourage many common operating systems for embedded applications, you can often maintain the Tracealyzer support if switching to a different operating system.