AccuracyIcelakeX

Accuracy Tests for Intel Icelake SP processor

Hardware description

CPU name: Intel(R) Xeon(R) Platinum 8368 CPU @ 2.40GHz
CPU stepping: 6
Sockets: 2
Cores per socket: 38
Threads per core: 2
Total number of processing units: 152

Available verification tests

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
MEM	load, load_avx512, triad_sse, stream, load_avx, copy_mem_avx, ddot, store_mem_avx, ddot_mem_avx, copy_sse, load_sse, stream_avx512, triad_avx, stream_avx, copy_avx, daxpy, store, stream_sse, triad_mem_avx, store_avx, daxpy_avx512, daxpy_sse, copy, triad_avx512, store_avx512, store_sse, daxpy_avx, ddot_avx512, daxpy_mem_avx, ddot_sse, copy_avx512, triad, ddot_avx, stream_mem_avx
MEM_FREERUN	load, load_avx512, triad_sse, stream, load_avx, copy_mem_avx, ddot, store_mem_avx, ddot_mem_avx, copy_sse, load_sse, stream_avx512, triad_avx, stream_avx, copy_avx, daxpy, store, stream_sse, triad_mem_avx, store_avx, daxpy_avx512, daxpy_sse, copy, triad_avx512, store_avx512, store_sse, daxpy_avx, ddot_avx512, daxpy_mem_avx, ddot_sse, copy_avx512, triad, ddot_avx, stream_mem_avx
FLOPS_DP	triad_sse, stream, ddot, sum, stream_avx512, triad_avx, stream_avx, daxpy_avx_fma, triad_avx_fma, daxpy, stream_sse, sum_avx, stream_avx_fma, daxpy_avx512, daxpy_sse, triad_avx512, sum_avx512, daxpy_avx, ddot_avx512, sum_sse, ddot_sse, triad, ddot_avx
FLOPS_SP	ddot_sp_sse, triad_sp_avx512, sum_sp_avx512, daxpy_sp_avx512, sum_sp_sse, sum_sp, ddot_sp_avx, triad_sp, ddot_sp_avx512, stream_sp_avx512, stream_sp_sse, ddot_sp, stream_sp, sum_sp_avx, triad_sp_avx, triad_sp_sse, daxpy_sp, daxpy_sp_avx, daxpy_sp_sse, stream_sp_avx
L3	load, copy, stream, ddot, triad, daxpy, store
L2	load, copy, stream, ddot, triad, daxpy, store

Information about the pictures

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.

Verification of Group MEM

Verification of Group MEM with Test load

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	12583.00	11354.95	-9.76%	12713.00	10859.74	-14.58%	12685.30	10947.41	-13.70%
471961kB	12506.00	11518.98	-7.89%	12512.00	11434.97	-8.61%	12503.50	11491.41	-8.09%
670002kB	12444.00	11856.49	-4.72%	12440.00	11833.60	-4.87%	12451.30	11853.99	-4.80%
868044kB	12471.00	12142.56	-2.63%	12459.00	12107.93	-2.82%	12462.00	12127.18	-2.69%

Verification of Group MEM with Test load_avx512

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	16768.00	14562.79	-13.15%	16778.00	14241.18	-15.12%	16784.50	14327.72	-14.64%
471961kB	16742.00	15253.27	-8.89%	16757.00	15182.67	-9.40%	16747.30	15231.39	-9.05%
670002kB	16688.00	15788.24	-5.39%	16686.00	15741.49	-5.66%	16683.50	15764.05	-5.51%
868044kB	16689.00	16116.34	-3.43%	16683.00	16092.96	-3.54%	16686.30	16105.69	-3.48%

Verification of Group MEM with Test triad_sse

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	17120.00	14141.46	-17.40%	17390.00	14045.35	-19.23%	17260.62	14058.43	-18.55%
471961kB	16583.75	14881.27	-10.27%	16682.50	14818.54	-11.17%	16647.12	14867.33	-10.69%
670002kB	16622.50	15507.11	-6.71%	16668.75	15513.64	-6.93%	16629.88	15491.46	-6.85%
868044kB	16382.50	15610.17	-4.71%	16386.25	15596.24	-4.82%	16392.00	15609.86	-4.77%

Verification of Group MEM with Test stream

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	16786.25	14216.80	-15.31%	17008.91	13967.13	-17.88%	16914.91	14061.47	-16.87%
471961kB	16479.59	14998.70	-8.99%	16432.92	14781.74	-10.05%	16464.26	14933.66	-9.30%
670002kB	16576.92	15447.27	-6.81%	16588.92	15435.16	-6.96%	16588.52	15449.31	-6.87%
868044kB	16150.26	15546.76	-3.74%	16163.60	15549.60	-3.80%	16162.26	15555.64	-3.75%

Verification of Group MEM with Test load_avx

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	16033.00	13914.13	-13.22%	16183.00	13709.79	-15.28%	16153.60	13762.72	-14.80%
471961kB	15848.00	14418.88	-9.02%	15846.00	14364.82	-9.35%	15848.10	14395.67	-9.16%
670002kB	15782.00	14902.94	-5.57%	15778.00	14873.82	-5.73%	15786.40	14901.27	-5.61%
868044kB	15800.00	15228.25	-3.62%	15782.00	15189.36	-3.76%	15788.60	15209.05	-3.67%

Verification of Group MEM with Test copy_mem_avx

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	22844.00	20329.63	-11.01%	23429.00	20131.46	-14.07%	23321.40	20168.42	-13.51%
471961kB	23528.00	21353.94	-9.24%	23593.00	21345.77	-9.52%	23551.80	21350.00	-9.35%
670002kB	22398.00	20874.21	-6.80%	22435.00	20856.52	-7.04%	22393.90	20852.40	-6.88%
868044kB	22708.00	21524.48	-5.21%	22741.00	21523.69	-5.35%	22713.60	21519.61	-5.26%

Verification of Group MEM with Test ddot

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	13221.00	11383.62	-13.90%	13198.00	11051.11	-16.27%	13265.00	11177.18	-15.74%
471961kB	11629.00	10559.83	-9.19%	11650.00	10509.94	-9.79%	11639.90	10538.16	-9.47%
670002kB	12598.00	11867.58	-5.80%	12643.00	11878.67	-6.05%	12616.40	11868.59	-5.93%
868044kB	11571.00	11218.82	-3.04%	11574.00	11212.83	-3.12%	11580.50	11224.51	-3.07%

Verification of Group MEM with Test store_mem_avx

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	26392.00	26396.54	0.02%	26389.00	26394.53	0.02%	26388.00	26392.91	0.02%
471961kB	26386.00	26390.15	0.02%	26381.00	26386.83	0.02%	26384.50	26389.40	0.02%
670002kB	26389.00	26392.97	0.02%	26387.00	26392.62	0.02%	26388.70	26393.42	0.02%
868044kB	26391.00	26395.10	0.02%	26391.00	26396.67	0.02%	26387.40	26392.12	0.02%

Verification of Group MEM with Test copy_sse

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	18976.50	16083.52	-15.25%	19156.50	15886.66	-17.07%	19069.20	15904.77	-16.59%
471961kB	17839.50	15967.65	-10.49%	17832.00	15923.66	-10.70%	17820.60	15929.98	-10.61%
670002kB	18352.50	17053.86	-7.08%	18336.00	16991.19	-7.33%	18336.00	17012.80	-7.22%
868044kB	17667.00	16834.70	-4.71%	17670.00	16821.91	-4.80%	17674.35	16835.69	-4.75%

Verification of Group MEM with Test load_sse

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	14282.00	12435.23	-12.93%	14486.00	12177.58	-15.94%	14381.10	12266.79	-14.70%
471961kB	14030.00	12870.76	-8.26%	14048.00	12829.30	-8.68%	14037.40	12857.28	-8.41%
670002kB	13860.00	13162.88	-5.03%	13864.00	13137.58	-5.24%	13861.30	13150.14	-5.13%
868044kB	13803.00	13415.21	-2.81%	13798.00	13398.62	-2.89%	13796.90	13403.25	-2.85%

Verification of Group MEM with Test stream_avx512

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	17880.89	14964.45	-16.31%	18163.55	14722.43	-18.95%	18014.75	14895.36	-17.31%
471961kB	17595.56	15944.64	-9.38%	17570.23	15759.22	-10.31%	17594.76	15884.35	-9.72%
670002kB	16900.91	15695.30	-7.13%	16902.24	15642.94	-7.45%	16900.91	15684.79	-7.20%
868044kB	17127.57	16442.02	-4.00%	17174.24	16464.90	-4.13%	17154.24	16453.86	-4.08%

Verification of Group MEM with Test triad_avx

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	17962.50	14749.81	-17.89%	18112.50	14663.03	-19.04%	18013.00	14644.81	-18.70%
471961kB	17256.25	15424.66	-10.61%	17227.50	15331.37	-11.01%	17232.88	15371.80	-10.80%
670002kB	16950.00	15783.80	-6.88%	17017.50	15805.56	-7.12%	16979.75	15793.48	-6.99%
868044kB	16935.00	16106.80	-4.89%	16905.00	16059.48	-5.00%	16923.38	16086.58	-4.94%

