Sourcery Analyzer
Quickly address performance bottlenecks
“We leveraged the capabilities of Mentor Embedded’s Sourcery Analyzer and Sourcery CodeBench tools to bring our advanced lightRadio ™ eNodeB high-capacity application portfolio into market more quickly and efficiently.”
—Pascal Bourrier,
R&D NodeB/eNodeB Software Platform Senior Manager
Alcatel-Lucent
Analysis Agents
An analysis agent is a powerful built-in utility in Sourcery Analyzer that enables users to automatically generate a pre-processed view of common performance analysis routines. Out of the box, Sourcery Analyzer includes a library of analysis agents that cover a variety of functionality in Linux systems. In addition, users have the flexibility to add custom analysis agents that are tailored to their application or the immediate problem being debugged.
Analysis Agents in Sourcery Analyzer
CPU State
You have a lot of cores, and you are worried some of them are not pulling their weight. Exposing more details than a utilization curve, the CPU state enables you to not only see idle time, but to also indicate where that non-idle time is going.
Software Thread State
How do you take advantage of multi-core processors? Multiple threads. But when things do not run as fast as intended, you need to see what all those threads are doing. Is your locking too coarse? You will see it here when all your threads end up in a wait state.
Scheduling
Is your consumer thread starving your producer thread of CPU time? Unfortunately, even a well-tuned scheduler can make some bad decisions. When it does, you will clearly see the problem here, and you can give it some extra guidance in the form of priorities, containers, CPU affinity, or even CPU isolation.
CPU utilization
How busy are your cores? Unexpected spikes highlight bottlenecks, while consistently low utilization hints at scaling limitations or room for additional services, or the possibility of cheaper hardware.
IRQ rate
Depending on your application, interrupts could mean two things: incoming data to handle, or time stolen from useful work. Sometimes both. In any case, understanding interrupt patterns is key to understanding performance.
Page Fault Rate
Memory management is a wonderful thing, but it introduces a new source of latency when you first touch memory you only thought you allocated. Whether it is after a fork() or after a malloc(), seeing page faults can help explain otherwise mysterious performance dips and tell you where you need to load and lock your memory.
Function Call Flow
A CPU's monotonous existence consists mostly of calling one function after another. However, precisely which functions are called, in which order, and how long they take, is of keen interest to the software developer. By seeing it on a timeline, uncommon patterns, whether they are call sequences or unusual durations, become readily apparent.
Filesystem Activity
Persistent storage is nice for preserving data, but not so nice for performance. Whether your application hits disk for data or just to write log messages, filesystem activity at an inopportune time can hurt.
Network Activity
An overview of network activity can reveal when control messages are being crowded out by data packets, or remind you to go check the depth of your receive queues.
Thread Migration Rate
Schedulers do their best to avoid migrating threads from one core to another because it all but guarantees poor cache behavior. However, sometimes that idle core next to a busy peer just proves too tempting. Once is OK, but thread ping-ponging is trouble. It is a situation you might be able to avoid by re-examining your threading strategy, if only you knew that was the source of your application's slow performance.
Custom Analysis Agents
All these analysis agents give you more visibility into your system more easily than ever, but what about your application? Sourcery Analyzer provides an API enabling you to write powerful analysis agents for your own applications, giving you flexibility and customizability that cannot be matched by tools limited to off-the-shelf functionality. Visualizing your application's state machines, or the usage of application-specific data structures, can be the difference between guessing and knowing why your system is behaving the way it is.