Help is available by moving the cursor above any 
symbol or by checking MAQAO website.
[ 0 / 9 ] Compilation options are not available
Compilation options are an important optimization leverage but ONE-View is not able to analyze them.
[ 4 / 4 ] Application profile is long enough (346.69 s)
To have good quality measurements, it is advised that the application profiling time is greater than 10 seconds.
[ 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.01 % 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 / 4 ] Too little time of the experiment time spent in analyzed loops (3.96%)
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.70% of observed threads are actually active
[ 4 / 4 ] CPU activity is good
CPU cores are active 99.70% of time
[ 0 / 4 ] Loop profile is flat
No hotspot found in the application (greatest loop coverage is 1.18%), and the twenty hottest loops cumulated coverage is lower than 20% of the application profiled time (3.93%)
[ 0 / 4 ] Too little time of the experiment time spent in analyzed innermost loops (3.17%)
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.99%)
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 (0.79%) lower than cumulative innermost loop coverage (3.17%)
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.21%) is spend in Libm/SVML (special functions)
| Loop ID | Analysis | Penalty Score |
|---|---|---|
| ►Loop 620 - libggml-base.so | Execution Time: 1 % - Vectorization Ratio: 40.00 % - Vector Length Use: 59.44 % | |
| ►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 |
| ►Control Flow Issues | 2 | |
| ○ | [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 | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Vectorization Roadblocks | 8 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Loop 1938 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 16.22 % - Vector Length Use: 51.35 % | |
| ►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 |
| ►Data Access Issues | 12 | |
| ○ | [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 6 issues ( = data accesses) costing 2 point each. | 12 |
| ►Vectorization Roadblocks | 12 | |
| ○ | [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 6 issues ( = data accesses) costing 2 point each. | 12 |
| ►Loop 1445 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 16.43 % - Vector Length Use: 43.58 % | |
| ►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] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ►Vectorization Roadblocks | 1003 | |
| ○ | [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 (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 767 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 80.00 % - Vector Length Use: 97.68 % | |
| ►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 |
| ►Data Access Issues | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Vectorization Roadblocks | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Loop 1446 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 49.48 % | |
| ►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 | 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 6 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 18.47 % | |
| ►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 |
| ►Loop 1454 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 100.00 % | |
| ►Data Access Issues | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Vectorization Roadblocks | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Loop 1127 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 26.56 % | |
| ►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 764 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 100.00 % | |
| ►Data Access Issues | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Vectorization Roadblocks | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Loop 411 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 25.00 % - Vector Length Use: 100.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 | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Vectorization Roadblocks | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
[ 0 / 9 ] Compilation options are not available
Compilation options are an important optimization leverage but ONE-View is not able to analyze them.
[ 4 / 4 ] Application profile is long enough (171.97 s)
To have good quality measurements, it is advised that the application profiling time is greater than 10 seconds.
[ 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.01 % 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 / 4 ] Too little time of the experiment time spent in analyzed loops (3.46%)
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 193.06% of observed threads are actually active
[ 4 / 4 ] CPU activity is good
CPU cores are active 96.77% of time
[ 0 / 4 ] Loop profile is flat
No hotspot found in the application (greatest loop coverage is 0.97%), and the twenty hottest loops cumulated coverage is lower than 20% of the application profiled time (3.44%)
[ 0 / 4 ] Too little time of the experiment time spent in analyzed innermost loops (2.63%)
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.90%)
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.49%)
[ 3 / 3 ] Cumulative Outermost/In between loops coverage (0.83%) lower than cumulative innermost loop coverage (2.63%)
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.20%) is spend in Libm/SVML (special functions)
| Loop ID | Analysis | Penalty Score |
|---|---|---|
| ►Loop 1938 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 16.22 % - Vector Length Use: 51.35 % | |
| ►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 |
| ►Data Access Issues | 12 | |
| ○ | [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 6 issues ( = data accesses) costing 2 point each. | 12 |
| ►Vectorization Roadblocks | 12 | |
| ○ | [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 6 issues ( = data accesses) costing 2 point each. | 12 |
| ►Loop 620 - libggml-base.so | Execution Time: 0 % - Vectorization Ratio: 40.00 % - Vector Length Use: 59.44 % | |
| ►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 |
| ►Control Flow Issues | 2 | |
| ○ | [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 | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Vectorization Roadblocks | 8 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Loop 1445 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 16.43 % - Vector Length Use: 43.58 % | |
| ►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] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ►Vectorization Roadblocks | 1003 | |
| ○ | [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 (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 767 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 80.00 % - Vector Length Use: 97.68 % | |
| ►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 |
| ►Data Access Issues | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Vectorization Roadblocks | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Loop 1446 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 49.48 % | |
| ►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 | 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 1127 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 26.56 % | |
| ►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 6 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 18.47 % | |
| ►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 |
| ►Loop 764 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 100.00 % | |
| ►Data Access Issues | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Vectorization Roadblocks | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Loop 1454 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 100.00 % | |
| ►Data Access Issues | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Vectorization Roadblocks | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Loop 1126 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 100.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 | 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 |
[ 0 / 9 ] Compilation options are not available
Compilation options are an important optimization leverage but ONE-View is not able to analyze them.
[ 4 / 4 ] Application profile is long enough (86.97 s)
To have good quality measurements, it is advised that the application profiling time is greater than 10 seconds.
[ 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.01 % 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 / 4 ] Too little time of the experiment time spent in analyzed loops (3.14%)
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 370.25% of observed threads are actually active
[ 4 / 4 ] CPU activity is good
CPU cores are active 93.22% of time
[ 0 / 4 ] Loop profile is flat
No hotspot found in the application (greatest loop coverage is 0.96%), and the twenty hottest loops cumulated coverage is lower than 20% of the application profiled time (3.11%)
[ 0 / 4 ] Too little time of the experiment time spent in analyzed innermost loops (2.34%)
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.72%)
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 (2.25%)
[ 3 / 3 ] Cumulative Outermost/In between loops coverage (0.80%) lower than cumulative innermost loop coverage (2.34%)
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.22%) is spend in Libm/SVML (special functions)
| Loop ID | Analysis | Penalty Score |
|---|---|---|
| ►Loop 1938 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 16.22 % - Vector Length Use: 51.35 % | |
| ►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 |
| ►Data Access Issues | 12 | |
| ○ | [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 6 issues ( = data accesses) costing 2 point each. | 12 |
| ►Vectorization Roadblocks | 12 | |
| ○ | [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 6 issues ( = data accesses) costing 2 point each. | 12 |
| ►Loop 1445 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 16.43 % - Vector Length Use: 43.58 % | |
| ►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] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ►Vectorization Roadblocks | 1003 | |
| ○ | [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 (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 620 - libggml-base.so | Execution Time: 0 % - Vectorization Ratio: 40.00 % - Vector Length Use: 59.44 % | |
| ►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 |
| ►Control Flow Issues | 2 | |
| ○ | [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 | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Vectorization Roadblocks | 8 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Loop 1446 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 49.48 % | |
| ►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 | 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 767 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 80.00 % - Vector Length Use: 97.68 % | |
| ►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 |
| ►Data Access Issues | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Vectorization Roadblocks | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Loop 6 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 18.47 % | |
| ►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 |
| ►Loop 1454 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 100.00 % | |
| ►Data Access Issues | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Vectorization Roadblocks | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Loop 764 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 100.00 % | |
| ►Data Access Issues | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Vectorization Roadblocks | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Loop 1127 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 26.56 % | |
| ►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 1447 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 0.00 % |
[ 0 / 9 ] Compilation options are not available
Compilation options are an important optimization leverage but ONE-View is not able to analyze them.
[ 4 / 4 ] Application profile is long enough (48.50 s)
To have good quality measurements, it is advised that the application profiling time is greater than 10 seconds.
[ 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.01 % 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 / 4 ] Too little time of the experiment time spent in analyzed loops (2.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 680.44% of observed threads are actually active
[ 3 / 4 ] CPU activity is below 90% (86.24%)
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.
[ 0 / 4 ] Loop profile is flat
No hotspot found in the application (greatest loop coverage is 0.87%), and the twenty hottest loops cumulated coverage is lower than 20% of the application profiled time (2.61%)
[ 0 / 4 ] Too little time of the experiment time spent in analyzed innermost loops (1.90%)
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.46%)
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 (1.40%)
[ 3 / 3 ] Cumulative Outermost/In between loops coverage (0.74%) lower than cumulative innermost loop coverage (1.90%)
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.23%) is spend in Libm/SVML (special functions)
| Loop ID | Analysis | Penalty Score |
|---|---|---|
| ►Loop 1938 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 16.22 % - Vector Length Use: 51.35 % | |
| ►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 |
| ►Data Access Issues | 12 | |
| ○ | [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 6 issues ( = data accesses) costing 2 point each. | 12 |
| ►Vectorization Roadblocks | 12 | |
| ○ | [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 6 issues ( = data accesses) costing 2 point each. | 12 |
| ►Loop 1445 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 16.43 % - Vector Length Use: 43.58 % | |
| ►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] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ►Vectorization Roadblocks | 1003 | |
| ○ | [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 (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 767 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 80.00 % - Vector Length Use: 97.68 % | |
| ►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 |
| ►Data Access Issues | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Vectorization Roadblocks | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Loop 6 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 18.47 % | |
| ►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 |
| ►Loop 1446 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 49.48 % | |
| ►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 | 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 1454 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 100.00 % | |
| ►Data Access Issues | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Vectorization Roadblocks | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Loop 1127 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 26.56 % | |
| ►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 764 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 100.00 % | |
| ►Data Access Issues | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Vectorization Roadblocks | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Loop 790 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 2.33 % - Vector Length Use: 20.20 % | |
| ►Loop Computation Issues | 14 | |
| ○ | [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 3 issues (= instructions) costing 4 points each. | 12 |
| ○ | [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 | 19 | |
| ○ | [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 (14 paths) - Simplify control structure. There are 14 issues ( = paths) costing 1 point each with a malus of 4 points. | 18 |
| ►Vectorization Roadblocks | 19 | |
| ○ | [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 (14 paths) - Simplify control structure. There are 14 issues ( = paths) costing 1 point each with a malus of 4 points. | 18 |
| ►Loop 411 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 25.00 % - Vector Length Use: 100.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 | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Vectorization Roadblocks | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
[ 0 / 9 ] Compilation options are not available
Compilation options are an important optimization leverage but ONE-View is not able to analyze them.
[ 4 / 4 ] Application profile is long enough (30.02 s)
To have good quality measurements, it is advised that the application profiling time is greater than 10 seconds.
[ 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.01 % 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 / 4 ] Too little time of the experiment time spent in analyzed loops (2.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 1166.81% of observed threads are actually active
[ 3 / 4 ] CPU activity is below 90% (74.44%)
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.
[ 0 / 4 ] Loop profile is flat
No hotspot found in the application (greatest loop coverage is 0.70%), and the twenty hottest loops cumulated coverage is lower than 20% of the application profiled time (2.51%)
[ 0 / 4 ] Too little time of the experiment time spent in analyzed innermost loops (1.90%)
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.19%)
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 (4.59%)
[ 3 / 3 ] Cumulative Outermost/In between loops coverage (0.63%) lower than cumulative innermost loop coverage (1.90%)
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.25%) is spend in Libm/SVML (special functions)
| Loop ID | Analysis | Penalty Score |
|---|---|---|
| ►Loop 1938 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 16.22 % - Vector Length Use: 51.35 % | |
| ►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 |
| ►Data Access Issues | 12 | |
| ○ | [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 6 issues ( = data accesses) costing 2 point each. | 12 |
| ►Vectorization Roadblocks | 12 | |
| ○ | [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 6 issues ( = data accesses) costing 2 point each. | 12 |
| ►Loop 1445 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 16.43 % - Vector Length Use: 43.58 % | |
| ►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] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ►Vectorization Roadblocks | 1003 | |
| ○ | [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 (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 1446 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 49.48 % | |
| ►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 | 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 767 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 80.00 % - Vector Length Use: 97.68 % | |
| ►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 |
| ►Data Access Issues | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Vectorization Roadblocks | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Loop 790 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 2.33 % - Vector Length Use: 20.20 % | |
| ►Loop Computation Issues | 14 | |
| ○ | [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 3 issues (= instructions) costing 4 points each. | 12 |
| ○ | [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 | 19 | |
| ○ | [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 (14 paths) - Simplify control structure. There are 14 issues ( = paths) costing 1 point each with a malus of 4 points. | 18 |
| ►Vectorization Roadblocks | 19 | |
| ○ | [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 (14 paths) - Simplify control structure. There are 14 issues ( = paths) costing 1 point each with a malus of 4 points. | 18 |
| ►Loop 6 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 18.47 % | |
| ►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 |
| ►Loop 620 - libggml-base.so | Execution Time: 0 % - Vectorization Ratio: 40.00 % - Vector Length Use: 59.44 % | |
| ►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 |
| ►Control Flow Issues | 2 | |
| ○ | [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 | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Vectorization Roadblocks | 8 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Loop 1454 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 100.00 % | |
| ►Data Access Issues | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Vectorization Roadblocks | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Loop 1127 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 26.56 % | |
| ►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 764 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 100.00 % | |
| ►Data Access Issues | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Vectorization Roadblocks | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
[ 0 / 9 ] Compilation options are not available
Compilation options are an important optimization leverage but ONE-View is not able to analyze them.
[ 4 / 4 ] Application profile is long enough (21.68 s)
To have good quality measurements, it is advised that the application profiling time is greater than 10 seconds.
[ 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.01 % 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 / 4 ] Too little time of the experiment time spent in analyzed loops (2.32%)
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 1457.99% of observed threads are actually active
[ 2 / 4 ] CPU activity is below 90% (62.26%)
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.
[ 0 / 4 ] Loop profile is flat
No hotspot found in the application (greatest loop coverage is 0.76%), and the twenty hottest loops cumulated coverage is lower than 20% of the application profiled time (2.30%)
[ 0 / 4 ] Too little time of the experiment time spent in analyzed innermost loops (1.74%)
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.04%)
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 (2.60%)
[ 3 / 3 ] Cumulative Outermost/In between loops coverage (0.58%) lower than cumulative innermost loop coverage (1.74%)
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.21%) is spend in Libm/SVML (special functions)
| Loop ID | Analysis | Penalty Score |
|---|---|---|
| ►Loop 1938 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 16.22 % - Vector Length Use: 51.35 % | |
| ►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 |
| ►Data Access Issues | 12 | |
| ○ | [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 6 issues ( = data accesses) costing 2 point each. | 12 |
| ►Vectorization Roadblocks | 12 | |
| ○ | [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 6 issues ( = data accesses) costing 2 point each. | 12 |
| ►Loop 1445 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 16.43 % - Vector Length Use: 43.58 % | |
| ►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] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ►Vectorization Roadblocks | 1003 | |
| ○ | [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 (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 767 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 80.00 % - Vector Length Use: 97.68 % | |
| ►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 |
| ►Data Access Issues | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Vectorization Roadblocks | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Loop 1446 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 49.48 % | |
| ►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 | 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 790 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 2.33 % - Vector Length Use: 20.20 % | |
| ►Loop Computation Issues | 14 | |
| ○ | [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 3 issues (= instructions) costing 4 points each. | 12 |
| ○ | [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 | 19 | |
| ○ | [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 (14 paths) - Simplify control structure. There are 14 issues ( = paths) costing 1 point each with a malus of 4 points. | 18 |
| ►Vectorization Roadblocks | 19 | |
| ○ | [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 (14 paths) - Simplify control structure. There are 14 issues ( = paths) costing 1 point each with a malus of 4 points. | 18 |
| ►Loop 6 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 18.47 % | |
| ►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 |
| ►Loop 1454 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 100.00 % | |
| ►Data Access Issues | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Vectorization Roadblocks | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Loop 764 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 100.00 % | |
| ►Data Access Issues | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Vectorization Roadblocks | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Loop 1127 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 26.56 % | |
| ►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 411 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 25.00 % - Vector Length Use: 100.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 | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Vectorization Roadblocks | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
[ 0 / 9 ] Compilation options are not available
Compilation options are an important optimization leverage but ONE-View is not able to analyze them.
[ 4 / 4 ] Application profile is long enough (17.23 s)
To have good quality measurements, it is advised that the application profiling time is greater than 10 seconds.
[ 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.01 % 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 / 4 ] Too little time of the experiment time spent in analyzed loops (2.32%)
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 1610.59% of observed threads are actually active
[ 2 / 4 ] CPU activity is below 90% (51.65%)
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.
[ 0 / 4 ] Loop profile is flat
No hotspot found in the application (greatest loop coverage is 0.67%), and the twenty hottest loops cumulated coverage is lower than 20% of the application profiled time (2.30%)
[ 0 / 4 ] Too little time of the experiment time spent in analyzed innermost loops (1.79%)
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.96%)
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 (2.91%)
[ 3 / 3 ] Cumulative Outermost/In between loops coverage (0.53%) lower than cumulative innermost loop coverage (1.79%)
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.23%) is spend in Libm/SVML (special functions)
| Loop ID | Analysis | Penalty Score |
|---|---|---|
| ►Loop 1938 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 16.22 % - Vector Length Use: 51.35 % | |
| ►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 |
| ►Data Access Issues | 12 | |
| ○ | [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 6 issues ( = data accesses) costing 2 point each. | 12 |
| ►Vectorization Roadblocks | 12 | |
| ○ | [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 6 issues ( = data accesses) costing 2 point each. | 12 |
| ►Loop 1445 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 16.43 % - Vector Length Use: 43.58 % | |
| ►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] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ►Vectorization Roadblocks | 1003 | |
| ○ | [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 (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 767 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 80.00 % - Vector Length Use: 97.68 % | |
| ►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 |
| ►Data Access Issues | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Vectorization Roadblocks | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Loop 790 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 2.33 % - Vector Length Use: 20.20 % | |
| ►Loop Computation Issues | 14 | |
| ○ | [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 3 issues (= instructions) costing 4 points each. | 12 |
| ○ | [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 | 19 | |
| ○ | [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 (14 paths) - Simplify control structure. There are 14 issues ( = paths) costing 1 point each with a malus of 4 points. | 18 |
| ►Vectorization Roadblocks | 19 | |
| ○ | [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 (14 paths) - Simplify control structure. There are 14 issues ( = paths) costing 1 point each with a malus of 4 points. | 18 |
| ►Loop 1446 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 49.48 % | |
| ►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 | 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 6 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 18.47 % | |
| ►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 |
| ►Loop 495 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 25.00 % - Vector Length Use: 100.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 | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Vectorization Roadblocks | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Loop 1127 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 26.56 % | |
| ►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 764 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 100.00 % | |
| ►Data Access Issues | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Vectorization Roadblocks | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Loop 1454 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 100.00 % | |
| ►Data Access Issues | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Vectorization Roadblocks | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
[ 0 / 9 ] Compilation options are not available
Compilation options are an important optimization leverage but ONE-View is not able to analyze them.
[ 4 / 4 ] Application profile is long enough (14.52 s)
To have good quality measurements, it is advised that the application profiling time is greater than 10 seconds.
[ 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.01 % 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 / 4 ] Too little time of the experiment time spent in analyzed loops (2.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 1670.49% of observed threads are actually active
[ 1 / 4 ] CPU activity is below 90% (42.86%)
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.
[ 0 / 4 ] Loop profile is flat
No hotspot found in the application (greatest loop coverage is 0.73%), and the twenty hottest loops cumulated coverage is lower than 20% of the application profiled time (2.30%)
[ 0 / 4 ] Too little time of the experiment time spent in analyzed innermost loops (1.82%)
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.97%)
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 (3.18%)
[ 3 / 3 ] Cumulative Outermost/In between loops coverage (0.51%) lower than cumulative innermost loop coverage (1.82%)
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.23%) is spend in Libm/SVML (special functions)
| Loop ID | Analysis | Penalty Score |
|---|---|---|
| ►Loop 1938 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 16.22 % - Vector Length Use: 51.35 % | |
| ►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 |
| ►Data Access Issues | 12 | |
| ○ | [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 6 issues ( = data accesses) costing 2 point each. | 12 |
| ►Vectorization Roadblocks | 12 | |
| ○ | [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 6 issues ( = data accesses) costing 2 point each. | 12 |
| ►Loop 1445 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 16.43 % - Vector Length Use: 43.58 % | |
| ►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] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ►Vectorization Roadblocks | 1003 | |
| ○ | [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 (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 790 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 2.33 % - Vector Length Use: 20.20 % | |
| ►Loop Computation Issues | 14 | |
| ○ | [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 3 issues (= instructions) costing 4 points each. | 12 |
| ○ | [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 | 19 | |
| ○ | [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 (14 paths) - Simplify control structure. There are 14 issues ( = paths) costing 1 point each with a malus of 4 points. | 18 |
| ►Vectorization Roadblocks | 19 | |
| ○ | [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 (14 paths) - Simplify control structure. There are 14 issues ( = paths) costing 1 point each with a malus of 4 points. | 18 |
| ►Loop 767 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 80.00 % - Vector Length Use: 97.68 % | |
| ►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 |
| ►Data Access Issues | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Vectorization Roadblocks | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Loop 1446 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 49.48 % | |
| ►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 | 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 6 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 18.47 % | |
| ►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 |
| ►Loop 1127 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 26.56 % | |
| ►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 1454 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 100.00 % | |
| ►Data Access Issues | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Vectorization Roadblocks | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Loop 764 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 100.00 % | |
| ►Data Access Issues | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Vectorization Roadblocks | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Loop 411 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 25.00 % - Vector Length Use: 100.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 | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Vectorization Roadblocks | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
[ 0 / 9 ] Compilation options are not available
Compilation options are an important optimization leverage but ONE-View is not able to analyze them.
[ 4 / 4 ] Application profile is long enough (12.71 s)
To have good quality measurements, it is advised that the application profiling time is greater than 10 seconds.
[ 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.01 % 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 / 4 ] Too little time of the experiment time spent in analyzed loops (2.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 1684.55% of observed threads are actually active
[ 1 / 4 ] CPU activity is below 90% (35.98%)
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.
[ 0 / 4 ] Loop profile is flat
No hotspot found in the application (greatest loop coverage is 0.72%), and the twenty hottest loops cumulated coverage is lower than 20% of the application profiled time (2.26%)
[ 0 / 4 ] Too little time of the experiment time spent in analyzed innermost loops (1.78%)
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.98%)
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 (3.28%)
[ 3 / 3 ] Cumulative Outermost/In between loops coverage (0.51%) lower than cumulative innermost loop coverage (1.78%)
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.23%) is spend in Libm/SVML (special functions)
| Loop ID | Analysis | Penalty Score |
|---|---|---|
| ►Loop 1938 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 16.22 % - Vector Length Use: 51.35 % | |
| ►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 |
| ►Data Access Issues | 12 | |
| ○ | [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 6 issues ( = data accesses) costing 2 point each. | 12 |
| ►Vectorization Roadblocks | 12 | |
| ○ | [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 6 issues ( = data accesses) costing 2 point each. | 12 |
| ►Loop 1445 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 16.43 % - Vector Length Use: 43.58 % | |
| ►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] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ►Vectorization Roadblocks | 1003 | |
| ○ | [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 (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 790 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 2.33 % - Vector Length Use: 20.20 % | |
| ►Loop Computation Issues | 14 | |
| ○ | [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 3 issues (= instructions) costing 4 points each. | 12 |
| ○ | [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 | 19 | |
| ○ | [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 (14 paths) - Simplify control structure. There are 14 issues ( = paths) costing 1 point each with a malus of 4 points. | 18 |
| ►Vectorization Roadblocks | 19 | |
| ○ | [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 (14 paths) - Simplify control structure. There are 14 issues ( = paths) costing 1 point each with a malus of 4 points. | 18 |
| ►Loop 767 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 80.00 % - Vector Length Use: 97.68 % | |
| ►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 |
| ►Data Access Issues | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Vectorization Roadblocks | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Loop 1446 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 49.48 % | |
| ►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 | 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 6 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 18.47 % | |
| ►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 |
| ►Loop 1127 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 26.56 % | |
| ►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 411 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 25.00 % - Vector Length Use: 100.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 | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Vectorization Roadblocks | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Loop 764 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 100.00 % | |
| ►Data Access Issues | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Vectorization Roadblocks | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Loop 1454 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 100.00 % | |
| ►Data Access Issues | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Vectorization Roadblocks | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
[ 0 / 9 ] Compilation options are not available
Compilation options are an important optimization leverage but ONE-View is not able to analyze them.
[ 4 / 4 ] Application profile is long enough (10.74 s)
To have good quality measurements, it is advised that the application profiling time is greater than 10 seconds.
[ 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.01 % 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 / 4 ] Too little time of the experiment time spent in analyzed loops (2.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 1667.52% of observed threads are actually active
[ 1 / 4 ] CPU activity is below 90% (30.52%)
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.
[ 0 / 4 ] Loop profile is flat
No hotspot found in the application (greatest loop coverage is 0.74%), and the twenty hottest loops cumulated coverage is lower than 20% of the application profiled time (2.42%)
[ 0 / 4 ] Too little time of the experiment time spent in analyzed innermost loops (1.93%)
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.97%)
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 (2.90%)
[ 3 / 3 ] Cumulative Outermost/In between loops coverage (0.51%) lower than cumulative innermost loop coverage (1.93%)
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.24%) is spend in Libm/SVML (special functions)
| Loop ID | Analysis | Penalty Score |
|---|---|---|
| ►Loop 1938 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 16.22 % - Vector Length Use: 51.35 % | |
| ►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 |
| ►Data Access Issues | 12 | |
| ○ | [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 6 issues ( = data accesses) costing 2 point each. | 12 |
| ►Vectorization Roadblocks | 12 | |
| ○ | [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 6 issues ( = data accesses) costing 2 point each. | 12 |
| ►Loop 1445 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 16.43 % - Vector Length Use: 43.58 % | |
| ►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] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ►Vectorization Roadblocks | 1003 | |
| ○ | [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 (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 790 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 2.33 % - Vector Length Use: 20.20 % | |
| ►Loop Computation Issues | 14 | |
| ○ | [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 3 issues (= instructions) costing 4 points each. | 12 |
| ○ | [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 | 19 | |
| ○ | [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 (14 paths) - Simplify control structure. There are 14 issues ( = paths) costing 1 point each with a malus of 4 points. | 18 |
| ►Vectorization Roadblocks | 19 | |
| ○ | [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 (14 paths) - Simplify control structure. There are 14 issues ( = paths) costing 1 point each with a malus of 4 points. | 18 |
| ►Loop 767 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 80.00 % - Vector Length Use: 97.68 % | |
| ►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 |
| ►Data Access Issues | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Vectorization Roadblocks | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Loop 6 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 18.47 % | |
| ►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 |
| ►Loop 1446 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 49.48 % | |
| ►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 | 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 1127 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 26.56 % | |
| ►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 1454 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 100.00 % | |
| ►Data Access Issues | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Vectorization Roadblocks | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Loop 764 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 100.00 % | |
| ►Data Access Issues | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Vectorization Roadblocks | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Loop 411 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 25.00 % - Vector Length Use: 100.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 | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Vectorization Roadblocks | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
[ 0 / 9 ] Compilation options are not available
Compilation options are an important optimization leverage but ONE-View is not able to analyze them.
[ 0 / 4 ] Application profile is too short (9.62 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.
[ 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.01 % 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 / 4 ] Too little time of the experiment time spent in analyzed loops (2.51%)
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 1639.70% of observed threads are actually active
[ 0 / 4 ] CPU activity is below 90% (26.24%)
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.
[ 0 / 4 ] Loop profile is flat
No hotspot found in the application (greatest loop coverage is 0.79%), and the twenty hottest loops cumulated coverage is lower than 20% of the application profiled time (2.49%)
[ 0 / 4 ] Too little time of the experiment time spent in analyzed innermost loops (2.04%)
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.99%)
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 (3.34%)
[ 3 / 3 ] Cumulative Outermost/In between loops coverage (0.47%) lower than cumulative innermost loop coverage (2.04%)
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.26%) is spend in Libm/SVML (special functions)
| Loop ID | Analysis | Penalty Score |
|---|---|---|
| ►Loop 1938 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 16.22 % - Vector Length Use: 51.35 % | |
| ►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 |
| ►Data Access Issues | 12 | |
| ○ | [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 6 issues ( = data accesses) costing 2 point each. | 12 |
| ►Vectorization Roadblocks | 12 | |
| ○ | [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 6 issues ( = data accesses) costing 2 point each. | 12 |
| ►Loop 790 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 2.33 % - Vector Length Use: 20.20 % | |
| ►Loop Computation Issues | 14 | |
| ○ | [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 3 issues (= instructions) costing 4 points each. | 12 |
| ○ | [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 | 19 | |
| ○ | [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 (14 paths) - Simplify control structure. There are 14 issues ( = paths) costing 1 point each with a malus of 4 points. | 18 |
| ►Vectorization Roadblocks | 19 | |
| ○ | [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 (14 paths) - Simplify control structure. There are 14 issues ( = paths) costing 1 point each with a malus of 4 points. | 18 |
| ►Loop 1445 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 16.43 % - Vector Length Use: 43.58 % | |
| ►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] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ►Vectorization Roadblocks | 1003 | |
| ○ | [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 (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 767 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 80.00 % - Vector Length Use: 97.68 % | |
| ►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 |
| ►Data Access Issues | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Vectorization Roadblocks | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Loop 1446 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 49.48 % | |
| ►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 | 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 6 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 18.47 % | |
| ►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 |
| ►Loop 1127 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 26.56 % | |
| ►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 1454 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 100.00 % | |
| ►Data Access Issues | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Vectorization Roadblocks | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Loop 495 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 25.00 % - Vector Length Use: 100.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 | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Vectorization Roadblocks | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Loop 411 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 25.00 % - Vector Length Use: 100.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 | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Vectorization Roadblocks | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
[ 0 / 9 ] Compilation options are not available
Compilation options are an important optimization leverage but ONE-View is not able to analyze them.
[ 0 / 4 ] Application profile is too short (8.84 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.
[ 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.01 % 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 / 4 ] Too little time of the experiment time spent in analyzed loops (2.70%)
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 1576.40% of observed threads are actually active
[ 0 / 4 ] CPU activity is below 90% (22.40%)
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.
[ 0 / 4 ] Loop profile is flat
No hotspot found in the application (greatest loop coverage is 0.47%), and the twenty hottest loops cumulated coverage is lower than 20% of the application profiled time (2.67%)
[ 0 / 4 ] Too little time of the experiment time spent in analyzed innermost loops (2.16%)
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.06%)
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 (3.00%)
[ 3 / 3 ] Cumulative Outermost/In between loops coverage (0.55%) lower than cumulative innermost loop coverage (2.16%)
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.27%) is spend in Libm/SVML (special functions)
| Loop ID | Analysis | Penalty Score |
|---|---|---|
| ►Loop 1940 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 58.06 % - Vector Length Use: 69.56 % | |
| ►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 |
| ►Data Access Issues | 24 | |
| ○ | [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 12 issues ( = data accesses) costing 2 point each. | 24 |
| ►Vectorization Roadblocks | 24 | |
| ○ | [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 12 issues ( = data accesses) costing 2 point each. | 24 |
| ►Loop 1938 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 16.22 % - Vector Length Use: 51.35 % | |
| ►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 |
| ►Data Access Issues | 12 | |
| ○ | [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 6 issues ( = data accesses) costing 2 point each. | 12 |
| ►Vectorization Roadblocks | 12 | |
| ○ | [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 6 issues ( = data accesses) costing 2 point each. | 12 |
| ►Loop 790 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 2.33 % - Vector Length Use: 20.20 % | |
| ►Loop Computation Issues | 14 | |
| ○ | [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 3 issues (= instructions) costing 4 points each. | 12 |
| ○ | [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 | 19 | |
| ○ | [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 (14 paths) - Simplify control structure. There are 14 issues ( = paths) costing 1 point each with a malus of 4 points. | 18 |
| ►Vectorization Roadblocks | 19 | |
| ○ | [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 (14 paths) - Simplify control structure. There are 14 issues ( = paths) costing 1 point each with a malus of 4 points. | 18 |
| ►Loop 1445 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 16.43 % - Vector Length Use: 43.58 % | |
| ►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] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ►Vectorization Roadblocks | 1003 | |
| ○ | [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 (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 767 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 80.00 % - Vector Length Use: 97.68 % | |
| ►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 |
| ►Data Access Issues | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Vectorization Roadblocks | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Loop 1446 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 49.48 % | |
| ►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 | 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 6 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 18.47 % | |
| ►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 |
| ►Loop 1127 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 26.56 % | |
| ►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 1454 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 100.00 % | |
| ►Data Access Issues | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Vectorization Roadblocks | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Loop 764 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 100.00 % | |
| ►Data Access Issues | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Vectorization Roadblocks | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
[ 0 / 9 ] Compilation options are not available
Compilation options are an important optimization leverage but ONE-View is not able to analyze them.
[ 0 / 4 ] Application profile is too short (8.04 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.
[ 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.01 % 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 / 4 ] Too little time of the experiment time spent in analyzed loops (2.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 1544.37% of observed threads are actually active
[ 0 / 4 ] CPU activity is below 90% (19.73%)
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.
[ 0 / 4 ] Loop profile is flat
No hotspot found in the application (greatest loop coverage is 0.68%), and the twenty hottest loops cumulated coverage is lower than 20% of the application profiled time (2.50%)
[ 0 / 4 ] Too little time of the experiment time spent in analyzed innermost loops (2.06%)
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 (2.84%)
[ 3 / 3 ] Cumulative Outermost/In between loops coverage (0.47%) lower than cumulative innermost loop coverage (2.06%)
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.27%) is spend in Libm/SVML (special functions)
| Loop ID | Analysis | Penalty Score |
|---|---|---|
| ►Loop 1938 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 16.22 % - Vector Length Use: 51.35 % | |
| ►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 |
| ►Data Access Issues | 12 | |
| ○ | [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 6 issues ( = data accesses) costing 2 point each. | 12 |
| ►Vectorization Roadblocks | 12 | |
| ○ | [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 6 issues ( = data accesses) costing 2 point each. | 12 |
| ►Loop 790 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 2.33 % - Vector Length Use: 20.20 % | |
| ►Loop Computation Issues | 14 | |
| ○ | [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 3 issues (= instructions) costing 4 points each. | 12 |
| ○ | [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 | 19 | |
| ○ | [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 (14 paths) - Simplify control structure. There are 14 issues ( = paths) costing 1 point each with a malus of 4 points. | 18 |
| ►Vectorization Roadblocks | 19 | |
| ○ | [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 (14 paths) - Simplify control structure. There are 14 issues ( = paths) costing 1 point each with a malus of 4 points. | 18 |
| ►Loop 1445 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 16.43 % - Vector Length Use: 43.58 % | |
| ►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] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ►Vectorization Roadblocks | 1003 | |
| ○ | [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 (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 767 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 80.00 % - Vector Length Use: 97.68 % | |
| ►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 |
| ►Data Access Issues | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Vectorization Roadblocks | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Loop 1446 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 49.48 % | |
| ►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 | 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 6 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 18.47 % | |
| ►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 |
| ►Loop 1127 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 26.56 % | |
| ►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 1940 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 58.06 % - Vector Length Use: 69.56 % | |
| ►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 |
| ►Data Access Issues | 24 | |
| ○ | [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 12 issues ( = data accesses) costing 2 point each. | 24 |
| ►Vectorization Roadblocks | 24 | |
| ○ | [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 12 issues ( = data accesses) costing 2 point each. | 24 |
| ►Loop 764 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 100.00 % | |
| ►Data Access Issues | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Vectorization Roadblocks | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Loop 1454 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 100.00 % | |
| ►Data Access Issues | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Vectorization Roadblocks | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
[ 0 / 9 ] Compilation options are not available
Compilation options are an important optimization leverage but ONE-View is not able to analyze them.
[ 0 / 4 ] Application profile is too short (7.45 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.
[ 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.01 % 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 / 4 ] Too little time of the experiment time spent in analyzed loops (2.84%)
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 1500.67% of observed threads are actually active
[ 0 / 4 ] CPU activity is below 90% (17.42%)
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.
[ 0 / 4 ] Loop profile is flat
No hotspot found in the application (greatest loop coverage is 0.55%), and the twenty hottest loops cumulated coverage is lower than 20% of the application profiled time (2.81%)
[ 0 / 4 ] Too little time of the experiment time spent in analyzed innermost loops (2.35%)
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.13%)
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 (2.79%)
[ 3 / 3 ] Cumulative Outermost/In between loops coverage (0.50%) lower than cumulative innermost loop coverage (2.35%)
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.29%) is spend in Libm/SVML (special functions)
| Loop ID | Analysis | Penalty Score |
|---|---|---|
| ►Loop 1940 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 58.06 % - Vector Length Use: 69.56 % | |
| ►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 |
| ►Data Access Issues | 24 | |
| ○ | [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 12 issues ( = data accesses) costing 2 point each. | 24 |
| ►Vectorization Roadblocks | 24 | |
| ○ | [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 12 issues ( = data accesses) costing 2 point each. | 24 |
| ►Loop 790 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 2.33 % - Vector Length Use: 20.20 % | |
| ►Loop Computation Issues | 14 | |
| ○ | [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 3 issues (= instructions) costing 4 points each. | 12 |
| ○ | [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 | 19 | |
| ○ | [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 (14 paths) - Simplify control structure. There are 14 issues ( = paths) costing 1 point each with a malus of 4 points. | 18 |
| ►Vectorization Roadblocks | 19 | |
| ○ | [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 (14 paths) - Simplify control structure. There are 14 issues ( = paths) costing 1 point each with a malus of 4 points. | 18 |
| ►Loop 1938 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 16.22 % - Vector Length Use: 51.35 % | |
| ►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 |
| ►Data Access Issues | 12 | |
| ○ | [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 6 issues ( = data accesses) costing 2 point each. | 12 |
| ►Vectorization Roadblocks | 12 | |
| ○ | [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 6 issues ( = data accesses) costing 2 point each. | 12 |
| ►Loop 767 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 80.00 % - Vector Length Use: 97.68 % | |
| ►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 |
| ►Data Access Issues | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Vectorization Roadblocks | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Loop 1445 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 16.43 % - Vector Length Use: 43.58 % | |
| ►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] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ►Vectorization Roadblocks | 1003 | |
| ○ | [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 (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 1446 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 49.48 % | |
| ►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 | 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 6 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 18.47 % | |
| ►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 |
| ►Loop 1127 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 26.56 % | |
| ►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 411 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 25.00 % - Vector Length Use: 100.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 | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Vectorization Roadblocks | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Loop 764 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 100.00 % | |
| ►Data Access Issues | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Vectorization Roadblocks | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
[ 0 / 9 ] Compilation options are not available
Compilation options are an important optimization leverage but ONE-View is not able to analyze them.
[ 0 / 4 ] Application profile is too short (7.07 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.
[ 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.01 % 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 / 4 ] Too little time of the experiment time spent in analyzed loops (2.68%)
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 1388.23% of observed threads are actually active
[ 0 / 4 ] CPU activity is below 90% (14.73%)
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.
[ 0 / 4 ] Loop profile is flat
No hotspot found in the application (greatest loop coverage is 0.73%), and the twenty hottest loops cumulated coverage is lower than 20% of the application profiled time (2.65%)
[ 0 / 4 ] Too little time of the experiment time spent in analyzed innermost loops (2.23%)
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.20%)
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 (2.71%)
[ 3 / 3 ] Cumulative Outermost/In between loops coverage (0.45%) lower than cumulative innermost loop coverage (2.23%)
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.31%) is spend in Libm/SVML (special functions)
| Loop ID | Analysis | Penalty Score |
|---|---|---|
| ►Loop 1940 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 58.06 % - Vector Length Use: 69.56 % | |
| ►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 |
| ►Data Access Issues | 24 | |
| ○ | [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 12 issues ( = data accesses) costing 2 point each. | 24 |
| ►Vectorization Roadblocks | 24 | |
| ○ | [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 12 issues ( = data accesses) costing 2 point each. | 24 |
| ►Loop 790 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 2.33 % - Vector Length Use: 20.20 % | |
| ►Loop Computation Issues | 14 | |
| ○ | [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 3 issues (= instructions) costing 4 points each. | 12 |
| ○ | [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 | 19 | |
| ○ | [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 (14 paths) - Simplify control structure. There are 14 issues ( = paths) costing 1 point each with a malus of 4 points. | 18 |
| ►Vectorization Roadblocks | 19 | |
| ○ | [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 (14 paths) - Simplify control structure. There are 14 issues ( = paths) costing 1 point each with a malus of 4 points. | 18 |
| ►Loop 1445 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 16.43 % - Vector Length Use: 43.58 % | |
| ►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] Non innermost loop (InBetween) - Collapse loop with innermost ones. This issue costs 2 points. | 2 |
| ►Vectorization Roadblocks | 1003 | |
| ○ | [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 (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 767 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 80.00 % - Vector Length Use: 97.68 % | |
| ►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 |
| ►Data Access Issues | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Vectorization Roadblocks | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Loop 1127 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 26.56 % | |
| ►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 1446 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 49.48 % | |
| ►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 | 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 6 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 0.00 % - Vector Length Use: 18.47 % | |
| ►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 |
| ►Loop 1938 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 16.22 % - Vector Length Use: 51.35 % | |
| ►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 |
| ►Data Access Issues | 12 | |
| ○ | [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 6 issues ( = data accesses) costing 2 point each. | 12 |
| ►Vectorization Roadblocks | 12 | |
| ○ | [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 6 issues ( = data accesses) costing 2 point each. | 12 |
| ►Loop 764 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 100.00 % - Vector Length Use: 100.00 % | |
| ►Data Access Issues | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Vectorization Roadblocks | 32 | |
| ○ | [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 16 issues ( = data accesses) costing 2 point each. | 32 |
| ►Loop 495 - libggml-cpu.so | Execution Time: 0 % - Vectorization Ratio: 25.00 % - Vector Length Use: 100.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 | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |
| ►Vectorization Roadblocks | 6 | |
| ○ | [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 3 issues ( = data accesses) costing 2 point each. | 6 |