What tools and techniques do you use to analyze microcontroller code performance?

For realtime / embedded, then If you have some GPIO and a logic analyzer (like Salae) then it's useful to profile / debug using these.

Profiling is typically an iterative process where code improvements are made based on the insights gained from profiling, then re-profile to analyze the effects of applied optimizations until the desired performance and resource utilization is achieved. Many microcontroller manufacturers provide their own profiling tools tailored to their hardware. These tools are often highly optimized and provide deep insights into the specific microcontroller's behavior. Profiling tools can often run in real-time, allowing to monitor code performance while the microcontroller is executing tasks. This is invaluable for debugging and optimizing code in real-world scenarios.

Profiler Tools: Profilers are software tools that help you analyze the runtime behavior of your code. They can provide information on which functions or sections of code consume the most CPU time Examples: GProf, Percepio Tracealyzer & SEGGER SystemView

In debugging time critical applications, the good old logic probes and oscilloscopes are essential. There are times where you cannot use breakpoints to capture an error in a specific line of code and the only way to capture it is to put a pin toggling method alongside that line of code. Then normally, the code is executed while the toggled pin is being monitored alongside the signals of interest.

We can use real time debugging tools and code tracing while executing the codes in the microcontroller. This feature can provide different tools to coders.

Most microcontroller (MCU) manufacturers provide a basic debug "probe" integrated onto their evaluation boards. Because Arm Cortex-M is so prolific, this is often an SWD-to-USB converter. It provides basic start/stop, breakpoint, and memory access debugging. However, some Arm MCUs feature a trace interface, allowing capture of code execution, memory status, and profiling in an Integrated Development Environment (IDE). Arm processors offer different levels of trace capability through SWO, ETM/TPIU, and ETS. For Infineon's Aurix family there is the Aurora Gigabit Trace interface. Developers working on complex or safety-critical applications typically use professional debug probes from suppliers such as Lauterbach, TASKING/iSYSTEM, or PLS.

I like to use existing peripherals to help test the firmware. For example, high speed timers can be used to time specific code sequences. If you are using an IDE with a debugger you can set breakpoints and watch appropriate variables to get the results of the timing. Or you can print the results to a serial port.

The technique suggested by Mr. John Perloe is good even for measuring the execution time of critical code sections, such as interrupt handlers. And it does not require the installation of software tools etc.

Today, developers are spoiled for choice with a range of free-to-use and open source simulation tools. Some, like Wokwi, can be used directly in the browser, while others, like Fritzing, need to be installed. A huge benefit of a simulator is being able to try an application idea before investing in, possibly expensive, hardware. However, there are limits. For example, most simulators only simulate electrically and not thermally, mechanically, or electromechanically. As a result, excessive energy in a diode or transistor that would cause a component to fail won't be apparent until the application is built and tested.

Static Analysis Tools: Static analysis tools analyze your code without running it. They can help identify potential issues like memory leaks, buffer overflows, and other code quality problems Examples: Coverity,Lint etc..

During the 20th Century, there were many different processor cores available, to benchmarks like EEMBC were helpful in comparing them. Today, with Arm in almost every device, there is less focus on benchmark performance. However, one area that remains relevant is in comparing low-power capabilities. Some applications need to save power while executing, while for others it is more important how much energy is consumed when the MCU is sleeping. The EEMBC ULPMark (Ultra-Low Power) helps here, as it is the silicon process used combined with the processor and low-power modes implemented that make the difference and are challenging to compare on paper.

It's important to remember that optimization is a tool and not a setting. By definition, the optimizer is removing code and variables or re-ordering code to achieve its goal. Simply setting compiler flags and hoping that you'll get faster/smaller code that still works is a path to failure and surprises - hopefully before the product reaches a customer! Carefully read the documentation to understand the strategy each optimization option uses. It is also sensible to have a thought-through testing strategy for your code so that you can check every function still works as expected. Also note that embedded systems are often very timing dependent. Optimizations will likely change how quickly some code sections execute.

There are few more aspects that could be equally important for performance and reliable operation of devices: 1. Code coverage: Untested code block may sometimes lead to system failure. 2. Architecture designing of code is equally important to get the best performance from the system. 3. Scenario based on integration testing will actually give the real performance of the system.

With the advent of IoT sensors and wearable electronics, the battery life of embedded systems makes a huge difference to market acceptance and success. Tools like the Otii Arc or Ace from Qoitech can accurately measure the power profile of your circuit and even simulate a battery. This helps to understand how your application will respond during the last days/hours of battery life, something that is challenging to test by other means.

Some other tools: Oscilloscopes and Logic Analyzers: These hardware tools can be used to analyze the behavior of signals and communication between microcontrollers and other components in real-time this is useful when we debug specific protocols/standardized protocols. Once we identify the signals we can optimize them as required. Hardware Performance Counters: Some microcontrollers and processors have hardware performance counters that can be used to measure various metrics like instruction counts, cache hits/misses, and more. These counters can provide low-level insights into code performance.