Run an analysis
This section shows how to run an analysis after setting up the example project.
Last updated
This section shows how to run an analysis after setting up the example project.
Last updated
After setting up the FFT-C project, you end up on the following page.
To run the analysis, click on Run analysis.
During the analysis, multiple steps are happening:
First, a static analysis is run. The source files and the compiled binary objects are put into relation to get an omniscient representation of the relation between each code statement and the associated instructions. The instructions are statically characterized in terms of functionality and impact, and by consequence, the associated code too.
Then, a dynamic analysis is run. To do that, the code gets instrumented, built and executed so it outputs profile data.
Then, static and dynamic analysis data are fused so we can take advantage of both through cost models, and estimate self and cumulated costs for each function of your code.
Finally, optimization potentials are researched in the code. This detection is based on the identification of advanced patterns in the code, the knowledge of the instruction costs for the target as well as its possible specific instructions.
After the analysis is over, which can take some time depending on the project and analysis mode, you can see an estimation on how much the code could benefit in terms of performance, here 9.5%.
This result can be obtained by applying the 14 detected optimization points.
To see further details, click See latest analysis button.
The analysis dashboard contains very useful information about the code.
The three first tiles represent the potential gain score. This score gives you information about the possible improvements in terms of performance (and hence, energy) by applying some optimizations in your source code.
Each tile represents different kinds of optimizations:
Bit-exact optimizations do not change anything to your application outputs. They basically are free optimizations which bring better performance with no trade-off.
Permissive optimizations may change the binary representation of your outputs, but not in a degrading way. Though binary representations may change because of different data types or maths functions being used for instance, this has no impact, or very marginal impact on the quality of your output.
Lossy optimizations modify the accuracy of calculations. E.g, when switching to a floating to fixed-point representation, using polynomial approximation or using smaller data sizes. These optimizations can have a huge impact on performance, but they come with an accuracy trade-off, which can be acceptable for your application or not.
In the Detected optimization kinds tile, you can see detailed information about what possible optimizations were detected or not in the code, and what they imply.
You may also get information about the number of estimated CPU cycles for your program and its functions, in terms of self or cumulative cost.
Functionality repartition gives you information about how your code behaves in time. For each function of your code, you can aknowledge what is the weight of calculations, memory or control instructions in your code. This way, you can identify what are the priorities when it comes to optimizing your functions. Does your function take a lot of time into memory operations why you expect it to be more calculation intensive? There may be something wrong with the way you access to the memory. You should look there first.
Code coverage gives you information about:
which part of your code actually has an impact on the machine instructions (static coverage), which can help you identify statically dead code, and
which part of your code is actually executed during the dynamic analysis (dynamic coverage), which can help you aknowledge if your code execution is representative enough of what you need to stimulate for the analysis.
Finally, a call graph sums up all the information.
In red and orange, you can see the functions that are the most costly in your code and their properties, and so where to look at first when it comes to put efforts in improving performance.
Once you've analyzed your code, let's !