Verification of Group MEM with Test stream_avx

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	18267.54	15418.70	-15.60%	18490.20	15284.09	-17.34%	18452.61	15341.69	-16.86%
471961kB	17992.88	16382.43	-8.95%	17940.88	16159.85	-9.93%	17977.42	16316.48	-9.24%
670002kB	17532.90	16312.50	-6.96%	17576.89	16318.55	-7.16%	17546.76	16307.58	-7.06%
868044kB	17638.23	16953.93	-3.88%	17744.89	17022.14	-4.07%	17723.96	17028.03	-3.93%

Verification of Group MEM with Test copy_avx

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	19279.50	16291.44	-15.50%	19440.00	16145.43	-16.95%	19365.75	16146.57	-16.62%
471961kB	18445.50	16497.91	-10.56%	18415.50	16439.24	-10.73%	18428.25	16464.50	-10.66%
670002kB	18697.50	17345.13	-7.23%	18667.50	17283.17	-7.42%	18675.60	17309.79	-7.31%
868044kB	18273.00	17390.94	-4.83%	18300.00	17407.71	-4.88%	18287.25	17400.19	-4.85%

Verification of Group MEM with Test daxpy

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	27388.50	15647.44	-42.87%	27607.50	15325.80	-44.49%	27598.05	15418.91	-44.13%
471961kB	25014.00	15001.45	-40.03%	25014.00	14963.11	-40.18%	25022.70	14991.16	-40.09%
670002kB	26308.50	16305.85	-38.02%	26428.50	16361.32	-38.09%	26401.35	16357.09	-38.04%
868044kB	25044.00	15944.38	-36.33%	25047.00	15916.45	-36.45%	25045.05	15929.62	-36.40%

Verification of Group MEM with Test store

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	19790.00	17140.21	-13.39%	19874.00	16872.93	-15.10%	19850.20	16935.19	-14.68%
471961kB	19666.00	17951.83	-8.72%	19670.00	17804.97	-9.48%	19665.40	17913.24	-8.91%
670002kB	19584.00	18476.95	-5.65%	19576.00	18432.67	-5.84%	19585.00	18460.68	-5.74%
868044kB	19554.00	18760.96	-4.06%	19546.00	18728.24	-4.18%	19546.40	18747.89	-4.09%

Verification of Group MEM with Test stream_sse

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	17792.89	15070.62	-15.30%	17990.22	14867.87	-17.36%	17929.42	14949.29	-16.62%
471961kB	17506.23	15920.87	-9.06%	17490.23	15767.77	-9.85%	17517.43	15887.39	-9.31%
670002kB	17250.24	16083.87	-6.76%	17227.57	16013.49	-7.05%	17235.84	16051.63	-6.87%
868044kB	17131.57	16475.22	-3.83%	17208.90	16531.19	-3.94%	17162.50	16494.15	-3.89%

Verification of Group MEM with Test triad_mem_avx

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	18535.00	15706.57	-15.26%	18789.00	15541.08	-17.29%	18731.00	15595.70	-16.74%
471961kB	17773.00	15927.32	-10.38%	17819.00	15920.02	-10.66%	17823.20	15948.58	-10.52%
670002kB	17393.00	16164.83	-7.06%	17772.00	16472.64	-7.31%	17645.70	16380.28	-7.17%
868044kB	17421.00	16451.56	-5.56%	17409.00	16400.67	-5.79%	17405.70	16419.32	-5.67%

Verification of Group MEM with Test store_avx

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	20064.00	17366.28	-13.45%	20150.00	16918.74	-16.04%	20108.00	17096.07	-14.98%
471961kB	19860.00	18111.73	-8.80%	19884.00	18081.44	-9.07%	19875.80	18097.76	-8.95%
670002kB	19808.00	18664.10	-5.77%	19812.00	18646.64	-5.88%	19807.20	18652.73	-5.83%
868044kB	19776.00	18970.02	-4.08%	19770.00	18947.79	-4.16%	19773.00	18960.48	-4.11%

Verification of Group MEM with Test daxpy_avx512

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	31920.00	17844.29	-44.10%	32103.00	17705.57	-44.85%	32060.40	17786.32	-44.52%
471961kB	30979.50	18457.66	-40.42%	31054.50	18480.57	-40.49%	31028.55	18477.82	-40.45%
670002kB	30594.00	18893.78	-38.24%	30705.00	18931.01	-38.35%	30646.80	18914.66	-38.28%
868044kB	30691.50	19441.97	-36.65%	30744.00	19466.24	-36.68%	30701.25	19438.86	-36.68%

Verification of Group MEM with Test daxpy_sse

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	28890.00	16322.37	-43.50%	29349.00	16201.66	-44.80%	29198.70	16221.94	-44.44%
471961kB	26994.00	16058.21	-40.51%	27022.50	16036.21	-40.66%	27025.05	16072.02	-40.53%
670002kB	28029.00	17419.44	-37.85%	28131.00	17390.15	-38.18%	28041.90	17347.54	-38.14%
868044kB	26782.50	16996.32	-36.54%	27015.00	17127.34	-36.60%	26919.30	17086.54	-36.51%

Verification of Group MEM with Test copy

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	18558.00	15734.14	-15.22%	18730.50	15568.22	-16.88%	18681.00	15595.85	-16.51%
471961kB	17089.50	15350.08	-10.18%	17109.00	15247.35	-10.88%	17101.65	15338.55	-10.31%
670002kB	17859.00	16599.04	-7.06%	17911.50	16621.00	-7.20%	17881.65	16605.52	-7.14%
868044kB	16956.00	16155.18	-4.72%	16956.00	16142.09	-4.80%	16955.55	16150.12	-4.75%

Verification of Group MEM with Test triad_avx512

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	18306.25	14704.77	-19.67%	18697.50	14914.89	-20.23%	18399.88	14741.79	-19.88%
471961kB	17591.25	15751.94	-10.46%	17557.50	15631.41	-10.97%	17511.00	15631.04	-10.74%
670002kB	16905.00	15714.90	-7.04%	17165.00	15926.51	-7.22%	16977.50	15768.43	-7.12%
868044kB	16968.75	16130.06	-4.94%	17105.00	16242.28	-5.04%	17132.62	16280.35	-4.97%

Verification of Group MEM with Test store_avx512

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	20068.00	17315.01	-13.72%	20178.00	16984.87	-15.82%	20153.20	17078.23	-15.26%
471961kB	19888.00	18130.45	-8.84%	19890.00	18048.82	-9.26%	19895.20	18096.80	-9.04%
670002kB	19786.00	18649.61	-5.74%	19802.00	18644.08	-5.85%	19797.20	18648.61	-5.80%
868044kB	19760.00	18955.23	-4.07%	19770.00	18944.58	-4.18%	19765.80	18950.50	-4.12%

Verification of Group MEM with Test store_sse

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	20040.00	17380.44	-13.27%	20134.00	17022.64	-15.45%	20107.00	17102.18	-14.94%
471961kB	19886.00	18144.81	-8.76%	19878.00	18051.94	-9.19%	19895.00	18109.97	-8.97%
670002kB	19812.00	18679.09	-5.72%	19810.00	18646.93	-5.87%	19811.40	18665.11	-5.79%
868044kB	19778.00	18968.84	-4.09%	19772.00	18950.07	-4.16%	19775.20	18961.92	-4.11%

Verification of Group MEM with Test daxpy_avx

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	30093.00	17011.23	-43.47%	30286.50	16734.05	-44.75%	30240.90	16806.18	-44.43%
471961kB	28257.00	16830.96	-40.44%	28303.50	16819.56	-40.57%	28292.10	16831.40	-40.51%
670002kB	28969.50	17889.78	-38.25%	29265.00	18085.06	-38.20%	29130.60	18000.47	-38.21%
868044kB	28197.00	17882.92	-36.58%	28224.00	17868.06	-36.69%	28217.40	17887.71	-36.61%

Verification of Group MEM with Test ddot_avx512

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	15542.00	13279.55	-14.56%	15660.00	13091.08	-16.40%	15653.80	13157.66	-15.94%
471961kB	15189.00	13656.80	-10.09%	15225.00	13583.71	-10.78%	15194.80	13628.54	-10.31%
670002kB	14935.00	13994.86	-6.29%	14986.00	14031.39	-6.37%	14987.20	14039.58	-6.32%
868044kB	15113.00	14536.49	-3.81%	15132.00	14541.85	-3.90%	15121.50	14537.50	-3.86%

Verification of Group MEM with Test daxpy_mem_avx

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	27504.00	16791.73	-38.95%	27676.50	16693.44	-39.68%	27624.75	16722.51	-39.47%
471961kB	27426.00	17355.73	-36.72%	27448.50	17284.50	-37.03%	27436.35	17333.58	-36.82%
670002kB	27279.00	17558.35	-35.63%	27301.50	17549.93	-35.72%	27298.50	17561.43	-35.67%
868044kB	27078.00	17667.86	-34.75%	27130.50	17695.83	-34.78%	27097.80	17678.08	-34.76%

Verification of Group MEM with Test ddot_sse

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	13829.00	11909.25	-13.88%	14077.00	11618.61	-17.46%	13980.10	11753.44	-15.92%
471961kB	12857.00	11569.66	-10.01%	12856.00	11527.27	-10.34%	12851.90	11546.61	-10.16%
670002kB	13419.00	12610.19	-6.03%	13489.00	12631.73	-6.36%	13453.70	12621.85	-6.18%
868044kB	12761.00	12344.21	-3.27%	12771.00	12343.70	-3.35%	12771.00	12348.21	-3.31%

