Help is available by moving the cursor above any symbol or by checking MAQAO website.
[ 4 / 4 ] Application profile is long enough (45.62 s)
To have good quality measurements, it is advised that the application profiling time is greater than 10 seconds.
[ 3 / 3 ] Optimization level option is correctly used
[ 3 / 3 ] Most of time spent in analyzed modules comes from functions compiled with -g and -fno-omit-frame-pointer
-g option gives access to debugging informations, such are source locations. -fno-omit-frame-pointer improve the accuracy of callchains found during the application profiling.
[ 3 / 3 ] Host configuration allows retrieval of all necessary metrics.
[ 0 / 3 ] Compilation of some functions is not optimized for the target processor
-march=x86-64 option is used but it is not specific enough to produce efficient code.
[ 0 / 2 ] Too much execution time spent in category "Others" (43.73 %)
If the category "Others" represents more than 20% of the execution time, it means that the application profile misses a representative part of the application. Examine functions details to properly identify “Others” category components. Rerun after adding most represented library names (e.g. more than 20% of coverage) to external_libraries (the names can be directly provided by ONE View)
[ 1 / 1 ] Lstopo present. The Topology lstopo report will be generated.
[ 0 / 0 ] Fastmath not used
Consider to add ffast-math to compilation flags (or replace -O3 with -Ofast) to unlock potential extra speedup by relaxing floating-point computation consistency. Warning: floating-point accuracy may be reduced and the compliance to IEEE/ISO rules/specifications for math functions will be relaxed, typically 'errno' will no longer be set after calling some math functions.
[ 4 / 4 ] Enough time of the experiment time spent in analyzed loops (32.48%)
If the time spent in analyzed loops is less than 30%, standard loop optimizations will have a limited impact on application performances.
[ 4 / 4 ] CPU activity is good
CPU cores are active 94.25% of time
[ 4 / 4 ] Threads activity is good
On average, more than 94.25% of observed threads are actually active
[ 4 / 4 ] Affinity is good (99.31%)
Threads are not migrating to CPU cores: probably successfully pinned
[ 4 / 4 ] Loop profile is not flat
At least one loop coverage is greater than 4% (21.15%), representing an hotspot for the application
[ 4 / 4 ] Enough time of the experiment time spent in analyzed innermost loops (27.50%)
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.
[ 3 / 3 ] Cumulative Outermost/In between loops coverage (4.97%) lower than cumulative innermost loop coverage (27.50%)
Having cumulative Outermost/In between loops coverage greater than cumulative innermost loop coverage will make loop optimization more complex
[ 3 / 3 ] Less than 10% (0.00%) is spend in BLAS1 operations
It could be more efficient to inline by hand BLAS1 operations
[ 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.82%) is spend in Libm/SVML (special functions)
Loop ID | Analysis | Penalty Score |
---|---|---|
►Loop 4426 - libCLASSpkg.so | Execution Time: 21 % - Vectorization Ratio: 50.00 % - Vector Length Use: 18.75 % | |
►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 | 1 | |
○ | [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 special instructions executing on a single port (BLEND/MERGE) - Simplify data access and try to get stride 1 access. There are 1 issues (= instructions) costing 1 point each. | 1 |
►Inefficient Vectorization | 1 | |
○ | [SA] Presence of special instructions executing on a single port (BLEND/MERGE) - Simplify data access and try to get stride 1 access. There are 1 issues (= instructions) costing 1 point each. | 1 |
►Loop 1093 - libCLASSpkg.so | Execution Time: 1 % - Vectorization Ratio: 0.00 % - Vector Length Use: 0.00 % | |
►Control Flow Issues | 2 | |
○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Vectorization Roadblocks | 1002 | |
○ | [SA] Too many paths (at least 1000 paths) - Simplify control structure. There are at least 1000 issues ( = paths) costing 1 point. | 1000 |
○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Loop 1092 - libCLASSpkg.so | Execution Time: 1 % - Vectorization Ratio: 0.00 % - Vector Length Use: 12.50 % | |
►Data Access Issues | 4 | |
○ | [SA] Presence of constant non unit stride data access - Use array restructuring, perform loop interchange or use gather instructions to lower a bit the cost. There are 2 issues ( = data accesses) costing 2 point each. | 4 |
►Vectorization Roadblocks | 4 | |
○ | [SA] Presence of constant non unit stride data access - Use array restructuring, perform loop interchange or use gather instructions to lower a bit the cost. There are 2 issues ( = data accesses) costing 2 point each. | 4 |
►Loop 4431 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 9.80 % | |
►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 | 12 | |
○ | [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] Too many paths (7 paths) - Simplify control structure. There are 7 issues ( = paths) costing 1 point each with a malus of 4 points. | 11 |
►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 | 12 | |
○ | [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] Too many paths (7 paths) - Simplify control structure. There are 7 issues ( = paths) costing 1 point each with a malus of 4 points. | 11 |
►Loop 1095 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 5.72 % - Vector Length Use: 10.44 % | |
►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 | 3 | |
○ | [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] Several paths (2 paths) - Simplify control structure or force the compiler to use masked instructions. There are 2 issues ( = paths) costing 1 point each. | 2 |
►Data Access Issues | 5 | |
○ | [SA] Presence of constant non unit stride data access - Use array restructuring, perform loop interchange or use gather instructions to lower a bit the cost. There are 2 issues ( = data accesses) costing 2 point each. | 4 |
○ | [SA] Presence of special instructions executing on a single port (BLEND/MERGE) - Simplify data access and try to get stride 1 access. There are 1 issues (= instructions) costing 1 point each. | 1 |
►Vectorization Roadblocks | 7 | |
○ | [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] Several paths (2 paths) - Simplify control structure or force the compiler to use masked instructions. There are 2 issues ( = paths) costing 1 point each. | 2 |
○ | [SA] Presence of constant non unit stride data access - Use array restructuring, perform loop interchange or use gather instructions to lower a bit the cost. There are 2 issues ( = data accesses) costing 2 point each. | 4 |
►Inefficient Vectorization | 1 | |
○ | [SA] Presence of special instructions executing on a single port (BLEND/MERGE) - Simplify data access and try to get stride 1 access. There are 1 issues (= instructions) costing 1 point each. | 1 |
►Loop 4424 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 16.98 % - Vector Length Use: 12.85 % | |
►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 | 5 | |
○ | [SA] Several paths (3 paths) - Simplify control structure or force the compiler to use masked instructions. There are 3 issues ( = paths) costing 1 point each. | 3 |
○ | [SA] Non innermost loop (Outermost) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Vectorization Roadblocks | 5 | |
○ | [SA] Several paths (3 paths) - Simplify control structure or force the compiler to use masked instructions. There are 3 issues ( = paths) costing 1 point each. | 3 |
○ | [SA] Non innermost loop (Outermost) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Loop 1143 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 0.00 % | |
►Control Flow Issues | 2 | |
○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Vectorization Roadblocks | 1002 | |
○ | [SA] Too many paths (at least 1000 paths) - Simplify control structure. There are at least 1000 issues ( = paths) costing 1 point. | 1000 |
○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Loop 864 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 11.25 % | |
►Control Flow Issues | 51 | |
○ | [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] Too many paths (44 paths) - Simplify control structure. There are 44 issues ( = paths) costing 1 point each with a malus of 4 points. | 48 |
○ | [SA] Non innermost loop (Outermost) - 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 | 51 | |
○ | [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] Too many paths (44 paths) - Simplify control structure. There are 44 issues ( = paths) costing 1 point each with a malus of 4 points. | 48 |
○ | [SA] Non innermost loop (Outermost) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Loop 1094 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 0.00 % | |
►Control Flow Issues | 12 | |
○ | [SA] Too many paths (6 paths) - Simplify control structure. There are 6 issues ( = paths) costing 1 point each with a malus of 4 points. | 10 |
○ | [SA] Non innermost loop (Outermost) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Vectorization Roadblocks | 12 | |
○ | [SA] Too many paths (6 paths) - Simplify control structure. There are 6 issues ( = paths) costing 1 point each with a malus of 4 points. | 10 |
○ | [SA] Non innermost loop (Outermost) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Loop 865 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 11.25 % | |
►Control Flow Issues | 42 | |
○ | [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] Too many paths (35 paths) - Simplify control structure. There are 35 issues ( = paths) costing 1 point each with a malus of 4 points. | 39 |
○ | [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 | 42 | |
○ | [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] Too many paths (35 paths) - Simplify control structure. There are 35 issues ( = paths) costing 1 point each with a malus of 4 points. | 39 |
○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
[ 4 / 4 ] Application profile is long enough (42.79 s)
To have good quality measurements, it is advised that the application profiling time is greater than 10 seconds.
[ 3 / 3 ] Optimization level option is correctly used
[ 3 / 3 ] Most of time spent in analyzed modules comes from functions compiled with -g and -fno-omit-frame-pointer
-g option gives access to debugging informations, such are source locations. -fno-omit-frame-pointer improves the accuracy of callchains found during the application profiling.
[ 3 / 3 ] Host configuration allows retrieval of all necessary metrics.
[ 0 / 3 ] Compilation of some functions is not optimized for the target processor
-march=x86-64 option is used but it is not specific enough to produce efficient code.
[ 0 / 2 ] Too much execution time spent in category "Others" (26.52 %)
If the category "Others" represents more than 20% of the execution time, it means that the application profile misses a representative part of the application. Examine functions details to properly identify “Others” category components. Rerun after adding most represented library names (e.g. more than 20% of coverage) to external_libraries (the names can be directly provided by ONE View)
[ 1 / 1 ] Lstopo present. The Topology lstopo report will be generated.
[ 0 / 0 ] Fastmath not used
Consider to add ffast-math to compilation flags (or replace -O3 with -Ofast) to unlock potential extra speedup by relaxing floating-point computation consistency. Warning: floating-point accuracy may be reduced and the compliance to IEEE/ISO rules/specifications for math functions will be relaxed, typically 'errno' will no longer be set after calling some math functions.
[ 0 / 4 ] Too little time of the experiment time spent in analyzed loops (28.34%)
If the time spent in analyzed loops is less than 30%, standard loop optimizations will have a limited impact on application performances.
[ 3 / 4 ] CPU activity is below 90% (87.89%)
CPU cores are idle more than 10% of time. Threads supposed to run on these cores are probably IO/sync waiting. Some hints: use faster filesystems to read/write data, improve parallel load balancing and/or scheduling.
[ 4 / 4 ] Threads activity is good
On average, more than 166.55% of observed threads are actually active
[ 4 / 4 ] Affinity is good (98.80%)
Threads are not migrating to CPU cores: probably successfully pinned
[ 4 / 4 ] Loop profile is not flat
At least one loop coverage is greater than 4% (20.55%), representing an hotspot for the application
[ 4 / 4 ] Enough time of the experiment time spent in analyzed innermost loops (25.70%)
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.
[ 3 / 3 ] Cumulative Outermost/In between loops coverage (2.64%) lower than cumulative innermost loop coverage (25.70%)
Having cumulative Outermost/In between loops coverage greater than cumulative innermost loop coverage will make loop optimization more complex
[ 3 / 3 ] Less than 10% (0.00%) is spend in BLAS1 operations
It could be more efficient to inline by hand BLAS1 operations
[ 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.44%) is spend in Libm/SVML (special functions)
Loop ID | Analysis | Penalty Score |
---|---|---|
►Loop 4426 - libCLASSpkg.so | Execution Time: 20 % - Vectorization Ratio: 50.00 % - Vector Length Use: 18.75 % | |
►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 | 1 | |
○ | [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 special instructions executing on a single port (BLEND/MERGE) - Simplify data access and try to get stride 1 access. There are 1 issues (= instructions) costing 1 point each. | 1 |
►Inefficient Vectorization | 1 | |
○ | [SA] Presence of special instructions executing on a single port (BLEND/MERGE) - Simplify data access and try to get stride 1 access. There are 1 issues (= instructions) costing 1 point each. | 1 |
►Loop 4425 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 12.50 % | |
►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 |
►Loop 1092 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 12.50 % | |
►Data Access Issues | 4 | |
○ | [SA] Presence of constant non unit stride data access - Use array restructuring, perform loop interchange or use gather instructions to lower a bit the cost. There are 2 issues ( = data accesses) costing 2 point each. | 4 |
►Vectorization Roadblocks | 4 | |
○ | [SA] Presence of constant non unit stride data access - Use array restructuring, perform loop interchange or use gather instructions to lower a bit the cost. There are 2 issues ( = data accesses) costing 2 point each. | 4 |
►Loop 4431 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 9.80 % | |
►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 | 12 | |
○ | [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] Too many paths (7 paths) - Simplify control structure. There are 7 issues ( = paths) costing 1 point each with a malus of 4 points. | 11 |
►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 | 12 | |
○ | [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] Too many paths (7 paths) - Simplify control structure. There are 7 issues ( = paths) costing 1 point each with a malus of 4 points. | 11 |
►Loop 1093 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 0.00 % | |
►Control Flow Issues | 2 | |
○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Vectorization Roadblocks | 1002 | |
○ | [SA] Too many paths (at least 1000 paths) - Simplify control structure. There are at least 1000 issues ( = paths) costing 1 point. | 1000 |
○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Loop 4424 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 16.98 % - Vector Length Use: 12.85 % | |
►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 | 5 | |
○ | [SA] Several paths (3 paths) - Simplify control structure or force the compiler to use masked instructions. There are 3 issues ( = paths) costing 1 point each. | 3 |
○ | [SA] Non innermost loop (Outermost) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Vectorization Roadblocks | 5 | |
○ | [SA] Several paths (3 paths) - Simplify control structure or force the compiler to use masked instructions. There are 3 issues ( = paths) costing 1 point each. | 3 |
○ | [SA] Non innermost loop (Outermost) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Loop 1095 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 5.72 % - Vector Length Use: 10.44 % | |
►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 | 3 | |
○ | [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] Several paths (2 paths) - Simplify control structure or force the compiler to use masked instructions. There are 2 issues ( = paths) costing 1 point each. | 2 |
►Data Access Issues | 5 | |
○ | [SA] Presence of constant non unit stride data access - Use array restructuring, perform loop interchange or use gather instructions to lower a bit the cost. There are 2 issues ( = data accesses) costing 2 point each. | 4 |
○ | [SA] Presence of special instructions executing on a single port (BLEND/MERGE) - Simplify data access and try to get stride 1 access. There are 1 issues (= instructions) costing 1 point each. | 1 |
►Vectorization Roadblocks | 7 | |
○ | [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] Several paths (2 paths) - Simplify control structure or force the compiler to use masked instructions. There are 2 issues ( = paths) costing 1 point each. | 2 |
○ | [SA] Presence of constant non unit stride data access - Use array restructuring, perform loop interchange or use gather instructions to lower a bit the cost. There are 2 issues ( = data accesses) costing 2 point each. | 4 |
►Inefficient Vectorization | 1 | |
○ | [SA] Presence of special instructions executing on a single port (BLEND/MERGE) - Simplify data access and try to get stride 1 access. There are 1 issues (= instructions) costing 1 point each. | 1 |
►Loop 1143 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 0.00 % | |
►Control Flow Issues | 2 | |
○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Vectorization Roadblocks | 1002 | |
○ | [SA] Too many paths (at least 1000 paths) - Simplify control structure. There are at least 1000 issues ( = paths) costing 1 point. | 1000 |
○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Loop 1094 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 0.00 % | |
►Control Flow Issues | 12 | |
○ | [SA] Too many paths (6 paths) - Simplify control structure. There are 6 issues ( = paths) costing 1 point each with a malus of 4 points. | 10 |
○ | [SA] Non innermost loop (Outermost) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Vectorization Roadblocks | 12 | |
○ | [SA] Too many paths (6 paths) - Simplify control structure. There are 6 issues ( = paths) costing 1 point each with a malus of 4 points. | 10 |
○ | [SA] Non innermost loop (Outermost) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Loop 3289 - libCLASSpkg.so | Execution Time: 0 % - 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 | 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 | 2 | |
○ | [SA] Presence of constant non unit stride data access - Use array restructuring, perform loop interchange or use gather instructions to lower a bit the cost. There are 1 issues ( = data accesses) costing 2 point each. | 2 |
►Vectorization Roadblocks | 3 | |
○ | [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 constant non unit stride data access - Use array restructuring, perform loop interchange or use gather instructions to lower a bit the cost. There are 1 issues ( = data accesses) costing 2 point each. | 2 |
[ 4 / 4 ] Application profile is long enough (41.52 s)
To have good quality measurements, it is advised that the application profiling time is greater than 10 seconds.
[ 3 / 3 ] Optimization level option is correctly used
[ 3 / 3 ] Most of time spent in analyzed modules comes from functions compiled with -g and -fno-omit-frame-pointer
-g option gives access to debugging informations, such are source locations. -fno-omit-frame-pointer improve the accuracy of callchains found during the application profiling.
[ 3 / 3 ] Host configuration allows retrieval of all necessary metrics.
[ 0 / 3 ] Compilation of some functions is not optimized for the target processor
-march=x86-64 option is used but it is not specific enough to produce efficient code.
[ 2 / 2 ] Application is correctly profiled ("Others" category represents 14.65 % 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.
[ 0 / 0 ] Fastmath not used
Consider to add ffast-math to compilation flags (or replace -O3 with -Ofast) to unlock potential extra speedup by relaxing floating-point computation consistency. Warning: floating-point accuracy may be reduced and the compliance to IEEE/ISO rules/specifications for math functions will be relaxed, typically 'errno' will no longer be set after calling some math functions.
[ 0 / 4 ] Too little time of the experiment time spent in analyzed loops (22.93%)
If the time spent in analyzed loops is less than 30%, standard loop optimizations will have a limited impact on application performances.
[ 3 / 4 ] CPU activity is below 90% (84.78%)
CPU cores are idle more than 10% of time. Threads supposed to run on these cores are probably IO/sync waiting. Some hints: use faster filesystems to read/write data, improve parallel load balancing and/or scheduling.
[ 4 / 4 ] Threads activity is good
On average, more than 309.21% of observed threads are actually active
[ 4 / 4 ] Affinity is good (98.45%)
Threads are not migrating to CPU cores: probably successfully pinned
[ 4 / 4 ] Loop profile is not flat
At least one loop coverage is greater than 4% (18.29%), representing an hotspot for the application
[ 4 / 4 ] Enough time of the experiment time spent in analyzed innermost loops (21.30%)
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.
[ 3 / 3 ] Cumulative Outermost/In between loops coverage (1.64%) lower than cumulative innermost loop coverage (21.30%)
Having cumulative Outermost/In between loops coverage greater than cumulative innermost loop coverage will make loop optimization more complex
[ 3 / 3 ] Less than 10% (0.00%) is spend in BLAS1 operations
It could be more efficient to inline by hand BLAS1 operations
[ 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.25%) is spend in Libm/SVML (special functions)
Loop ID | Analysis | Penalty Score |
---|---|---|
►Loop 4426 - libCLASSpkg.so | Execution Time: 18 % - Vectorization Ratio: 50.00 % - Vector Length Use: 18.75 % | |
►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 | 1 | |
○ | [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 special instructions executing on a single port (BLEND/MERGE) - Simplify data access and try to get stride 1 access. There are 1 issues (= instructions) costing 1 point each. | 1 |
►Inefficient Vectorization | 1 | |
○ | [SA] Presence of special instructions executing on a single port (BLEND/MERGE) - Simplify data access and try to get stride 1 access. There are 1 issues (= instructions) costing 1 point each. | 1 |
►Loop 4425 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 12.50 % | |
►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 |
►Loop 1093 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 0.00 % | |
►Control Flow Issues | 2 | |
○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Vectorization Roadblocks | 1002 | |
○ | [SA] Too many paths (at least 1000 paths) - Simplify control structure. There are at least 1000 issues ( = paths) costing 1 point. | 1000 |
○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Loop 1092 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 12.50 % | |
►Data Access Issues | 4 | |
○ | [SA] Presence of constant non unit stride data access - Use array restructuring, perform loop interchange or use gather instructions to lower a bit the cost. There are 2 issues ( = data accesses) costing 2 point each. | 4 |
►Vectorization Roadblocks | 4 | |
○ | [SA] Presence of constant non unit stride data access - Use array restructuring, perform loop interchange or use gather instructions to lower a bit the cost. There are 2 issues ( = data accesses) costing 2 point each. | 4 |
►Loop 4424 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 16.98 % - Vector Length Use: 12.85 % | |
►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 | 5 | |
○ | [SA] Several paths (3 paths) - Simplify control structure or force the compiler to use masked instructions. There are 3 issues ( = paths) costing 1 point each. | 3 |
○ | [SA] Non innermost loop (Outermost) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Vectorization Roadblocks | 5 | |
○ | [SA] Several paths (3 paths) - Simplify control structure or force the compiler to use masked instructions. There are 3 issues ( = paths) costing 1 point each. | 3 |
○ | [SA] Non innermost loop (Outermost) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Loop 4431 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 9.80 % | |
►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 | 12 | |
○ | [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] Too many paths (7 paths) - Simplify control structure. There are 7 issues ( = paths) costing 1 point each with a malus of 4 points. | 11 |
►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 | 12 | |
○ | [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] Too many paths (7 paths) - Simplify control structure. There are 7 issues ( = paths) costing 1 point each with a malus of 4 points. | 11 |
►Loop 1095 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 5.72 % - Vector Length Use: 10.44 % | |
►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 | 3 | |
○ | [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] Several paths (2 paths) - Simplify control structure or force the compiler to use masked instructions. There are 2 issues ( = paths) costing 1 point each. | 2 |
►Data Access Issues | 5 | |
○ | [SA] Presence of constant non unit stride data access - Use array restructuring, perform loop interchange or use gather instructions to lower a bit the cost. There are 2 issues ( = data accesses) costing 2 point each. | 4 |
○ | [SA] Presence of special instructions executing on a single port (BLEND/MERGE) - Simplify data access and try to get stride 1 access. There are 1 issues (= instructions) costing 1 point each. | 1 |
►Vectorization Roadblocks | 7 | |
○ | [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] Several paths (2 paths) - Simplify control structure or force the compiler to use masked instructions. There are 2 issues ( = paths) costing 1 point each. | 2 |
○ | [SA] Presence of constant non unit stride data access - Use array restructuring, perform loop interchange or use gather instructions to lower a bit the cost. There are 2 issues ( = data accesses) costing 2 point each. | 4 |
►Inefficient Vectorization | 1 | |
○ | [SA] Presence of special instructions executing on a single port (BLEND/MERGE) - Simplify data access and try to get stride 1 access. There are 1 issues (= instructions) costing 1 point each. | 1 |
►Loop 1248 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 12.50 % | |
►Data Access Issues | 4 | |
○ | [SA] Presence of constant non unit stride data access - Use array restructuring, perform loop interchange or use gather instructions to lower a bit the cost. There are 2 issues ( = data accesses) costing 2 point each. | 4 |
►Vectorization Roadblocks | 4 | |
○ | [SA] Presence of constant non unit stride data access - Use array restructuring, perform loop interchange or use gather instructions to lower a bit the cost. There are 2 issues ( = data accesses) costing 2 point each. | 4 |
►Loop 1173 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 12.50 % | |
►Control Flow Issues | 10 | |
○ | [SA] Too many paths (6 paths) - Simplify control structure. There are 6 issues ( = paths) costing 1 point each with a malus of 4 points. | 10 |
►Vectorization Roadblocks | 10 | |
○ | [SA] Too many paths (6 paths) - Simplify control structure. There are 6 issues ( = paths) costing 1 point each with a malus of 4 points. | 10 |
►Loop 1094 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 0.00 % | |
►Control Flow Issues | 12 | |
○ | [SA] Too many paths (6 paths) - Simplify control structure. There are 6 issues ( = paths) costing 1 point each with a malus of 4 points. | 10 |
○ | [SA] Non innermost loop (Outermost) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Vectorization Roadblocks | 12 | |
○ | [SA] Too many paths (6 paths) - Simplify control structure. There are 6 issues ( = paths) costing 1 point each with a malus of 4 points. | 10 |
○ | [SA] Non innermost loop (Outermost) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
[ 4 / 4 ] Application profile is long enough (47.25 s)
To have good quality measurements, it is advised that the application profiling time is greater than 10 seconds.
[ 3 / 3 ] Optimization level option is correctly used
[ 3 / 3 ] Most of time spent in analyzed modules comes from functions compiled with -g and -fno-omit-frame-pointer
-g option gives access to debugging informations, such are source locations. -fno-omit-frame-pointer improve the accuracy of callchains found during the application profiling.
[ 3 / 3 ] Host configuration allows retrieval of all necessary metrics.
[ 0 / 3 ] Compilation of some functions is not optimized for the target processor
-march=x86-64 option is used but it is not specific enough to produce efficient code.
[ 2 / 2 ] Application is correctly profiled ("Others" category represents 6.68 % 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.
[ 0 / 0 ] Fastmath not used
Consider to add ffast-math to compilation flags (or replace -O3 with -Ofast) to unlock potential extra speedup by relaxing floating-point computation consistency. Warning: floating-point accuracy may be reduced and the compliance to IEEE/ISO rules/specifications for math functions will be relaxed, typically 'errno' will no longer be set after calling some math functions.
[ 0 / 4 ] Too little time of the experiment time spent in analyzed loops (26.80%)
If the time spent in analyzed loops is less than 30%, standard loop optimizations will have a limited impact on application performances.
[ 3 / 4 ] CPU activity is below 90% (86.00%)
CPU cores are idle more than 10% of time. Threads supposed to run on these cores are probably IO/sync waiting. Some hints: use faster filesystems to read/write data, improve parallel load balancing and/or scheduling.
[ 4 / 4 ] Threads activity is good
On average, more than 628.39% of observed threads are actually active
[ 4 / 4 ] Affinity is good (98.50%)
Threads are not migrating to CPU cores: probably successfully pinned
[ 4 / 4 ] Loop profile is not flat
At least one loop coverage is greater than 4% (23.46%), representing an hotspot for the application
[ 4 / 4 ] Enough time of the experiment time spent in analyzed innermost loops (25.95%)
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.
[ 3 / 3 ] Cumulative Outermost/In between loops coverage (0.85%) lower than cumulative innermost loop coverage (25.95%)
Having cumulative Outermost/In between loops coverage greater than cumulative innermost loop coverage will make loop optimization more complex
[ 3 / 3 ] Less than 10% (0.00%) is spend in BLAS1 operations
It could be more efficient to inline by hand BLAS1 operations
[ 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.14%) is spend in Libm/SVML (special functions)
Loop ID | Analysis | Penalty Score |
---|---|---|
►Loop 4426 - libCLASSpkg.so | Execution Time: 23 % - Vectorization Ratio: 50.00 % - Vector Length Use: 18.75 % | |
►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 | 1 | |
○ | [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 special instructions executing on a single port (BLEND/MERGE) - Simplify data access and try to get stride 1 access. There are 1 issues (= instructions) costing 1 point each. | 1 |
►Inefficient Vectorization | 1 | |
○ | [SA] Presence of special instructions executing on a single port (BLEND/MERGE) - Simplify data access and try to get stride 1 access. There are 1 issues (= instructions) costing 1 point each. | 1 |
►Loop 4425 - libCLASSpkg.so | Execution Time: 1 % - Vectorization Ratio: 0.00 % - Vector Length Use: 12.50 % | |
►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 |
►Loop 4424 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 16.98 % - Vector Length Use: 12.85 % | |
►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 | 5 | |
○ | [SA] Several paths (3 paths) - Simplify control structure or force the compiler to use masked instructions. There are 3 issues ( = paths) costing 1 point each. | 3 |
○ | [SA] Non innermost loop (Outermost) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Vectorization Roadblocks | 5 | |
○ | [SA] Several paths (3 paths) - Simplify control structure or force the compiler to use masked instructions. There are 3 issues ( = paths) costing 1 point each. | 3 |
○ | [SA] Non innermost loop (Outermost) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Loop 1092 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 12.50 % | |
►Data Access Issues | 4 | |
○ | [SA] Presence of constant non unit stride data access - Use array restructuring, perform loop interchange or use gather instructions to lower a bit the cost. There are 2 issues ( = data accesses) costing 2 point each. | 4 |
►Vectorization Roadblocks | 4 | |
○ | [SA] Presence of constant non unit stride data access - Use array restructuring, perform loop interchange or use gather instructions to lower a bit the cost. There are 2 issues ( = data accesses) costing 2 point each. | 4 |
►Loop 4431 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 9.80 % | |
►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 | 12 | |
○ | [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] Too many paths (7 paths) - Simplify control structure. There are 7 issues ( = paths) costing 1 point each with a malus of 4 points. | 11 |
►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 | 12 | |
○ | [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] Too many paths (7 paths) - Simplify control structure. There are 7 issues ( = paths) costing 1 point each with a malus of 4 points. | 11 |
►Loop 1093 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 0.00 % | |
►Control Flow Issues | 2 | |
○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Vectorization Roadblocks | 1002 | |
○ | [SA] Too many paths (at least 1000 paths) - Simplify control structure. There are at least 1000 issues ( = paths) costing 1 point. | 1000 |
○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Loop 1095 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 5.72 % - Vector Length Use: 10.44 % | |
►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 | 3 | |
○ | [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] Several paths (2 paths) - Simplify control structure or force the compiler to use masked instructions. There are 2 issues ( = paths) costing 1 point each. | 2 |
►Data Access Issues | 5 | |
○ | [SA] Presence of constant non unit stride data access - Use array restructuring, perform loop interchange or use gather instructions to lower a bit the cost. There are 2 issues ( = data accesses) costing 2 point each. | 4 |
○ | [SA] Presence of special instructions executing on a single port (BLEND/MERGE) - Simplify data access and try to get stride 1 access. There are 1 issues (= instructions) costing 1 point each. | 1 |
►Vectorization Roadblocks | 7 | |
○ | [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] Several paths (2 paths) - Simplify control structure or force the compiler to use masked instructions. There are 2 issues ( = paths) costing 1 point each. | 2 |
○ | [SA] Presence of constant non unit stride data access - Use array restructuring, perform loop interchange or use gather instructions to lower a bit the cost. There are 2 issues ( = data accesses) costing 2 point each. | 4 |
►Inefficient Vectorization | 1 | |
○ | [SA] Presence of special instructions executing on a single port (BLEND/MERGE) - Simplify data access and try to get stride 1 access. There are 1 issues (= instructions) costing 1 point each. | 1 |
►Loop 1143 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 0.00 % | |
►Control Flow Issues | 2 | |
○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Vectorization Roadblocks | 1002 | |
○ | [SA] Too many paths (at least 1000 paths) - Simplify control structure. There are at least 1000 issues ( = paths) costing 1 point. | 1000 |
○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Loop 1094 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 0.00 % | |
►Control Flow Issues | 12 | |
○ | [SA] Too many paths (6 paths) - Simplify control structure. There are 6 issues ( = paths) costing 1 point each with a malus of 4 points. | 10 |
○ | [SA] Non innermost loop (Outermost) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Vectorization Roadblocks | 12 | |
○ | [SA] Too many paths (6 paths) - Simplify control structure. There are 6 issues ( = paths) costing 1 point each with a malus of 4 points. | 10 |
○ | [SA] Non innermost loop (Outermost) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Loop 3289 - libCLASSpkg.so | Execution Time: 0 % - 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 | 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 | 2 | |
○ | [SA] Presence of constant non unit stride data access - Use array restructuring, perform loop interchange or use gather instructions to lower a bit the cost. There are 1 issues ( = data accesses) costing 2 point each. | 2 |
►Vectorization Roadblocks | 3 | |
○ | [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 constant non unit stride data access - Use array restructuring, perform loop interchange or use gather instructions to lower a bit the cost. There are 1 issues ( = data accesses) costing 2 point each. | 2 |
[ 4 / 4 ] Application profile is long enough (54.05 s)
To have good quality measurements, it is advised that the application profiling time is greater than 10 seconds.
[ 3 / 3 ] Optimization level option is correctly used
[ 3 / 3 ] Most of time spent in analyzed modules comes from functions compiled with -g and -fno-omit-frame-pointer
-g option gives access to debugging informations, such are source locations. -fno-omit-frame-pointer improve the accuracy of callchains found during the application profiling.
[ 3 / 3 ] Host configuration allows retrieval of all necessary metrics.
[ 0 / 3 ] Compilation of some functions is not optimized for the target processor
-march=x86-64 option is used but it is not specific enough to produce efficient code.
[ 2 / 2 ] Application is correctly profiled ("Others" category represents 2.81 % 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.
[ 0 / 0 ] Fastmath not used
Consider to add ffast-math to compilation flags (or replace -O3 with -Ofast) to unlock potential extra speedup by relaxing floating-point computation consistency. Warning: floating-point accuracy may be reduced and the compliance to IEEE/ISO rules/specifications for math functions will be relaxed, typically 'errno' will no longer be set after calling some math functions.
[ 0 / 4 ] Too little time of the experiment time spent in analyzed loops (25.99%)
If the time spent in analyzed loops is less than 30%, standard loop optimizations will have a limited impact on application performances.
[ 3 / 4 ] CPU activity is below 90% (87.41%)
CPU cores are idle more than 10% of time. Threads supposed to run on these cores are probably IO/sync waiting. Some hints: use faster filesystems to read/write data, improve parallel load balancing and/or scheduling.
[ 4 / 4 ] Threads activity is good
On average, more than 1285.36% of observed threads are actually active
[ 4 / 4 ] Affinity is good (98.64%)
Threads are not migrating to CPU cores: probably successfully pinned
[ 4 / 4 ] Loop profile is not flat
At least one loop coverage is greater than 4% (23.13%), representing an hotspot for the application
[ 4 / 4 ] Enough time of the experiment time spent in analyzed innermost loops (25.56%)
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.
[ 3 / 3 ] Cumulative Outermost/In between loops coverage (0.44%) lower than cumulative innermost loop coverage (25.56%)
Having cumulative Outermost/In between loops coverage greater than cumulative innermost loop coverage will make loop optimization more complex
[ 3 / 3 ] Less than 10% (0.00%) is spend in BLAS1 operations
It could be more efficient to inline by hand BLAS1 operations
[ 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.05%) is spend in Libm/SVML (special functions)
Loop ID | Analysis | Penalty Score |
---|---|---|
►Loop 4426 - libCLASSpkg.so | Execution Time: 23 % - Vectorization Ratio: 50.00 % - Vector Length Use: 18.75 % | |
►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 | 1 | |
○ | [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 special instructions executing on a single port (BLEND/MERGE) - Simplify data access and try to get stride 1 access. There are 1 issues (= instructions) costing 1 point each. | 1 |
►Inefficient Vectorization | 1 | |
○ | [SA] Presence of special instructions executing on a single port (BLEND/MERGE) - Simplify data access and try to get stride 1 access. There are 1 issues (= instructions) costing 1 point each. | 1 |
►Loop 4425 - libCLASSpkg.so | Execution Time: 2 % - Vectorization Ratio: 0.00 % - Vector Length Use: 12.50 % | |
►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 |
►Loop 4424 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 16.98 % - Vector Length Use: 12.85 % | |
►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 | 5 | |
○ | [SA] Several paths (3 paths) - Simplify control structure or force the compiler to use masked instructions. There are 3 issues ( = paths) costing 1 point each. | 3 |
○ | [SA] Non innermost loop (Outermost) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Vectorization Roadblocks | 5 | |
○ | [SA] Several paths (3 paths) - Simplify control structure or force the compiler to use masked instructions. There are 3 issues ( = paths) costing 1 point each. | 3 |
○ | [SA] Non innermost loop (Outermost) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Loop 1092 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 12.50 % | |
►Data Access Issues | 4 | |
○ | [SA] Presence of constant non unit stride data access - Use array restructuring, perform loop interchange or use gather instructions to lower a bit the cost. There are 2 issues ( = data accesses) costing 2 point each. | 4 |
►Vectorization Roadblocks | 4 | |
○ | [SA] Presence of constant non unit stride data access - Use array restructuring, perform loop interchange or use gather instructions to lower a bit the cost. There are 2 issues ( = data accesses) costing 2 point each. | 4 |
►Loop 4431 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 9.80 % | |
►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 | 12 | |
○ | [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] Too many paths (7 paths) - Simplify control structure. There are 7 issues ( = paths) costing 1 point each with a malus of 4 points. | 11 |
►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 | 12 | |
○ | [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] Too many paths (7 paths) - Simplify control structure. There are 7 issues ( = paths) costing 1 point each with a malus of 4 points. | 11 |
►Loop 1093 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 0.00 % | |
►Control Flow Issues | 2 | |
○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Vectorization Roadblocks | 1002 | |
○ | [SA] Too many paths (at least 1000 paths) - Simplify control structure. There are at least 1000 issues ( = paths) costing 1 point. | 1000 |
○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Loop 1095 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 5.72 % - Vector Length Use: 10.44 % | |
►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 | 3 | |
○ | [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] Several paths (2 paths) - Simplify control structure or force the compiler to use masked instructions. There are 2 issues ( = paths) costing 1 point each. | 2 |
►Data Access Issues | 5 | |
○ | [SA] Presence of constant non unit stride data access - Use array restructuring, perform loop interchange or use gather instructions to lower a bit the cost. There are 2 issues ( = data accesses) costing 2 point each. | 4 |
○ | [SA] Presence of special instructions executing on a single port (BLEND/MERGE) - Simplify data access and try to get stride 1 access. There are 1 issues (= instructions) costing 1 point each. | 1 |
►Vectorization Roadblocks | 7 | |
○ | [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] Several paths (2 paths) - Simplify control structure or force the compiler to use masked instructions. There are 2 issues ( = paths) costing 1 point each. | 2 |
○ | [SA] Presence of constant non unit stride data access - Use array restructuring, perform loop interchange or use gather instructions to lower a bit the cost. There are 2 issues ( = data accesses) costing 2 point each. | 4 |
►Inefficient Vectorization | 1 | |
○ | [SA] Presence of special instructions executing on a single port (BLEND/MERGE) - Simplify data access and try to get stride 1 access. There are 1 issues (= instructions) costing 1 point each. | 1 |
►Loop 1173 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 12.50 % | |
►Control Flow Issues | 10 | |
○ | [SA] Too many paths (6 paths) - Simplify control structure. There are 6 issues ( = paths) costing 1 point each with a malus of 4 points. | 10 |
►Vectorization Roadblocks | 10 | |
○ | [SA] Too many paths (6 paths) - Simplify control structure. There are 6 issues ( = paths) costing 1 point each with a malus of 4 points. | 10 |
►Loop 1143 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 0.00 % | |
►Control Flow Issues | 2 | |
○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Vectorization Roadblocks | 1002 | |
○ | [SA] Too many paths (at least 1000 paths) - Simplify control structure. There are at least 1000 issues ( = paths) costing 1 point. | 1000 |
○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Loop 1094 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 0.00 % | |
►Control Flow Issues | 12 | |
○ | [SA] Too many paths (6 paths) - Simplify control structure. There are 6 issues ( = paths) costing 1 point each with a malus of 4 points. | 10 |
○ | [SA] Non innermost loop (Outermost) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Vectorization Roadblocks | 12 | |
○ | [SA] Too many paths (6 paths) - Simplify control structure. There are 6 issues ( = paths) costing 1 point each with a malus of 4 points. | 10 |
○ | [SA] Non innermost loop (Outermost) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
[ 4 / 4 ] Application profile is long enough (55.95 s)
To have good quality measurements, it is advised that the application profiling time is greater than 10 seconds.
[ 3 / 3 ] Optimization level option is correctly used
[ 3 / 3 ] Most of time spent in analyzed modules comes from functions compiled with -g and -fno-omit-frame-pointer
-g option gives access to debugging informations, such are source locations. -fno-omit-frame-pointer improve the accuracy of callchains found during the application profiling.
[ 3 / 3 ] Host configuration allows retrieval of all necessary metrics.
[ 0 / 3 ] Compilation of some functions is not optimized for the target processor
-march=x86-64 option is used but it is not specific enough to produce efficient code.
[ 2 / 2 ] Application is correctly profiled ("Others" category represents 1.69 % 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.
[ 0 / 0 ] Fastmath not used
Consider to add ffast-math to compilation flags (or replace -O3 with -Ofast) to unlock potential extra speedup by relaxing floating-point computation consistency. Warning: floating-point accuracy may be reduced and the compliance to IEEE/ISO rules/specifications for math functions will be relaxed, typically 'errno' will no longer be set after calling some math functions.
[ 0 / 4 ] Too little time of the experiment time spent in analyzed loops (25.81%)
If the time spent in analyzed loops is less than 30%, standard loop optimizations will have a limited impact on application performances.
[ 3 / 4 ] CPU activity is below 90% (87.85%)
CPU cores are idle more than 10% of time. Threads supposed to run on these cores are probably IO/sync waiting. Some hints: use faster filesystems to read/write data, improve parallel load balancing and/or scheduling.
[ 4 / 4 ] Threads activity is good
On average, more than 2099.66% of observed threads are actually active
[ 4 / 4 ] Affinity is good (98.66%)
Threads are not migrating to CPU cores: probably successfully pinned
[ 4 / 4 ] Loop profile is not flat
At least one loop coverage is greater than 4% (22.62%), representing an hotspot for the application
[ 4 / 4 ] Enough time of the experiment time spent in analyzed innermost loops (25.41%)
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.
[ 3 / 3 ] Cumulative Outermost/In between loops coverage (0.40%) lower than cumulative innermost loop coverage (25.41%)
Having cumulative Outermost/In between loops coverage greater than cumulative innermost loop coverage will make loop optimization more complex
[ 3 / 3 ] Less than 10% (0.00%) is spend in BLAS1 operations
It could be more efficient to inline by hand BLAS1 operations
[ 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.03%) is spend in Libm/SVML (special functions)
Loop ID | Analysis | Penalty Score |
---|---|---|
►Loop 4426 - libCLASSpkg.so | Execution Time: 22 % - Vectorization Ratio: 50.00 % - Vector Length Use: 18.75 % | |
►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 | 1 | |
○ | [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 special instructions executing on a single port (BLEND/MERGE) - Simplify data access and try to get stride 1 access. There are 1 issues (= instructions) costing 1 point each. | 1 |
►Inefficient Vectorization | 1 | |
○ | [SA] Presence of special instructions executing on a single port (BLEND/MERGE) - Simplify data access and try to get stride 1 access. There are 1 issues (= instructions) costing 1 point each. | 1 |
►Loop 4425 - libCLASSpkg.so | Execution Time: 2 % - Vectorization Ratio: 0.00 % - Vector Length Use: 12.50 % | |
►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 |
►Loop 4424 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 16.98 % - Vector Length Use: 12.85 % | |
►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 | 5 | |
○ | [SA] Several paths (3 paths) - Simplify control structure or force the compiler to use masked instructions. There are 3 issues ( = paths) costing 1 point each. | 3 |
○ | [SA] Non innermost loop (Outermost) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Vectorization Roadblocks | 5 | |
○ | [SA] Several paths (3 paths) - Simplify control structure or force the compiler to use masked instructions. There are 3 issues ( = paths) costing 1 point each. | 3 |
○ | [SA] Non innermost loop (Outermost) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Loop 1092 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 12.50 % | |
►Data Access Issues | 4 | |
○ | [SA] Presence of constant non unit stride data access - Use array restructuring, perform loop interchange or use gather instructions to lower a bit the cost. There are 2 issues ( = data accesses) costing 2 point each. | 4 |
►Vectorization Roadblocks | 4 | |
○ | [SA] Presence of constant non unit stride data access - Use array restructuring, perform loop interchange or use gather instructions to lower a bit the cost. There are 2 issues ( = data accesses) costing 2 point each. | 4 |
►Loop 4431 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 9.80 % | |
►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 | 12 | |
○ | [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] Too many paths (7 paths) - Simplify control structure. There are 7 issues ( = paths) costing 1 point each with a malus of 4 points. | 11 |
►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 | 12 | |
○ | [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] Too many paths (7 paths) - Simplify control structure. There are 7 issues ( = paths) costing 1 point each with a malus of 4 points. | 11 |
►Loop 1093 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 0.00 % | |
►Control Flow Issues | 2 | |
○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Vectorization Roadblocks | 1002 | |
○ | [SA] Too many paths (at least 1000 paths) - Simplify control structure. There are at least 1000 issues ( = paths) costing 1 point. | 1000 |
○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Loop 1094 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 0.00 % | |
►Control Flow Issues | 12 | |
○ | [SA] Too many paths (6 paths) - Simplify control structure. There are 6 issues ( = paths) costing 1 point each with a malus of 4 points. | 10 |
○ | [SA] Non innermost loop (Outermost) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Vectorization Roadblocks | 12 | |
○ | [SA] Too many paths (6 paths) - Simplify control structure. There are 6 issues ( = paths) costing 1 point each with a malus of 4 points. | 10 |
○ | [SA] Non innermost loop (Outermost) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Loop 1095 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 5.72 % - Vector Length Use: 10.44 % | |
►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 | 3 | |
○ | [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] Several paths (2 paths) - Simplify control structure or force the compiler to use masked instructions. There are 2 issues ( = paths) costing 1 point each. | 2 |
►Data Access Issues | 5 | |
○ | [SA] Presence of constant non unit stride data access - Use array restructuring, perform loop interchange or use gather instructions to lower a bit the cost. There are 2 issues ( = data accesses) costing 2 point each. | 4 |
○ | [SA] Presence of special instructions executing on a single port (BLEND/MERGE) - Simplify data access and try to get stride 1 access. There are 1 issues (= instructions) costing 1 point each. | 1 |
►Vectorization Roadblocks | 7 | |
○ | [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] Several paths (2 paths) - Simplify control structure or force the compiler to use masked instructions. There are 2 issues ( = paths) costing 1 point each. | 2 |
○ | [SA] Presence of constant non unit stride data access - Use array restructuring, perform loop interchange or use gather instructions to lower a bit the cost. There are 2 issues ( = data accesses) costing 2 point each. | 4 |
►Inefficient Vectorization | 1 | |
○ | [SA] Presence of special instructions executing on a single port (BLEND/MERGE) - Simplify data access and try to get stride 1 access. There are 1 issues (= instructions) costing 1 point each. | 1 |
►Loop 3289 - libCLASSpkg.so | Execution Time: 0 % - 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 | 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 | 2 | |
○ | [SA] Presence of constant non unit stride data access - Use array restructuring, perform loop interchange or use gather instructions to lower a bit the cost. There are 1 issues ( = data accesses) costing 2 point each. | 2 |
►Vectorization Roadblocks | 3 | |
○ | [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 constant non unit stride data access - Use array restructuring, perform loop interchange or use gather instructions to lower a bit the cost. There are 1 issues ( = data accesses) costing 2 point each. | 2 |
►Loop 2781 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 25.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 |
[ 4 / 4 ] Application profile is long enough (66.28 s)
To have good quality measurements, it is advised that the application profiling time is greater than 10 seconds.
[ 3 / 3 ] Optimization level option is correctly used
[ 3 / 3 ] Most of time spent in analyzed modules comes from functions compiled with -g and -fno-omit-frame-pointer
-g option gives access to debugging informations, such are source locations. -fno-omit-frame-pointer improves the accuracy of callchains found during the application profiling.
[ 3 / 3 ] Host configuration allows retrieval of all necessary metrics.
[ 0 / 3 ] Compilation of some functions is not optimized for the target processor
-march=x86-64 option is used but it is not specific enough to produce efficient code.
[ 2 / 2 ] Application is correctly profiled ("Others" category represents 0.71 % 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.
[ 0 / 0 ] Fastmath not used
Consider to add ffast-math to compilation flags (or replace -O3 with -Ofast) to unlock potential extra speedup by relaxing floating-point computation consistency. Warning: floating-point accuracy may be reduced and the compliance to IEEE/ISO rules/specifications for math functions will be relaxed, typically 'errno' will no longer be set after calling some math functions.
[ 0 / 4 ] Too little time of the experiment time spent in analyzed loops (18.62%)
If the time spent in analyzed loops is less than 30%, standard loop optimizations will have a limited impact on application performances.
[ 3 / 4 ] CPU activity is below 90% (88.48%)
CPU cores are idle more than 10% of time. Threads supposed to run on these cores are probably IO/sync waiting. Some hints: use faster filesystems to read/write data, improve parallel load balancing and/or scheduling.
[ 4 / 4 ] Threads activity is good
On average, more than 4260.22% of observed threads are actually active
[ 4 / 4 ] Affinity is good (98.87%)
Threads are not migrating to CPU cores: probably successfully pinned
[ 4 / 4 ] Loop profile is not flat
At least one loop coverage is greater than 4% (13.95%), representing an hotspot for the application
[ 4 / 4 ] Enough time of the experiment time spent in analyzed innermost loops (18.30%)
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.
[ 3 / 3 ] Cumulative Outermost/In between loops coverage (0.32%) lower than cumulative innermost loop coverage (18.30%)
Having cumulative Outermost/In between loops coverage greater than cumulative innermost loop coverage will make loop optimization more complex
[ 3 / 3 ] Less than 10% (0.00%) is spend in BLAS1 operations
It could be more efficient to inline by hand BLAS1 operations
[ 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.01%) is spend in Libm/SVML (special functions)
Loop ID | Analysis | Penalty Score |
---|---|---|
►Loop 4426 - libCLASSpkg.so | Execution Time: 13 % - Vectorization Ratio: 50.00 % - Vector Length Use: 18.75 % | |
►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 | 1 | |
○ | [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 special instructions executing on a single port (BLEND/MERGE) - Simplify data access and try to get stride 1 access. There are 1 issues (= instructions) costing 1 point each. | 1 |
►Inefficient Vectorization | 1 | |
○ | [SA] Presence of special instructions executing on a single port (BLEND/MERGE) - Simplify data access and try to get stride 1 access. There are 1 issues (= instructions) costing 1 point each. | 1 |
►Loop 4425 - libCLASSpkg.so | Execution Time: 4 % - Vectorization Ratio: 0.00 % - Vector Length Use: 12.50 % | |
►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 |
►Loop 4424 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 16.98 % - Vector Length Use: 12.85 % | |
►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 | 5 | |
○ | [SA] Several paths (3 paths) - Simplify control structure or force the compiler to use masked instructions. There are 3 issues ( = paths) costing 1 point each. | 3 |
○ | [SA] Non innermost loop (Outermost) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Vectorization Roadblocks | 5 | |
○ | [SA] Several paths (3 paths) - Simplify control structure or force the compiler to use masked instructions. There are 3 issues ( = paths) costing 1 point each. | 3 |
○ | [SA] Non innermost loop (Outermost) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Loop 4431 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 9.80 % | |
►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 | 12 | |
○ | [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] Too many paths (7 paths) - Simplify control structure. There are 7 issues ( = paths) costing 1 point each with a malus of 4 points. | 11 |
►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 | 12 | |
○ | [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] Too many paths (7 paths) - Simplify control structure. There are 7 issues ( = paths) costing 1 point each with a malus of 4 points. | 11 |
►Loop 1092 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 12.50 % | |
►Data Access Issues | 4 | |
○ | [SA] Presence of constant non unit stride data access - Use array restructuring, perform loop interchange or use gather instructions to lower a bit the cost. There are 2 issues ( = data accesses) costing 2 point each. | 4 |
►Vectorization Roadblocks | 4 | |
○ | [SA] Presence of constant non unit stride data access - Use array restructuring, perform loop interchange or use gather instructions to lower a bit the cost. There are 2 issues ( = data accesses) costing 2 point each. | 4 |
►Loop 1093 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 0.00 % | |
►Control Flow Issues | 2 | |
○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Vectorization Roadblocks | 1002 | |
○ | [SA] Too many paths (at least 1000 paths) - Simplify control structure. There are at least 1000 issues ( = paths) costing 1 point. | 1000 |
○ | [SA] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Loop 1095 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 5.72 % - Vector Length Use: 10.44 % | |
►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 | 3 | |
○ | [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] Several paths (2 paths) - Simplify control structure or force the compiler to use masked instructions. There are 2 issues ( = paths) costing 1 point each. | 2 |
►Data Access Issues | 5 | |
○ | [SA] Presence of constant non unit stride data access - Use array restructuring, perform loop interchange or use gather instructions to lower a bit the cost. There are 2 issues ( = data accesses) costing 2 point each. | 4 |
○ | [SA] Presence of special instructions executing on a single port (BLEND/MERGE) - Simplify data access and try to get stride 1 access. There are 1 issues (= instructions) costing 1 point each. | 1 |
►Vectorization Roadblocks | 7 | |
○ | [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] Several paths (2 paths) - Simplify control structure or force the compiler to use masked instructions. There are 2 issues ( = paths) costing 1 point each. | 2 |
○ | [SA] Presence of constant non unit stride data access - Use array restructuring, perform loop interchange or use gather instructions to lower a bit the cost. There are 2 issues ( = data accesses) costing 2 point each. | 4 |
►Inefficient Vectorization | 1 | |
○ | [SA] Presence of special instructions executing on a single port (BLEND/MERGE) - Simplify data access and try to get stride 1 access. There are 1 issues (= instructions) costing 1 point each. | 1 |
►Loop 893 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 4.66 % - Vector Length Use: 9.66 % | |
►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 | 6 | |
○ | [SA] Presence of calls - Inline either by compiler or by hand and use SVML for libm calls. There are 2 issues (= calls) costing 1 point each. | 2 |
○ | [SA] Several paths (4 paths) - Simplify control structure or force the compiler to use masked instructions. There are 4 issues ( = paths) costing 1 point each. | 4 |
►Data Access Issues | 11 | |
○ | [SA] Presence of constant non unit stride data access - Use array restructuring, perform loop interchange or use gather instructions to lower a bit the cost. There are 5 issues ( = data accesses) costing 2 point each. | 10 |
○ | [SA] Presence of special instructions executing on a single port (BLEND/MERGE) - Simplify data access and try to get stride 1 access. There are 1 issues (= instructions) costing 1 point each. | 1 |
►Vectorization Roadblocks | 16 | |
○ | [SA] Presence of calls - Inline either by compiler or by hand and use SVML for libm calls. There are 2 issues (= calls) costing 1 point each. | 2 |
○ | [SA] Several paths (4 paths) - Simplify control structure or force the compiler to use masked instructions. There are 4 issues ( = paths) costing 1 point each. | 4 |
○ | [SA] Presence of constant non unit stride data access - Use array restructuring, perform loop interchange or use gather instructions to lower a bit the cost. There are 5 issues ( = data accesses) costing 2 point each. | 10 |
►Inefficient Vectorization | 1 | |
○ | [SA] Presence of special instructions executing on a single port (BLEND/MERGE) - Simplify data access and try to get stride 1 access. There are 1 issues (= instructions) costing 1 point each. | 1 |
►Loop 2781 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 25.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 |
►Loop 1094 - libCLASSpkg.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 0.00 % | |
►Control Flow Issues | 12 | |
○ | [SA] Too many paths (6 paths) - Simplify control structure. There are 6 issues ( = paths) costing 1 point each with a malus of 4 points. | 10 |
○ | [SA] Non innermost loop (Outermost) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
►Vectorization Roadblocks | 12 | |
○ | [SA] Too many paths (6 paths) - Simplify control structure. There are 6 issues ( = paths) costing 1 point each with a malus of 4 points. | 10 |
○ | [SA] Non innermost loop (Outermost) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |