Help is available by moving the cursor above any 
symbol or by checking MAQAO website.
[ 0 / 4 ] Application profile is too short (4.82 s)
If the overall application profiling time is less than 10 seconds, many of the measurements at function or loop level will very likely be under the measurement quality threshold (0,1 seconds).
Rerun to increase runtime duration: for example use a larger dataset or include a repetition loop.
[ 3 / 3 ] Most of time spent in analyzed modules comes from functions with source/debug info
-g option gives access to debugging informations, such are source locations.
[ 2.91 / 3 ] Architecture specific option -march=native is used
[ 2.40 / 3 ] Most of time spent in analyzed modules comes from functions with compilation options informations but -fno-omit-frame-pointer is missing
-fno-omit-frame-pointer improves the accuracy of callchains found during the application profiling.
[ 2.95 / 3 ] Optimization level option is correctly used
[ 2 / 3 ] Security settings from the host restrict profiling. Some metrics will be missing or incomplete.
Current value for kernel.perf_event_paranoid is 2. If possible, set it to 1 or check with your system administrator which flag can be used to achieve this.
[ 2 / 2 ] Application is correctly profiled ("Others" category represents 0.00 % of the execution time)
To have a representative profiling, it is advised that the category "Others" represents less than 20% of the execution time in order to analyze as much as possible of the user code
[ 1 / 1 ] Lstopo present. The Topology lstopo report will be generated.
[ 4 / 4 ] Enough time of the experiment time spent in analyzed loops (98.65%)
If the time spent in analyzed loops is less than 30%, standard loop optimizations will have a limited impact on application performances.
[ 4 / 4 ] Threads activity is good
On average, more than 99.22% of observed threads are actually active
[ 4 / 4 ] CPU activity is good
CPU cores are active 99.22% of time
[ 4 / 4 ] Loop profile is not flat
At least one loop coverage is greater than 4% (29.46%), representing an hotspot for the application
[ 4 / 4 ] Enough time of the experiment time spent in analyzed innermost loops (73.55%)
If the time spent in analyzed innermost loops is less than 15%, standard innermost loop optimizations such as vectorisation will have a limited impact on application performances.
[ 4 / 4 ] Affinity is good (99.14%)
Threads are not migrating to CPU cores: probably successfully pinned
[ 3 / 3 ] Less than 10% (0.00%) is spend in BLAS1 operations
It could be more efficient to inline by hand BLAS1 operations
[ 3 / 3 ] Functions mostly use all threads
Functions running on a reduced number of threads (typically sequential code) cover less than 10% of application walltime (0.00%)
[ 3 / 3 ] Cumulative Outermost/In between loops coverage (25.10%) lower than cumulative innermost loop coverage (73.55%)
Having cumulative Outermost/In between loops coverage greater than cumulative innermost loop coverage will make loop optimization more complex
[ 2 / 2 ] Less than 10% (0.00%) is spend in BLAS2 operations
BLAS2 calls usually could make a poor cache usage and could benefit from inlining.
[ 2 / 2 ] Less than 10% (0.00%) is spend in Libm/SVML (special functions)
| Loop ID | Analysis | Penalty Score |
|---|---|---|
| ►Loop 21 - libqmckl.so.0.0.0 | Execution Time: 29 % - Vectorization Ratio: 100.00 % - Vector Length Use: 81.25 % | |
| ►Data Access Issues | 24 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 3 issues ( = indirect data accesses) costing 4 point each. | 12 |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 3 issues (= instructions) costing 4 points each. | 12 |
| ►Vectorization Roadblocks | 12 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 3 issues ( = indirect data accesses) costing 4 point each. | 12 |
| ►Inefficient Vectorization | 12 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 3 issues (= instructions) costing 4 points each. | 12 |
| ►Loop 30 - libqmckl.so.0.0.0 | Execution Time: 28 % - Vectorization Ratio: 0.00 % - Vector Length Use: 12.50 % | |
| ►Loop Computation Issues | 2 | |
| ○ | [SA] Presence of a large number of scalar integer instructions - Simplify loop structure, perform loop splitting or perform unroll and jam. This issue costs 2 points. | 2 |
| ►Control Flow Issues | 85 | |
| ○ | [SA] Too many paths (81 paths) - Simplify control structure. There are 81 issues ( = paths) costing 1 point each with a malus of 4 points. | 85 |
| ►Data Access Issues | 2 | |
| ○ | [SA] More than 20% of the loads are accessing the stack - Perform loop splitting to decrease pressure on registers. This issue costs 2 points. | 2 |
| ►Vectorization Roadblocks | 85 | |
| ○ | [SA] Too many paths (81 paths) - Simplify control structure. There are 81 issues ( = paths) costing 1 point each with a malus of 4 points. | 85 |
| ►Loop 18 - libqmckl.so.0.0.0 | Execution Time: 24 % - Vectorization Ratio: 70.91 % - Vector Length Use: 57.27 % | |
| ►Loop Computation Issues | 2 | |
| ○ | [SA] Presence of a large number of scalar integer instructions - Simplify loop structure, perform loop splitting or perform unroll and jam. This issue costs 2 points. | 2 |
| ►Control Flow Issues | 293 | |
| ○ | [SA] Too many paths (287 paths) - Simplify control structure. There are 287 issues ( = paths) costing 1 point each with a malus of 4 points. | 291 |
| ○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ►Data Access Issues | 154 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 14 issues (= instructions) costing 4 points each. | 56 |
| ○ | [SA] Presence of special instructions executing on a single port (INSERT/EXTRACT, SHUFFLE/PERM, BROADCAST) - Simplify data access and try to get stride 1 access. There are 96 issues (= instructions) costing 1 point each. | 96 |
| ○ | [SA] More than 20% of the loads are accessing the stack - Perform loop splitting to decrease pressure on registers. This issue costs 2 points. | 2 |
| ►Vectorization Roadblocks | 293 | |
| ○ | [SA] Too many paths (287 paths) - Simplify control structure. There are 287 issues ( = paths) costing 1 point each with a malus of 4 points. | 291 |
| ○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ►Inefficient Vectorization | 154 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 14 issues (= instructions) costing 4 points each. | 56 |
| ○ | [SA] Presence of special instructions executing on a single port (INSERT/EXTRACT, SHUFFLE/PERM, BROADCAST) - Simplify data access and try to get stride 1 access. There are 96 issues (= instructions) costing 1 point each. | 96 |
| ○ | [SA] Inefficient vectorization: use of masked instructions - Simplify control structure. The issue costs 2 points. | 2 |
| ►Loop 19 - libqmckl.so.0.0.0 | Execution Time: 5 % - Vectorization Ratio: 100.00 % - Vector Length Use: 83.33 % | |
| ►Data Access Issues | 16 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 2 issues ( = indirect data accesses) costing 4 point each. | 8 |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 2 issues (= instructions) costing 4 points each. | 8 |
| ►Vectorization Roadblocks | 8 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 2 issues ( = indirect data accesses) costing 4 point each. | 8 |
| ►Inefficient Vectorization | 8 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 2 issues (= instructions) costing 4 points each. | 8 |
| ►Loop 23 - libqmckl.so.0.0.0 | Execution Time: 4 % - Vectorization Ratio: 100.00 % - Vector Length Use: 83.33 % | |
| ►Data Access Issues | 16 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 2 issues ( = indirect data accesses) costing 4 point each. | 8 |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 2 issues (= instructions) costing 4 points each. | 8 |
| ►Vectorization Roadblocks | 8 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 2 issues ( = indirect data accesses) costing 4 point each. | 8 |
| ►Inefficient Vectorization | 8 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 2 issues (= instructions) costing 4 points each. | 8 |
| ○Loop 22 - libqmckl.so.0.0.0 | Execution Time: 2 % - Vectorization Ratio: 100.00 % - Vector Length Use: 100.00 % | |
| ►Loop 707 - libqmckl.so.0.0.0 | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 50.00 % | |
| ►Loop Computation Issues | 4 | |
| ○ | [SA] Presence of expensive FP instructions - Perform hoisting, change algorithm, use SVML or proper numerical library or perform value profiling (count the number of distinct input values). There are 1 issues (= instructions) costing 4 points each. | 4 |
| ►Loop 207 - libqmckl.so.0.0.0 | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 12.50 % | |
| ►Loop Computation Issues | 4 | |
| ○ | [SA] Less than 10% of the FP ADD/SUB/MUL arithmetic operations are performed using FMA - Reorganize arithmetic expressions to exhibit potential for FMA. This issue costs 4 points. | 4 |
| ►Loop 699 - libqmckl.so.0.0.0 | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 50.00 % | |
| ►Data Access Issues | 0 | |
| ○ | [SA] Inefficient vectorization: more than 10% of the vector loads instructions are unaligned - When allocating arrays, don’t forget to align them. There are 0 issues ( = arrays) costing 2 points each | 0 |
| ►Loop 698 - libqmckl.so.0.0.0 | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 50.00 % | |
| ►Loop Computation Issues | 4 | |
| ○ | [SA] Presence of expensive FP instructions - Perform hoisting, change algorithm, use SVML or proper numerical library or perform value profiling (count the number of distinct input values). There are 1 issues (= instructions) costing 4 points each. | 4 |
[ 0 / 4 ] Application profile is too short (4.78 s)
If the overall application profiling time is less than 10 seconds, many of the measurements at function or loop level will very likely be under the measurement quality threshold (0,1 seconds).
Rerun to increase runtime duration: for example use a larger dataset or include a repetition loop.
[ 3 / 3 ] Most of time spent in analyzed modules comes from functions with source/debug info
-g option gives access to debugging informations, such are source locations.
[ 2.93 / 3 ] Architecture specific option -march=native is used
[ 2.40 / 3 ] Most of time spent in analyzed modules comes from functions with compilation options informations but -fno-omit-frame-pointer is missing
-fno-omit-frame-pointer improves the accuracy of callchains found during the application profiling.
[ 2.96 / 3 ] Optimization level option is correctly used
[ 2 / 3 ] Security settings from the host restrict profiling. Some metrics will be missing or incomplete.
Current value for kernel.perf_event_paranoid is 2. If possible, set it to 1 or check with your system administrator which flag can be used to achieve this.
[ 2 / 2 ] Application is correctly profiled ("Others" category represents 0.00 % of the execution time)
To have a representative profiling, it is advised that the category "Others" represents less than 20% of the execution time in order to analyze as much as possible of the user code
[ 1 / 1 ] Lstopo present. The Topology lstopo report will be generated.
[ 4 / 4 ] Enough time of the experiment time spent in analyzed loops (98.53%)
If the time spent in analyzed loops is less than 30%, standard loop optimizations will have a limited impact on application performances.
[ 4 / 4 ] Threads activity is good
On average, more than 99.59% of observed threads are actually active
[ 4 / 4 ] CPU activity is good
CPU cores are active 99.59% of time
[ 4 / 4 ] Loop profile is not flat
At least one loop coverage is greater than 4% (29.74%), representing an hotspot for the application
[ 4 / 4 ] Enough time of the experiment time spent in analyzed innermost loops (72.36%)
If the time spent in analyzed innermost loops is less than 15%, standard innermost loop optimizations such as vectorisation will have a limited impact on application performances.
[ 4 / 4 ] Affinity is good (99.70%)
Threads are not migrating to CPU cores: probably successfully pinned
[ 3 / 3 ] Less than 10% (0.00%) is spend in BLAS1 operations
It could be more efficient to inline by hand BLAS1 operations
[ 3 / 3 ] Functions mostly use all threads
Functions running on a reduced number of threads (typically sequential code) cover less than 10% of application walltime (0.00%)
[ 3 / 3 ] Cumulative Outermost/In between loops coverage (26.18%) lower than cumulative innermost loop coverage (72.36%)
Having cumulative Outermost/In between loops coverage greater than cumulative innermost loop coverage will make loop optimization more complex
[ 2 / 2 ] Less than 10% (0.00%) is spend in BLAS2 operations
BLAS2 calls usually could make a poor cache usage and could benefit from inlining.
[ 2 / 2 ] Less than 10% (0.00%) is spend in Libm/SVML (special functions)
| Loop ID | Analysis | Penalty Score |
|---|---|---|
| ►Loop 21 - libqmckl.so.0.0.0 | Execution Time: 29 % - Vectorization Ratio: 100.00 % - Vector Length Use: 81.25 % | |
| ►Data Access Issues | 24 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 3 issues ( = indirect data accesses) costing 4 point each. | 12 |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 3 issues (= instructions) costing 4 points each. | 12 |
| ►Vectorization Roadblocks | 12 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 3 issues ( = indirect data accesses) costing 4 point each. | 12 |
| ►Inefficient Vectorization | 12 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 3 issues (= instructions) costing 4 points each. | 12 |
| ►Loop 30 - libqmckl.so.0.0.0 | Execution Time: 28 % - Vectorization Ratio: 0.00 % - Vector Length Use: 12.50 % | |
| ►Loop Computation Issues | 2 | |
| ○ | [SA] Presence of a large number of scalar integer instructions - Simplify loop structure, perform loop splitting or perform unroll and jam. This issue costs 2 points. | 2 |
| ►Control Flow Issues | 85 | |
| ○ | [SA] Too many paths (81 paths) - Simplify control structure. There are 81 issues ( = paths) costing 1 point each with a malus of 4 points. | 85 |
| ►Data Access Issues | 2 | |
| ○ | [SA] More than 20% of the loads are accessing the stack - Perform loop splitting to decrease pressure on registers. This issue costs 2 points. | 2 |
| ►Vectorization Roadblocks | 85 | |
| ○ | [SA] Too many paths (81 paths) - Simplify control structure. There are 81 issues ( = paths) costing 1 point each with a malus of 4 points. | 85 |
| ►Loop 18 - libqmckl.so.0.0.0 | Execution Time: 25 % - Vectorization Ratio: 70.91 % - Vector Length Use: 57.27 % | |
| ►Loop Computation Issues | 2 | |
| ○ | [SA] Presence of a large number of scalar integer instructions - Simplify loop structure, perform loop splitting or perform unroll and jam. This issue costs 2 points. | 2 |
| ►Control Flow Issues | 293 | |
| ○ | [SA] Too many paths (287 paths) - Simplify control structure. There are 287 issues ( = paths) costing 1 point each with a malus of 4 points. | 291 |
| ○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ►Data Access Issues | 154 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 14 issues (= instructions) costing 4 points each. | 56 |
| ○ | [SA] Presence of special instructions executing on a single port (INSERT/EXTRACT, SHUFFLE/PERM, BROADCAST) - Simplify data access and try to get stride 1 access. There are 96 issues (= instructions) costing 1 point each. | 96 |
| ○ | [SA] More than 20% of the loads are accessing the stack - Perform loop splitting to decrease pressure on registers. This issue costs 2 points. | 2 |
| ►Vectorization Roadblocks | 293 | |
| ○ | [SA] Too many paths (287 paths) - Simplify control structure. There are 287 issues ( = paths) costing 1 point each with a malus of 4 points. | 291 |
| ○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ►Inefficient Vectorization | 154 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 14 issues (= instructions) costing 4 points each. | 56 |
| ○ | [SA] Presence of special instructions executing on a single port (INSERT/EXTRACT, SHUFFLE/PERM, BROADCAST) - Simplify data access and try to get stride 1 access. There are 96 issues (= instructions) costing 1 point each. | 96 |
| ○ | [SA] Inefficient vectorization: use of masked instructions - Simplify control structure. The issue costs 2 points. | 2 |
| ►Loop 19 - libqmckl.so.0.0.0 | Execution Time: 5 % - Vectorization Ratio: 100.00 % - Vector Length Use: 83.33 % | |
| ►Data Access Issues | 16 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 2 issues ( = indirect data accesses) costing 4 point each. | 8 |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 2 issues (= instructions) costing 4 points each. | 8 |
| ►Vectorization Roadblocks | 8 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 2 issues ( = indirect data accesses) costing 4 point each. | 8 |
| ►Inefficient Vectorization | 8 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 2 issues (= instructions) costing 4 points each. | 8 |
| ►Loop 23 - libqmckl.so.0.0.0 | Execution Time: 4 % - Vectorization Ratio: 100.00 % - Vector Length Use: 83.33 % | |
| ►Data Access Issues | 16 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 2 issues ( = indirect data accesses) costing 4 point each. | 8 |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 2 issues (= instructions) costing 4 points each. | 8 |
| ►Vectorization Roadblocks | 8 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 2 issues ( = indirect data accesses) costing 4 point each. | 8 |
| ►Inefficient Vectorization | 8 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 2 issues (= instructions) costing 4 points each. | 8 |
| ○Loop 22 - libqmckl.so.0.0.0 | Execution Time: 1 % - Vectorization Ratio: 100.00 % - Vector Length Use: 100.00 % | |
| ►Loop 35 - bench_pop_c | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 50.00 % | |
| ►Vectorization Roadblocks | 0 | |
| ○ | [SA] Out of user code (executable and library listed in external_libraries ). This issue is a warning. | 0 |
| ►Loop 707 - libqmckl.so.0.0.0 | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 50.00 % | |
| ►Loop Computation Issues | 4 | |
| ○ | [SA] Presence of expensive FP instructions - Perform hoisting, change algorithm, use SVML or proper numerical library or perform value profiling (count the number of distinct input values). There are 1 issues (= instructions) costing 4 points each. | 4 |
| ○Loop 24 - libqmckl.so.0.0.0 | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 100.00 % | |
| ►Loop 554 - libqmckl.so.0.0.0 | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 50.00 % | |
| ►Loop Computation Issues | 4 | |
| ○ | [SA] Less than 10% of the FP ADD/SUB/MUL arithmetic operations are performed using FMA - Reorganize arithmetic expressions to exhibit potential for FMA. This issue costs 4 points. | 4 |
| ►Data Access Issues | 0 | |
| ○ | [SA] Inefficient vectorization: more than 10% of the vector loads instructions are unaligned - When allocating arrays, don’t forget to align them. There are 0 issues ( = arrays) costing 2 points each | 0 |
[ 0 / 4 ] Application profile is too short (4.76 s)
If the overall application profiling time is less than 10 seconds, many of the measurements at function or loop level will very likely be under the measurement quality threshold (0,1 seconds).
Rerun to increase runtime duration: for example use a larger dataset or include a repetition loop.
[ 3 / 3 ] Most of time spent in analyzed modules comes from functions with source/debug info
-g option gives access to debugging informations, such are source locations.
[ 2.94 / 3 ] Architecture specific option -march=native is used
[ 2.40 / 3 ] Most of time spent in analyzed modules comes from functions with compilation options informations but -fno-omit-frame-pointer is missing
-fno-omit-frame-pointer improves the accuracy of callchains found during the application profiling.
[ 2.97 / 3 ] Optimization level option is correctly used
[ 2 / 3 ] Security settings from the host restrict profiling. Some metrics will be missing or incomplete.
Current value for kernel.perf_event_paranoid is 2. If possible, set it to 1 or check with your system administrator which flag can be used to achieve this.
[ 2 / 2 ] Application is correctly profiled ("Others" category represents 0.00 % of the execution time)
To have a representative profiling, it is advised that the category "Others" represents less than 20% of the execution time in order to analyze as much as possible of the user code
[ 1 / 1 ] Lstopo present. The Topology lstopo report will be generated.
[ 4 / 4 ] Enough time of the experiment time spent in analyzed loops (98.43%)
If the time spent in analyzed loops is less than 30%, standard loop optimizations will have a limited impact on application performances.
[ 4 / 4 ] Threads activity is good
On average, more than 99.45% of observed threads are actually active
[ 4 / 4 ] CPU activity is good
CPU cores are active 99.45% of time
[ 4 / 4 ] Loop profile is not flat
At least one loop coverage is greater than 4% (27.81%), representing an hotspot for the application
[ 4 / 4 ] Enough time of the experiment time spent in analyzed innermost loops (70.09%)
If the time spent in analyzed innermost loops is less than 15%, standard innermost loop optimizations such as vectorisation will have a limited impact on application performances.
[ 4 / 4 ] Affinity is good (99.67%)
Threads are not migrating to CPU cores: probably successfully pinned
[ 3 / 3 ] Less than 10% (0.00%) is spend in BLAS1 operations
It could be more efficient to inline by hand BLAS1 operations
[ 3 / 3 ] Functions mostly use all threads
Functions running on a reduced number of threads (typically sequential code) cover less than 10% of application walltime (0.00%)
[ 3 / 3 ] Cumulative Outermost/In between loops coverage (28.33%) lower than cumulative innermost loop coverage (70.09%)
Having cumulative Outermost/In between loops coverage greater than cumulative innermost loop coverage will make loop optimization more complex
[ 2 / 2 ] Less than 10% (0.00%) is spend in BLAS2 operations
BLAS2 calls usually could make a poor cache usage and could benefit from inlining.
[ 2 / 2 ] Less than 10% (0.00%) is spend in Libm/SVML (special functions)
| Loop ID | Analysis | Penalty Score |
|---|---|---|
| ►Loop 18 - libqmckl.so.0.0.0 | Execution Time: 27 % - Vectorization Ratio: 70.91 % - Vector Length Use: 57.27 % | |
| ►Loop Computation Issues | 2 | |
| ○ | [SA] Presence of a large number of scalar integer instructions - Simplify loop structure, perform loop splitting or perform unroll and jam. This issue costs 2 points. | 2 |
| ►Control Flow Issues | 293 | |
| ○ | [SA] Too many paths (287 paths) - Simplify control structure. There are 287 issues ( = paths) costing 1 point each with a malus of 4 points. | 291 |
| ○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ►Data Access Issues | 154 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 14 issues (= instructions) costing 4 points each. | 56 |
| ○ | [SA] Presence of special instructions executing on a single port (INSERT/EXTRACT, SHUFFLE/PERM, BROADCAST) - Simplify data access and try to get stride 1 access. There are 96 issues (= instructions) costing 1 point each. | 96 |
| ○ | [SA] More than 20% of the loads are accessing the stack - Perform loop splitting to decrease pressure on registers. This issue costs 2 points. | 2 |
| ►Vectorization Roadblocks | 293 | |
| ○ | [SA] Too many paths (287 paths) - Simplify control structure. There are 287 issues ( = paths) costing 1 point each with a malus of 4 points. | 291 |
| ○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ►Inefficient Vectorization | 154 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 14 issues (= instructions) costing 4 points each. | 56 |
| ○ | [SA] Presence of special instructions executing on a single port (INSERT/EXTRACT, SHUFFLE/PERM, BROADCAST) - Simplify data access and try to get stride 1 access. There are 96 issues (= instructions) costing 1 point each. | 96 |
| ○ | [SA] Inefficient vectorization: use of masked instructions - Simplify control structure. The issue costs 2 points. | 2 |
| ►Loop 21 - libqmckl.so.0.0.0 | Execution Time: 27 % - Vectorization Ratio: 100.00 % - Vector Length Use: 81.25 % | |
| ►Data Access Issues | 24 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 3 issues ( = indirect data accesses) costing 4 point each. | 12 |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 3 issues (= instructions) costing 4 points each. | 12 |
| ►Vectorization Roadblocks | 12 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 3 issues ( = indirect data accesses) costing 4 point each. | 12 |
| ►Inefficient Vectorization | 12 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 3 issues (= instructions) costing 4 points each. | 12 |
| ►Loop 30 - libqmckl.so.0.0.0 | Execution Time: 27 % - Vectorization Ratio: 0.00 % - Vector Length Use: 12.50 % | |
| ►Loop Computation Issues | 2 | |
| ○ | [SA] Presence of a large number of scalar integer instructions - Simplify loop structure, perform loop splitting or perform unroll and jam. This issue costs 2 points. | 2 |
| ►Control Flow Issues | 85 | |
| ○ | [SA] Too many paths (81 paths) - Simplify control structure. There are 81 issues ( = paths) costing 1 point each with a malus of 4 points. | 85 |
| ►Data Access Issues | 2 | |
| ○ | [SA] More than 20% of the loads are accessing the stack - Perform loop splitting to decrease pressure on registers. This issue costs 2 points. | 2 |
| ►Vectorization Roadblocks | 85 | |
| ○ | [SA] Too many paths (81 paths) - Simplify control structure. There are 81 issues ( = paths) costing 1 point each with a malus of 4 points. | 85 |
| ►Loop 19 - libqmckl.so.0.0.0 | Execution Time: 5 % - Vectorization Ratio: 100.00 % - Vector Length Use: 83.33 % | |
| ►Data Access Issues | 16 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 2 issues ( = indirect data accesses) costing 4 point each. | 8 |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 2 issues (= instructions) costing 4 points each. | 8 |
| ►Vectorization Roadblocks | 8 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 2 issues ( = indirect data accesses) costing 4 point each. | 8 |
| ►Inefficient Vectorization | 8 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 2 issues (= instructions) costing 4 points each. | 8 |
| ►Loop 23 - libqmckl.so.0.0.0 | Execution Time: 4 % - Vectorization Ratio: 100.00 % - Vector Length Use: 83.33 % | |
| ►Data Access Issues | 16 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 2 issues ( = indirect data accesses) costing 4 point each. | 8 |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 2 issues (= instructions) costing 4 points each. | 8 |
| ►Vectorization Roadblocks | 8 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 2 issues ( = indirect data accesses) costing 4 point each. | 8 |
| ►Inefficient Vectorization | 8 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 2 issues (= instructions) costing 4 points each. | 8 |
| ○Loop 22 - libqmckl.so.0.0.0 | Execution Time: 3 % - Vectorization Ratio: 100.00 % - Vector Length Use: 100.00 % | |
| ○Loop 217 - libqmckl.so.0.0.0 | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 100.00 % | |
| ►Loop 28 - libqmckl.so.0.0.0 | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 11.03 % | |
| ►Control Flow Issues | 334 | |
| ○ | [SA] Too many paths (328 paths) - Simplify control structure. There are 328 issues ( = paths) costing 1 point each with a malus of 4 points. | 332 |
| ○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ►Data Access Issues | 2 | |
| ○ | [SA] More than 20% of the loads are accessing the stack - Perform loop splitting to decrease pressure on registers. This issue costs 2 points. | 2 |
| ►Vectorization Roadblocks | 334 | |
| ○ | [SA] Too many paths (328 paths) - Simplify control structure. There are 328 issues ( = paths) costing 1 point each with a malus of 4 points. | 332 |
| ○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ►Loop 698 - libqmckl.so.0.0.0 | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 50.00 % | |
| ►Loop Computation Issues | 4 | |
| ○ | [SA] Presence of expensive FP instructions - Perform hoisting, change algorithm, use SVML or proper numerical library or perform value profiling (count the number of distinct input values). There are 1 issues (= instructions) costing 4 points each. | 4 |
| ►Loop 707 - libqmckl.so.0.0.0 | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 50.00 % | |
| ►Loop Computation Issues | 4 | |
| ○ | [SA] Presence of expensive FP instructions - Perform hoisting, change algorithm, use SVML or proper numerical library or perform value profiling (count the number of distinct input values). There are 1 issues (= instructions) costing 4 points each. | 4 |
[ 0 / 4 ] Application profile is too short (4.80 s)
If the overall application profiling time is less than 10 seconds, many of the measurements at function or loop level will very likely be under the measurement quality threshold (0,1 seconds).
Rerun to increase runtime duration: for example use a larger dataset or include a repetition loop.
[ 3 / 3 ] Most of time spent in analyzed modules comes from functions with source/debug info
-g option gives access to debugging informations, such are source locations.
[ 2.93 / 3 ] Architecture specific option -march=native is used
[ 2.40 / 3 ] Most of time spent in analyzed modules comes from functions with compilation options informations but -fno-omit-frame-pointer is missing
-fno-omit-frame-pointer improves the accuracy of callchains found during the application profiling.
[ 2.95 / 3 ] Optimization level option is correctly used
[ 2 / 3 ] Security settings from the host restrict profiling. Some metrics will be missing or incomplete.
Current value for kernel.perf_event_paranoid is 2. If possible, set it to 1 or check with your system administrator which flag can be used to achieve this.
[ 2 / 2 ] Application is correctly profiled ("Others" category represents 0.10 % of the execution time)
To have a representative profiling, it is advised that the category "Others" represents less than 20% of the execution time in order to analyze as much as possible of the user code
[ 1 / 1 ] Lstopo present. The Topology lstopo report will be generated.
[ 4 / 4 ] Enough time of the experiment time spent in analyzed loops (98.33%)
If the time spent in analyzed loops is less than 30%, standard loop optimizations will have a limited impact on application performances.
[ 4 / 4 ] Threads activity is good
On average, more than 99.41% of observed threads are actually active
[ 4 / 4 ] CPU activity is good
CPU cores are active 99.41% of time
[ 4 / 4 ] Loop profile is not flat
At least one loop coverage is greater than 4% (28.23%), representing an hotspot for the application
[ 4 / 4 ] Enough time of the experiment time spent in analyzed innermost loops (72.19%)
If the time spent in analyzed innermost loops is less than 15%, standard innermost loop optimizations such as vectorisation will have a limited impact on application performances.
[ 4 / 4 ] Affinity is good (99.75%)
Threads are not migrating to CPU cores: probably successfully pinned
[ 3 / 3 ] Less than 10% (0.00%) is spend in BLAS1 operations
It could be more efficient to inline by hand BLAS1 operations
[ 3 / 3 ] Functions mostly use all threads
Functions running on a reduced number of threads (typically sequential code) cover less than 10% of application walltime (0.00%)
[ 3 / 3 ] Cumulative Outermost/In between loops coverage (26.15%) lower than cumulative innermost loop coverage (72.19%)
Having cumulative Outermost/In between loops coverage greater than cumulative innermost loop coverage will make loop optimization more complex
[ 2 / 2 ] Less than 10% (0.00%) is spend in BLAS2 operations
BLAS2 calls usually could make a poor cache usage and could benefit from inlining.
[ 2 / 2 ] Less than 10% (0.00%) is spend in Libm/SVML (special functions)
| Loop ID | Analysis | Penalty Score |
|---|---|---|
| ►Loop 30 - libqmckl.so.0.0.0 | Execution Time: 28 % - Vectorization Ratio: 0.00 % - Vector Length Use: 12.50 % | |
| ►Loop Computation Issues | 2 | |
| ○ | [SA] Presence of a large number of scalar integer instructions - Simplify loop structure, perform loop splitting or perform unroll and jam. This issue costs 2 points. | 2 |
| ►Control Flow Issues | 85 | |
| ○ | [SA] Too many paths (81 paths) - Simplify control structure. There are 81 issues ( = paths) costing 1 point each with a malus of 4 points. | 85 |
| ►Data Access Issues | 2 | |
| ○ | [SA] More than 20% of the loads are accessing the stack - Perform loop splitting to decrease pressure on registers. This issue costs 2 points. | 2 |
| ►Vectorization Roadblocks | 85 | |
| ○ | [SA] Too many paths (81 paths) - Simplify control structure. There are 81 issues ( = paths) costing 1 point each with a malus of 4 points. | 85 |
| ►Loop 21 - libqmckl.so.0.0.0 | Execution Time: 27 % - Vectorization Ratio: 100.00 % - Vector Length Use: 81.25 % | |
| ►Data Access Issues | 24 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 3 issues ( = indirect data accesses) costing 4 point each. | 12 |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 3 issues (= instructions) costing 4 points each. | 12 |
| ►Vectorization Roadblocks | 12 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 3 issues ( = indirect data accesses) costing 4 point each. | 12 |
| ►Inefficient Vectorization | 12 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 3 issues (= instructions) costing 4 points each. | 12 |
| ►Loop 18 - libqmckl.so.0.0.0 | Execution Time: 25 % - Vectorization Ratio: 70.91 % - Vector Length Use: 57.27 % | |
| ►Loop Computation Issues | 2 | |
| ○ | [SA] Presence of a large number of scalar integer instructions - Simplify loop structure, perform loop splitting or perform unroll and jam. This issue costs 2 points. | 2 |
| ►Control Flow Issues | 293 | |
| ○ | [SA] Too many paths (287 paths) - Simplify control structure. There are 287 issues ( = paths) costing 1 point each with a malus of 4 points. | 291 |
| ○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ►Data Access Issues | 154 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 14 issues (= instructions) costing 4 points each. | 56 |
| ○ | [SA] Presence of special instructions executing on a single port (INSERT/EXTRACT, SHUFFLE/PERM, BROADCAST) - Simplify data access and try to get stride 1 access. There are 96 issues (= instructions) costing 1 point each. | 96 |
| ○ | [SA] More than 20% of the loads are accessing the stack - Perform loop splitting to decrease pressure on registers. This issue costs 2 points. | 2 |
| ►Vectorization Roadblocks | 293 | |
| ○ | [SA] Too many paths (287 paths) - Simplify control structure. There are 287 issues ( = paths) costing 1 point each with a malus of 4 points. | 291 |
| ○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ►Inefficient Vectorization | 154 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 14 issues (= instructions) costing 4 points each. | 56 |
| ○ | [SA] Presence of special instructions executing on a single port (INSERT/EXTRACT, SHUFFLE/PERM, BROADCAST) - Simplify data access and try to get stride 1 access. There are 96 issues (= instructions) costing 1 point each. | 96 |
| ○ | [SA] Inefficient vectorization: use of masked instructions - Simplify control structure. The issue costs 2 points. | 2 |
| ►Loop 23 - libqmckl.so.0.0.0 | Execution Time: 5 % - Vectorization Ratio: 100.00 % - Vector Length Use: 83.33 % | |
| ►Data Access Issues | 16 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 2 issues ( = indirect data accesses) costing 4 point each. | 8 |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 2 issues (= instructions) costing 4 points each. | 8 |
| ►Vectorization Roadblocks | 8 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 2 issues ( = indirect data accesses) costing 4 point each. | 8 |
| ►Inefficient Vectorization | 8 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 2 issues (= instructions) costing 4 points each. | 8 |
| ►Loop 19 - libqmckl.so.0.0.0 | Execution Time: 4 % - Vectorization Ratio: 100.00 % - Vector Length Use: 83.33 % | |
| ►Data Access Issues | 16 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 2 issues ( = indirect data accesses) costing 4 point each. | 8 |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 2 issues (= instructions) costing 4 points each. | 8 |
| ►Vectorization Roadblocks | 8 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 2 issues ( = indirect data accesses) costing 4 point each. | 8 |
| ►Inefficient Vectorization | 8 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 2 issues (= instructions) costing 4 points each. | 8 |
| ○Loop 22 - libqmckl.so.0.0.0 | Execution Time: 3 % - Vectorization Ratio: 100.00 % - Vector Length Use: 100.00 % | |
| ►Loop 207 - libqmckl.so.0.0.0 | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 12.50 % | |
| ►Loop Computation Issues | 4 | |
| ○ | [SA] Less than 10% of the FP ADD/SUB/MUL arithmetic operations are performed using FMA - Reorganize arithmetic expressions to exhibit potential for FMA. This issue costs 4 points. | 4 |
| ►Loop 28 - libqmckl.so.0.0.0 | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 11.03 % | |
| ►Control Flow Issues | 334 | |
| ○ | [SA] Too many paths (328 paths) - Simplify control structure. There are 328 issues ( = paths) costing 1 point each with a malus of 4 points. | 332 |
| ○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ►Data Access Issues | 2 | |
| ○ | [SA] More than 20% of the loads are accessing the stack - Perform loop splitting to decrease pressure on registers. This issue costs 2 points. | 2 |
| ►Vectorization Roadblocks | 334 | |
| ○ | [SA] Too many paths (328 paths) - Simplify control structure. There are 328 issues ( = paths) costing 1 point each with a malus of 4 points. | 332 |
| ○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ○Loop 24 - libqmckl.so.0.0.0 | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 100.00 % | |
| ►Loop 698 - libqmckl.so.0.0.0 | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 50.00 % | |
| ►Loop Computation Issues | 4 | |
| ○ | [SA] Presence of expensive FP instructions - Perform hoisting, change algorithm, use SVML or proper numerical library or perform value profiling (count the number of distinct input values). There are 1 issues (= instructions) costing 4 points each. | 4 |
[ 0 / 4 ] Application profile is too short (4.80 s)
If the overall application profiling time is less than 10 seconds, many of the measurements at function or loop level will very likely be under the measurement quality threshold (0,1 seconds).
Rerun to increase runtime duration: for example use a larger dataset or include a repetition loop.
[ 3 / 3 ] Most of time spent in analyzed modules comes from functions with source/debug info
-g option gives access to debugging informations, such are source locations.
[ 2.92 / 3 ] Architecture specific option -march=native is used
[ 2.40 / 3 ] Most of time spent in analyzed modules comes from functions with compilation options informations but -fno-omit-frame-pointer is missing
-fno-omit-frame-pointer improves the accuracy of callchains found during the application profiling.
[ 2.95 / 3 ] Optimization level option is correctly used
[ 2 / 3 ] Security settings from the host restrict profiling. Some metrics will be missing or incomplete.
Current value for kernel.perf_event_paranoid is 2. If possible, set it to 1 or check with your system administrator which flag can be used to achieve this.
[ 2 / 2 ] Application is correctly profiled ("Others" category represents 0.00 % of the execution time)
To have a representative profiling, it is advised that the category "Others" represents less than 20% of the execution time in order to analyze as much as possible of the user code
[ 1 / 1 ] Lstopo present. The Topology lstopo report will be generated.
[ 4 / 4 ] Enough time of the experiment time spent in analyzed loops (98.85%)
If the time spent in analyzed loops is less than 30%, standard loop optimizations will have a limited impact on application performances.
[ 4 / 4 ] Threads activity is good
On average, more than 99.30% of observed threads are actually active
[ 4 / 4 ] CPU activity is good
CPU cores are active 99.30% of time
[ 4 / 4 ] Loop profile is not flat
At least one loop coverage is greater than 4% (28.99%), representing an hotspot for the application
[ 4 / 4 ] Enough time of the experiment time spent in analyzed innermost loops (75.81%)
If the time spent in analyzed innermost loops is less than 15%, standard innermost loop optimizations such as vectorisation will have a limited impact on application performances.
[ 4 / 4 ] Affinity is good (99.21%)
Threads are not migrating to CPU cores: probably successfully pinned
[ 3 / 3 ] Less than 10% (0.00%) is spend in BLAS1 operations
It could be more efficient to inline by hand BLAS1 operations
[ 3 / 3 ] Functions mostly use all threads
Functions running on a reduced number of threads (typically sequential code) cover less than 10% of application walltime (0.00%)
[ 3 / 3 ] Cumulative Outermost/In between loops coverage (23.04%) lower than cumulative innermost loop coverage (75.81%)
Having cumulative Outermost/In between loops coverage greater than cumulative innermost loop coverage will make loop optimization more complex
[ 2 / 2 ] Less than 10% (0.00%) is spend in BLAS2 operations
BLAS2 calls usually could make a poor cache usage and could benefit from inlining.
[ 2 / 2 ] Less than 10% (0.00%) is spend in Libm/SVML (special functions)
| Loop ID | Analysis | Penalty Score |
|---|---|---|
| ►Loop 21 - libqmckl.so.0.0.0 | Execution Time: 28 % - Vectorization Ratio: 100.00 % - Vector Length Use: 81.25 % | |
| ►Data Access Issues | 24 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 3 issues ( = indirect data accesses) costing 4 point each. | 12 |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 3 issues (= instructions) costing 4 points each. | 12 |
| ►Vectorization Roadblocks | 12 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 3 issues ( = indirect data accesses) costing 4 point each. | 12 |
| ►Inefficient Vectorization | 12 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 3 issues (= instructions) costing 4 points each. | 12 |
| ►Loop 30 - libqmckl.so.0.0.0 | Execution Time: 28 % - Vectorization Ratio: 0.00 % - Vector Length Use: 12.50 % | |
| ►Loop Computation Issues | 2 | |
| ○ | [SA] Presence of a large number of scalar integer instructions - Simplify loop structure, perform loop splitting or perform unroll and jam. This issue costs 2 points. | 2 |
| ►Control Flow Issues | 85 | |
| ○ | [SA] Too many paths (81 paths) - Simplify control structure. There are 81 issues ( = paths) costing 1 point each with a malus of 4 points. | 85 |
| ►Data Access Issues | 2 | |
| ○ | [SA] More than 20% of the loads are accessing the stack - Perform loop splitting to decrease pressure on registers. This issue costs 2 points. | 2 |
| ►Vectorization Roadblocks | 85 | |
| ○ | [SA] Too many paths (81 paths) - Simplify control structure. There are 81 issues ( = paths) costing 1 point each with a malus of 4 points. | 85 |
| ►Loop 18 - libqmckl.so.0.0.0 | Execution Time: 22 % - Vectorization Ratio: 70.91 % - Vector Length Use: 57.27 % | |
| ►Loop Computation Issues | 2 | |
| ○ | [SA] Presence of a large number of scalar integer instructions - Simplify loop structure, perform loop splitting or perform unroll and jam. This issue costs 2 points. | 2 |
| ►Control Flow Issues | 293 | |
| ○ | [SA] Too many paths (287 paths) - Simplify control structure. There are 287 issues ( = paths) costing 1 point each with a malus of 4 points. | 291 |
| ○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ►Data Access Issues | 154 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 14 issues (= instructions) costing 4 points each. | 56 |
| ○ | [SA] Presence of special instructions executing on a single port (INSERT/EXTRACT, SHUFFLE/PERM, BROADCAST) - Simplify data access and try to get stride 1 access. There are 96 issues (= instructions) costing 1 point each. | 96 |
| ○ | [SA] More than 20% of the loads are accessing the stack - Perform loop splitting to decrease pressure on registers. This issue costs 2 points. | 2 |
| ►Vectorization Roadblocks | 293 | |
| ○ | [SA] Too many paths (287 paths) - Simplify control structure. There are 287 issues ( = paths) costing 1 point each with a malus of 4 points. | 291 |
| ○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ►Inefficient Vectorization | 154 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 14 issues (= instructions) costing 4 points each. | 56 |
| ○ | [SA] Presence of special instructions executing on a single port (INSERT/EXTRACT, SHUFFLE/PERM, BROADCAST) - Simplify data access and try to get stride 1 access. There are 96 issues (= instructions) costing 1 point each. | 96 |
| ○ | [SA] Inefficient vectorization: use of masked instructions - Simplify control structure. The issue costs 2 points. | 2 |
| ►Loop 23 - libqmckl.so.0.0.0 | Execution Time: 6 % - Vectorization Ratio: 100.00 % - Vector Length Use: 83.33 % | |
| ►Data Access Issues | 16 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 2 issues ( = indirect data accesses) costing 4 point each. | 8 |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 2 issues (= instructions) costing 4 points each. | 8 |
| ►Vectorization Roadblocks | 8 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 2 issues ( = indirect data accesses) costing 4 point each. | 8 |
| ►Inefficient Vectorization | 8 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 2 issues (= instructions) costing 4 points each. | 8 |
| ►Loop 19 - libqmckl.so.0.0.0 | Execution Time: 5 % - Vectorization Ratio: 100.00 % - Vector Length Use: 83.33 % | |
| ►Data Access Issues | 16 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 2 issues ( = indirect data accesses) costing 4 point each. | 8 |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 2 issues (= instructions) costing 4 points each. | 8 |
| ►Vectorization Roadblocks | 8 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 2 issues ( = indirect data accesses) costing 4 point each. | 8 |
| ►Inefficient Vectorization | 8 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 2 issues (= instructions) costing 4 points each. | 8 |
| ○Loop 22 - libqmckl.so.0.0.0 | Execution Time: 3 % - Vectorization Ratio: 100.00 % - Vector Length Use: 100.00 % | |
| ►Loop 207 - libqmckl.so.0.0.0 | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 12.50 % | |
| ►Loop Computation Issues | 4 | |
| ○ | [SA] Less than 10% of the FP ADD/SUB/MUL arithmetic operations are performed using FMA - Reorganize arithmetic expressions to exhibit potential for FMA. This issue costs 4 points. | 4 |
| ►Loop 27 - libqmckl.so.0.0.0 | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 82.69 % | |
| ►Data Access Issues | 24 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 3 issues ( = indirect data accesses) costing 4 point each. | 12 |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 3 issues (= instructions) costing 4 points each. | 12 |
| ►Vectorization Roadblocks | 12 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 3 issues ( = indirect data accesses) costing 4 point each. | 12 |
| ►Inefficient Vectorization | 12 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 3 issues (= instructions) costing 4 points each. | 12 |
| ►Loop 28 - libqmckl.so.0.0.0 | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 11.03 % | |
| ►Control Flow Issues | 334 | |
| ○ | [SA] Too many paths (328 paths) - Simplify control structure. There are 328 issues ( = paths) costing 1 point each with a malus of 4 points. | 332 |
| ○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ►Data Access Issues | 2 | |
| ○ | [SA] More than 20% of the loads are accessing the stack - Perform loop splitting to decrease pressure on registers. This issue costs 2 points. | 2 |
| ►Vectorization Roadblocks | 334 | |
| ○ | [SA] Too many paths (328 paths) - Simplify control structure. There are 328 issues ( = paths) costing 1 point each with a malus of 4 points. | 332 |
| ○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ►Loop 554 - libqmckl.so.0.0.0 | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 50.00 % | |
| ►Loop Computation Issues | 4 | |
| ○ | [SA] Less than 10% of the FP ADD/SUB/MUL arithmetic operations are performed using FMA - Reorganize arithmetic expressions to exhibit potential for FMA. This issue costs 4 points. | 4 |
| ►Data Access Issues | 0 | |
| ○ | [SA] Inefficient vectorization: more than 10% of the vector loads instructions are unaligned - When allocating arrays, don’t forget to align them. There are 0 issues ( = arrays) costing 2 points each | 0 |
[ 0 / 4 ] Application profile is too short (4.82 s)
If the overall application profiling time is less than 10 seconds, many of the measurements at function or loop level will very likely be under the measurement quality threshold (0,1 seconds).
Rerun to increase runtime duration: for example use a larger dataset or include a repetition loop.
[ 3 / 3 ] Most of time spent in analyzed modules comes from functions with source/debug info
-g option gives access to debugging informations, such are source locations.
[ 2.90 / 3 ] Architecture specific option -march=native is used
[ 2.40 / 3 ] Most of time spent in analyzed modules comes from functions with compilation options informations but -fno-omit-frame-pointer is missing
-fno-omit-frame-pointer improves the accuracy of callchains found during the application profiling.
[ 2.93 / 3 ] Optimization level option is correctly used
[ 2 / 3 ] Security settings from the host restrict profiling. Some metrics will be missing or incomplete.
Current value for kernel.perf_event_paranoid is 2. If possible, set it to 1 or check with your system administrator which flag can be used to achieve this.
[ 2 / 2 ] Application is correctly profiled ("Others" category represents 0.10 % of the execution time)
To have a representative profiling, it is advised that the category "Others" represents less than 20% of the execution time in order to analyze as much as possible of the user code
[ 1 / 1 ] Lstopo present. The Topology lstopo report will be generated.
[ 4 / 4 ] Enough time of the experiment time spent in analyzed loops (98.44%)
If the time spent in analyzed loops is less than 30%, standard loop optimizations will have a limited impact on application performances.
[ 4 / 4 ] Threads activity is good
On average, more than 99.14% of observed threads are actually active
[ 4 / 4 ] CPU activity is good
CPU cores are active 99.14% of time
[ 4 / 4 ] Loop profile is not flat
At least one loop coverage is greater than 4% (28.94%), representing an hotspot for the application
[ 4 / 4 ] Enough time of the experiment time spent in analyzed innermost loops (72.10%)
If the time spent in analyzed innermost loops is less than 15%, standard innermost loop optimizations such as vectorisation will have a limited impact on application performances.
[ 4 / 4 ] Affinity is good (99.09%)
Threads are not migrating to CPU cores: probably successfully pinned
[ 3 / 3 ] Less than 10% (0.00%) is spend in BLAS1 operations
It could be more efficient to inline by hand BLAS1 operations
[ 3 / 3 ] Functions mostly use all threads
Functions running on a reduced number of threads (typically sequential code) cover less than 10% of application walltime (0.00%)
[ 3 / 3 ] Cumulative Outermost/In between loops coverage (26.35%) lower than cumulative innermost loop coverage (72.10%)
Having cumulative Outermost/In between loops coverage greater than cumulative innermost loop coverage will make loop optimization more complex
[ 2 / 2 ] Less than 10% (0.00%) is spend in BLAS2 operations
BLAS2 calls usually could make a poor cache usage and could benefit from inlining.
[ 2 / 2 ] Less than 10% (0.00%) is spend in Libm/SVML (special functions)
| Loop ID | Analysis | Penalty Score |
|---|---|---|
| ►Loop 30 - libqmckl.so.0.0.0 | Execution Time: 28 % - Vectorization Ratio: 0.00 % - Vector Length Use: 12.50 % | |
| ►Loop Computation Issues | 2 | |
| ○ | [SA] Presence of a large number of scalar integer instructions - Simplify loop structure, perform loop splitting or perform unroll and jam. This issue costs 2 points. | 2 |
| ►Control Flow Issues | 85 | |
| ○ | [SA] Too many paths (81 paths) - Simplify control structure. There are 81 issues ( = paths) costing 1 point each with a malus of 4 points. | 85 |
| ►Data Access Issues | 2 | |
| ○ | [SA] More than 20% of the loads are accessing the stack - Perform loop splitting to decrease pressure on registers. This issue costs 2 points. | 2 |
| ►Vectorization Roadblocks | 85 | |
| ○ | [SA] Too many paths (81 paths) - Simplify control structure. There are 81 issues ( = paths) costing 1 point each with a malus of 4 points. | 85 |
| ►Loop 21 - libqmckl.so.0.0.0 | Execution Time: 27 % - Vectorization Ratio: 100.00 % - Vector Length Use: 81.25 % | |
| ►Data Access Issues | 24 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 3 issues ( = indirect data accesses) costing 4 point each. | 12 |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 3 issues (= instructions) costing 4 points each. | 12 |
| ►Vectorization Roadblocks | 12 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 3 issues ( = indirect data accesses) costing 4 point each. | 12 |
| ►Inefficient Vectorization | 12 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 3 issues (= instructions) costing 4 points each. | 12 |
| ►Loop 18 - libqmckl.so.0.0.0 | Execution Time: 25 % - Vectorization Ratio: 70.91 % - Vector Length Use: 57.27 % | |
| ►Loop Computation Issues | 2 | |
| ○ | [SA] Presence of a large number of scalar integer instructions - Simplify loop structure, perform loop splitting or perform unroll and jam. This issue costs 2 points. | 2 |
| ►Control Flow Issues | 293 | |
| ○ | [SA] Too many paths (287 paths) - Simplify control structure. There are 287 issues ( = paths) costing 1 point each with a malus of 4 points. | 291 |
| ○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ►Data Access Issues | 154 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 14 issues (= instructions) costing 4 points each. | 56 |
| ○ | [SA] Presence of special instructions executing on a single port (INSERT/EXTRACT, SHUFFLE/PERM, BROADCAST) - Simplify data access and try to get stride 1 access. There are 96 issues (= instructions) costing 1 point each. | 96 |
| ○ | [SA] More than 20% of the loads are accessing the stack - Perform loop splitting to decrease pressure on registers. This issue costs 2 points. | 2 |
| ►Vectorization Roadblocks | 293 | |
| ○ | [SA] Too many paths (287 paths) - Simplify control structure. There are 287 issues ( = paths) costing 1 point each with a malus of 4 points. | 291 |
| ○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ►Inefficient Vectorization | 154 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 14 issues (= instructions) costing 4 points each. | 56 |
| ○ | [SA] Presence of special instructions executing on a single port (INSERT/EXTRACT, SHUFFLE/PERM, BROADCAST) - Simplify data access and try to get stride 1 access. There are 96 issues (= instructions) costing 1 point each. | 96 |
| ○ | [SA] Inefficient vectorization: use of masked instructions - Simplify control structure. The issue costs 2 points. | 2 |
| ►Loop 19 - libqmckl.so.0.0.0 | Execution Time: 4 % - Vectorization Ratio: 100.00 % - Vector Length Use: 83.33 % | |
| ►Data Access Issues | 16 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 2 issues ( = indirect data accesses) costing 4 point each. | 8 |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 2 issues (= instructions) costing 4 points each. | 8 |
| ►Vectorization Roadblocks | 8 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 2 issues ( = indirect data accesses) costing 4 point each. | 8 |
| ►Inefficient Vectorization | 8 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 2 issues (= instructions) costing 4 points each. | 8 |
| ►Loop 23 - libqmckl.so.0.0.0 | Execution Time: 3 % - Vectorization Ratio: 100.00 % - Vector Length Use: 83.33 % | |
| ►Data Access Issues | 16 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 2 issues ( = indirect data accesses) costing 4 point each. | 8 |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 2 issues (= instructions) costing 4 points each. | 8 |
| ►Vectorization Roadblocks | 8 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 2 issues ( = indirect data accesses) costing 4 point each. | 8 |
| ►Inefficient Vectorization | 8 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 2 issues (= instructions) costing 4 points each. | 8 |
| ○Loop 22 - libqmckl.so.0.0.0 | Execution Time: 3 % - Vectorization Ratio: 100.00 % - Vector Length Use: 100.00 % | |
| ►Loop 207 - libqmckl.so.0.0.0 | Execution Time: 1 % - Vectorization Ratio: 0.00 % - Vector Length Use: 12.50 % | |
| ►Loop Computation Issues | 4 | |
| ○ | [SA] Less than 10% of the FP ADD/SUB/MUL arithmetic operations are performed using FMA - Reorganize arithmetic expressions to exhibit potential for FMA. This issue costs 4 points. | 4 |
| ►Loop 707 - libqmckl.so.0.0.0 | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 50.00 % | |
| ►Loop Computation Issues | 4 | |
| ○ | [SA] Presence of expensive FP instructions - Perform hoisting, change algorithm, use SVML or proper numerical library or perform value profiling (count the number of distinct input values). There are 1 issues (= instructions) costing 4 points each. | 4 |
| ►Loop 698 - libqmckl.so.0.0.0 | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 50.00 % | |
| ►Loop Computation Issues | 4 | |
| ○ | [SA] Presence of expensive FP instructions - Perform hoisting, change algorithm, use SVML or proper numerical library or perform value profiling (count the number of distinct input values). There are 1 issues (= instructions) costing 4 points each. | 4 |
| ►Loop 28 - libqmckl.so.0.0.0 | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 11.03 % | |
| ►Control Flow Issues | 334 | |
| ○ | [SA] Too many paths (328 paths) - Simplify control structure. There are 328 issues ( = paths) costing 1 point each with a malus of 4 points. | 332 |
| ○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ►Data Access Issues | 2 | |
| ○ | [SA] More than 20% of the loads are accessing the stack - Perform loop splitting to decrease pressure on registers. This issue costs 2 points. | 2 |
| ►Vectorization Roadblocks | 334 | |
| ○ | [SA] Too many paths (328 paths) - Simplify control structure. There are 328 issues ( = paths) costing 1 point each with a malus of 4 points. | 332 |
| ○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
[ 0 / 4 ] Application profile is too short (4.78 s)
If the overall application profiling time is less than 10 seconds, many of the measurements at function or loop level will very likely be under the measurement quality threshold (0,1 seconds).
Rerun to increase runtime duration: for example use a larger dataset or include a repetition loop.
[ 3 / 3 ] Most of time spent in analyzed modules comes from functions with source/debug info
-g option gives access to debugging informations, such are source locations.
[ 2.91 / 3 ] Architecture specific option -march=native is used
[ 2.40 / 3 ] Most of time spent in analyzed modules comes from functions with compilation options informations but -fno-omit-frame-pointer is missing
-fno-omit-frame-pointer improves the accuracy of callchains found during the application profiling.
[ 2.94 / 3 ] Optimization level option is correctly used
[ 2 / 3 ] Security settings from the host restrict profiling. Some metrics will be missing or incomplete.
Current value for kernel.perf_event_paranoid is 2. If possible, set it to 1 or check with your system administrator which flag can be used to achieve this.
[ 2 / 2 ] Application is correctly profiled ("Others" category represents 0.21 % of the execution time)
To have a representative profiling, it is advised that the category "Others" represents less than 20% of the execution time in order to analyze as much as possible of the user code
[ 1 / 1 ] Lstopo present. The Topology lstopo report will be generated.
[ 4 / 4 ] Enough time of the experiment time spent in analyzed loops (98.33%)
If the time spent in analyzed loops is less than 30%, standard loop optimizations will have a limited impact on application performances.
[ 4 / 4 ] Threads activity is good
On average, more than 99.03% of observed threads are actually active
[ 4 / 4 ] CPU activity is good
CPU cores are active 99.03% of time
[ 4 / 4 ] Loop profile is not flat
At least one loop coverage is greater than 4% (28.63%), representing an hotspot for the application
[ 4 / 4 ] Enough time of the experiment time spent in analyzed innermost loops (74.61%)
If the time spent in analyzed innermost loops is less than 15%, standard innermost loop optimizations such as vectorisation will have a limited impact on application performances.
[ 4 / 4 ] Affinity is good (98.83%)
Threads are not migrating to CPU cores: probably successfully pinned
[ 3 / 3 ] Less than 10% (0.00%) is spend in BLAS1 operations
It could be more efficient to inline by hand BLAS1 operations
[ 3 / 3 ] Functions mostly use all threads
Functions running on a reduced number of threads (typically sequential code) cover less than 10% of application walltime (0.00%)
[ 3 / 3 ] Cumulative Outermost/In between loops coverage (23.72%) lower than cumulative innermost loop coverage (74.61%)
Having cumulative Outermost/In between loops coverage greater than cumulative innermost loop coverage will make loop optimization more complex
[ 2 / 2 ] Less than 10% (0.00%) is spend in BLAS2 operations
BLAS2 calls usually could make a poor cache usage and could benefit from inlining.
[ 2 / 2 ] Less than 10% (0.00%) is spend in Libm/SVML (special functions)
| Loop ID | Analysis | Penalty Score |
|---|---|---|
| ►Loop 21 - libqmckl.so.0.0.0 | Execution Time: 28 % - Vectorization Ratio: 100.00 % - Vector Length Use: 81.25 % | |
| ►Data Access Issues | 24 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 3 issues ( = indirect data accesses) costing 4 point each. | 12 |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 3 issues (= instructions) costing 4 points each. | 12 |
| ►Vectorization Roadblocks | 12 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 3 issues ( = indirect data accesses) costing 4 point each. | 12 |
| ►Inefficient Vectorization | 12 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 3 issues (= instructions) costing 4 points each. | 12 |
| ►Loop 30 - libqmckl.so.0.0.0 | Execution Time: 28 % - Vectorization Ratio: 0.00 % - Vector Length Use: 12.50 % | |
| ►Loop Computation Issues | 2 | |
| ○ | [SA] Presence of a large number of scalar integer instructions - Simplify loop structure, perform loop splitting or perform unroll and jam. This issue costs 2 points. | 2 |
| ►Control Flow Issues | 85 | |
| ○ | [SA] Too many paths (81 paths) - Simplify control structure. There are 81 issues ( = paths) costing 1 point each with a malus of 4 points. | 85 |
| ►Data Access Issues | 2 | |
| ○ | [SA] More than 20% of the loads are accessing the stack - Perform loop splitting to decrease pressure on registers. This issue costs 2 points. | 2 |
| ►Vectorization Roadblocks | 85 | |
| ○ | [SA] Too many paths (81 paths) - Simplify control structure. There are 81 issues ( = paths) costing 1 point each with a malus of 4 points. | 85 |
| ►Loop 18 - libqmckl.so.0.0.0 | Execution Time: 23 % - Vectorization Ratio: 70.91 % - Vector Length Use: 57.27 % | |
| ►Loop Computation Issues | 2 | |
| ○ | [SA] Presence of a large number of scalar integer instructions - Simplify loop structure, perform loop splitting or perform unroll and jam. This issue costs 2 points. | 2 |
| ►Control Flow Issues | 293 | |
| ○ | [SA] Too many paths (287 paths) - Simplify control structure. There are 287 issues ( = paths) costing 1 point each with a malus of 4 points. | 291 |
| ○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ►Data Access Issues | 154 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 14 issues (= instructions) costing 4 points each. | 56 |
| ○ | [SA] Presence of special instructions executing on a single port (INSERT/EXTRACT, SHUFFLE/PERM, BROADCAST) - Simplify data access and try to get stride 1 access. There are 96 issues (= instructions) costing 1 point each. | 96 |
| ○ | [SA] More than 20% of the loads are accessing the stack - Perform loop splitting to decrease pressure on registers. This issue costs 2 points. | 2 |
| ►Vectorization Roadblocks | 293 | |
| ○ | [SA] Too many paths (287 paths) - Simplify control structure. There are 287 issues ( = paths) costing 1 point each with a malus of 4 points. | 291 |
| ○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ►Inefficient Vectorization | 154 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 14 issues (= instructions) costing 4 points each. | 56 |
| ○ | [SA] Presence of special instructions executing on a single port (INSERT/EXTRACT, SHUFFLE/PERM, BROADCAST) - Simplify data access and try to get stride 1 access. There are 96 issues (= instructions) costing 1 point each. | 96 |
| ○ | [SA] Inefficient vectorization: use of masked instructions - Simplify control structure. The issue costs 2 points. | 2 |
| ►Loop 19 - libqmckl.so.0.0.0 | Execution Time: 6 % - Vectorization Ratio: 100.00 % - Vector Length Use: 83.33 % | |
| ►Data Access Issues | 16 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 2 issues ( = indirect data accesses) costing 4 point each. | 8 |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 2 issues (= instructions) costing 4 points each. | 8 |
| ►Vectorization Roadblocks | 8 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 2 issues ( = indirect data accesses) costing 4 point each. | 8 |
| ►Inefficient Vectorization | 8 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 2 issues (= instructions) costing 4 points each. | 8 |
| ►Loop 23 - libqmckl.so.0.0.0 | Execution Time: 4 % - Vectorization Ratio: 100.00 % - Vector Length Use: 83.33 % | |
| ►Data Access Issues | 16 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 2 issues ( = indirect data accesses) costing 4 point each. | 8 |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 2 issues (= instructions) costing 4 points each. | 8 |
| ►Vectorization Roadblocks | 8 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 2 issues ( = indirect data accesses) costing 4 point each. | 8 |
| ►Inefficient Vectorization | 8 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 2 issues (= instructions) costing 4 points each. | 8 |
| ○Loop 22 - libqmckl.so.0.0.0 | Execution Time: 3 % - Vectorization Ratio: 100.00 % - Vector Length Use: 100.00 % | |
| ►Loop 207 - libqmckl.so.0.0.0 | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 12.50 % | |
| ►Loop Computation Issues | 4 | |
| ○ | [SA] Less than 10% of the FP ADD/SUB/MUL arithmetic operations are performed using FMA - Reorganize arithmetic expressions to exhibit potential for FMA. This issue costs 4 points. | 4 |
| ○Loop 24 - libqmckl.so.0.0.0 | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 100.00 % | |
| ►Loop 28 - libqmckl.so.0.0.0 | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 11.03 % | |
| ►Control Flow Issues | 334 | |
| ○ | [SA] Too many paths (328 paths) - Simplify control structure. There are 328 issues ( = paths) costing 1 point each with a malus of 4 points. | 332 |
| ○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ►Data Access Issues | 2 | |
| ○ | [SA] More than 20% of the loads are accessing the stack - Perform loop splitting to decrease pressure on registers. This issue costs 2 points. | 2 |
| ►Vectorization Roadblocks | 334 | |
| ○ | [SA] Too many paths (328 paths) - Simplify control structure. There are 328 issues ( = paths) costing 1 point each with a malus of 4 points. | 332 |
| ○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ►Loop 707 - libqmckl.so.0.0.0 | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 50.00 % | |
| ►Loop Computation Issues | 4 | |
| ○ | [SA] Presence of expensive FP instructions - Perform hoisting, change algorithm, use SVML or proper numerical library or perform value profiling (count the number of distinct input values). There are 1 issues (= instructions) costing 4 points each. | 4 |
[ 0 / 4 ] Application profile is too short (5.60 s)
If the overall application profiling time is less than 10 seconds, many of the measurements at function or loop level will very likely be under the measurement quality threshold (0,1 seconds).
Rerun to increase runtime duration: for example use a larger dataset or include a repetition loop.
[ 3 / 3 ] Most of time spent in analyzed modules comes from functions with source/debug info
-g option gives access to debugging informations, such are source locations.
[ 2.92 / 3 ] Architecture specific option -march=native is used
[ 2.40 / 3 ] Most of time spent in analyzed modules comes from functions with compilation options informations but -fno-omit-frame-pointer is missing
-fno-omit-frame-pointer improves the accuracy of callchains found during the application profiling.
[ 2.96 / 3 ] Optimization level option is correctly used
[ 2 / 3 ] Security settings from the host restrict profiling. Some metrics will be missing or incomplete.
Current value for kernel.perf_event_paranoid is 2. If possible, set it to 1 or check with your system administrator which flag can be used to achieve this.
[ 2 / 2 ] Application is correctly profiled ("Others" category represents 0.36 % of the execution time)
To have a representative profiling, it is advised that the category "Others" represents less than 20% of the execution time in order to analyze as much as possible of the user code
[ 1 / 1 ] Lstopo present. The Topology lstopo report will be generated.
[ 4 / 4 ] Enough time of the experiment time spent in analyzed loops (98.03%)
If the time spent in analyzed loops is less than 30%, standard loop optimizations will have a limited impact on application performances.
[ 4 / 4 ] Threads activity is good
On average, more than 99.29% of observed threads are actually active
[ 4 / 4 ] CPU activity is good
CPU cores are active 99.29% of time
[ 4 / 4 ] Loop profile is not flat
At least one loop coverage is greater than 4% (30.29%), representing an hotspot for the application
[ 4 / 4 ] Enough time of the experiment time spent in analyzed innermost loops (72.83%)
If the time spent in analyzed innermost loops is less than 15%, standard innermost loop optimizations such as vectorisation will have a limited impact on application performances.
[ 4 / 4 ] Affinity is good (99.23%)
Threads are not migrating to CPU cores: probably successfully pinned
[ 3 / 3 ] Less than 10% (0.00%) is spend in BLAS1 operations
It could be more efficient to inline by hand BLAS1 operations
[ 3 / 3 ] Functions mostly use all threads
Functions running on a reduced number of threads (typically sequential code) cover less than 10% of application walltime (0.00%)
[ 3 / 3 ] Cumulative Outermost/In between loops coverage (25.20%) lower than cumulative innermost loop coverage (72.83%)
Having cumulative Outermost/In between loops coverage greater than cumulative innermost loop coverage will make loop optimization more complex
[ 2 / 2 ] Less than 10% (0.00%) is spend in BLAS2 operations
BLAS2 calls usually could make a poor cache usage and could benefit from inlining.
[ 2 / 2 ] Less than 10% (0.00%) is spend in Libm/SVML (special functions)
| Loop ID | Analysis | Penalty Score |
|---|---|---|
| ►Loop 21 - libqmckl.so.0.0.0 | Execution Time: 30 % - Vectorization Ratio: 100.00 % - Vector Length Use: 81.25 % | |
| ►Data Access Issues | 24 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 3 issues ( = indirect data accesses) costing 4 point each. | 12 |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 3 issues (= instructions) costing 4 points each. | 12 |
| ►Vectorization Roadblocks | 12 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 3 issues ( = indirect data accesses) costing 4 point each. | 12 |
| ►Inefficient Vectorization | 12 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 3 issues (= instructions) costing 4 points each. | 12 |
| ►Loop 30 - libqmckl.so.0.0.0 | Execution Time: 27 % - Vectorization Ratio: 0.00 % - Vector Length Use: 12.50 % | |
| ►Loop Computation Issues | 2 | |
| ○ | [SA] Presence of a large number of scalar integer instructions - Simplify loop structure, perform loop splitting or perform unroll and jam. This issue costs 2 points. | 2 |
| ►Control Flow Issues | 85 | |
| ○ | [SA] Too many paths (81 paths) - Simplify control structure. There are 81 issues ( = paths) costing 1 point each with a malus of 4 points. | 85 |
| ►Data Access Issues | 2 | |
| ○ | [SA] More than 20% of the loads are accessing the stack - Perform loop splitting to decrease pressure on registers. This issue costs 2 points. | 2 |
| ►Vectorization Roadblocks | 85 | |
| ○ | [SA] Too many paths (81 paths) - Simplify control structure. There are 81 issues ( = paths) costing 1 point each with a malus of 4 points. | 85 |
| ►Loop 18 - libqmckl.so.0.0.0 | Execution Time: 25 % - Vectorization Ratio: 70.91 % - Vector Length Use: 57.27 % | |
| ►Loop Computation Issues | 2 | |
| ○ | [SA] Presence of a large number of scalar integer instructions - Simplify loop structure, perform loop splitting or perform unroll and jam. This issue costs 2 points. | 2 |
| ►Control Flow Issues | 293 | |
| ○ | [SA] Too many paths (287 paths) - Simplify control structure. There are 287 issues ( = paths) costing 1 point each with a malus of 4 points. | 291 |
| ○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ►Data Access Issues | 154 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 14 issues (= instructions) costing 4 points each. | 56 |
| ○ | [SA] Presence of special instructions executing on a single port (INSERT/EXTRACT, SHUFFLE/PERM, BROADCAST) - Simplify data access and try to get stride 1 access. There are 96 issues (= instructions) costing 1 point each. | 96 |
| ○ | [SA] More than 20% of the loads are accessing the stack - Perform loop splitting to decrease pressure on registers. This issue costs 2 points. | 2 |
| ►Vectorization Roadblocks | 293 | |
| ○ | [SA] Too many paths (287 paths) - Simplify control structure. There are 287 issues ( = paths) costing 1 point each with a malus of 4 points. | 291 |
| ○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ►Inefficient Vectorization | 154 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 14 issues (= instructions) costing 4 points each. | 56 |
| ○ | [SA] Presence of special instructions executing on a single port (INSERT/EXTRACT, SHUFFLE/PERM, BROADCAST) - Simplify data access and try to get stride 1 access. There are 96 issues (= instructions) costing 1 point each. | 96 |
| ○ | [SA] Inefficient vectorization: use of masked instructions - Simplify control structure. The issue costs 2 points. | 2 |
| ►Loop 23 - libqmckl.so.0.0.0 | Execution Time: 5 % - Vectorization Ratio: 100.00 % - Vector Length Use: 83.33 % | |
| ►Data Access Issues | 16 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 2 issues ( = indirect data accesses) costing 4 point each. | 8 |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 2 issues (= instructions) costing 4 points each. | 8 |
| ►Vectorization Roadblocks | 8 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 2 issues ( = indirect data accesses) costing 4 point each. | 8 |
| ►Inefficient Vectorization | 8 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 2 issues (= instructions) costing 4 points each. | 8 |
| ►Loop 19 - libqmckl.so.0.0.0 | Execution Time: 4 % - Vectorization Ratio: 100.00 % - Vector Length Use: 83.33 % | |
| ►Data Access Issues | 16 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 2 issues ( = indirect data accesses) costing 4 point each. | 8 |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 2 issues (= instructions) costing 4 points each. | 8 |
| ►Vectorization Roadblocks | 8 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 2 issues ( = indirect data accesses) costing 4 point each. | 8 |
| ►Inefficient Vectorization | 8 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 2 issues (= instructions) costing 4 points each. | 8 |
| ○Loop 22 - libqmckl.so.0.0.0 | Execution Time: 2 % - Vectorization Ratio: 100.00 % - Vector Length Use: 100.00 % | |
| ►Loop 207 - libqmckl.so.0.0.0 | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 12.50 % | |
| ►Loop Computation Issues | 4 | |
| ○ | [SA] Less than 10% of the FP ADD/SUB/MUL arithmetic operations are performed using FMA - Reorganize arithmetic expressions to exhibit potential for FMA. This issue costs 4 points. | 4 |
| ►Loop 20 - libqmckl.so.0.0.0 | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 83.33 % | |
| ►Data Access Issues | 16 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 2 issues ( = indirect data accesses) costing 4 point each. | 8 |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 2 issues (= instructions) costing 4 points each. | 8 |
| ►Vectorization Roadblocks | 8 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 2 issues ( = indirect data accesses) costing 4 point each. | 8 |
| ►Inefficient Vectorization | 8 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 2 issues (= instructions) costing 4 points each. | 8 |
| ○Loop 24 - libqmckl.so.0.0.0 | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 100.00 % | |
| ►Loop 563 - libqmckl.so.0.0.0 | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 45.83 % | |
| ►Loop Computation Issues | 6 | |
| ○ | [SA] Less than 10% of the FP ADD/SUB/MUL arithmetic operations are performed using FMA - Reorganize arithmetic expressions to exhibit potential for FMA. This issue costs 4 points. | 4 |
| ○ | [SA] Presence of a large number of scalar integer instructions - Simplify loop structure, perform loop splitting or perform unroll and jam. This issue costs 2 points. | 2 |
| ►Control Flow Issues | 1 | |
| ○ | [SA] Presence of calls - Inline either by compiler or by hand and use SVML for libm calls. There are 1 issues (= calls) costing 1 point each. | 1 |
| ►Data Access Issues | 10 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 1 issues ( = indirect data accesses) costing 4 point each. | 4 |
| ○ | [SA] Inefficient vectorization: more than 10% of the vector loads instructions are unaligned - When allocating arrays, don’t forget to align them. There are 0 issues ( = arrays) costing 2 points each | 0 |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 1 issues (= instructions) costing 4 points each. | 4 |
| ○ | [SA] More than 20% of the loads are accessing the stack - Perform loop splitting to decrease pressure on registers. This issue costs 2 points. | 2 |
| ►Vectorization Roadblocks | 5 | |
| ○ | [SA] Presence of calls - Inline either by compiler or by hand and use SVML for libm calls. There are 1 issues (= calls) costing 1 point each. | 1 |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 1 issues ( = indirect data accesses) costing 4 point each. | 4 |
| ►Inefficient Vectorization | 4 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 1 issues (= instructions) costing 4 points each. | 4 |
[ 0 / 4 ] Application profile is too short (5.54 s)
If the overall application profiling time is less than 10 seconds, many of the measurements at function or loop level will very likely be under the measurement quality threshold (0,1 seconds).
Rerun to increase runtime duration: for example use a larger dataset or include a repetition loop.
[ 3 / 3 ] Most of time spent in analyzed modules comes from functions with source/debug info
-g option gives access to debugging informations, such are source locations.
[ 2.92 / 3 ] Architecture specific option -march=native is used
[ 2.40 / 3 ] Most of time spent in analyzed modules comes from functions with compilation options informations but -fno-omit-frame-pointer is missing
-fno-omit-frame-pointer improves the accuracy of callchains found during the application profiling.
[ 2.96 / 3 ] Optimization level option is correctly used
[ 2 / 3 ] Security settings from the host restrict profiling. Some metrics will be missing or incomplete.
Current value for kernel.perf_event_paranoid is 2. If possible, set it to 1 or check with your system administrator which flag can be used to achieve this.
[ 2 / 2 ] Application is correctly profiled ("Others" category represents 0.00 % of the execution time)
To have a representative profiling, it is advised that the category "Others" represents less than 20% of the execution time in order to analyze as much as possible of the user code
[ 1 / 1 ] Lstopo present. The Topology lstopo report will be generated.
[ 4 / 4 ] Enough time of the experiment time spent in analyzed loops (98.28%)
If the time spent in analyzed loops is less than 30%, standard loop optimizations will have a limited impact on application performances.
[ 4 / 4 ] Threads activity is good
On average, more than 99.34% of observed threads are actually active
[ 4 / 4 ] CPU activity is good
CPU cores are active 99.34% of time
[ 4 / 4 ] Loop profile is not flat
At least one loop coverage is greater than 4% (29.99%), representing an hotspot for the application
[ 4 / 4 ] Enough time of the experiment time spent in analyzed innermost loops (73.53%)
If the time spent in analyzed innermost loops is less than 15%, standard innermost loop optimizations such as vectorisation will have a limited impact on application performances.
[ 4 / 4 ] Affinity is good (99.67%)
Threads are not migrating to CPU cores: probably successfully pinned
[ 3 / 3 ] Less than 10% (0.00%) is spend in BLAS1 operations
It could be more efficient to inline by hand BLAS1 operations
[ 3 / 3 ] Functions mostly use all threads
Functions running on a reduced number of threads (typically sequential code) cover less than 10% of application walltime (0.00%)
[ 3 / 3 ] Cumulative Outermost/In between loops coverage (24.75%) lower than cumulative innermost loop coverage (73.53%)
Having cumulative Outermost/In between loops coverage greater than cumulative innermost loop coverage will make loop optimization more complex
[ 2 / 2 ] Less than 10% (0.00%) is spend in BLAS2 operations
BLAS2 calls usually could make a poor cache usage and could benefit from inlining.
[ 2 / 2 ] Less than 10% (0.00%) is spend in Libm/SVML (special functions)
| Loop ID | Analysis | Penalty Score |
|---|---|---|
| ►Loop 21 - libqmckl.so.0.0.0 | Execution Time: 29 % - Vectorization Ratio: 100.00 % - Vector Length Use: 81.25 % | |
| ►Data Access Issues | 24 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 3 issues ( = indirect data accesses) costing 4 point each. | 12 |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 3 issues (= instructions) costing 4 points each. | 12 |
| ►Vectorization Roadblocks | 12 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 3 issues ( = indirect data accesses) costing 4 point each. | 12 |
| ►Inefficient Vectorization | 12 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 3 issues (= instructions) costing 4 points each. | 12 |
| ►Loop 30 - libqmckl.so.0.0.0 | Execution Time: 28 % - Vectorization Ratio: 0.00 % - Vector Length Use: 12.50 % | |
| ►Loop Computation Issues | 2 | |
| ○ | [SA] Presence of a large number of scalar integer instructions - Simplify loop structure, perform loop splitting or perform unroll and jam. This issue costs 2 points. | 2 |
| ►Control Flow Issues | 85 | |
| ○ | [SA] Too many paths (81 paths) - Simplify control structure. There are 81 issues ( = paths) costing 1 point each with a malus of 4 points. | 85 |
| ►Data Access Issues | 2 | |
| ○ | [SA] More than 20% of the loads are accessing the stack - Perform loop splitting to decrease pressure on registers. This issue costs 2 points. | 2 |
| ►Vectorization Roadblocks | 85 | |
| ○ | [SA] Too many paths (81 paths) - Simplify control structure. There are 81 issues ( = paths) costing 1 point each with a malus of 4 points. | 85 |
| ►Loop 18 - libqmckl.so.0.0.0 | Execution Time: 24 % - Vectorization Ratio: 70.91 % - Vector Length Use: 57.27 % | |
| ►Loop Computation Issues | 2 | |
| ○ | [SA] Presence of a large number of scalar integer instructions - Simplify loop structure, perform loop splitting or perform unroll and jam. This issue costs 2 points. | 2 |
| ►Control Flow Issues | 293 | |
| ○ | [SA] Too many paths (287 paths) - Simplify control structure. There are 287 issues ( = paths) costing 1 point each with a malus of 4 points. | 291 |
| ○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ►Data Access Issues | 154 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 14 issues (= instructions) costing 4 points each. | 56 |
| ○ | [SA] Presence of special instructions executing on a single port (INSERT/EXTRACT, SHUFFLE/PERM, BROADCAST) - Simplify data access and try to get stride 1 access. There are 96 issues (= instructions) costing 1 point each. | 96 |
| ○ | [SA] More than 20% of the loads are accessing the stack - Perform loop splitting to decrease pressure on registers. This issue costs 2 points. | 2 |
| ►Vectorization Roadblocks | 293 | |
| ○ | [SA] Too many paths (287 paths) - Simplify control structure. There are 287 issues ( = paths) costing 1 point each with a malus of 4 points. | 291 |
| ○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ►Inefficient Vectorization | 154 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 14 issues (= instructions) costing 4 points each. | 56 |
| ○ | [SA] Presence of special instructions executing on a single port (INSERT/EXTRACT, SHUFFLE/PERM, BROADCAST) - Simplify data access and try to get stride 1 access. There are 96 issues (= instructions) costing 1 point each. | 96 |
| ○ | [SA] Inefficient vectorization: use of masked instructions - Simplify control structure. The issue costs 2 points. | 2 |
| ►Loop 23 - libqmckl.so.0.0.0 | Execution Time: 5 % - Vectorization Ratio: 100.00 % - Vector Length Use: 83.33 % | |
| ►Data Access Issues | 16 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 2 issues ( = indirect data accesses) costing 4 point each. | 8 |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 2 issues (= instructions) costing 4 points each. | 8 |
| ►Vectorization Roadblocks | 8 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 2 issues ( = indirect data accesses) costing 4 point each. | 8 |
| ►Inefficient Vectorization | 8 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 2 issues (= instructions) costing 4 points each. | 8 |
| ►Loop 19 - libqmckl.so.0.0.0 | Execution Time: 3 % - Vectorization Ratio: 100.00 % - Vector Length Use: 83.33 % | |
| ►Data Access Issues | 16 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 2 issues ( = indirect data accesses) costing 4 point each. | 8 |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 2 issues (= instructions) costing 4 points each. | 8 |
| ►Vectorization Roadblocks | 8 | |
| ○ | [SA] Presence of indirect accesses - Use array restructuring or gather instructions to lower the cost. There are 2 issues ( = indirect data accesses) costing 4 point each. | 8 |
| ►Inefficient Vectorization | 8 | |
| ○ | [SA] Presence of expensive instructions (GATHER/SCATTER) - Use array restructuring. There are 2 issues (= instructions) costing 4 points each. | 8 |
| ○Loop 22 - libqmckl.so.0.0.0 | Execution Time: 3 % - Vectorization Ratio: 100.00 % - Vector Length Use: 100.00 % | |
| ►Loop 207 - libqmckl.so.0.0.0 | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 12.50 % | |
| ►Loop Computation Issues | 4 | |
| ○ | [SA] Less than 10% of the FP ADD/SUB/MUL arithmetic operations are performed using FMA - Reorganize arithmetic expressions to exhibit potential for FMA. This issue costs 4 points. | 4 |
| ►Loop 28 - libqmckl.so.0.0.0 | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 11.03 % | |
| ►Control Flow Issues | 334 | |
| ○ | [SA] Too many paths (328 paths) - Simplify control structure. There are 328 issues ( = paths) costing 1 point each with a malus of 4 points. | 332 |
| ○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ►Data Access Issues | 2 | |
| ○ | [SA] More than 20% of the loads are accessing the stack - Perform loop splitting to decrease pressure on registers. This issue costs 2 points. | 2 |
| ►Vectorization Roadblocks | 334 | |
| ○ | [SA] Too many paths (328 paths) - Simplify control structure. There are 328 issues ( = paths) costing 1 point each with a malus of 4 points. | 332 |
| ○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ►Loop 707 - libqmckl.so.0.0.0 | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 50.00 % | |
| ►Loop Computation Issues | 4 | |
| ○ | [SA] Presence of expensive FP instructions - Perform hoisting, change algorithm, use SVML or proper numerical library or perform value profiling (count the number of distinct input values). There are 1 issues (= instructions) costing 4 points each. | 4 |
| ►Loop 554 - libqmckl.so.0.0.0 | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 50.00 % | |
| ►Loop Computation Issues | 4 | |
| ○ | [SA] Less than 10% of the FP ADD/SUB/MUL arithmetic operations are performed using FMA - Reorganize arithmetic expressions to exhibit potential for FMA. This issue costs 4 points. | 4 |
| ►Data Access Issues | 0 | |
| ○ | [SA] Inefficient vectorization: more than 10% of the vector loads instructions are unaligned - When allocating arrays, don’t forget to align them. There are 0 issues ( = arrays) costing 2 points each | 0 |