Verification of Group MEM with Test copy_avx512

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	12628.00	15637.94	23.84%	12538.00	15752.49	25.64%	12604.60	15666.87	24.30%
471961kB	12111.00	16180.51	33.60%	12114.00	16243.06	34.09%	12107.10	16204.39	33.84%
670002kB	12102.00	16790.46	38.74%	12138.00	16875.61	39.03%	12110.50	16818.09	38.87%
868044kB	11950.00	17035.46	42.56%	11976.00	17085.68	42.67%	11964.60	17062.68	42.61%

Verification of Group MEM with Test triad

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	16537.50	13426.99	-18.81%	16532.50	13278.95	-19.68%	16554.75	13346.27	-19.38%
471961kB	16016.25	14344.24	-10.44%	16111.25	14327.09	-11.07%	16050.38	14339.88	-10.66%
670002kB	16177.50	15089.75	-6.72%	16163.75	15053.86	-6.87%	16188.00	15089.85	-6.78%
868044kB	15708.75	14973.52	-4.68%	15736.25	14984.42	-4.78%	15729.75	14988.11	-4.71%

Verification of Group MEM with Test ddot_avx

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	14550.00	12419.58	-14.64%	14650.00	12230.28	-16.52%	14618.30	12260.13	-16.13%
471961kB	13550.00	12181.23	-10.10%	13561.00	12135.15	-10.51%	13562.90	12174.87	-10.23%
670002kB	14023.00	13155.46	-6.19%	14123.00	13205.21	-6.50%	14071.30	13180.04	-6.33%
868044kB	13513.00	13038.15	-3.51%	13515.00	13024.75	-3.63%	13518.30	13038.14	-3.55%

Verification of Group MEM with Test stream_mem_avx

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	19360.00	16900.01	-12.71%	19688.00	16555.22	-15.91%	19630.00	16628.47	-15.29%
471961kB	19189.00	17285.26	-9.92%	19227.00	17275.90	-10.15%	19213.80	17285.75	-10.03%
670002kB	18678.00	17312.29	-7.31%	18790.00	17383.90	-7.48%	18748.10	17360.09	-7.40%
868044kB	18715.00	17814.45	-4.81%	18712.00	17796.00	-4.90%	18723.40	17815.58	-4.85%

Verification of Group MEM_FREERUN

Verification of Group MEM_FREERUN with Test load

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	12597.00	11317.51	-10.16%	12697.00	10993.00	-13.42%	12680.00	11053.59	-12.82%
471961kB	12509.00	11557.93	-7.60%	12511.00	11535.31	-7.80%	12508.20	11543.56	-7.71%
670002kB	12446.00	11873.41	-4.60%	12456.00	11863.26	-4.76%	12453.00	11870.14	-4.68%
868044kB	12467.00	12142.30	-2.60%	12441.00	12107.97	-2.68%	12460.50	12133.22	-2.63%

Verification of Group MEM_FREERUN with Test load_avx512

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	16769.00	14706.12	-12.30%	16783.00	14183.56	-15.49%	16777.70	14459.41	-13.82%
471961kB	16745.00	15313.47	-8.55%	16746.00	15253.29	-8.91%	16744.50	15282.20	-8.73%
670002kB	16688.00	15802.11	-5.31%	16699.00	15772.64	-5.55%	16685.10	15779.13	-5.43%
868044kB	16682.00	16120.08	-3.37%	16687.00	16106.13	-3.48%	16684.70	16113.10	-3.43%

Verification of Group MEM_FREERUN with Test triad_sse

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	17140.00	14246.18	-16.88%	17256.25	14069.51	-18.47%	17238.38	14123.94	-18.07%
471961kB	16727.50	14971.53	-10.50%	16735.00	14922.78	-10.83%	16735.25	14950.95	-10.66%
670002kB	16551.25	15420.83	-6.83%	16503.75	15342.49	-7.04%	16575.88	15429.14	-6.92%
868044kB	16376.25	15592.48	-4.79%	16417.50	15618.15	-4.87%	16394.75	15603.56	-4.83%

Verification of Group MEM_FREERUN with Test stream

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	16671.58	14229.94	-14.65%	16898.24	14050.58	-16.85%	16812.51	14089.23	-16.20%
471961kB	16491.59	15050.78	-8.74%	16502.25	14969.66	-9.29%	16511.99	15052.14	-8.84%
670002kB	16694.25	15550.39	-6.85%	16694.25	15524.28	-7.01%	16698.52	15541.99	-6.93%
868044kB	16170.26	15569.87	-3.71%	16170.26	15550.18	-3.83%	16177.60	15568.87	-3.76%

Verification of Group MEM_FREERUN with Test load_avx

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	15987.00	13970.02	-12.62%	16045.00	13808.47	-13.94%	16039.20	13839.47	-13.71%
471961kB	15835.00	14474.83	-8.59%	15835.00	14423.30	-8.92%	15831.80	14441.10	-8.78%
670002kB	15787.00	14925.92	-5.45%	15771.00	14882.92	-5.63%	15781.90	14911.31	-5.52%
868044kB	15792.00	15226.40	-3.58%	15781.00	15194.14	-3.72%	15787.70	15213.89	-3.63%

Verification of Group MEM_FREERUN with Test copy_mem_avx

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	22896.00	20359.80	-11.08%	23242.00	20120.09	-13.43%	23171.10	20188.44	-12.87%
471961kB	23498.00	21358.62	-9.10%	23560.00	21337.27	-9.43%	23507.90	21346.17	-9.20%
670002kB	22222.00	20718.79	-6.76%	22366.00	20815.62	-6.93%	22269.60	20742.06	-6.86%
868044kB	22656.00	21465.49	-5.25%	22682.00	21473.83	-5.33%	22674.00	21474.40	-5.29%

Verification of Group MEM_FREERUN with Test ddot

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	12938.00	11314.01	-12.55%	13034.00	11065.27	-15.10%	13009.80	11137.16	-14.39%
471961kB	11635.00	10533.13	-9.47%	11635.00	10476.74	-9.96%	11632.50	10515.66	-9.60%
670002kB	12662.00	11927.85	-5.80%	12663.00	11897.51	-6.05%	12665.30	11915.57	-5.92%
868044kB	11585.00	11260.97	-2.80%	11591.00	11255.32	-2.90%	11587.30	11257.25	-2.85%

Verification of Group MEM_FREERUN with Test store_mem_avx

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	26388.00	26391.83	0.01%	26386.00	26390.75	0.02%	26388.80	26393.06	0.02%
471961kB	26387.00	26390.95	0.01%	26383.00	26388.50	0.02%	26384.50	26388.96	0.02%
670002kB	26390.00	26393.81	0.01%	26379.00	26384.25	0.02%	26388.00	26392.37	0.02%
868044kB	26387.00	26391.14	0.02%	26382.00	26387.10	0.02%	26383.50	26388.11	0.02%

Verification of Group MEM_FREERUN with Test copy_sse

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	18796.50	16033.22	-14.70%	18877.50	15837.43	-16.10%	18868.65	15934.78	-15.55%
471961kB	17826.00	15975.41	-10.38%	17854.50	15967.52	-10.57%	17836.50	15964.86	-10.49%
670002kB	18327.00	17022.31	-7.12%	18339.00	17018.42	-7.20%	18328.80	17015.89	-7.16%
868044kB	17695.50	16865.64	-4.69%	17698.50	16856.98	-4.75%	17701.35	16862.57	-4.74%

Verification of Group MEM_FREERUN with Test load_sse

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	14247.00	12534.88	-12.02%	14313.00	12376.26	-13.53%	14307.30	12419.78	-13.19%
471961kB	14023.00	12918.77	-7.87%	14037.00	12913.22	-8.01%	14031.10	12915.83	-7.95%
670002kB	13853.00	13173.12	-4.91%	13862.00	13164.06	-5.03%	13860.40	13172.80	-4.96%
868044kB	13800.00	13416.80	-2.78%	13800.00	13402.44	-2.88%	13800.20	13409.27	-2.83%

Verification of Group MEM_FREERUN with Test stream_avx512

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	17946.22	15129.14	-15.70%	18052.88	14855.46	-17.71%	17965.42	14938.63	-16.85%
471961kB	17462.23	15816.74	-9.42%	17476.90	15764.44	-9.80%	17481.83	15789.73	-9.68%
670002kB	16980.91	15765.79	-7.16%	17034.24	15783.17	-7.34%	17012.24	15782.95	-7.23%
868044kB	17175.57	16484.57	-4.02%	17156.90	16455.09	-4.09%	17165.44	16468.40	-4.06%

Verification of Group MEM_FREERUN with Test triad_avx

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	17821.25	14711.02	-17.45%	18120.00	14722.80	-18.75%	18052.00	14715.97	-18.48%
471961kB	17281.25	15487.65	-10.38%	17337.50	15457.70	-10.84%	17292.75	15457.87	-10.61%
670002kB	16861.25	15698.16	-6.90%	16916.25	15714.98	-7.10%	16976.75	15792.22	-6.98%
868044kB	16956.25	16126.48	-4.89%	16958.75	16108.32	-5.01%	16967.88	16128.28	-4.95%

Verification of Group MEM_FREERUN with Test stream_avx

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	18338.21	15450.70	-15.75%	18463.54	15338.79	-16.92%	18418.87	15342.83	-16.70%
471961kB	18036.88	16426.37	-8.93%	18026.22	16279.50	-9.69%	18037.15	16382.00	-9.18%
670002kB	17488.90	16276.39	-6.93%	17479.56	16242.03	-7.08%	17484.36	16260.24	-7.00%
868044kB	17623.56	16944.41	-3.85%	17642.23	16941.15	-3.97%	17629.03	16937.02	-3.93%

