AccuracyBroadwellEP
CPU name: Intel(R) Xeon(R) CPU E5-2680 v4 @ 2.40GHz
CPU stepping: 1
Sockets: 2
Cores per socket: 14
Threads per core: 2
Total number of processing units: 56
Not all performance groups can be tested for accuracy. We don't have a test application for each performance group. Here only the groups are listed that can be verified. Each group is followed by the low-level benchmarks that are performed for comparison.
| Group | Tests |
|---|---|
| FLOPS_AVX | sum_avx, triad_avx, stream_avx, daxpy_avx, ddot_avx |
| CLOCK | load, daxpy, stream, ddot, triad, copy, store |
| MEM | load, copy, stream, ddot, triad, daxpy, store |
| FLOPS_SP | triad_sp_sse, sum_sp_sse, sum_sp, ddot_sp_avx, triad_sp, daxpy_sp, ddot_sp_sse, stream_sp_sse, ddot_sp, stream_sp, sum_sp_avx, triad_sp_avx, daxpy_sp_avx, daxpy_sp_sse, stream_sp_avx |
| L2 | load, copy, stream, ddot, triad, daxpy, store |
| L3 | load, copy, stream, ddot, triad, daxpy, store |
| BRANCH | load, triad, copy, store, stream |
| UOPS | triad, daxpy, ddot, stream |
| FLOPS_DP | triad_sse, stream_sse, daxpy_avx, stream, sum_sse, sum, sum_avx, ddot_sse, triad_avx, stream_avx, ddot, daxpy_sse, triad, daxpy, ddot_avx |
| DATA | triad, copy, stream, store |
For memory bandwidth accuracy tests, the result of likwid-bench needs to be scaled to represent the real values. The reason is traffic caused by write-allocates (the store operation on a cache line that is not present at the L1 cache must be loaded first before the store operation can complete). In these cases, the figures contain three curves, the original output of likwid-bench, the scaled version and the derived metrics of likwid-perfctr measurements.
Benchmark performed with data sizes: 24kB, 128kB, 2MB, 1GB.
Each data size is tested 10 times, hence the first 10 entries on the x-axis correspond to the 10 runs for the first data size of 24kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MFLOP/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 24kB | 13284.00 | 13178.69 | -0.79% | 13284.00 | 13177.72 | -0.80% | 13284.10 | 13178.31 | -0.80% |
| 128kB | 10336.00 | 10336.03 | 0.00% | 10204.00 | 10204.94 | 0.01% | 10324.70 | 10325.18 | 0.00% |
| 2MB | 4952.00 | 4951.96 | 0.00% | 4945.00 | 4945.61 | 0.01% | 4948.40 | 4948.64 | 0.00% |
| 1GB | 1676.00 | 1676.17 | 0.01% | 1680.00 | 1680.89 | 0.05% | 1680.40 | 1680.84 | 0.03% |
Benchmark performed with data sizes: 24kB, 128kB, 2MB, 1GB.
Each data size is tested 10 times, hence the first 10 entries on the x-axis correspond to the 10 runs for the first data size of 24kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MFLOP/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 24kB | 12568.00 | 12334.13 | -1.86% | 12565.00 | 12330.49 | -1.87% | 12564.70 | 12330.44 | -1.86% |
| 128kB | 4372.00 | 4372.01 | 0.00% | 4369.00 | 4369.98 | 0.02% | 4350.20 | 4350.61 | 0.01% |
| 2MB | 2212.00 | 2211.99 | 0.00% | 2212.00 | 2212.79 | 0.04% | 2212.00 | 2212.29 | 0.01% |
| 1GB | 786.00 | 786.11 | 0.01% | 801.00 | 801.77 | 0.10% | 795.80 | 796.17 | 0.05% |
Benchmark performed with data sizes: 24kB, 128kB, 2MB, 1GB.
Each data size is tested 10 times, hence the first 10 entries on the x-axis correspond to the 10 runs for the first data size of 24kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MFLOP/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 24kB | 16412.00 | 16281.52 | -0.80% | 16417.00 | 16285.69 | -0.80% | 16406.60 | 16275.87 | -0.80% |
| 128kB | 5341.00 | 5336.82 | -0.08% | 5244.00 | 5239.13 | -0.09% | 5284.90 | 5280.45 | -0.08% |
| 2MB | 2772.00 | 2772.00 | 0.00% | 2773.00 | 2773.76 | 0.03% | 2773.10 | 2773.34 | 0.01% |
| 1GB | 1012.00 | 1012.07 | 0.01% | 1010.00 | 1010.67 | 0.07% | 1007.70 | 1008.09 | 0.04% |
Benchmark performed with data sizes: 24kB, 128kB, 2MB, 1GB.
Each data size is tested 10 times, hence the first 10 entries on the x-axis correspond to the 10 runs for the first data size of 24kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MFLOP/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 24kB | 16866.00 | 16731.87 | -0.80% | 16864.00 | 16729.11 | -0.80% | 16866.10 | 16731.65 | -0.80% |
| 128kB | 6291.00 | 6285.39 | -0.09% | 6415.00 | 6408.59 | -0.10% | 6403.10 | 6397.19 | -0.09% |
| 2MB | 3679.00 | 3679.15 | 0.00% | 3726.00 | 3726.61 | 0.02% | 3708.90 | 3709.21 | 0.01% |
| 1GB | 1376.00 | 1376.09 | 0.01% | 1374.00 | 1374.97 | 0.07% | 1374.60 | 1375.15 | 0.04% |
Benchmark performed with data sizes: 24kB, 128kB, 2MB, 1GB.
Each data size is tested 10 times, hence the first 10 entries on the x-axis correspond to the 10 runs for the first data size of 24kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MFLOP/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 24kB | 20560.00 | 20396.50 | -0.80% | 20553.00 | 20388.92 | -0.80% | 20558.70 | 20394.95 | -0.80% |
| 128kB | 10029.00 | 10029.01 | 0.00% | 8232.00 | 8232.97 | 0.01% | 9790.80 | 9791.34 | 0.01% |
| 2MB | 5124.00 | 5123.95 | 0.00% | 5130.00 | 5130.61 | 0.01% | 5128.20 | 5128.22 | 0.00% |
| 1GB | 1779.00 | 1779.00 | 0.00% | 1813.00 | 1813.82 | 0.05% | 1803.90 | 1804.22 | 0.02% |
Benchmark performed with data sizes: 229989kB, 436017kB, 642045kB, 848073kB.
Each data size is tested 5 times, hence the first 5 entries on the x-axis correspond to the 5 runs for the first data size of 229989kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'Instructions'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 229989kB | 2529878928.00 | 2529888000.00 | 0.00% | 2529878928.00 | 2529888000.00 | 0.00% | 2529878928.00 | 2529888000.00 | 0.00% |
| 436017kB | 2398093296.00 | 2398102000.00 | 0.00% | 2398093296.00 | 2398102000.00 | 0.00% | 2398093296.00 | 2398102000.00 | 0.00% |
| 642045kB | 3531247472.00 | 3531256000.00 | 0.00% | 3531247472.00 | 3531256000.00 | 0.00% | 3531247472.00 | 3531256000.00 | 0.00% |
| 848073kB | 2332200656.00 | 2332209000.00 | 0.00% | 2332200656.00 | 2332209000.00 | 0.00% | 2332200656.00 | 2332209000.00 | 0.00% |
Benchmark performed with data sizes: 229989kB, 436017kB, 642045kB, 848073kB.
Each data size is tested 5 times, hence the first 5 entries on the x-axis correspond to the 5 runs for the first data size of 229989kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'Instructions'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 229989kB | 4369790865.00 | 4369800000.00 | 0.00% | 4369790865.00 | 4369800000.00 | 0.00% | 4369790865.00 | 4369800000.00 | 0.00% |
| 436017kB | 4142161137.00 | 4142170000.00 | 0.00% | 4142161137.00 | 4142170000.00 | 0.00% | 4142161137.00 | 4142170000.00 | 0.00% |
| 642045kB | 6099427441.00 | 6099436000.00 | 0.00% | 6099427441.00 | 6099436000.00 | 0.00% | 6099427441.00 | 6099436000.00 | 0.00% |
| 848073kB | 4028346577.00 | 4028355000.00 | 0.00% | 4028346577.00 | 4028355000.00 | 0.00% | 4028346577.00 | 4028355000.00 | 0.00% |
Benchmark performed with data sizes: 229989kB, 436017kB, 642045kB, 848073kB.
Each data size is tested 5 times, hence the first 5 entries on the x-axis correspond to the 5 runs for the first data size of 229989kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'Instructions'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 229989kB | 2913193105.00 | 2913202000.00 | 0.00% | 2913193105.00 | 2913202000.00 | 0.00% | 2913193105.00 | 2913202000.00 | 0.00% |
| 436017kB | 2761440561.00 | 2761449000.00 | 0.00% | 2761440561.00 | 2761449000.00 | 0.00% | 2761440561.00 | 2761449000.00 | 0.00% |
| 642045kB | 4066284561.00 | 4066293000.00 | 0.00% | 4066284561.00 | 4066293000.00 | 0.00% | 4066284561.00 | 4066293000.00 | 0.00% |
| 848073kB | 2685564289.00 | 2685572000.00 | 0.00% | 2685564289.00 | 2685572000.00 | 0.00% | 2685564289.00 | 2685572000.00 | 0.00% |
Benchmark performed with data sizes: 229989kB, 436017kB, 642045kB, 848073kB.
Each data size is tested 5 times, hence the first 5 entries on the x-axis correspond to the 5 runs for the first data size of 229989kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'Instructions'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 229989kB | 3449834900.00 | 3449844000.00 | 0.00% | 6899669780.00 | 6899681000.00 | 0.00% | 5519735828.00 | 5519746200.00 | 0.00% |
| 436017kB | 6540254420.00 | 6540264000.00 | 0.00% | 6540254420.00 | 6540264000.00 | 0.00% | 6540254420.00 | 6540264000.00 | 0.00% |
| 642045kB | 4815337460.00 | 4815346000.00 | 0.00% | 4815337460.00 | 4815346000.00 | 0.00% | 4815337460.00 | 4815346000.00 | 0.00% |
| 848073kB | 3180273620.00 | 3180282000.00 | 0.00% | 6360547220.00 | 6360556000.00 | 0.00% | 4452383060.00 | 4452391600.00 | 0.00% |
Benchmark performed with data sizes: 229989kB, 436017kB, 642045kB, 848073kB.
Each data size is tested 5 times, hence the first 5 entries on the x-axis correspond to the 5 runs for the first data size of 229989kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'Instructions'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 229989kB | 2184895440.00 | 2184905000.00 | 0.00% | 2184895440.00 | 2184905000.00 | 0.00% | 2184895440.00 | 2184905000.00 | 0.00% |
| 436017kB | 2071080272.00 | 2071089000.00 | 0.00% | 2071080272.00 | 2071089000.00 | 0.00% | 2071080272.00 | 2071089000.00 | 0.00% |
| 642045kB | 3049713424.00 | 3049722000.00 | 0.00% | 3049713424.00 | 3049722000.00 | 0.00% | 3049713424.00 | 3049722000.00 | 0.00% |
| 848073kB | 2014173296.00 | 2014181000.00 | 0.00% | 2014173296.00 | 2014181000.00 | 0.00% | 2014173296.00 | 2014181000.00 | 0.00% |
Benchmark performed with data sizes: 229989kB, 436017kB, 642045kB, 848073kB.
Each data size is tested 5 times, hence the first 5 entries on the x-axis correspond to the 5 runs for the first data size of 229989kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'Instructions'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 229989kB | 2529878928.00 | 2529888000.00 | 0.00% | 2529878928.00 | 2529888000.00 | 0.00% | 2529878928.00 | 2529888000.00 | 0.00% |
| 436017kB | 2398093296.00 | 2398102000.00 | 0.00% | 2398093296.00 | 2398102000.00 | 0.00% | 2398093296.00 | 2398102000.00 | 0.00% |
| 642045kB | 3531247472.00 | 3531256000.00 | 0.00% | 3531247472.00 | 3531256000.00 | 0.00% | 3531247472.00 | 3531256000.00 | 0.00% |
| 848073kB | 2332200656.00 | 2332209000.00 | 0.00% | 2332200656.00 | 2332209000.00 | 0.00% | 2332200656.00 | 2332209000.00 | 0.00% |
Benchmark performed with data sizes: 229989kB, 436017kB, 642045kB, 848073kB.
Each data size is tested 5 times, hence the first 5 entries on the x-axis correspond to the 5 runs for the first data size of 229989kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'Instructions'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 229989kB | 3219845908.00 | 3219855000.00 | 0.00% | 3219845908.00 | 3219855000.00 | 0.00% | 3219845908.00 | 3219855000.00 | 0.00% |
| 436017kB | 3052118964.00 | 3052128000.00 | 0.00% | 3052118964.00 | 3052128000.00 | 0.00% | 3052118964.00 | 3052128000.00 | 0.00% |
| 642045kB | 2247157492.00 | 2247165000.00 | 0.00% | 2247157492.00 | 2247165000.00 | 0.00% | 2247157492.00 | 2247165000.00 | 0.00% |
| 848073kB | 2968255492.00 | 2968264000.00 | 0.00% | 2968255492.00 | 2968264000.00 | 0.00% | 2968255492.00 | 2968264000.00 | 0.00% |
Benchmark performed with data sizes: 229989kB, 436017kB, 642045kB, 848073kB.
Each data size is tested 10 times, hence the first 10 entries on the x-axis correspond to the 10 runs for the first data size of 229989kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MByte/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 229989kB | 13396.00 | 13476.61 | 0.60% | 12251.00 | 12333.67 | 0.67% | 13149.20 | 13230.82 | 0.62% |
| 436017kB | 13395.00 | 13475.92 | 0.60% | 12090.00 | 12180.23 | 0.75% | 12761.90 | 12844.77 | 0.65% |
| 642045kB | 13395.00 | 13475.37 | 0.60% | 13390.00 | 13474.30 | 0.63% | 13392.50 | 13474.66 | 0.61% |
| 848073kB | 11676.00 | 11756.85 | 0.69% | 12619.00 | 12700.96 | 0.65% | 12956.80 | 13038.22 | 0.63% |
Benchmark performed with data sizes: 229989kB, 436017kB, 642045kB, 848073kB.
Each data size is tested 10 times, hence the first 10 entries on the x-axis correspond to the 10 runs for the first data size of 229989kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.50. The table entries for BENCH and LIKWID have the unit 'MByte/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 229989kB | 16807.50 | 16886.50 | 0.47% | 16755.00 | 16838.72 | 0.50% | 16690.50 | 16770.97 | 0.48% |
| 436017kB | 16677.00 | 16755.98 | 0.47% | 16600.50 | 16685.04 | 0.51% | 16635.15 | 16715.63 | 0.48% |
| 642045kB | 16653.00 | 16731.90 | 0.47% | 16689.00 | 16774.24 | 0.51% | 16652.55 | 16732.93 | 0.48% |
| 848073kB | 16333.50 | 16412.26 | 0.48% | 16081.50 | 16165.39 | 0.52% | 16306.20 | 16386.80 | 0.49% |
Benchmark performed with data sizes: 229989kB, 436017kB, 642045kB, 848073kB.
Each data size is tested 10 times, hence the first 10 entries on the x-axis correspond to the 10 runs for the first data size of 229989kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.33. The table entries for BENCH and LIKWID have the unit 'MByte/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 229989kB | 15180.95 | 15257.21 | 0.50% | 15619.61 | 15704.11 | 0.54% | 15554.28 | 15633.34 | 0.51% |
| 436017kB | 15590.28 | 15668.65 | 0.50% | 15850.27 | 15931.56 | 0.51% | 15754.54 | 15834.37 | 0.51% |
| 642045kB | 16024.93 | 16104.36 | 0.50% | 15896.94 | 15980.70 | 0.53% | 15966.13 | 16046.45 | 0.50% |
| 848073kB | 15887.60 | 15965.20 | 0.49% | 16163.60 | 16249.09 | 0.53% | 16108.00 | 16188.07 | 0.50% |
Benchmark performed with data sizes: 229989kB, 436017kB, 642045kB, 848073kB.
Each data size is tested 10 times, hence the first 10 entries on the x-axis correspond to the 10 runs for the first data size of 229989kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MByte/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 229989kB | 13390.00 | 13471.02 | 0.61% | 14747.00 | 14829.83 | 0.56% | 14648.60 | 14730.81 | 0.56% |
| 436017kB | 14896.00 | 14977.83 | 0.55% | 14900.00 | 14983.54 | 0.56% | 14806.60 | 14889.15 | 0.56% |
| 642045kB | 14902.00 | 14982.54 | 0.54% | 14929.00 | 15011.51 | 0.55% | 14734.90 | 14816.64 | 0.56% |
| 848073kB | 14615.00 | 14696.70 | 0.56% | 14593.00 | 14679.73 | 0.59% | 14426.30 | 14509.21 | 0.58% |
Benchmark performed with data sizes: 229989kB, 436017kB, 642045kB, 848073kB.
Each data size is tested 10 times, hence the first 10 entries on the x-axis correspond to the 10 runs for the first data size of 229989kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.25. The table entries for BENCH and LIKWID have the unit 'MByte/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 229989kB | 15747.50 | 15825.21 | 0.49% | 15695.00 | 15781.20 | 0.55% | 15758.75 | 15838.26 | 0.50% |
| 436017kB | 15721.25 | 15798.26 | 0.49% | 15720.00 | 15800.39 | 0.51% | 15760.12 | 15838.41 | 0.50% |
| 642045kB | 15781.25 | 15857.73 | 0.48% | 15766.25 | 15851.51 | 0.54% | 15763.88 | 15842.52 | 0.50% |
| 848073kB | 15776.25 | 15853.17 | 0.49% | 15808.75 | 15888.34 | 0.50% | 15808.75 | 15886.74 | 0.49% |
Benchmark performed with data sizes: 229989kB, 436017kB, 642045kB, 848073kB.
Each data size is tested 10 times, hence the first 10 entries on the x-axis correspond to the 10 runs for the first data size of 229989kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MByte/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 229989kB | 17246.00 | 17326.97 | 0.47% | 16977.00 | 17065.57 | 0.52% | 17080.80 | 17163.26 | 0.48% |
| 436017kB | 16767.00 | 16848.00 | 0.48% | 17138.00 | 17220.93 | 0.48% | 17085.20 | 17167.06 | 0.48% |
| 642045kB | 16925.00 | 17006.11 | 0.48% | 16886.00 | 16972.03 | 0.51% | 16933.20 | 17016.00 | 0.49% |
| 848073kB | 17009.00 | 17090.06 | 0.48% | 16905.00 | 16987.99 | 0.49% | 16864.10 | 16945.97 | 0.49% |
Benchmark performed with data sizes: 229989kB, 436017kB, 642045kB, 848073kB.
Each data size is tested 10 times, hence the first 10 entries on the x-axis correspond to the 10 runs for the first data size of 229989kB and so on.
The table contains the values after scaling the original values up using the scaling factor 2.00. The table entries for BENCH and LIKWID have the unit 'MByte/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 229989kB | 16514.00 | 16594.60 | 0.49% | 16544.00 | 16628.18 | 0.51% | 16521.80 | 16604.12 | 0.50% |
| 436017kB | 16428.00 | 16508.81 | 0.49% | 16524.00 | 16607.58 | 0.51% | 16465.00 | 16546.81 | 0.50% |
| 642045kB | 16532.00 | 16612.23 | 0.49% | 16674.00 | 16760.40 | 0.52% | 16512.60 | 16594.89 | 0.50% |
| 848073kB | 16464.00 | 16544.24 | 0.49% | 16476.00 | 16560.10 | 0.51% | 16469.40 | 16551.43 | 0.50% |
Benchmark performed with data sizes: 24kB, 128kB, 2MB, 1GB.
Each data size is tested 10 times, hence the first 10 entries on the x-axis correspond to the 10 runs for the first data size of 24kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MFLOP/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 24kB | 12873.00 | 12770.99 | -0.79% | 12872.00 | 12769.08 | -0.80% | 12871.60 | 12769.20 | -0.80% |
| 128kB | 7371.00 | 7371.22 | 0.00% | 7212.00 | 7212.92 | 0.01% | 7298.30 | 7298.88 | 0.01% |
| 2MB | 4383.00 | 4383.01 | 0.00% | 4380.00 | 4380.56 | 0.01% | 4383.30 | 4383.34 | 0.00% |
| 1GB | 1583.00 | 1583.05 | 0.00% | 1580.00 | 1580.96 | 0.06% | 1575.00 | 1575.46 | 0.03% |
Benchmark performed with data sizes: 24kB, 128kB, 2MB, 1GB.
Each data size is tested 10 times, hence the first 10 entries on the x-axis correspond to the 10 runs for the first data size of 24kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MFLOP/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 24kB | 13091.00 | 13056.93 | -0.26% | 13223.00 | 13187.81 | -0.27% | 13208.40 | 13173.82 | -0.26% |
| 128kB | 11752.00 | 11752.01 | 0.00% | 11707.00 | 11707.77 | 0.01% | 11834.60 | 11834.99 | 0.00% |
| 2MB | 9165.00 | 9165.13 | 0.00% | 9156.00 | 9156.90 | 0.01% | 9161.80 | 9162.35 | 0.01% |
| 1GB | 3352.00 | 3352.17 | 0.00% | 3513.00 | 3513.98 | 0.03% | 3504.90 | 3505.54 | 0.02% |
Benchmark performed with data sizes: 24kB, 128kB, 2MB, 1GB.
Each data size is tested 10 times, hence the first 10 entries on the x-axis correspond to the 10 runs for the first data size of 24kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MFLOP/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 24kB | 3297.00 | 3297.18 | 0.01% | 3296.00 | 3296.92 | 0.03% | 3296.30 | 3296.89 | 0.02% |
| 128kB | 3294.00 | 3294.00 | 0.00% | 3288.00 | 3288.97 | 0.03% | 3291.30 | 3291.87 | 0.02% |
| 2MB | 3295.00 | 3295.00 | 0.00% | 3294.00 | 3294.94 | 0.03% | 3285.30 | 3285.63 | 0.01% |
| 1GB | 2788.00 | 2788.00 | 0.00% | 2787.00 | 2787.91 | 0.03% | 2707.90 | 2708.30 | 0.01% |
Benchmark performed with data sizes: 24kB, 128kB, 2MB, 1GB.
Each data size is tested 10 times, hence the first 10 entries on the x-axis correspond to the 10 runs for the first data size of 24kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MFLOP/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 24kB | 34170.00 | 34079.80 | -0.26% | 34174.00 | 34082.95 | -0.27% | 34178.50 | 34087.98 | -0.26% |
| 128kB | 19930.00 | 19930.07 | 0.00% | 19837.00 | 19837.98 | 0.00% | 19850.90 | 19851.49 | 0.00% |
| 2MB | 10244.00 | 10244.18 | 0.00% | 10251.00 | 10251.97 | 0.01% | 10248.70 | 10249.21 | 0.00% |
| 1GB | 3585.00 | 3585.01 | 0.00% | 3625.00 | 3625.84 | 0.02% | 3621.30 | 3621.81 | 0.01% |
Benchmark performed with data sizes: 24kB, 128kB, 2MB, 1GB.
Each data size is tested 10 times, hence the first 10 entries on the x-axis correspond to the 10 runs for the first data size of 24kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MFLOP/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 24kB | 3280.00 | 3271.92 | -0.25% | 3281.00 | 3272.27 | -0.27% | 3280.10 | 3271.82 | -0.25% |
| 128kB | 3220.00 | 3220.14 | 0.00% | 3220.00 | 3220.92 | 0.03% | 3191.30 | 3191.90 | 0.02% |
| 2MB | 3094.00 | 3094.12 | 0.00% | 3094.00 | 3094.96 | 0.03% | 3088.60 | 3089.11 | 0.02% |
| 1GB | 1542.00 | 1542.07 | 0.00% | 1591.00 | 1591.94 | 0.06% | 1560.00 | 1560.53 | 0.03% |
Benchmark performed with data sizes: 24kB, 128kB, 2MB, 1GB.
Each data size is tested 10 times, hence the first 10 entries on the x-axis correspond to the 10 runs for the first data size of 24kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MFLOP/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 24kB | 4372.00 | 4371.99 | 0.00% | 4370.00 | 4370.96 | 0.02% | 4370.30 | 4370.77 | 0.01% |
| 128kB | 3773.00 | 3773.17 | 0.00% | 4184.00 | 4184.99 | 0.02% | 4104.30 | 4104.93 | 0.02% |
| 2MB | 3703.00 | 3703.09 | 0.00% | 4099.00 | 4099.97 | 0.02% | 3951.30 | 3951.72 | 0.01% |
| 1GB | 2728.00 | 2728.04 | 0.00% | 2731.00 | 2731.96 | 0.04% | 2682.10 | 2682.60 | 0.02% |
Benchmark performed with data sizes: 24kB, 128kB, 2MB, 1GB.
Each data size is tested 10 times, hence the first 10 entries on the x-axis correspond to the 10 runs for the first data size of 24kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MFLOP/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 24kB | 17476.00 | 17476.08 | 0.00% | 17476.00 | 17476.93 | 0.01% | 17475.90 | 17476.36 | 0.00% |
| 128kB | 13305.00 | 13305.05 | 0.00% | 13264.00 | 13264.95 | 0.01% | 13185.00 | 13185.50 | 0.00% |
| 2MB | 9818.00 | 9818.08 | 0.00% | 9804.00 | 9804.99 | 0.01% | 9798.80 | 9799.36 | 0.01% |
| 1GB | 3564.00 | 3564.03 | 0.00% | 3575.00 | 3575.89 | 0.02% | 3676.50 | 3676.89 | 0.01% |
Benchmark performed with data sizes: 24kB, 128kB, 2MB, 1GB.
Each data size is tested 10 times, hence the first 10 entries on the x-axis correspond to the 10 runs for the first data size of 24kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MFLOP/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 24kB | 15543.00 | 15543.02 | 0.00% | 15521.00 | 15521.97 | 0.01% | 15521.40 | 15521.81 | 0.00% |
| 128kB | 10237.00 | 10236.06 | -0.01% | 10220.00 | 10218.21 | -0.02% | 10190.20 | 10188.93 | -0.01% |
| 2MB | 5492.00 | 5491.95 | 0.00% | 5499.00 | 5499.89 | 0.02% | 5494.40 | 5494.81 | 0.01% |
| 1GB | 1976.00 | 1976.06 | 0.00% | 1998.00 | 1998.78 | 0.04% | 1991.30 | 1991.71 | 0.02% |
Benchmark performed with data sizes: 24kB, 128kB, 2MB, 1GB.
Each data size is tested 10 times, hence the first 10 entries on the x-axis correspond to the 10 runs for the first data size of 24kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MFLOP/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 24kB | 6514.00 | 6514.02 | 0.00% | 6513.00 | 6513.96 | 0.01% | 6513.40 | 6513.88 | 0.01% |
| 128kB | 5326.00 | 5326.17 | 0.00% | 5431.00 | 5431.99 | 0.02% | 5333.80 | 5334.41 | 0.01% |
| 2MB | 5449.00 | 5449.00 | 0.00% | 5456.00 | 5456.94 | 0.02% | 5199.00 | 5199.40 | 0.01% |
| 1GB | 3624.00 | 3624.10 | 0.00% | 3195.00 | 3195.78 | 0.02% | 3434.80 | 3435.22 | 0.01% |
Benchmark performed with data sizes: 24kB, 128kB, 2MB, 1GB.
Each data size is tested 10 times, hence the first 10 entries on the x-axis correspond to the 10 runs for the first data size of 24kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MFLOP/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 24kB | 4359.00 | 4359.01 | 0.00% | 4357.00 | 4357.92 | 0.02% | 4357.00 | 4357.45 | 0.01% |
| 128kB | 4140.00 | 4139.99 | 0.00% | 4138.00 | 4137.23 | -0.02% | 4120.00 | 4119.73 | -0.01% |
| 2MB | 3822.00 | 3822.18 | 0.00% | 3821.00 | 3821.92 | 0.02% | 3821.00 | 3821.50 | 0.01% |
| 1GB | 2059.00 | 2058.99 | 0.00% | 1842.00 | 1842.90 | 0.05% | 2007.00 | 2007.64 | 0.03% |
Benchmark performed with data sizes: 24kB, 128kB, 2MB, 1GB.
Each data size is tested 10 times, hence the first 10 entries on the x-axis correspond to the 10 runs for the first data size of 24kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MFLOP/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 24kB | 26303.00 | 26233.81 | -0.26% | 26303.00 | 26232.91 | -0.27% | 26300.90 | 26231.29 | -0.26% |
| 128kB | 20381.00 | 20380.99 | 0.00% | 20673.00 | 20673.89 | 0.00% | 20622.20 | 20622.63 | 0.00% |
| 2MB | 9908.00 | 9908.03 | 0.00% | 9908.00 | 9908.98 | 0.01% | 9901.30 | 9901.95 | 0.01% |
| 1GB | 3368.00 | 3368.10 | 0.00% | 3352.00 | 3352.70 | 0.02% | 3361.60 | 3362.04 | 0.01% |
Benchmark performed with data sizes: 24kB, 128kB, 2MB, 1GB.
Each data size is tested 10 times, hence the first 10 entries on the x-axis correspond to the 10 runs for the first data size of 24kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MFLOP/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 24kB | 24304.00 | 24239.85 | -0.26% | 24333.00 | 24268.09 | -0.27% | 24329.60 | 24265.08 | -0.27% |
| 128kB | 8719.00 | 8719.18 | 0.00% | 8678.00 | 8678.93 | 0.01% | 8700.70 | 8701.31 | 0.01% |
| 2MB | 4425.00 | 4425.12 | 0.00% | 4424.00 | 4424.96 | 0.02% | 4423.90 | 4424.46 | 0.01% |
| 1GB | 1587.00 | 1587.08 | 0.01% | 1599.00 | 1599.86 | 0.05% | 1591.20 | 1591.59 | 0.02% |
Benchmark performed with data sizes: 24kB, 128kB, 2MB, 1GB.
Each data size is tested 10 times, hence the first 10 entries on the x-axis correspond to the 10 runs for the first data size of 24kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MFLOP/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 24kB | 29005.00 | 28928.47 | -0.26% | 29005.00 | 28927.72 | -0.27% | 29004.20 | 28927.44 | -0.26% |
| 128kB | 12828.00 | 12828.15 | 0.00% | 12840.00 | 12840.96 | 0.01% | 12821.00 | 12821.58 | 0.00% |
| 2MB | 7458.00 | 7458.06 | 0.00% | 7255.00 | 7255.88 | 0.01% | 7415.60 | 7416.16 | 0.01% |
| 1GB | 2746.00 | 2746.04 | 0.00% | 2741.00 | 2741.74 | 0.03% | 2746.80 | 2747.22 | 0.02% |
Benchmark performed with data sizes: 24kB, 128kB, 2MB, 1GB.
Each data size is tested 10 times, hence the first 10 entries on the x-axis correspond to the 10 runs for the first data size of 24kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MFLOP/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 24kB | 17190.00 | 17145.14 | -0.26% | 17193.00 | 17147.18 | -0.27% | 17190.50 | 17145.17 | -0.26% |
| 128kB | 11685.00 | 11685.00 | 0.00% | 11690.00 | 11690.97 | 0.01% | 11690.40 | 11690.87 | 0.00% |
| 2MB | 7099.00 | 7099.05 | 0.00% | 7102.00 | 7102.93 | 0.01% | 7071.90 | 7072.36 | 0.01% |
| 1GB | 2757.00 | 2757.11 | 0.00% | 2761.00 | 2761.96 | 0.03% | 2760.40 | 2760.78 | 0.01% |
Benchmark performed with data sizes: 24kB, 128kB, 2MB, 1GB.
Each data size is tested 10 times, hence the first 10 entries on the x-axis correspond to the 10 runs for the first data size of 24kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MFLOP/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 24kB | 32748.00 | 32486.95 | -0.80% | 32752.00 | 32490.15 | -0.80% | 32753.90 | 32492.44 | -0.80% |
| 128kB | 10690.00 | 10680.88 | -0.09% | 10674.00 | 10664.10 | -0.09% | 10601.30 | 10591.85 | -0.09% |
| 2MB | 5545.00 | 5545.05 | 0.00% | 5544.00 | 5544.37 | 0.01% | 5546.10 | 5546.08 | 0.00% |
| 1GB | 2016.00 | 2016.11 | 0.01% | 2023.00 | 2023.88 | 0.04% | 2016.30 | 2016.88 | 0.03% |
Benchmark performed with data sizes: 85kB, 129kB, 173kB, 217kB.
Each data size is tested 5 times, hence the first 5 entries on the x-axis correspond to the 5 runs for the first data size of 85kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MByte/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 85kB | 25566.00 | 25741.39 | 0.69% | 25631.00 | 25812.98 | 0.71% | 25591.40 | 25769.96 | 0.70% |
| 129kB | 25546.00 | 25656.60 | 0.43% | 25588.00 | 25704.72 | 0.46% | 25576.00 | 25689.64 | 0.44% |
| 173kB | 25276.00 | 25361.47 | 0.34% | 25509.00 | 25598.72 | 0.35% | 25435.80 | 25523.38 | 0.34% |
| 217kB | 25542.00 | 25594.68 | 0.21% | 25529.00 | 25602.20 | 0.29% | 25455.00 | 25521.57 | 0.26% |
Benchmark performed with data sizes: 85kB, 129kB, 173kB, 217kB.
Each data size is tested 5 times, hence the first 5 entries on the x-axis correspond to the 5 runs for the first data size of 85kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.50. The table entries for BENCH and LIKWID have the unit 'MByte/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 85kB | 61353.00 | 61597.46 | 0.40% | 60673.50 | 60986.43 | 0.52% | 60743.40 | 61042.29 | 0.49% |
| 129kB | 61233.00 | 61426.41 | 0.32% | 61147.50 | 61361.48 | 0.35% | 61077.00 | 61286.37 | 0.34% |
| 173kB | 61654.50 | 61784.46 | 0.21% | 61044.00 | 61215.16 | 0.28% | 61285.80 | 61442.89 | 0.26% |
| 217kB | 60654.00 | 60738.75 | 0.14% | 60702.00 | 60813.53 | 0.18% | 59749.80 | 59853.52 | 0.17% |
Benchmark performed with data sizes: 85kB, 129kB, 173kB, 217kB.
Each data size is tested 5 times, hence the first 5 entries on the x-axis correspond to the 5 runs for the first data size of 85kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.33. The table entries for BENCH and LIKWID have the unit 'MByte/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 85kB | 51804.04 | 52371.71 | 1.10% | 55157.29 | 56074.97 | 1.66% | 54473.30 | 55319.67 | 1.55% |
| 129kB | 54915.96 | 55596.23 | 1.24% | 55250.62 | 55974.73 | 1.31% | 55168.75 | 55872.04 | 1.27% |
| 173kB | 51817.37 | 52247.98 | 0.83% | 55286.62 | 55934.21 | 1.17% | 54122.65 | 54705.16 | 1.07% |
| 217kB | 52877.34 | 53342.82 | 0.88% | 55206.62 | 55811.83 | 1.10% | 53817.59 | 54347.02 | 0.98% |
Benchmark performed with data sizes: 85kB, 129kB, 173kB, 217kB.
Each data size is tested 5 times, hence the first 5 entries on the x-axis correspond to the 5 runs for the first data size of 85kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MByte/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 85kB | 38928.00 | 40072.44 | 2.94% | 39487.00 | 40772.61 | 3.26% | 39316.00 | 40540.92 | 3.12% |
| 129kB | 35406.00 | 36192.72 | 2.22% | 39504.00 | 40625.56 | 2.84% | 38136.20 | 39120.02 | 2.57% |
| 173kB | 37869.00 | 38728.44 | 2.27% | 39502.00 | 40556.98 | 2.67% | 39053.20 | 40045.69 | 2.54% |
| 217kB | 29674.00 | 29935.87 | 0.88% | 38475.00 | 39423.05 | 2.46% | 34194.80 | 34822.78 | 1.78% |
Benchmark performed with data sizes: 85kB, 129kB, 173kB, 217kB.
Each data size is tested 5 times, hence the first 5 entries on the x-axis correspond to the 5 runs for the first data size of 85kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.25. The table entries for BENCH and LIKWID have the unit 'MByte/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 85kB | 44031.25 | 45140.46 | 2.52% | 53218.75 | 55002.74 | 3.35% | 50344.25 | 51873.31 | 3.02% |
| 129kB | 52427.50 | 53879.03 | 2.77% | 53407.50 | 55053.20 | 3.08% | 53026.75 | 54595.63 | 2.96% |
| 173kB | 44442.50 | 45554.69 | 2.50% | 52991.25 | 54466.51 | 2.78% | 49653.75 | 50968.10 | 2.64% |
| 217kB | 49255.00 | 50367.54 | 2.26% | 52600.00 | 53997.33 | 2.66% | 51289.50 | 52569.90 | 2.49% |
Benchmark performed with data sizes: 85kB, 129kB, 173kB, 217kB.
Each data size is tested 5 times, hence the first 5 entries on the x-axis correspond to the 5 runs for the first data size of 85kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MByte/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 85kB | 44513.00 | 45412.55 | 2.02% | 44795.00 | 45749.14 | 2.13% | 44619.60 | 45542.38 | 2.07% |
| 129kB | 39942.00 | 40303.82 | 0.91% | 44861.00 | 45735.05 | 1.95% | 43711.40 | 44455.52 | 1.69% |
| 173kB | 43995.00 | 44740.20 | 1.69% | 44874.00 | 45711.37 | 1.87% | 44522.80 | 45309.63 | 1.77% |
| 217kB | 43604.00 | 44277.95 | 1.55% | 44536.00 | 45283.99 | 1.68% | 44014.60 | 44724.41 | 1.61% |
Benchmark performed with data sizes: 85kB, 129kB, 173kB, 217kB.
Each data size is tested 5 times, hence the first 5 entries on the x-axis correspond to the 5 runs for the first data size of 85kB and so on.
The table contains the values after scaling the original values up using the scaling factor 2.00. The table entries for BENCH and LIKWID have the unit 'MByte/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 85kB | 46724.00 | 46858.86 | 0.29% | 46718.00 | 46854.67 | 0.29% | 46722.80 | 46858.64 | 0.29% |
| 129kB | 46766.00 | 46866.25 | 0.21% | 46764.00 | 46865.35 | 0.22% | 46762.00 | 46862.79 | 0.22% |
| 173kB | 46544.00 | 46609.30 | 0.14% | 46774.00 | 46841.32 | 0.14% | 46733.20 | 46799.21 | 0.14% |
| 217kB | 45788.00 | 45845.55 | 0.13% | 46686.00 | 46746.45 | 0.13% | 46220.00 | 46278.98 | 0.13% |
Benchmark performed with data sizes: 3967kB, 7602kB, 11237kB, 14872kB.
Each data size is tested 5 times, hence the first 5 entries on the x-axis correspond to the 5 runs for the first data size of 3967kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MByte/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 3967kB | 25209.00 | 25222.80 | 0.05% | 25145.00 | 25159.43 | 0.06% | 25156.00 | 25170.07 | 0.06% |
| 7602kB | 25057.00 | 25061.08 | 0.02% | 25254.00 | 25258.73 | 0.02% | 25178.20 | 25182.58 | 0.02% |
| 11237kB | 25226.00 | 25231.29 | 0.02% | 25288.00 | 25294.10 | 0.02% | 25284.40 | 25290.09 | 0.02% |
| 14872kB | 25010.00 | 25012.88 | 0.01% | 24825.00 | 24828.68 | 0.01% | 24829.40 | 24832.66 | 0.01% |
Benchmark performed with data sizes: 3967kB, 7602kB, 11237kB, 14872kB.
Each data size is tested 5 times, hence the first 5 entries on the x-axis correspond to the 5 runs for the first data size of 3967kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.50. The table entries for BENCH and LIKWID have the unit 'MByte/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 3967kB | 42498.00 | 36966.88 | -13.02% | 42345.00 | 34883.61 | -17.62% | 42462.30 | 36298.75 | -14.52% |
| 7602kB | 42513.00 | 37107.82 | -12.71% | 42549.00 | 36939.34 | -13.18% | 42539.40 | 37009.60 | -13.00% |
| 11237kB | 42537.00 | 37033.64 | -12.94% | 42466.50 | 36119.88 | -14.94% | 42520.50 | 36832.38 | -13.38% |
| 14872kB | 41644.50 | 35314.22 | -15.20% | 40092.00 | 31580.41 | -21.23% | 41150.70 | 33956.19 | -17.51% |
Benchmark performed with data sizes: 3967kB, 7602kB, 11237kB, 14872kB.
Each data size is tested 5 times, hence the first 5 entries on the x-axis correspond to the 5 runs for the first data size of 3967kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.33. The table entries for BENCH and LIKWID have the unit 'MByte/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 3967kB | 42089.47 | 33910.66 | -19.43% | 39731.40 | 31133.36 | -21.64% | 41633.06 | 33255.10 | -20.14% |
| 7602kB | 42097.47 | 34844.44 | -17.23% | 42214.78 | 33547.67 | -20.53% | 41660.52 | 33444.00 | -19.73% |
| 11237kB | 42106.80 | 34485.98 | -18.10% | 42146.79 | 33593.25 | -20.29% | 42118.80 | 34048.96 | -19.16% |
| 14872kB | 39920.68 | 32295.04 | -19.10% | 40617.84 | 32069.74 | -21.05% | 39985.20 | 31775.35 | -20.54% |
Benchmark performed with data sizes: 3967kB, 7602kB, 11237kB, 14872kB.
Each data size is tested 5 times, hence the first 5 entries on the x-axis correspond to the 5 runs for the first data size of 3967kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MByte/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 3967kB | 26667.00 | 26688.10 | 0.08% | 32206.00 | 32232.86 | 0.08% | 30623.80 | 30648.99 | 0.08% |
| 7602kB | 25177.00 | 25181.09 | 0.02% | 32347.00 | 32368.22 | 0.07% | 30916.60 | 30929.70 | 0.04% |
| 11237kB | 32382.00 | 32391.91 | 0.03% | 32393.00 | 32404.09 | 0.03% | 32408.60 | 32418.90 | 0.03% |
| 14872kB | 24321.00 | 24326.59 | 0.02% | 31750.00 | 31758.53 | 0.03% | 29039.40 | 29046.86 | 0.03% |
Benchmark performed with data sizes: 3967kB, 7602kB, 11237kB, 14872kB.
Each data size is tested 5 times, hence the first 5 entries on the x-axis correspond to the 5 runs for the first data size of 3967kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.33. The table entries for BENCH and LIKWID have the unit 'MByte/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 3967kB | 43859.70 | 35053.27 | -20.08% | 43875.69 | 35022.52 | -20.18% | 43867.70 | 35046.76 | -20.11% |
| 7602kB | 43629.09 | 34974.88 | -19.84% | 43671.75 | 34958.87 | -19.95% | 43651.48 | 34967.93 | -19.89% |
| 11237kB | 43770.39 | 34978.78 | -20.09% | 43897.02 | 34975.22 | -20.32% | 43436.34 | 34570.08 | -20.42% |
| 14872kB | 35293.84 | 27343.87 | -22.53% | 42022.82 | 33400.66 | -20.52% | 38773.50 | 30461.80 | -21.50% |
Benchmark performed with data sizes: 3967kB, 7602kB, 11237kB, 14872kB.
Each data size is tested 5 times, hence the first 5 entries on the x-axis correspond to the 5 runs for the first data size of 3967kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MByte/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 3967kB | 37689.00 | 25886.34 | -31.32% | 38540.00 | 26467.59 | -31.32% | 38356.00 | 26357.89 | -31.28% |
| 7602kB | 38492.00 | 26440.65 | -31.31% | 38641.00 | 26477.89 | -31.48% | 38603.00 | 26486.81 | -31.39% |
| 11237kB | 34761.00 | 23816.31 | -31.49% | 38647.00 | 26481.65 | -31.48% | 37865.40 | 25951.52 | -31.46% |
| 14872kB | 34495.00 | 23678.93 | -31.36% | 38666.00 | 26495.14 | -31.48% | 36942.60 | 25337.47 | -31.41% |
Benchmark performed with data sizes: 3967kB, 7602kB, 11237kB, 14872kB.
Each data size is tested 5 times, hence the first 5 entries on the x-axis correspond to the 5 runs for the first data size of 3967kB and so on.
The table contains the values after scaling the original values up using the scaling factor 2.00. The table entries for BENCH and LIKWID have the unit 'MByte/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 3967kB | 41710.00 | 30784.93 | -26.19% | 41588.00 | 28907.91 | -30.49% | 41687.20 | 30370.03 | -27.15% |
| 7602kB | 41708.00 | 30785.49 | -26.19% | 41598.00 | 29081.37 | -30.09% | 41692.80 | 30402.08 | -27.08% |
| 11237kB | 41726.00 | 30767.87 | -26.26% | 41388.00 | 26673.47 | -35.55% | 41602.00 | 29254.81 | -29.69% |
| 14872kB | 41490.00 | 30484.21 | -26.53% | 38916.00 | 27110.53 | -30.34% | 40621.20 | 29295.48 | -27.91% |
Benchmark performed with data sizes: 12kB, 1MB, 4MB, 1GB.
Each data size is tested 5 times, hence the first 5 entries on the x-axis correspond to the 5 runs for the first data size of 12kB and so on.
The table contains the values after scaling the original values up using the scaling factor 11.00. The table entries for BENCH and LIKWID have the unit 'Instructions per branch'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 12kB | 11.00 | 10.95 | -0.43% | 11.00 | 10.95 | -0.43% | 11.00 | 10.95 | -0.43% |
| 1MB | 11.00 | 11.00 | -0.01% | 11.00 | 11.00 | -0.01% | 11.00 | 11.00 | -0.01% |
| 4MB | 11.00 | 11.00 | 0.00% | 11.00 | 11.00 | 0.00% | 11.00 | 11.00 | 0.00% |
| 1GB | 11.00 | 11.00 | 0.00% | 0.00 | 0.00 | 0.00% | 11.00 | 11.00 | 0.00% |
Benchmark performed with data sizes: 12kB, 1MB, 4MB, 1GB.
Each data size is tested 5 times, hence the first 5 entries on the x-axis correspond to the 5 runs for the first data size of 12kB and so on.
The table contains the values after scaling the original values up using the scaling factor 19.00. The table entries for BENCH and LIKWID have the unit 'Instructions per branch'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 12kB | 19.00 | 18.69 | -1.64% | 19.00 | 18.69 | -1.64% | 19.00 | 18.69 | -1.64% |
| 1MB | 19.00 | 19.00 | -0.02% | 19.00 | 19.00 | -0.02% | 19.00 | 19.00 | -0.02% |
| 4MB | 19.00 | 19.00 | -0.01% | 19.00 | 19.00 | -0.01% | 19.00 | 19.00 | -0.01% |
| 1GB | 19.00 | 19.00 | 0.00% | 19.00 | 19.00 | 0.00% | 19.00 | 19.00 | 0.00% |
Benchmark performed with data sizes: 12kB, 1MB, 4MB, 1GB.
Each data size is tested 5 times, hence the first 5 entries on the x-axis correspond to the 5 runs for the first data size of 12kB and so on.
The table contains the values after scaling the original values up using the scaling factor 11.00. The table entries for BENCH and LIKWID have the unit 'Instructions per branch'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 12kB | 11.00 | 10.96 | -0.38% | 11.00 | 10.96 | -0.38% | 11.00 | 10.96 | -0.38% |
| 1MB | 11.00 | 11.00 | 0.00% | 11.00 | 11.00 | 0.00% | 11.00 | 11.00 | 0.00% |
| 4MB | 11.00 | 11.00 | 0.00% | 11.00 | 11.00 | 0.00% | 11.00 | 11.00 | 0.00% |
| 1GB | 11.00 | 11.00 | 0.00% | 0.00 | 0.00 | 0.00% | 11.00 | 11.00 | 0.00% |
Benchmark performed with data sizes: 12kB, 1MB, 4MB, 1GB.
Each data size is tested 5 times, hence the first 5 entries on the x-axis correspond to the 5 runs for the first data size of 12kB and so on.
The table contains the values after scaling the original values up using the scaling factor 7.00. The table entries for BENCH and LIKWID have the unit 'Instructions per branch'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 12kB | 7.00 | 7.02 | 0.26% | 7.00 | 7.02 | 0.26% | 7.00 | 7.02 | 0.26% |
| 1MB | 7.00 | 7.00 | 0.00% | 7.00 | 7.00 | 0.00% | 7.00 | 7.00 | 0.00% |
| 4MB | 7.00 | 7.00 | 0.00% | 7.00 | 7.00 | 0.00% | 7.00 | 7.00 | 0.00% |
| 1GB | 7.00 | 7.00 | 0.00% | 0.00 | 0.00 | 0.00% | 7.00 | 7.00 | 0.00% |
Benchmark performed with data sizes: 12kB, 1MB, 4MB, 1GB.
Each data size is tested 5 times, hence the first 5 entries on the x-axis correspond to the 5 runs for the first data size of 12kB and so on.
The table contains the values after scaling the original values up using the scaling factor 19.00. The table entries for BENCH and LIKWID have the unit 'Instructions per branch'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 12kB | 19.00 | 18.77 | -1.19% | 19.00 | 18.77 | -1.19% | 19.00 | 18.77 | -1.19% |
| 1MB | 19.00 | 19.00 | -0.02% | 19.00 | 19.00 | -0.02% | 19.00 | 19.00 | -0.02% |
| 4MB | 19.00 | 19.00 | 0.00% | 19.00 | 19.00 | 0.00% | 19.00 | 19.00 | 0.00% |
| 1GB | 19.00 | 19.00 | 0.00% | 19.00 | 19.00 | 0.00% | 19.00 | 19.00 | 0.00% |
Benchmark performed with data sizes: 229989kB, 436017kB, 642045kB, 848073kB.
Each data size is tested 5 times, hence the first 5 entries on the x-axis correspond to the 5 runs for the first data size of 229989kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'Micro Ops'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 229989kB | 3449834880.00 | 3452886000.00 | 0.09% | 3449834880.00 | 3452929000.00 | 0.09% | 3449834880.00 | 3452904800.00 | 0.09% |
| 436017kB | 3270126720.00 | 3273021000.00 | 0.09% | 3270126720.00 | 3273265000.00 | 0.10% | 3270126720.00 | 3273095600.00 | 0.09% |
| 642045kB | 4815336960.00 | 4819556000.00 | 0.09% | 4815336960.00 | 4819626000.00 | 0.09% | 4815336960.00 | 4819586200.00 | 0.09% |
| 848073kB | 3180273600.00 | 3183087000.00 | 0.09% | 3180273600.00 | 3183138000.00 | 0.09% | 3180273600.00 | 3183113600.00 | 0.09% |
Benchmark performed with data sizes: 229989kB, 436017kB, 642045kB, 848073kB.
Each data size is tested 5 times, hence the first 5 entries on the x-axis correspond to the 5 runs for the first data size of 229989kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'Micro Ops'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 229989kB | 5979713792.00 | 5983033000.00 | 0.06% | 5979713792.00 | 5983107000.00 | 0.06% | 5979713792.00 | 5983061400.00 | 0.06% |
| 436017kB | 5668220480.00 | 5671343000.00 | 0.06% | 5668220480.00 | 5671436000.00 | 0.06% | 5668220480.00 | 5671388400.00 | 0.06% |
| 642045kB | 8346584896.00 | 8351239000.00 | 0.06% | 8346584896.00 | 8351374000.00 | 0.06% | 8346584896.00 | 8351314200.00 | 0.06% |
| 848073kB | 5512474240.00 | 5515548000.00 | 0.06% | 5512474240.00 | 5515667000.00 | 0.06% | 5512474240.00 | 5515615400.00 | 0.06% |
Benchmark performed with data sizes: 229989kB, 436017kB, 642045kB, 848073kB.
Each data size is tested 5 times, hence the first 5 entries on the x-axis correspond to the 5 runs for the first data size of 229989kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'Micro Ops'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 229989kB | 4139801856.00 | 4142443000.00 | 0.06% | 8279603712.00 | 8284981000.00 | 0.06% | 5795722598.40 | 5799477200.00 | 0.07% |
| 436017kB | 3924152640.00 | 3926592000.00 | 0.06% | 7848305280.00 | 7853165000.00 | 0.06% | 5493813696.00 | 5497308800.00 | 0.06% |
| 642045kB | 5778404928.00 | 5781944000.00 | 0.06% | 5778404928.00 | 5782024000.00 | 0.06% | 5778404928.00 | 5781976200.00 | 0.06% |
| 848073kB | 3816328320.00 | 3818782000.00 | 0.06% | 7632656640.00 | 7637465000.00 | 0.06% | 6106125312.00 | 6109998200.00 | 0.06% |
Benchmark performed with data sizes: 229989kB, 436017kB, 642045kB, 848073kB.
Each data size is tested 5 times, hence the first 5 entries on the x-axis correspond to the 5 runs for the first data size of 229989kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'Micro Ops'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 229989kB | 3986474752.00 | 3989718000.00 | 0.08% | 3986474752.00 | 3989952000.00 | 0.09% | 3986474752.00 | 3989824200.00 | 0.08% |
| 436017kB | 3778813376.00 | 3781911000.00 | 0.08% | 3778813376.00 | 3781971000.00 | 0.08% | 3778813376.00 | 3781935400.00 | 0.08% |
| 642045kB | 5564389376.00 | 5568922000.00 | 0.08% | 5564389376.00 | 5568990000.00 | 0.08% | 5564389376.00 | 5568950400.00 | 0.08% |
| 848073kB | 3674982688.00 | 3677944000.00 | 0.08% | 3674982688.00 | 3677994000.00 | 0.08% | 3674982688.00 | 3677960000.00 | 0.08% |
Benchmark performed with data sizes: 12kB, 24kB, 128kB, 2MB, 1GB.
Each data size is tested 10 times, hence the first 10 entries on the x-axis correspond to the 10 runs for the first data size of 12kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MFLOP/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 12kB | 6310.00 | 6193.03 | -1.85% | 6315.00 | 6197.15 | -1.87% | 6312.90 | 6195.39 | -1.86% |
| 24kB | 6435.00 | 6384.45 | -0.79% | 6435.00 | 6383.58 | -0.80% | 6435.00 | 6384.06 | -0.79% |
| 128kB | 3679.00 | 3679.03 | 0.00% | 3682.00 | 3682.96 | 0.03% | 3652.80 | 3653.32 | 0.01% |
| 2MB | 2189.00 | 2189.00 | 0.00% | 2192.00 | 2192.70 | 0.03% | 2191.40 | 2191.77 | 0.02% |
| 1GB | 780.00 | 780.02 | 0.00% | 788.00 | 788.82 | 0.10% | 786.60 | 786.91 | 0.04% |
Benchmark performed with data sizes: 12kB, 24kB, 128kB, 2MB, 1GB.
Each data size is tested 10 times, hence the first 10 entries on the x-axis correspond to the 10 runs for the first data size of 12kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MFLOP/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 12kB | 8262.00 | 8196.80 | -0.79% | 8263.00 | 8197.10 | -0.80% | 8260.50 | 8195.02 | -0.79% |
| 24kB | 8476.00 | 8476.18 | 0.00% | 8474.00 | 8474.91 | 0.01% | 8475.40 | 8475.78 | 0.00% |
| 128kB | 5019.00 | 5015.11 | -0.08% | 5195.00 | 5190.13 | -0.09% | 5160.20 | 5155.86 | -0.08% |
| 2MB | 2749.00 | 2749.01 | 0.00% | 2748.00 | 2748.81 | 0.03% | 2743.10 | 2743.57 | 0.02% |
| 1GB | 999.00 | 999.20 | 0.02% | 986.00 | 986.90 | 0.09% | 996.70 | 997.14 | 0.04% |
Benchmark performed with data sizes: 12kB, 24kB, 128kB, 2MB, 1GB.
Each data size is tested 10 times, hence the first 10 entries on the x-axis correspond to the 10 runs for the first data size of 12kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MFLOP/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 12kB | 16821.00 | 16687.35 | -0.79% | 16824.00 | 16689.44 | -0.80% | 16821.60 | 16687.51 | -0.80% |
| 24kB | 16868.00 | 16734.01 | -0.79% | 16866.00 | 16731.14 | -0.80% | 16866.10 | 16731.84 | -0.80% |
| 128kB | 6424.00 | 6418.51 | -0.09% | 6421.00 | 6414.72 | -0.10% | 6420.20 | 6414.27 | -0.09% |
| 2MB | 3727.00 | 3727.00 | 0.00% | 3726.00 | 3726.73 | 0.02% | 3713.10 | 3713.26 | 0.00% |
| 1GB | 1363.00 | 1363.54 | 0.04% | 1374.00 | 1374.90 | 0.07% | 1369.70 | 1370.40 | 0.05% |
Benchmark performed with data sizes: 12kB, 24kB, 128kB, 2MB, 1GB.
Each data size is tested 10 times, hence the first 10 entries on the x-axis correspond to the 10 runs for the first data size of 12kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MFLOP/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 12kB | 4239.00 | 4239.02 | 0.00% | 4239.00 | 4239.97 | 0.02% | 4239.10 | 4239.55 | 0.01% |
| 24kB | 4318.00 | 4318.19 | 0.00% | 4318.00 | 4318.91 | 0.02% | 4317.80 | 4318.37 | 0.01% |
| 128kB | 3454.00 | 3454.02 | 0.00% | 3450.00 | 3449.36 | -0.02% | 3446.10 | 3446.00 | 0.00% |
| 2MB | 2627.00 | 2627.14 | 0.01% | 2438.00 | 2438.88 | 0.04% | 2586.20 | 2586.74 | 0.02% |
| 1GB | 1002.00 | 1002.05 | 0.00% | 981.00 | 981.99 | 0.10% | 1000.40 | 1000.92 | 0.05% |
Benchmark performed with data sizes: 12kB, 24kB, 128kB, 2MB, 1GB.
Each data size is tested 10 times, hence the first 10 entries on the x-axis correspond to the 10 runs for the first data size of 12kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MFLOP/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 12kB | 6646.00 | 6593.80 | -0.79% | 6647.00 | 6593.83 | -0.80% | 6646.40 | 6593.77 | -0.79% |
| 24kB | 6609.00 | 6592.36 | -0.25% | 6612.00 | 6594.40 | -0.27% | 6611.20 | 6594.01 | -0.26% |
| 128kB | 5863.00 | 5863.04 | 0.00% | 6150.00 | 6150.94 | 0.02% | 5915.60 | 5916.12 | 0.01% |
| 2MB | 4583.00 | 4583.00 | 0.00% | 4580.00 | 4580.89 | 0.02% | 4580.50 | 4581.01 | 0.01% |
| 1GB | 1796.00 | 1796.08 | 0.00% | 1795.00 | 1795.93 | 0.05% | 1755.90 | 1756.37 | 0.03% |
Benchmark performed with data sizes: 12kB, 24kB, 128kB, 2MB, 1GB.
Each data size is tested 10 times, hence the first 10 entries on the x-axis correspond to the 10 runs for the first data size of 12kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MFLOP/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 12kB | 3305.00 | 3297.07 | -0.24% | 3306.00 | 3297.19 | -0.27% | 3305.90 | 3297.31 | -0.26% |
| 24kB | 3297.00 | 3297.01 | 0.00% | 3296.00 | 3296.98 | 0.03% | 3296.50 | 3296.92 | 0.01% |
| 128kB | 3203.00 | 3203.19 | 0.01% | 3198.00 | 3198.92 | 0.03% | 3203.90 | 3204.48 | 0.02% |
| 2MB | 3165.00 | 3164.99 | 0.00% | 3047.00 | 3047.87 | 0.03% | 3144.90 | 3145.24 | 0.01% |
| 1GB | 1674.00 | 1674.16 | 0.01% | 1664.00 | 1664.91 | 0.05% | 1638.30 | 1638.77 | 0.03% |
Benchmark performed with data sizes: 12kB, 24kB, 128kB, 2MB, 1GB.
Each data size is tested 10 times, hence the first 10 entries on the x-axis correspond to the 10 runs for the first data size of 12kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MFLOP/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 12kB | 13411.00 | 13161.43 | -1.86% | 13411.00 | 13160.65 | -1.87% | 13410.90 | 13160.86 | -1.86% |
| 24kB | 13284.00 | 13178.56 | -0.79% | 13283.00 | 13176.81 | -0.80% | 13283.40 | 13177.53 | -0.80% |
| 128kB | 10206.00 | 10206.21 | 0.00% | 10310.00 | 10310.97 | 0.01% | 10322.90 | 10323.42 | 0.01% |
| 2MB | 4946.00 | 4945.99 | 0.00% | 4950.00 | 4950.40 | 0.01% | 4945.00 | 4945.04 | 0.00% |
| 1GB | 1679.00 | 1679.03 | 0.00% | 1683.00 | 1683.90 | 0.05% | 1680.60 | 1681.04 | 0.03% |
Benchmark performed with data sizes: 12kB, 24kB, 128kB, 2MB, 1GB.
Each data size is tested 10 times, hence the first 10 entries on the x-axis correspond to the 10 runs for the first data size of 12kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MFLOP/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 12kB | 12172.00 | 12075.59 | -0.79% | 12177.00 | 12079.61 | -0.80% | 12186.50 | 12089.57 | -0.80% |
| 24kB | 12601.00 | 12568.33 | -0.26% | 12604.00 | 12570.54 | -0.27% | 12603.40 | 12570.26 | -0.26% |
| 128kB | 6013.00 | 6013.07 | 0.00% | 5968.00 | 5968.84 | 0.01% | 6007.80 | 6008.33 | 0.01% |
| 2MB | 4885.00 | 4885.00 | 0.00% | 4883.00 | 4883.92 | 0.02% | 4878.90 | 4879.46 | 0.01% |
| 1GB | 1868.00 | 1868.04 | 0.00% | 1787.00 | 1787.96 | 0.05% | 1844.30 | 1844.75 | 0.02% |
Benchmark performed with data sizes: 12kB, 24kB, 128kB, 2MB, 1GB.
Each data size is tested 10 times, hence the first 10 entries on the x-axis correspond to the 10 runs for the first data size of 12kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MFLOP/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 12kB | 12377.00 | 12146.77 | -1.86% | 12379.00 | 12147.91 | -1.87% | 12378.90 | 12148.40 | -1.86% |
| 24kB | 12555.00 | 12321.55 | -1.86% | 12566.00 | 12331.46 | -1.87% | 12562.80 | 12328.75 | -1.86% |
| 128kB | 4355.00 | 4355.07 | 0.00% | 4348.00 | 4348.95 | 0.02% | 4321.60 | 4322.24 | 0.01% |
| 2MB | 2211.00 | 2211.01 | 0.00% | 2210.00 | 2210.81 | 0.04% | 2211.40 | 2211.76 | 0.02% |
| 1GB | 799.00 | 799.06 | 0.01% | 787.00 | 787.86 | 0.11% | 796.00 | 796.52 | 0.07% |
Benchmark performed with data sizes: 12kB, 24kB, 128kB, 2MB, 1GB.
Each data size is tested 10 times, hence the first 10 entries on the x-axis correspond to the 10 runs for the first data size of 12kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MFLOP/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 12kB | 15432.00 | 15309.30 | -0.80% | 16351.00 | 16220.39 | -0.80% | 15737.60 | 15612.16 | -0.80% |
| 24kB | 16416.00 | 16285.60 | -0.79% | 16414.00 | 16283.08 | -0.80% | 16409.90 | 16279.29 | -0.80% |
| 128kB | 5165.00 | 5161.10 | -0.08% | 5353.00 | 5348.09 | -0.09% | 5276.90 | 5272.52 | -0.08% |
| 2MB | 2772.00 | 2771.97 | 0.00% | 2771.00 | 2771.82 | 0.03% | 2772.50 | 2772.98 | 0.02% |
| 1GB | 1011.00 | 1011.25 | 0.02% | 1010.00 | 1010.89 | 0.09% | 1007.40 | 1007.89 | 0.05% |
Benchmark performed with data sizes: 12kB, 24kB, 128kB, 2MB, 1GB.
Each data size is tested 10 times, hence the first 10 entries on the x-axis correspond to the 10 runs for the first data size of 12kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MFLOP/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 12kB | 6313.00 | 6297.09 | -0.25% | 6315.00 | 6298.16 | -0.27% | 6313.80 | 6297.37 | -0.26% |
| 24kB | 6434.00 | 6434.02 | 0.00% | 6434.00 | 6434.95 | 0.01% | 6434.00 | 6434.28 | 0.00% |
| 128kB | 4848.00 | 4848.06 | 0.00% | 4936.00 | 4936.85 | 0.02% | 4897.50 | 4897.92 | 0.01% |
| 2MB | 3191.00 | 3191.06 | 0.00% | 4028.00 | 4028.76 | 0.02% | 3870.30 | 3870.76 | 0.01% |
| 1GB | 1689.00 | 1689.05 | 0.00% | 1866.00 | 1866.86 | 0.05% | 1824.30 | 1824.79 | 0.03% |
Benchmark performed with data sizes: 12kB, 24kB, 128kB, 2MB, 1GB.
Each data size is tested 10 times, hence the first 10 entries on the x-axis correspond to the 10 runs for the first data size of 12kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MFLOP/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 12kB | 8438.00 | 8371.32 | -0.79% | 8439.00 | 8371.49 | -0.80% | 8439.20 | 8372.11 | -0.79% |
| 24kB | 8597.00 | 8575.02 | -0.26% | 8597.00 | 8574.26 | -0.26% | 8597.70 | 8575.39 | -0.26% |
| 128kB | 5891.00 | 5891.09 | 0.00% | 5888.00 | 5888.98 | 0.02% | 5890.10 | 5890.53 | 0.01% |
| 2MB | 3558.00 | 3558.00 | 0.00% | 3557.00 | 3557.84 | 0.02% | 3545.10 | 3545.66 | 0.02% |
| 1GB | 1371.00 | 1371.17 | 0.01% | 1368.00 | 1368.96 | 0.07% | 1378.20 | 1378.75 | 0.04% |
Benchmark performed with data sizes: 12kB, 24kB, 128kB, 2MB, 1GB.
Each data size is tested 10 times, hence the first 10 entries on the x-axis correspond to the 10 runs for the first data size of 12kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MFLOP/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 12kB | 3217.00 | 3192.20 | -0.77% | 3218.00 | 3192.28 | -0.80% | 3217.70 | 3192.32 | -0.79% |
| 24kB | 3251.00 | 3243.31 | -0.24% | 3252.00 | 3243.38 | -0.26% | 3251.80 | 3243.52 | -0.25% |
| 128kB | 2641.00 | 2641.00 | 0.00% | 2653.00 | 2653.98 | 0.04% | 2656.40 | 2656.80 | 0.02% |
| 2MB | 2056.00 | 2056.04 | 0.00% | 2056.00 | 2056.98 | 0.05% | 2028.90 | 2029.34 | 0.02% |
| 1GB | 789.00 | 789.00 | 0.00% | 787.00 | 787.98 | 0.12% | 787.20 | 787.72 | 0.07% |
Benchmark performed with data sizes: 12kB, 24kB, 128kB, 2MB, 1GB.
Each data size is tested 10 times, hence the first 10 entries on the x-axis correspond to the 10 runs for the first data size of 12kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MFLOP/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 12kB | 4299.00 | 4288.47 | -0.24% | 4300.00 | 4288.68 | -0.26% | 4299.80 | 4288.78 | -0.26% |
| 24kB | 4341.00 | 4341.27 | 0.01% | 4340.00 | 4340.96 | 0.02% | 4340.70 | 4341.41 | 0.02% |
| 128kB | 3737.00 | 3737.04 | 0.00% | 3551.00 | 3551.92 | 0.03% | 3698.00 | 3698.45 | 0.01% |
| 2MB | 3207.00 | 3207.02 | 0.00% | 3202.00 | 3202.98 | 0.03% | 3169.40 | 3169.86 | 0.01% |
| 1GB | 1415.00 | 1415.00 | 0.00% | 1414.00 | 1414.96 | 0.07% | 1407.10 | 1407.55 | 0.03% |
Benchmark performed with data sizes: 12kB, 24kB, 128kB, 2MB, 1GB.
Each data size is tested 10 times, hence the first 10 entries on the x-axis correspond to the 10 runs for the first data size of 12kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'MFLOP/s'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 12kB | 20186.00 | 19810.05 | -1.86% | 20187.00 | 19810.26 | -1.87% | 20187.70 | 19811.43 | -1.86% |
| 24kB | 20561.00 | 20397.35 | -0.80% | 20560.00 | 20395.51 | -0.80% | 20561.20 | 20397.10 | -0.80% |
| 128kB | 9928.00 | 9928.01 | 0.00% | 9941.00 | 9941.98 | 0.01% | 9966.80 | 9967.05 | 0.00% |
| 2MB | 5131.00 | 5131.06 | 0.00% | 5124.00 | 5124.48 | 0.01% | 5124.50 | 5124.64 | 0.00% |
| 1GB | 1799.00 | 1798.99 | 0.00% | 1793.00 | 1793.87 | 0.05% | 1803.70 | 1804.15 | 0.03% |
Benchmark performed with data sizes: 12kB, 1MB, 4MB, 1GB.
Each data size is tested 5 times, hence the first 5 entries on the x-axis correspond to the 5 runs for the first data size of 12kB and so on.
The table contains the values after scaling the original values up using the scaling factor 3.00. The table entries for BENCH and LIKWID have the unit 'Load/Store ratio'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 12kB | 3.00 | 2.98 | -0.70% | 3.00 | 2.98 | -0.70% | 3.00 | 2.98 | -0.70% |
| 1MB | 3.00 | 3.00 | -0.01% | 3.00 | 3.00 | -0.01% | 3.00 | 3.00 | -0.01% |
| 4MB | 3.00 | 3.00 | 0.00% | 3.00 | 3.00 | 0.00% | 3.00 | 3.00 | 0.00% |
| 1GB | 3.00 | 3.00 | 0.00% | 0.00 | 0.00 | 0.00% | 3.00 | 3.00 | 0.00% |
Benchmark performed with data sizes: 12kB, 1MB, 4MB, 1GB.
Each data size is tested 5 times, hence the first 5 entries on the x-axis correspond to the 5 runs for the first data size of 12kB and so on.
The table contains the values after scaling the original values up using the scaling factor 1.00. The table entries for BENCH and LIKWID have the unit 'Load/Store ratio'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 12kB | 1.00 | 1.01 | 0.53% | 1.00 | 1.01 | 0.53% | 1.00 | 1.01 | 0.53% |
| 1MB | 1.00 | 1.00 | 0.01% | 1.00 | 1.00 | 0.01% | 1.00 | 1.00 | 0.01% |
| 4MB | 1.00 | 1.00 | 0.00% | 0.00 | 0.00 | 0.00% | 1.00 | 1.00 | 0.00% |
| 1GB | 1.00 | 1.00 | 0.00% | 0.00 | 0.00 | 0.00% | 1.00 | 1.00 | 0.00% |
Benchmark performed with data sizes: 12kB, 1MB, 4MB, 1GB.
Each data size is tested 5 times, hence the first 5 entries on the x-axis correspond to the 5 runs for the first data size of 12kB and so on.
The table contains the values after scaling the original values up using the scaling factor 2.00. The table entries for BENCH and LIKWID have the unit 'Load/Store ratio'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 12kB | 2.00 | 2.00 | -0.10% | 2.00 | 2.00 | -0.10% | 2.00 | 2.00 | -0.10% |
| 1MB | 2.00 | 2.00 | 0.00% | 0.00 | 0.00 | 0.00% | 2.00 | 2.00 | 0.00% |
| 4MB | 2.00 | 2.00 | 0.00% | 0.00 | 0.00 | 0.00% | 2.00 | 2.00 | 0.00% |
| 1GB | 2.00 | 2.00 | 0.00% | 0.00 | 0.00 | 0.00% | 2.00 | 2.00 | 0.00% |
Benchmark performed with data sizes: 12kB, 1MB, 4MB, 1GB.
Each data size is tested 5 times, hence the first 5 entries on the x-axis correspond to the 5 runs for the first data size of 12kB and so on.
The table contains the values after scaling the original values up using the scaling factor 0.00. The table entries for BENCH and LIKWID have the unit 'Load/Store ratio'
| Variant | BENCH (Min) | LIKWID (Min) | Error (Min) | BENCH (Max) | LIKWID (Max) | Error (Max) | BENCH (Avg) | LIKWID (Avg) | Error (Avg) |
|---|---|---|---|---|---|---|---|---|---|
| 12kB | 0.00 | 0.00 | 0.00% | 0.00 | 0.00 | 0.00% | 0.00 | 0.01 | 0.00% |
| 1MB | 0.00 | 0.00 | 0.00% | 0.00 | 0.00 | 0.00% | 0.00 | 0.00 | 0.00% |
| 4MB | 0.00 | 0.00 | 0.00% | 0.00 | 0.00 | 0.00% | 0.00 | 0.00 | 0.00% |
| 1GB | 0.00 | 0.00 | 0.00% | 0.00 | 0.00 | 0.00% | 0.00 | 0.00 | 0.00% |