Verification of Group MEM_FREERUN with Test copy_avx

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	19297.50	16373.43	-15.15%	19411.50	16173.80	-16.68%	19404.15	16257.44	-16.22%
471961kB	18481.50	16537.41	-10.52%	18468.00	16477.13	-10.78%	18466.80	16492.53	-10.69%
670002kB	18546.00	17190.03	-7.31%	18661.50	17279.85	-7.40%	18639.75	17271.07	-7.34%
868044kB	18262.50	17381.55	-4.82%	18310.50	17406.64	-4.94%	18261.75	17373.11	-4.87%

Verification of Group MEM_FREERUN with Test daxpy

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	27267.00	15633.74	-42.66%	27453.00	15374.53	-44.00%	27420.15	15456.82	-43.63%
471961kB	25000.50	14972.99	-40.11%	25029.00	14952.41	-40.26%	25010.10	14959.33	-40.19%
670002kB	26553.00	16466.27	-37.99%	26644.50	16500.21	-38.07%	26573.85	16469.21	-38.02%
868044kB	25026.00	15939.16	-36.31%	25044.00	15937.45	-36.36%	25034.55	15936.92	-36.34%

Verification of Group MEM_FREERUN with Test store

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	19914.00	17284.44	-13.20%	19960.00	17092.08	-14.37%	19933.20	17132.35	-14.05%
471961kB	19680.00	17983.51	-8.62%	19680.00	17945.71	-8.81%	19681.60	17965.22	-8.72%
670002kB	19588.00	18474.82	-5.68%	19592.00	18446.95	-5.84%	19589.40	18463.48	-5.75%
868044kB	19566.00	18778.75	-4.02%	19560.00	18759.04	-4.09%	19564.60	18770.22	-4.06%

Verification of Group MEM_FREERUN with Test stream_sse

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	17758.22	15102.91	-14.95%	17971.55	14962.11	-16.75%	17874.89	14982.18	-16.18%
471961kB	17547.56	15958.49	-9.06%	17558.23	15824.40	-9.87%	17545.56	15929.46	-9.21%
670002kB	17258.24	16090.69	-6.77%	17298.23	16081.54	-7.03%	17276.37	16086.22	-6.89%
868044kB	17210.24	16536.60	-3.91%	17262.24	16570.41	-4.01%	17229.17	16546.90	-3.96%

Verification of Group MEM_FREERUN with Test triad_mem_avx

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	18464.00	15730.87	-14.80%	18749.00	15661.04	-16.47%	18625.20	15650.14	-15.97%
471961kB	17838.00	16049.96	-10.02%	17813.00	15958.44	-10.41%	17814.40	15993.07	-10.22%
670002kB	17516.00	16304.04	-6.92%	17660.00	16408.65	-7.09%	17583.00	16356.33	-6.98%
868044kB	17432.00	16471.17	-5.51%	17462.00	16471.00	-5.68%	17454.70	16476.07	-5.61%

Verification of Group MEM_FREERUN with Test store_avx

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	20202.00	17625.11	-12.76%	20282.00	17315.29	-14.63%	20263.60	17384.10	-14.21%
471961kB	19962.00	18230.10	-8.68%	19964.00	18181.63	-8.93%	19962.00	18195.64	-8.85%
670002kB	19814.00	18688.91	-5.68%	19806.00	18655.85	-5.81%	19820.00	18679.93	-5.75%
868044kB	19804.00	18997.74	-4.07%	19802.00	18980.05	-4.15%	19802.40	18989.28	-4.11%

Verification of Group MEM_FREERUN with Test daxpy_avx512

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	31521.00	17891.43	-43.24%	31950.00	17801.35	-44.28%	31818.15	17779.12	-44.12%
471961kB	31114.50	18566.57	-40.33%	31233.00	18632.50	-40.34%	31147.95	18573.09	-40.37%
670002kB	30699.00	18932.10	-38.33%	30915.00	19072.53	-38.31%	30836.70	19032.57	-38.28%
868044kB	30774.00	19476.34	-36.71%	30837.00	19512.91	-36.72%	30797.10	19487.02	-36.72%

Verification of Group MEM_FREERUN with Test daxpy_sse

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	29109.00	16536.71	-43.19%	29454.00	16427.78	-44.23%	29328.30	16413.69	-44.03%
471961kB	27034.50	16120.04	-40.37%	27090.00	16148.46	-40.39%	27052.35	16120.19	-40.41%
670002kB	27930.00	17273.04	-38.16%	28053.00	17315.95	-38.27%	28011.60	17312.51	-38.20%
868044kB	26812.50	17034.06	-36.47%	26833.50	17033.77	-36.52%	26819.70	17031.97	-36.49%

Verification of Group MEM_FREERUN with Test copy

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	18498.00	15781.14	-14.69%	18589.50	15599.35	-16.09%	18583.20	15670.23	-15.67%
471961kB	17052.00	15313.95	-10.19%	17085.00	15293.19	-10.49%	17073.30	15304.16	-10.36%
670002kB	17977.50	16710.24	-7.05%	17992.50	16695.94	-7.21%	17974.20	16690.09	-7.14%
868044kB	16951.50	16175.96	-4.58%	16957.50	16168.19	-4.65%	16956.60	16174.80	-4.61%

Verification of Group MEM_FREERUN with Test triad_avx512

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	18222.50	14650.09	-19.60%	18322.50	14630.82	-20.15%	18344.50	14710.86	-19.81%
471961kB	17422.50	15541.20	-10.80%	17415.00	15463.85	-11.20%	17600.62	15683.80	-10.89%
670002kB	16782.50	15600.24	-7.04%	17166.25	15926.78	-7.22%	16958.88	15745.18	-7.16%
868044kB	17012.50	16165.20	-4.98%	17055.00	16182.98	-5.11%	17120.38	16262.43	-5.01%

Verification of Group MEM_FREERUN with Test store_avx512

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	20208.00	17528.31	-13.26%	20310.00	17291.08	-14.86%	20281.40	17351.50	-14.45%
471961kB	19970.00	18252.82	-8.60%	19972.00	18165.14	-9.05%	19966.00	18209.02	-8.80%
670002kB	19834.00	18688.33	-5.78%	19844.00	18667.01	-5.93%	19843.20	18686.56	-5.83%
868044kB	19792.00	18994.12	-4.03%	19798.00	18970.33	-4.18%	19793.80	18982.24	-4.10%

Verification of Group MEM_FREERUN with Test store_sse

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	20168.00	17567.84	-12.89%	20232.00	17317.97	-14.40%	20209.60	17370.97	-14.05%
471961kB	19906.00	18200.11	-8.57%	19942.00	18162.85	-8.92%	19923.00	18179.53	-8.75%
670002kB	19808.00	18676.08	-5.71%	19816.00	18662.10	-5.82%	19815.20	18671.37	-5.77%
868044kB	19792.00	18981.80	-4.09%	19790.00	18965.36	-4.17%	19791.60	18974.98	-4.13%

Verification of Group MEM_FREERUN with Test daxpy_avx

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	29982.00	17070.05	-43.07%	30333.00	16942.81	-44.14%	30206.85	16961.15	-43.85%
471961kB	28273.50	16911.18	-40.19%	28357.50	16936.81	-40.27%	28290.15	16905.28	-40.24%
670002kB	29049.00	17953.73	-38.20%	29142.00	18008.49	-38.20%	29091.00	17973.99	-38.21%
868044kB	28146.00	17849.91	-36.58%	28167.00	17852.82	-36.62%	28147.20	17841.76	-36.61%

Verification of Group MEM_FREERUN with Test ddot_avx512

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	15412.00	13241.10	-14.09%	15577.00	13120.02	-15.77%	15478.60	13119.50	-15.24%
471961kB	15231.00	13683.53	-10.16%	15224.00	13632.60	-10.45%	15219.70	13656.05	-10.27%
670002kB	14963.00	14022.85	-6.28%	14989.00	14021.87	-6.45%	14975.60	14021.78	-6.37%
868044kB	15131.00	14556.52	-3.80%	15139.00	14552.08	-3.88%	15123.70	14541.87	-3.85%

Verification of Group MEM_FREERUN with Test daxpy_mem_avx

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	27538.50	16938.80	-38.49%	27685.50	16826.05	-39.22%	27602.70	16800.53	-39.13%
471961kB	27354.00	17324.84	-36.66%	27379.50	17292.34	-36.84%	27369.30	17324.55	-36.70%
670002kB	27106.50	17429.34	-35.70%	27243.00	17493.74	-35.79%	27176.55	17472.24	-35.71%
868044kB	27087.00	17678.31	-34.74%	27120.00	17680.66	-34.81%	27109.50	17685.97	-34.76%

Verification of Group MEM_FREERUN with Test ddot_sse

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	13869.00	11962.17	-13.75%	13988.00	11798.37	-15.65%	13958.20	11830.27	-15.24%
471961kB	12847.00	11588.37	-9.80%	12870.00	11558.94	-10.19%	12843.90	11568.85	-9.93%
670002kB	13435.00	12606.47	-6.17%	13437.00	12595.16	-6.27%	13417.60	12581.96	-6.23%
868044kB	12765.00	12341.31	-3.32%	12768.00	12335.80	-3.39%	12766.80	12338.26	-3.36%

Verification of Group MEM_FREERUN with Test copy_avx512

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	12562.00	15651.92	24.60%	12494.00	15852.47	26.88%	12583.80	15747.79	25.14%
471961kB	12140.00	16281.24	34.11%	12124.00	16300.42	34.45%	12135.40	16293.96	34.27%
670002kB	12083.00	16774.74	38.83%	12116.00	16846.75	39.05%	12109.80	16821.98	38.91%
868044kB	11948.00	17048.98	42.69%	11992.00	17119.72	42.76%	11982.50	17096.83	42.68%

Verification of Group MEM_FREERUN with Test triad

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	16472.50	13481.60	-18.16%	16606.25	13386.92	-19.39%	16534.62	13376.72	-19.10%
471961kB	15933.75	14325.55	-10.09%	16041.25	14284.65	-10.95%	15990.38	14304.37	-10.54%
670002kB	16086.25	15006.60	-6.71%	16068.75	14946.07	-6.99%	16096.12	14998.40	-6.82%
868044kB	15781.25	15041.47	-4.69%	15788.75	15036.75	-4.76%	15761.25	15016.13	-4.73%

Verification of Group MEM_FREERUN with Test ddot_avx

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	14436.00	12463.43	-13.66%	14548.00	12304.94	-15.42%	14539.90	12344.69	-15.10%
471961kB	13544.00	12234.87	-9.67%	13552.00	12193.00	-10.03%	13551.90	12225.55	-9.79%
670002kB	14063.00	13176.39	-6.30%	14080.00	13180.17	-6.39%	14069.90	13178.65	-6.33%
868044kB	13502.00	13021.52	-3.56%	13496.00	13009.22	-3.61%	13500.00	13016.82	-3.58%

Verification of Group MEM_FREERUN with Test stream_mem_avx

Benchmark performed with data sizes: 273919kB, 471961kB, 670002kB, 868044kB.

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 273919kB 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)
273919kB	19357.00	16915.05	-12.62%	19571.00	16664.71	-14.85%	19560.80	16724.22	-14.50%
471961kB	19232.00	17406.48	-9.49%	19248.00	17363.03	-9.79%	19265.30	17404.17	-9.66%
670002kB	18944.00	17582.43	-7.19%	19073.00	17678.43	-7.31%	19006.70	17626.54	-7.26%
868044kB	18718.00	17840.99	-4.69%	18686.00	17775.09	-4.87%	18706.80	17810.98	-4.79%

Verification of Group FLOPS_DP

Verification of Group FLOPS_DP with Test triad_sse

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	8011.00	8010.99	0.00%	8011.00	8011.94	0.01%	8010.70	8011.16	0.01%
24kB	8153.00	8153.12	0.00%	8145.00	8145.89	0.01%	8156.50	8157.01	0.01%
128kB	3920.00	3920.32	0.01%	3920.00	3920.94	0.02%	3919.80	3920.44	0.02%
2MB	2012.00	2011.99	0.00%	2011.00	2011.97	0.05%	2016.00	2016.50	0.03%
1GB	819.00	819.11	0.01%	821.00	821.94	0.11%	819.90	820.25	0.04%

Verification of Group FLOPS_DP with Test stream

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	5649.00	5649.02	0.00%	5638.00	5638.96	0.02%	5641.70	5642.08	0.01%
24kB	5583.00	5583.04	0.00%	5583.00	5583.89	0.02%	5582.20	5582.79	0.01%
128kB	4112.00	4112.08	0.00%	4111.00	4111.97	0.02%	4111.30	4111.95	0.02%
2MB	2525.00	2525.01	0.00%	2545.00	2545.80	0.03%	2544.30	2544.72	0.02%
1GB	1020.00	1020.03	0.00%	1018.00	1018.87	0.09%	1019.30	1019.81	0.05%

Verification of Group FLOPS_DP with Test ddot

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	6168.00	6168.16	0.00%	6169.00	6169.91	0.01%	6168.50	6168.97	0.01%
24kB	6189.00	6189.11	0.00%	6188.00	6188.90	0.01%	6188.80	6189.23	0.01%
128kB	4420.00	4420.06	0.00%	4424.00	4424.79	0.02%	4426.60	4427.01	0.01%
2MB	3563.00	3563.00	0.00%	3558.00	3558.85	0.02%	3558.60	3559.14	0.02%
1GB	1486.00	1486.15	0.01%	1488.00	1488.62	0.04%	1487.00	1487.38	0.03%

Verification of Group FLOPS_DP with Test sum

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	5997.00	5997.10	0.00%	5996.00	5996.94	0.02%	6000.40	6000.98	0.01%
24kB	6088.00	6088.07	0.00%	6087.00	6087.87	0.01%	6090.30	6090.65	0.01%
128kB	3324.00	3324.10	0.00%	3324.00	3324.73	0.02%	3324.80	3325.28	0.01%
2MB	3064.00	3064.05	0.00%	3058.00	3058.81	0.03%	3061.10	3061.51	0.01%
1GB	1523.00	1523.07	0.00%	1522.00	1522.82	0.05%	1522.20	1522.67	0.03%

Verification of Group FLOPS_DP with Test stream_avx512

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	14869.00	14869.19	0.00%	14776.00	14776.85	0.01%	14784.70	14785.23	0.00%
24kB	15368.00	15367.97	0.00%	15368.00	15368.89	0.01%	15373.10	15373.61	0.00%
128kB	6166.00	6166.00	0.00%	6157.00	6157.70	0.01%	6168.70	6168.99	0.00%
2MB	2460.00	2460.01	0.00%	2436.00	2436.97	0.04%	2442.70	2443.35	0.03%
1GB	1066.00	1066.17	0.02%	1066.00	1066.77	0.07%	1066.00	1066.40	0.04%

Verification of Group FLOPS_DP with Test triad_avx

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	14745.00	14745.04	0.00%	14807.00	14807.92	0.01%	14765.60	14766.12	0.00%
24kB	15376.00	15375.99	0.00%	15186.00	15186.88	0.01%	15200.60	15200.92	0.00%
128kB	6596.00	6596.03	0.00%	6596.00	6596.96	0.01%	6596.00	6596.44	0.01%
2MB	2038.00	2038.01	0.00%	2043.00	2043.95	0.05%	2041.40	2041.88	0.02%
1GB	846.00	846.04	0.00%	847.00	847.83	0.10%	845.40	845.93	0.06%

Verification of Group FLOPS_DP with Test stream_avx

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	18053.00	18052.99	0.00%	18049.00	18049.94	0.01%	18060.20	18060.64	0.00%
24kB	18821.00	18821.02	0.00%	18820.00	18820.94	0.00%	18824.10	18824.59	0.00%
128kB	8763.00	8763.19	0.00%	8755.00	8755.91	0.01%	8758.30	8758.84	0.01%
2MB	2663.00	2663.15	0.01%	2662.00	2662.98	0.04%	2662.60	2663.23	0.02%
1GB	1098.00	1098.28	0.03%	1097.00	1097.87	0.08%	1097.50	1097.98	0.04%

Verification of Group FLOPS_DP with Test daxpy_avx_fma

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	22008.00	22008.00	0.00%	22009.00	22009.77	0.00%	22008.20	22008.45	0.00%
24kB	22607.00	22607.01	0.00%	22608.00	22608.82	0.00%	22613.20	22613.70	0.00%
128kB	11114.00	11114.15	0.00%	11112.00	11112.95	0.01%	11112.70	11113.20	0.00%
2MB	3953.00	3952.99	0.00%	3950.00	3950.84	0.02%	3945.20	3945.61	0.01%
1GB	1659.00	1659.27	0.02%	1658.00	1658.97	0.06%	1658.40	1659.09	0.04%

Verification of Group FLOPS_DP with Test triad_avx_fma

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	15213.00	15213.30	0.00%	15208.00	15208.81	0.01%	15212.00	15212.60	0.00%
24kB	15649.00	15649.01	0.00%	15652.00	15652.88	0.01%	15656.40	15656.93	0.00%
128kB	6600.00	6600.26	0.00%	6608.00	6608.97	0.01%	6606.60	6607.19	0.01%
2MB	2039.00	2039.00	0.00%	2042.00	2042.90	0.04%	2040.50	2040.90	0.02%
1GB	853.00	853.07	0.01%	853.00	853.93	0.11%	851.10	851.49	0.05%

Verification of Group FLOPS_DP with Test daxpy

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	5541.00	5541.31	0.01%	5541.00	5541.94	0.02%	5540.00	5540.75	0.01%
24kB	5636.00	5636.00	0.00%	5635.00	5635.97	0.02%	5635.40	5635.99	0.01%
128kB	4404.00	4404.07	0.00%	4403.00	4403.97	0.02%	4403.50	4403.98	0.01%
2MB	3416.00	3416.05	0.00%	3413.00	3413.91	0.03%	3412.40	3412.91	0.01%
1GB	1401.00	1401.02	0.00%	1402.00	1402.91	0.06%	1401.50	1401.99	0.03%

Verification of Group FLOPS_DP with Test stream_sse

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	10855.00	10855.13	0.00%	10853.00	10853.95	0.01%	10854.20	10854.79	0.01%
24kB	11175.00	11175.07	0.00%	11174.00	11174.89	0.01%	11172.70	11173.14	0.00%
128kB	5666.00	5665.99	0.00%	5663.00	5663.98	0.02%	5665.50	5666.01	0.01%
2MB	2656.00	2656.01	0.00%	2657.00	2657.93	0.03%	2660.80	2661.22	0.02%
1GB	1072.00	1072.00	0.00%	1071.00	1071.92	0.09%	1071.30	1071.97	0.06%

Verification of Group FLOPS_DP with Test sum_avx

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	21718.00	21718.02	0.00%	21715.00	21715.75	0.00%	21728.40	21728.78	0.00%
24kB	22477.00	22476.99	0.00%	22475.00	22475.80	0.00%	22509.00	22509.50	0.00%
128kB	12472.00	12472.13	0.00%	12471.00	12471.94	0.01%	12471.80	12472.30	0.00%
2MB	4307.00	4307.07	0.00%	4554.00	4554.95	0.02%	4354.80	4355.30	0.01%
1GB	1913.00	1912.99	0.00%	1912.00	1912.95	0.05%	1912.60	1913.19	0.03%

Verification of Group FLOPS_DP with Test stream_avx_fma

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	20595.00	20595.09	0.00%	20590.00	20590.90	0.00%	20593.10	20593.64	0.00%
24kB	21930.00	21929.95	0.00%	22112.00	22112.84	0.00%	21951.10	21951.63	0.00%
128kB	8791.00	8791.01	0.00%	8786.00	8786.87	0.01%	8789.30	8789.67	0.00%
2MB	2690.00	2690.06	0.00%	2690.00	2690.91	0.03%	2690.20	2690.65	0.02%
1GB	1107.00	1107.11	0.01%	1105.00	1105.89	0.08%	1105.60	1106.25	0.06%

Verification of Group FLOPS_DP with Test daxpy_avx512

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	15114.00	15113.98	0.00%	15128.00	15128.92	0.01%	15168.30	15168.84	0.00%
24kB	15665.00	15665.13	0.00%	15645.00	15645.92	0.01%	15651.00	15651.55	0.00%
128kB	8858.00	8858.01	0.00%	8859.00	8859.94	0.01%	8859.30	8859.82	0.01%
2MB	3640.00	3640.46	0.01%	3637.00	3637.96	0.03%	3636.10	3636.80	0.02%
1GB	1686.00	1686.05	0.00%	1685.00	1685.90	0.05%	1686.40	1686.88	0.03%

Verification of Group FLOPS_DP with Test daxpy_sse

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	11260.00	11260.02	0.00%	11275.00	11275.55	0.00%	11275.70	11275.96	0.00%
24kB	11087.00	11087.21	0.00%	11084.00	11084.86	0.01%	11084.70	11085.29	0.01%
128kB	5934.00	5934.02	0.00%	5933.00	5933.85	0.01%	5934.30	5934.67	0.01%
2MB	3795.00	3794.99	0.00%	3800.00	3800.94	0.02%	3791.60	3792.05	0.01%
1GB	1508.00	1508.03	0.00%	1508.00	1508.94	0.06%	1508.30	1508.70	0.03%

Verification of Group FLOPS_DP with Test triad_avx512

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	11395.00	11394.98	0.00%	11394.00	11394.84	0.01%	11665.10	11665.51	0.00%
24kB	11593.00	11593.12	0.00%	11591.00	11591.83	0.01%	11595.50	11596.01	0.00%
128kB	5551.00	5551.06	0.00%	5696.00	5696.92	0.02%	5720.50	5720.93	0.01%
2MB	1916.00	1916.06	0.00%	1870.00	1870.96	0.05%	1906.90	1907.25	0.02%
1GB	852.00	852.01	0.00%	860.00	860.85	0.10%	853.00	853.40	0.05%

Verification of Group FLOPS_DP with Test sum_avx512

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	22084.00	22084.07	0.00%	22100.00	22100.89	0.00%	22133.50	22134.01	0.00%
24kB	22350.00	22350.05	0.00%	22338.00	22338.79	0.00%	22360.90	22361.17	0.00%
128kB	14948.00	14948.01	0.00%	14930.00	14930.81	0.01%	14948.10	14948.29	0.00%
2MB	4172.00	4172.04	0.00%	4097.00	4097.97	0.02%	4172.80	4173.39	0.01%
1GB	2005.00	2005.07	0.00%	2005.00	2005.89	0.04%	2005.30	2005.87	0.03%

Verification of Group FLOPS_DP with Test daxpy_avx

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	19983.00	19982.95	0.00%	19965.00	19965.72	0.00%	19977.40	19977.72	0.00%
24kB	20475.00	20474.97	0.00%	20472.00	20472.85	0.00%	20473.30	20473.67	0.00%
128kB	10454.00	10453.99	0.00%	10452.00	10452.91	0.01%	10450.60	10451.02	0.00%
2MB	3951.00	3951.02	0.00%	3938.00	3938.89	0.02%	3947.80	3948.23	0.01%
1GB	1575.00	1574.99	0.00%	1573.00	1573.94	0.06%	1573.90	1574.19	0.02%

Verification of Group FLOPS_DP with Test ddot_avx512

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	22337.00	22337.01	0.00%	22335.00	22335.74	0.00%	22283.50	22283.78	0.00%
24kB	22665.00	22665.01	0.00%	22552.00	22552.68	0.00%	22583.50	22583.85	0.00%
128kB	14775.00	14774.96	0.00%	14772.00	14772.92	0.01%	14772.90	14773.41	0.00%
2MB	3873.00	3873.31	0.01%	3870.00	3870.89	0.02%	3878.80	3879.44	0.02%
1GB	1861.00	1861.06	0.00%	1862.00	1862.79	0.04%	1860.70	1861.01	0.02%

Verification of Group FLOPS_DP with Test sum_sse

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	11870.00	11869.99	0.00%	11870.00	11870.86	0.01%	11869.50	11869.94	0.00%
24kB	11885.00	11884.95	0.00%	11922.00	11922.81	0.01%	11893.40	11893.78	0.00%
128kB	6098.00	6097.99	0.00%	6097.00	6097.91	0.01%	6097.20	6097.68	0.01%
2MB	3951.00	3951.28	0.01%	3937.00	3937.93	0.02%	3948.80	3949.46	0.02%
1GB	1678.00	1678.06	0.00%	1677.00	1677.93	0.06%	1677.10	1677.56	0.03%

Verification of Group FLOPS_DP with Test ddot_sse

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	12053.00	12053.11	0.00%	12048.00	12048.92	0.01%	12063.00	12063.47	0.00%
24kB	12151.00	12151.01	0.00%	12096.00	12096.82	0.01%	12132.60	12133.00	0.00%
128kB	6190.00	6190.06	0.00%	6190.00	6190.87	0.01%	6190.30	6190.74	0.01%
2MB	4020.00	4020.08	0.00%	4015.00	4015.95	0.02%	4019.00	4019.41	0.01%
1GB	1615.00	1615.00	0.00%	1615.00	1615.98	0.06%	1616.50	1617.03	0.03%

Verification of Group FLOPS_DP with Test triad

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	4126.00	4126.05	0.00%	4125.00	4125.97	0.02%	4125.40	4125.91	0.01%
24kB	4158.00	4158.08	0.00%	4156.00	4156.76	0.02%	4156.60	4157.13	0.01%
128kB	2948.00	2948.11	0.00%	2945.00	2945.92	0.03%	2946.40	2946.83	0.01%
2MB	1955.00	1955.06	0.00%	1948.00	1948.89	0.05%	1951.40	1951.90	0.03%
1GB	788.00	788.04	0.00%	786.00	786.92	0.12%	787.50	787.91	0.05%

Verification of Group FLOPS_DP with Test ddot_avx

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	22159.00	22158.99	0.00%	22167.00	22167.88	0.00%	22242.60	22242.95	0.00%
24kB	22976.00	22976.01	0.00%	22997.00	22997.84	0.00%	22992.70	22993.10	0.00%
128kB	12034.00	12034.01	0.00%	12038.00	12038.74	0.01%	12037.60	12037.88	0.00%
2MB	4201.00	4201.02	0.00%	4156.00	4156.87	0.02%	4164.60	4164.95	0.01%
1GB	1703.00	1703.05	0.00%	1703.00	1703.77	0.05%	1703.60	1703.92	0.02%

Verification of Group FLOPS_SP

Verification of Group FLOPS_SP with Test ddot_sp_sse

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	13167.00	13167.00	0.00%	13154.00	13154.82	0.01%	13157.50	13157.89	0.00%
128kB	12760.00	12760.16	0.00%	12760.00	12760.63	0.00%	12758.80	12759.23	0.00%
2MB	9445.00	9445.10	0.00%	8729.00	8729.83	0.01%	9104.10	9104.53	0.00%
1GB	3272.00	3272.05	0.00%	3270.00	3270.87	0.03%	3272.00	3272.53	0.02%

Verification of Group FLOPS_SP with Test triad_sp_avx512

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	23137.00	23136.98	0.00%	23135.00	23135.82	0.00%	23275.30	23275.57	0.00%
128kB	12824.00	12823.99	0.00%	12865.00	12865.91	0.01%	12866.90	12867.26	0.00%
2MB	4061.00	4061.08	0.00%	4036.00	4036.90	0.02%	4004.50	4004.99	0.01%
1GB	1713.00	1713.19	0.01%	1713.00	1713.84	0.05%	1724.50	1724.95	0.03%

Verification of Group FLOPS_SP with Test sum_sp_avx512

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	43667.00	43667.01	0.00%	43676.00	43676.71	0.00%	43685.20	43685.35	0.00%
128kB	33650.00	33649.96	0.00%	33785.00	33785.94	0.00%	33583.80	33584.23	0.00%
2MB	8208.00	8208.06	0.00%	8249.00	8249.94	0.01%	8211.50	8211.90	0.00%
1GB	4018.00	4018.03	0.00%	4019.00	4019.77	0.02%	4020.40	4020.69	0.01%

Verification of Group FLOPS_SP with Test daxpy_sp_avx512

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	31103.00	31102.96	0.00%	31032.00	31032.75	0.00%	31055.00	31055.26	0.00%
128kB	17588.00	17588.04	0.00%	17586.00	17586.89	0.01%	17582.50	17582.92	0.00%
2MB	7272.00	7272.06	0.00%	7346.00	7346.89	0.01%	7335.50	7335.96	0.01%
1GB	3389.00	3388.99	0.00%	3387.00	3387.97	0.03%	3388.20	3388.78	0.02%

Verification of Group FLOPS_SP with Test sum_sp_sse

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	23785.00	23785.02	0.00%	23782.00	23782.90	0.00%	23791.40	23791.72	0.00%
128kB	12146.00	12146.01	0.00%	12147.00	12147.69	0.01%	12150.20	12150.48	0.00%
2MB	7972.00	7972.18	0.00%	8042.00	8042.87	0.01%	8020.60	8021.15	0.01%
1GB	3351.00	3351.02	0.00%	3352.00	3352.87	0.03%	3352.60	3353.02	0.01%

Verification of Group FLOPS_SP with Test sum_sp

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	3195.00	3194.99	0.00%	3195.00	3195.97	0.03%	3195.10	3195.75	0.02%
128kB	3187.00	3187.05	0.00%	3186.00	3186.98	0.03%	3186.30	3186.81	0.02%
2MB	3183.00	3183.04	0.00%	3182.00	3182.75	0.02%	3182.90	3183.34	0.01%
1GB	2359.00	2359.05	0.00%	2358.00	2358.94	0.04%	2359.20	2359.57	0.02%

Verification of Group FLOPS_SP with Test ddot_sp_avx

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	26403.00	26402.94	0.00%	26402.00	26402.93	0.00%	26396.60	26397.12	0.00%
128kB	24390.00	24390.03	0.00%	24377.00	24377.75	0.00%	24387.50	24388.03	0.00%
2MB	8467.00	8467.01	0.00%	9120.00	9120.96	0.01%	8877.80	8878.24	0.00%
1GB	3429.00	3429.06	0.00%	3432.00	3432.88	0.03%	3431.80	3432.21	0.01%

Verification of Group FLOPS_SP with Test triad_sp

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	4165.00	4164.98	0.00%	4164.00	4164.79	0.02%	4164.10	4164.45	0.01%
128kB	3803.00	3803.04	0.00%	3802.00	3802.97	0.03%	3803.20	3803.63	0.01%
2MB	3460.00	3460.01	0.00%	3454.00	3454.88	0.03%	3456.60	3457.01	0.01%
1GB	1535.00	1535.05	0.00%	1540.00	1540.90	0.06%	1535.20	1535.68	0.03%

Verification of Group FLOPS_SP with Test ddot_sp_avx512

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	44301.00	44300.99	0.00%	44194.00	44194.65	0.00%	44232.20	44232.47	0.00%
128kB	30101.00	30100.95	0.00%	30111.00	30111.84	0.00%	30109.50	30109.82	0.00%
2MB	8104.00	8104.04	0.00%	8370.00	8370.80	0.01%	8026.40	8026.84	0.01%
1GB	3729.00	3729.11	0.00%	3734.00	3734.96	0.03%	3732.60	3733.25	0.02%

Verification of Group FLOPS_SP with Test stream_sp_avx512

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	30748.00	30747.97	0.00%	30721.00	30721.80	0.00%	30754.00	30754.36	0.00%
128kB	12308.00	12308.15	0.00%	12320.00	12320.87	0.01%	12320.90	12321.45	0.00%
2MB	4879.00	4879.01	0.00%	4879.00	4879.85	0.02%	4899.30	4899.59	0.01%
1GB	2132.00	2132.15	0.01%	2138.00	2138.91	0.04%	2133.00	2133.48	0.02%

Verification of Group FLOPS_SP with Test stream_sp_sse

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	19766.00	19766.02	0.00%	19767.00	19767.73	0.00%	19767.00	19767.37	0.00%
128kB	11918.00	11918.02	0.00%	11925.00	11925.86	0.01%	11921.40	11921.97	0.00%
2MB	5458.00	5458.01	0.00%	5508.00	5508.65	0.01%	5457.90	5458.24	0.01%
1GB	2129.00	2129.04	0.00%	2119.00	2119.85	0.04%	2125.60	2126.13	0.03%

Verification of Group FLOPS_SP with Test ddot_sp

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	6280.00	6279.99	0.00%	6279.00	6279.91	0.01%	6279.70	6280.29	0.01%
128kB	5937.00	5937.06	0.00%	5937.00	5937.90	0.02%	5937.10	5937.71	0.01%
2MB	5583.00	5583.03	0.00%	5585.00	5585.86	0.02%	5587.80	5588.26	0.01%
1GB	2799.00	2798.99	0.00%	2797.00	2797.86	0.03%	2797.40	2797.85	0.02%

Verification of Group FLOPS_SP with Test stream_sp

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	5658.00	5658.05	0.00%	5657.00	5657.95	0.02%	5656.60	5657.05	0.01%
128kB	5511.00	5511.04	0.00%	5516.00	5516.80	0.01%	5509.60	5509.85	0.00%
2MB	4323.00	4323.03	0.00%	4333.00	4333.83	0.02%	4327.70	4328.09	0.01%
1GB	1937.00	1936.99	0.00%	1937.00	1937.97	0.05%	1937.30	1937.83	0.03%

Verification of Group FLOPS_SP with Test sum_sp_avx

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	26285.00	26285.01	0.00%	26283.00	26283.87	0.00%	26276.20	26276.48	0.00%
128kB	25072.00	25072.04	0.00%	25070.00	25070.82	0.00%	25072.20	25072.51	0.00%
2MB	8462.00	8462.09	0.00%	8294.00	8294.93	0.01%	8488.00	8488.49	0.01%
1GB	3800.00	3799.99	0.00%	3803.00	3803.96	0.03%	3800.20	3800.68	0.01%

Verification of Group FLOPS_SP with Test triad_sp_avx

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	29140.00	29140.00	0.00%	29116.00	29116.81	0.00%	29142.10	29142.47	0.00%
128kB	13531.00	13531.04	0.00%	13534.00	13534.80	0.01%	13532.30	13532.86	0.00%
2MB	4381.00	4381.03	0.00%	4556.00	4556.92	0.02%	4695.20	4695.67	0.01%
1GB	1695.00	1695.12	0.01%	1694.00	1694.94	0.06%	1696.10	1696.64	0.03%

Verification of Group FLOPS_SP with Test triad_sp_sse

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	16181.00	16181.05	0.00%	16245.00	16245.75	0.00%	16200.70	16201.14	0.00%
128kB	7833.00	7833.02	0.00%	7835.00	7835.71	0.01%	7833.80	7834.07	0.00%
2MB	4057.00	4057.10	0.00%	4069.00	4069.69	0.02%	4094.80	4095.14	0.01%
1GB	1648.00	1648.02	0.00%	1635.00	1635.95	0.06%	1642.30	1642.74	0.03%

Verification of Group FLOPS_SP with Test daxpy_sp

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	5682.00	5682.05	0.00%	5680.00	5680.92	0.02%	5680.10	5680.67	0.01%
128kB	5689.00	5689.14	0.00%	5687.00	5687.93	0.02%	5687.80	5688.27	0.01%
2MB	5458.00	5458.15	0.00%	5529.00	5529.72	0.01%	5455.00	5455.38	0.01%
1GB	2705.00	2705.03	0.00%	2703.00	2703.97	0.04%	2699.50	2699.95	0.02%

Verification of Group FLOPS_SP with Test daxpy_sp_avx

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	36241.00	36241.20	0.00%	36237.00	36237.82	0.00%	36241.40	36241.90	0.00%
128kB	21117.00	21116.98	0.00%	21136.00	21136.81	0.00%	21133.90	21134.20	0.00%
2MB	7940.00	7939.98	0.00%	8058.00	8058.73	0.01%	8281.50	8281.89	0.00%
1GB	3169.00	3169.01	0.00%	3168.00	3168.96	0.03%	3169.00	3169.46	0.01%

Verification of Group FLOPS_SP with Test daxpy_sp_sse

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	20068.00	20068.20	0.00%	20067.00	20067.56	0.00%	20071.40	20071.81	0.00%
128kB	11850.00	11849.99	0.00%	11846.00	11846.91	0.01%	11847.40	11847.96	0.00%
2MB	7594.00	7594.04	0.00%	7593.00	7593.94	0.01%	7712.90	7713.44	0.01%
1GB	2912.00	2912.16	0.01%	2913.00	2913.99	0.03%	2914.20	2914.75	0.02%

Verification of Group FLOPS_SP with Test stream_sp_avx

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	36841.00	36841.21	0.00%	36816.00	36816.88	0.00%	36819.70	36820.22	0.00%
128kB	17521.00	17521.06	0.00%	17529.00	17529.87	0.00%	17523.80	17524.27	0.00%
2MB	5538.00	5538.00	0.00%	5330.00	5330.88	0.02%	5384.20	5384.53	0.01%
1GB	2193.00	2193.15	0.01%	2195.00	2195.68	0.03%	2197.10	2197.47	0.02%

Verification of Group L3

Verification of Group L3 with Test load

Benchmark performed with data sizes: 13081kB, 24499kB, 35916kB, 47334kB.

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 13081kB 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)
13081kB	24705.00	49409.68	100.00%	24730.00	49461.97	100.01%	24718.40	49438.84	100.01%
24499kB	24699.00	49397.03	100.00%	24727.00	49454.92	100.00%	24717.40	49434.17	100.00%
35916kB	24114.00	48227.91	100.00%	24721.00	49439.95	99.99%	24462.00	48922.51	99.99%
47334kB	22362.00	44721.43	99.99%	23273.00	46542.43	99.98%	22712.20	45421.34	99.99%

Verification of Group L3 with Test copy

Benchmark performed with data sizes: 13081kB, 24499kB, 35916kB, 47334kB.

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 13081kB 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)
13081kB	44731.50	59647.81	33.35%	44773.50	59703.94	33.35%	44748.90	59671.87	33.35%
24499kB	44691.00	59589.02	33.34%	44733.00	59646.94	33.34%	44711.10	59617.56	33.34%
35916kB	44088.00	58784.34	33.33%	44581.50	59441.53	33.33%	44434.80	59245.97	33.33%
47334kB	39055.50	52072.99	33.33%	41085.00	54778.80	33.33%	40446.00	53926.85	33.33%

Verification of Group L3 with Test stream

Benchmark performed with data sizes: 13081kB, 24499kB, 35916kB, 47334kB.

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 13081kB 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)
13081kB	40644.50	60991.47	50.06%	40663.17	61063.99	50.17%	40636.77	61004.24	50.12%
24499kB	40659.17	61009.93	50.05%	40636.50	61012.00	50.14%	40657.57	61015.14	50.07%
35916kB	39495.46	59269.81	50.07%	40487.21	60759.08	50.07%	40091.57	60164.52	50.07%
47334kB	35411.14	53145.97	50.08%	38994.25	58524.68	50.09%	36940.63	55438.35	50.07%

Verification of Group L3 with Test ddot

Benchmark performed with data sizes: 13081kB, 24499kB, 35916kB, 47334kB.

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 13081kB 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)
13081kB	28628.00	57260.06	100.01%	28687.00	57380.45	100.02%	28641.40	57288.68	100.02%
24499kB	27584.00	55171.61	100.01%	27591.00	55186.60	100.02%	27586.60	55176.89	100.01%
35916kB	27866.00	55733.47	100.01%	28610.00	57220.53	100.00%	28348.20	56697.30	100.00%
47334kB	26656.00	53311.70	100.00%	26808.00	53614.10	99.99%	26743.00	53484.55	99.99%

Verification of Group L3 with Test triad

Benchmark performed with data sizes: 13081kB, 24499kB, 35916kB, 47334kB.

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 13081kB 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)
13081kB	40500.54	60834.10	50.21%	40463.21	60847.80	50.38%	40486.14	60848.60	50.29%
24499kB	41004.41	61578.63	50.18%	41089.72	61708.65	50.18%	41047.60	61638.53	50.16%
35916kB	40491.21	60785.02	50.12%	40908.44	61401.47	50.09%	40771.67	61197.39	50.10%
47334kB	35336.50	53041.03	50.10%	36446.89	54700.09	50.08%	35964.07	53977.94	50.09%

Verification of Group L3 with Test daxpy

Benchmark performed with data sizes: 13081kB, 24499kB, 35916kB, 47334kB.

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 13081kB 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)
13081kB	41140.00	54860.51	33.35%	41223.00	54969.80	33.35%	41175.80	54907.73	33.35%
24499kB	40586.00	54119.15	33.34%	40601.00	54139.60	33.35%	40592.00	54127.13	33.34%
35916kB	37648.00	50196.62	33.33%	39880.00	53173.07	33.33%	39059.60	52080.07	33.33%
47334kB	36865.00	49155.32	33.34%	38493.00	51323.93	33.33%	37999.60	50665.87	33.33%

Verification of Group L3 with Test store

Benchmark performed with data sizes: 13081kB, 24499kB, 35916kB, 47334kB.

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 13081kB 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)
13081kB	53544.00	53547.57	0.01%	53548.00	53553.76	0.01%	53544.00	53548.60	0.01%
24499kB	53532.00	53531.87	0.00%	53538.00	53540.19	0.00%	53536.00	53537.26	0.00%
35916kB	53494.00	53493.99	0.00%	53362.00	53360.61	0.00%	53276.00	53275.66	0.00%
47334kB	48032.00	48031.12	0.00%	47688.00	47684.91	-0.01%	48656.40	48654.96	0.00%

Verification of Group L2

Verification of Group L2 with Test load

Benchmark performed with data sizes: 308kB, 554kB, 801kB, 1047kB.

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 308kB 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)
308kB	26624.00	26677.65	0.20%	26616.00	26671.68	0.21%	26622.40	26677.32	0.21%
554kB	26646.00	26677.90	0.12%	26645.00	26677.89	0.12%	26645.60	26678.01	0.12%
801kB	26656.00	26680.10	0.09%	26655.00	26679.91	0.09%	26657.80	26682.40	0.09%
1047kB	26664.00	26683.72	0.07%	26664.00	26684.27	0.08%	26664.20	26684.23	0.08%

Verification of Group L2 with Test copy

Benchmark performed with data sizes: 308kB, 554kB, 801kB, 1047kB.

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 308kB 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)
308kB	74127.00	74229.58	0.14%	74122.50	74225.70	0.14%	74128.20	74230.98	0.14%
554kB	74355.00	74411.58	0.08%	74353.50	74411.31	0.08%	74349.30	74406.36	0.08%
801kB	74433.00	74477.27	0.06%	74478.00	74524.13	0.06%	74462.10	74507.43	0.06%
1047kB	71463.00	71495.32	0.05%	74542.50	74577.91	0.05%	73918.80	73953.33	0.05%

Verification of Group L2 with Test stream

Benchmark performed with data sizes: 308kB, 554kB, 801kB, 1047kB.

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 308kB 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)
308kB	65816.88	65972.93	0.24%	65815.54	65975.42	0.24%	65806.74	65965.42	0.24%
554kB	65835.54	65925.13	0.14%	65824.87	65915.51	0.14%	65837.67	65927.73	0.14%
801kB	65876.86	65952.81	0.12%	65884.86	65961.91	0.12%	65876.86	65953.38	0.12%
1047kB	65904.85	65961.05	0.09%	65906.19	65963.24	0.09%	65908.59	65965.14	0.09%

Verification of Group L2 with Test ddot

Benchmark performed with data sizes: 308kB, 554kB, 801kB, 1047kB.

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 308kB 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)
308kB	31422.00	31504.07	0.26%	31369.00	31454.48	0.27%	31406.00	31489.14	0.26%
554kB	31308.00	31355.35	0.15%	31269.00	31319.34	0.16%	31293.80	31342.58	0.16%
801kB	31288.00	31323.94	0.11%	31286.00	31322.56	0.12%	31286.00	31322.28	0.12%
1047kB	31263.00	31292.25	0.09%	31267.00	31297.16	0.10%	31265.00	31294.58	0.09%

Verification of Group L2 with Test triad

Benchmark performed with data sizes: 308kB, 554kB, 801kB, 1047kB.

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 308kB 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)
308kB	70189.12	65978.09	-6.00%	70421.06	66193.86	-6.00%	70306.69	66087.28	-6.00%
554kB	69438.64	65201.32	-6.10%	69469.29	65229.38	-6.10%	69457.03	65218.10	-6.10%
801kB	69073.39	64843.54	-6.12%	69577.27	65317.28	-6.12%	69389.85	65141.27	-6.12%
1047kB	59091.89	55455.92	-6.15%	59710.40	56036.09	-6.15%	59585.37	55919.13	-6.15%

Verification of Group L2 with Test daxpy

Benchmark performed with data sizes: 308kB, 554kB, 801kB, 1047kB.

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 308kB 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)
308kB	52923.00	53014.95	0.17%	52937.00	53030.34	0.18%	52933.20	53025.72	0.17%
554kB	53058.00	53108.57	0.10%	53058.00	53109.52	0.10%	53057.40	53108.45	0.10%
801kB	53075.00	53115.28	0.08%	53082.00	53122.53	0.08%	53081.00	53121.41	0.08%
1047kB	53081.00	53111.40	0.06%	53098.00	53129.14	0.06%	53094.80	53125.62	0.06%

Verification of Group L2 with Test store

Benchmark performed with data sizes: 308kB, 554kB, 801kB, 1047kB.

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 308kB 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)
308kB	81264.00	81349.76	0.11%	81258.00	81345.01	0.11%	81258.80	81345.24	0.11%
554kB	81416.00	81460.66	0.05%	81404.00	81450.16	0.06%	81412.80	81458.42	0.06%
801kB	81450.00	81478.74	0.04%	81462.00	81491.62	0.04%	81459.60	81488.82	0.04%
1047kB	81486.00	81507.46	0.03%	81500.00	81522.93	0.03%	81488.40	81510.39	0.03%