rocm-systems/tests/workloads/mixbench2/mi100/SQ_IFETCH_LEVEL.csv

1	Index	KernelName	gpu-id	queue-id	queue-index	pid	tid	grd	wgr	lds	scr	vgpr	sgpr	fbar	sig	obj	GRBM_COUNT	GRBM_GUI_ACTIVE	SQ_WAVES	SQ_IFETCH	SQ_IFETCH_LEVEL	SQ_ACCUM_PREV_HIRES	DispatchNs	BeginNs	EndNs	CompleteNs
2	0	__amd_rocclr_fillBuffer.kd	0	0	0	763517	763522	33554432	256	0	0	8	32	6464	0x0	0x7f1e10e04180	505857	505857	524288	6291456	792695	101403392	12073442306812763	12073442552623215	12073442552948813	12073442553060085
3	1	void benchmark_func<short, 256, 8u, 0u>(short, short*) [clone .kd]	0	0	2	763517	763522	32768	256	0	0	24	24	12480	0x0	0x7f1e10e35100	28539	28539	512	8192	9217	1173568	12073442567379506	12073442567681010	12073442567687570	12073442567692658
4	2	void benchmark_func<float, 256, 8u, 0u>(float, float*) [clone .kd]	0	0	4	763517	763522	4194304	256	0	0	24	24	12928	0x7f1f1ca96900	0x7f1e10e35140	214259	214259	65536	917504	142240	18192764	12073442567759682	12073442567986768	12073442568117488	12073442568121335
5	3	void benchmark_func<HIP_vector_type<float, 2u>, 256, 8u, 0u>(HIP_vector_type<float, 2u>, HIP_vector_type<float, 2u>*) [clone .kd]	0	0	6	763517	763522	4194304	256	0	0	36	24	13632	0x7f1f1ca96800	0x7f1e10e35180	393065	393065	65536	1245184	186478	24045128	12073442568191485	12073442568370446	12073442568621965	12073442568692055
6	4	void benchmark_func<double, 256, 8u, 0u>(double, double*) [clone .kd]	0	0	8	763517	763522	4194304	256	0	0	28	24	14080	0x7f1f1ca96700	0x7f1e10e351c0	401499	401499	65536	983040	136900	17499500	12073442568722141	12073442568916523	12073442569172522	12073442569242528
7	5	void benchmark_func<__half2, 256, 8u, 0u>(__half2, __half2*) [clone .kd]	0	0	10	763517	763522	4194304	256	0	0	24	24	14528	0x7f1f1ca96600	0x7f1e10e35200	213081	213081	65536	1048576	160724	20564616	12073442569267755	12073442569460360	12073442569591079	12073442569594713
8	6	void benchmark_func<int, 256, 8u, 0u>(int, int*) [clone .kd]	0	0	12	763517	763522	4194304	256	0	0	24	24	14976	0x7f1f1ca96500	0x7f1e10e35240	227035	227035	65536	983040	148738	19037424	12073442569641490	12073442569825158	12073442569964197	12073442569967836
9	7	void benchmark_func<float, 256, 8u, 1u>(float, float*) [clone .kd]	0	0	14	763517	763522	4194304	256	0	0	24	24	15424	0x7f1f1ca96400	0x7f1e10e35280	222873	222873	65536	1048576	146512	18741904	12073442570053776	12073442570236036	12073442570373795	12073442570377387
10	8	void benchmark_func<HIP_vector_type<float, 2u>, 256, 8u, 1u>(HIP_vector_type<float, 2u>, HIP_vector_type<float, 2u>*) [clone .kd]	0	0	16	763517	763522	4194304	256	0	0	28	24	16128	0x7f1f1ca96300	0x7f1e10e352c0	401427	401427	65536	1572864	230484	29428540	12073442570422100	12073442570609954	12073442570864352	12073442570907833
11	9	void benchmark_func<double, 256, 8u, 1u>(double, double*) [clone .kd]	0	0	18	763517	763522	4194304	256	0	0	28	24	16832	0x7f1f1ca96a00	0x7f1e10e35300	400665	400665	65536	1179648	158696	20293616	12073442570932338	12073442571137151	12073442571394109	12073442571435854
12	10	void benchmark_func<__half2, 256, 8u, 1u>(__half2, __half2*) [clone .kd]	0	0	20	763517	763522	4194304	256	0	0	24	24	17536	0x7f1f1ca96900	0x7f1e10e35340	209635	209635	65536	1114112	157401	20120112	12073442571473424	12073442571646588	12073442571774587	12073442571778290
13	11	void benchmark_func<int, 256, 8u, 1u>(int, int*) [clone .kd]	0	0	22	763517	763522	4194304	256	0	0	24	24	18240	0x7f1f1ca96800	0x7f1e10e35380	218289	218289	65536	1114112	158885	20326760	12073442571830367	12073442572007066	12073442572139865	12073442572143519
14	12	void benchmark_func<float, 256, 8u, 2u>(float, float*) [clone .kd]	0	0	24	763517	763522	4194304	256	0	0	24	24	18944	0x7f1f1ca96700	0x7f1e10e353c0	211643	211643	65536	1179648	163612	20977828	12073442572211586	12073442572383544	12073442572513143	12073442572516633
15	13	void benchmark_func<HIP_vector_type<float, 2u>, 256, 8u, 2u>(HIP_vector_type<float, 2u>, HIP_vector_type<float, 2u>*) [clone .kd]	0	0	26	763517	763522	4194304	256	0	0	28	24	19904	0x7f1f1ca96600	0x7f1e10e35400	391025	391025	65536	1835008	259721	33301056	12073442572568198	12073442572748182	12073442572999220	12073442573049282
16	14	void benchmark_func<double, 256, 8u, 2u>(double, double*) [clone .kd]	0	0	28	763517	763522	4194304	256	0	0	28	24	20608	0x7f1f1ca96500	0x7f1e10e35440	397499	397499	65536	1310720	176643	22690832	12073442573075060	12073442573269459	12073442573523217	12073442573569629
17	15	void benchmark_func<__half2, 256, 8u, 2u>(__half2, __half2*) [clone .kd]	0	0	30	763517	763522	4194304	256	0	0	24	24	21312	0x7f1f1ca96400	0x7f1e10e35480	212137	212137	65536	1245184	177253	22659800	12073442573594476	12073442573783056	12073442573913455	12073442573917075
18	16	void benchmark_func<int, 256, 8u, 2u>(int, int*) [clone .kd]	0	0	32	763517	763522	4194304	256	0	0	24	24	22016	0x7f1f1ca96300	0x7f1e10e354c0	225907	225907	65536	1310720	199209	25442024	12073442573963602	12073442574152494	12073442574290893	12073442574294577
19	17	void benchmark_func<float, 256, 8u, 3u>(float, float*) [clone .kd]	0	0	34	763517	763522	4194304	256	0	0	24	24	22720	0x7f1f1ca96a00	0x7f1e10e35500	207801	207801	65536	1310720	181602	23188560	12073442574359828	12073442574528972	12073442574656811	12073442574660477
20	18	void benchmark_func<HIP_vector_type<float, 2u>, 256, 8u, 3u>(HIP_vector_type<float, 2u>, HIP_vector_type<float, 2u>*) [clone .kd]	0	0	36	763517	763522	4194304	256	0	0	28	24	23680	0x7f1f1ca96900	0x7f1e10e35540	393595	393595	65536	2097152	293196	37577396	12073442574705751	12073442574890410	12073442575141928	12073442575184310
21	19	void benchmark_func<double, 256, 8u, 3u>(double, double*) [clone .kd]	0	0	38	763517	763522	4194304	256	0	0	28	24	24384	0x7f1f1ca96800	0x7f1e10e35580	391921	391921	65536	1441792	196009	25073804	12073442575218724	12073442575398887	12073442575649926	12073442575691673
22	20	void benchmark_func<__half2, 256, 8u, 3u>(__half2, __half2*) [clone .kd]	0	0	40	763517	763522	4194304	256	0	0	24	24	25088	0x7f1f1ca96700	0x7f1e10e355c0	215067	215067	65536	1376256	187092	23944812	12073442575723623	12073442575901284	12073442576032963	12073442576036684
23	21	void benchmark_func<int, 256, 8u, 3u>(int, int*) [clone .kd]	0	0	42	763517	763522	4194304	256	0	0	24	24	25792	0x7f1f1ca96600	0x7f1e10e35600	215097	215097	65536	1507328	211274	27029248	12073442576090454	12073442576269602	12073442576402241	12073442576406031
24	22	void benchmark_func<float, 256, 8u, 4u>(float, float*) [clone .kd]	0	0	44	763517	763522	4194304	256	0	0	24	24	26496	0x7f1f1ca96500	0x7f1e10e35640	221331	221331	65536	1441792	203730	26016836	12073442576470440	12073442576642240	12073442576777759	12073442576781539
25	23	void benchmark_func<HIP_vector_type<float, 2u>, 256, 8u, 4u>(HIP_vector_type<float, 2u>, HIP_vector_type<float, 2u>*) [clone .kd]	0	0	46	763517	763522	4194304	256	0	0	28	24	27712	0x7f1f1ca96400	0x7f1e10e35680	400689	400689	65536	2359296	322581	41426080	12073442576827153	12073442577006558	12073442577263357	12073442577333975
26	24	void benchmark_func<double, 256, 8u, 4u>(double, double*) [clone .kd]	0	0	48	763517	763522	4194304	256	0	0	28	24	28416	0x7f1f1ca96300	0x7f1e10e356c0	397699	397699	65536	1572864	210836	26967904	12073442577359623	12073442577548635	12073442577802554	12073442577870763
27	25	void benchmark_func<__half2, 256, 8u, 4u>(__half2, __half2*) [clone .kd]	0	0	50	763517	763522	4194304	256	0	0	24	24	29120	0x7f1f1ca96a00	0x7f1e10e35700	210769	210769	65536	1507328	212415	27184588	12073442577899957	12073442578098072	12073442578227831	12073442578231774
28	26	void benchmark_func<int, 256, 8u, 4u>(int, int*) [clone .kd]	0	0	52	763517	763522	4194304	256	0	0	24	24	30080	0x7f1f1ca96900	0x7f1e10e35740	208835	208835	65536	1703936	233960	29945436	12073442578284111	12073442578462870	12073442578590709	12073442578594418
29	27	void benchmark_func<float, 256, 8u, 5u>(float, float*) [clone .kd]	0	0	54	763517	763522	4194304	256	0	0	24	24	30784	0x7f1f1ca96800	0x7f1e10e35780	220609	220609	65536	1572864	215161	27548040	12073442578658086	12073442578821588	12073442578957907	12073442578961710
30	28	void benchmark_func<HIP_vector_type<float, 2u>, 256, 8u, 5u>(HIP_vector_type<float, 2u>, HIP_vector_type<float, 2u>*) [clone .kd]	0	0	56	763517	763522	4194304	256	0	0	28	24	32000	0x7f1f1ca96700	0x7f1e10e357c0	398907	398907	65536	2621440	359664	46029156	12073442579020008	12073442579203346	12073442579458864	12073442579480344
31	29	void benchmark_func<double, 256, 8u, 5u>(double, double*) [clone .kd]	0	0	58	763517	763522	4194304	256	0	0	28	24	32960	0x7f1f1ca96600	0x7f1e10e35800	397993	397993	65536	1703936	227991	29164236	12073442579534515	12073442579703183	12073442579958062	12073442580013865
32	30	void benchmark_func<__half2, 256, 8u, 5u>(__half2, __half2*) [clone .kd]	0	0	60	763517	763522	4194304	256	0	0	24	24	33920	0x7f1f1ca96500	0x7f1e10e35840	221179	221179	65536	1638400	230483	29472216	12073442580038691	12073442580228300	12073442580364139	12073442580367933
33	31	void benchmark_func<int, 256, 8u, 5u>(int, int*) [clone .kd]	0	0	62	763517	763522	4194304	256	0	0	24	24	34880	0x7f1f1ca96400	0x7f1e10e35880	213433	213433	65536	1900544	291679	37284400	12073442580420681	12073442580594058	12073442580726057	12073442580729666
34	32	void benchmark_func<float, 256, 8u, 6u>(float, float*) [clone .kd]	0	0	64	763517	763522	4194304	256	0	0	24	24	35840	0x7f1f1ca96300	0x7f1e10e358c0	209395	209395	65536	1703936	236591	30233080	12073442580794817	12073442580960616	12073442581088615	12073442581092630
35	33	void benchmark_func<HIP_vector_type<float, 2u>, 256, 8u, 6u>(HIP_vector_type<float, 2u>, HIP_vector_type<float, 2u>*) [clone .kd]	0	0	66	763517	763522	4194304	256	0	0	28	24	37312	0x7f1f1ca96a00	0x7f1e10e35900	467529	467529	65536	2883584	393079	50321740	12073442581143655	12073442581326854	12073442581629252	12073442581676665
36	34	void benchmark_func<double, 256, 8u, 6u>(double, double*) [clone .kd]	0	0	68	763517	763522	4194304	256	0	0	28	24	38272	0x7f1f1ca96900	0x7f1e10e35940	400083	400083	65536	1835008	243204	31316336	12073442581699808	12073442581889091	12073442582144449	12073442582191592
37	35	void benchmark_func<__half2, 256, 8u, 6u>(__half2, __half2*) [clone .kd]	0	0	70	763517	763522	4194304	256	0	0	24	24	39232	0x7f1f1ca96800	0x7f1e10e35980	216321	216321	65536	1769472	251354	32255872	12073442582217440	12073442582405248	12073442582538687	12073442582542495
38	36	void benchmark_func<int, 256, 8u, 6u>(int, int*) [clone .kd]	0	0	72	763517	763522	4194304	256	0	0	24	24	40192	0x7f1f1ca96700	0x7f1e10e359c0	217259	217259	65536	2097152	297237	38154228	12073442582594601	12073442582773246	12073442582906525	12073442582910358
39	37	void benchmark_func<float, 256, 8u, 7u>(float, float*) [clone .kd]	0	0	74	763517	763522	4194304	256	0	0	24	24	41152	0x7f1f1ca96600	0x7f1e10e35a00	209569	209569	65536	1835008	249844	31898912	12073442582972995	12073442583146044	12073442583275323	12073442583279274
40	38	void benchmark_func<HIP_vector_type<float, 2u>, 256, 8u, 7u>(HIP_vector_type<float, 2u>, HIP_vector_type<float, 2u>*) [clone .kd]	0	0	76	763517	763522	4194304	256	0	0	28	24	42624	0x7f1f1ca96500	0x7f1e10e35a40	408987	408987	65536	3145728	433871	55425672	12073442583331321	12073442583506682	12073442583768920	12073442583836770
41	39	void benchmark_func<double, 256, 8u, 7u>(double, double*) [clone .kd]	0	0	78	763517	763522	4194304	256	0	0	28	24	43584	0x7f1f1ca96400	0x7f1e10e35a80	386481	386481	65536	1966080	264139	33689908	12073442583863399	12073442584052119	12073442584300597	12073442584370472
42	40	void benchmark_func<__half2, 256, 8u, 7u>(__half2, __half2*) [clone .kd]	0	0	80	763517	763522	4194304	256	0	0	24	24	44544	0x7f1f1ca96300	0x7f1e10e35ac0	214859	214859	65536	1900544	299881	38375928	12073442584394516	12073442584589236	12073442584721235	12073442584724910
43	41	void benchmark_func<int, 256, 8u, 7u>(int, int*) [clone .kd]	0	0	82	763517	763522	4194304	256	0	0	24	24	45760	0x7f1f1ca96a00	0x7f1e10e35b00	217057	217057	65536	2293760	306196	39360280	12073442584778189	12073442584951314	12073442585086033	12073442585090019
44	42	void benchmark_func<float, 256, 8u, 8u>(float, float*) [clone .kd]	0	0	84	763517	763522	4194304	256	0	0	24	24	46720	0x7f1f1ca96900	0x7f1e10e35b40	212467	212467	65536	1966080	271943	34729740	12073442585156302	12073442585326032	12073442585456271	12073442585459986
45	43	void benchmark_func<HIP_vector_type<float, 2u>, 256, 8u, 8u>(HIP_vector_type<float, 2u>, HIP_vector_type<float, 2u>*) [clone .kd]	0	0	86	763517	763522	4194304	256	0	0	28	24	48448	0x7f1f1ca96800	0x7f1e10e35b80	404441	404441	65536	3407872	457462	58465704	12073442585510751	12073442585685230	12073442585946028	12073442586024636
46	44	void benchmark_func<double, 256, 8u, 8u>(double, double*) [clone .kd]	0	0	88	763517	763522	4194304	256	0	0	28	24	49408	0x7f1f1ca96700	0x7f1e10e35bc0	463259	463259	65536	2097152	277035	35336816	12073442586049873	12073442586236427	12073442586534345	12073442586602510
47	45	void benchmark_func<__half2, 256, 8u, 8u>(__half2, __half2*) [clone .kd]	0	0	90	763517	763522	4194304	256	0	0	24	24	50368	0x7f1f1ca96600	0x7f1e10e35c00	209873	209873	65536	2031616	275313	35241344	12073442586626735	12073442586809703	12073442586938023	12073442586941810
48	46	void benchmark_func<int, 256, 8u, 8u>(int, int*) [clone .kd]	0	0	92	763517	763522	4194304	256	0	0	24	24	51584	0x7f1f1ca96500	0x7f1e10e35c40	223387	223387	65536	2490368	347507	44738152	12073442586993446	12073442587175141	12073442587313861	12073442587317969
49	47	void benchmark_func<float, 256, 8u, 9u>(float, float*) [clone .kd]	0	0	94	763517	763522	4194304	256	0	0	24	24	52544	0x7f1f1ca96400	0x7f1e10e35c80	213105	213105	65536	2097152	298675	38320440	12073442587381818	12073442587545059	12073442587675939	12073442587679872
50	48	void benchmark_func<HIP_vector_type<float, 2u>, 256, 8u, 9u>(HIP_vector_type<float, 2u>, HIP_vector_type<float, 2u>*) [clone .kd]	0	0	96	763517	763522	4194304	256	0	0	28	24	54272	0x7f1f1ca96300	0x7f1e10e35cc0	400931	400931	65536	3670016	498096	63565992	12073442587731588	12073442587907777	12073442588166496	12073442588214996
51	49	void benchmark_func<double, 256, 8u, 9u>(double, double*) [clone .kd]	0	0	98	763517	763522	4194304	256	0	0	28	24	55488	0x7f1f1ca96a00	0x7f1e10e35d00	397057	397057	65536	2228224	297527	38063000	12073442588239512	12073442588427134	12073442588682333	12073442588728741
52	50	void benchmark_func<__half2, 256, 8u, 9u>(__half2, __half2*) [clone .kd]	0	0	100	763517	763522	4194304	256	0	0	24	24	56704	0x7f1f1ca96900	0x7f1e10e35d40	218387	218387	65536	2162688	343442	44023484	12073442588755711	12073442588934492	12073442589069371	12073442589073452
53	51	void benchmark_func<int, 256, 8u, 9u>(int, int*) [clone .kd]	0	0	102	763517	763522	4194304	256	0	0	24	24	58176	0x7f1f1ca96800	0x7f1e10e35d80	227785	227785	65536	2686976	411894	52827384	12073442589125679	12073442589309369	12073442589450969	12073442589454770
54	52	void benchmark_func<float, 256, 8u, 10u>(float, float*) [clone .kd]	0	0	104	763517	763522	4194304	256	0	0	24	24	59392	0x7f1f1ca96700	0x7f1e10e35dc0	214883	214883	65536	2228224	339702	43427736	12073442589517577	12073442589683607	12073442589814167	12073442589818406
55	53	void benchmark_func<HIP_vector_type<float, 2u>, 256, 8u, 10u>(HIP_vector_type<float, 2u>, HIP_vector_type<float, 2u>*) [clone .kd]	0	0	106	763517	763522	4194304	256	0	0	28	24	61376	0x7f1f1ca96600	0x7f1e10e35e00	411881	411881	65536	3932160	526145	67191120	12073442589872116	12073442590053525	12073442590319124	12073442590366034
56	54	void benchmark_func<double, 256, 8u, 10u>(double, double*) [clone .kd]	0	0	108	763517	763522	4194304	256	0	0	28	24	62592	0x7f1f1ca96500	0x7f1e10e35e40	389043	389043	65536	2359296	311032	39816072	12073442590390820	12073442590574802	12073442590825361	12073442590871543
57	55	void benchmark_func<__half2, 256, 8u, 10u>(__half2, __half2*) [clone .kd]	0	0	110	763517	763522	4194304	256	0	0	24	24	63808	0x7f1f1ca96400	0x7f1e10e35e80	220625	220625	65536	2293760	332872	42534424	12073442590894446	12073442591086960	12073442591220879	12073442591224890
58	56	void benchmark_func<int, 256, 8u, 10u>(int, int*) [clone .kd]	0	0	112	763517	763522	4194304	256	0	0	24	24	65280	0x7f1f1ca96300	0x7f1e10e35ec0	226355	226355	65536	2883584	385551	49343860	12073442591276636	12073442591460237	12073442591601517	12073442591605357
59	57	void benchmark_func<float, 256, 8u, 11u>(float, float*) [clone .kd]	0	0	114	763517	763522	4194304	256	0	0	24	24	66496	0x7f1f1ca96a00	0x7f1e10e35f00	208465	208465	65536	2359296	324810	41567772	12073442591670718	12073442591833195	12073442591961675	12073442591965356
60	58	void benchmark_func<HIP_vector_type<float, 2u>, 256, 8u, 11u>(HIP_vector_type<float, 2u>, HIP_vector_type<float, 2u>*) [clone .kd]	0	0	116	763517	763522	4194304	256	0	0	28	24	68480	0x7f1f1ca96900	0x7f1e10e35f40	412379	412379	65536	4194304	552439	70512872	12073442592013786	12073442592198793	12073442592465192	12073442592514587
61	59	void benchmark_func<double, 256, 8u, 11u>(double, double*) [clone .kd]	0	0	118	763517	763522	4194304	256	0	0	28	24	69696	0x7f1f1ca96800	0x7f1e10e35f80	395281	395281	65536	2490368	336091	42975544	12073442592538110	12073442592722310	12073442592976549	12073442593024404
62	60	void benchmark_func<__half2, 256, 8u, 11u>(__half2, __half2*) [clone .kd]	0	0	120	763517	763522	4194304	256	0	0	24	24	70912	0x7f1f1ca96700	0x7f1e10e35fc0	282939	282939	65536	2424832	364732	46738432	12073442593047928	12073442593235268	12073442593413187	12073442593417024
63	61	void benchmark_func<int, 256, 8u, 11u>(int, int*) [clone .kd]	0	0	122	763517	763522	4194304	256	0	0	24	24	72384	0x7f1f1ca96600	0x7f1e10e36000	229849	229849	65536	3080192	486313	62282884	12073442593468279	12073442593645025	12073442593786944	12073442593790908
64	62	void benchmark_func<float, 256, 8u, 12u>(float, float*) [clone .kd]	0	0	124	763517	763522	4194304	256	0	0	24	24	73600	0x7f1f1ca96500	0x7f1e10e36040	216219	216219	65536	2490368	340514	43604024	12073442593854447	12073442594023583	12073442594157022	12073442594161076
65	63	void benchmark_func<HIP_vector_type<float, 2u>, 256, 8u, 12u>(HIP_vector_type<float, 2u>, HIP_vector_type<float, 2u>*) [clone .kd]	0	0	126	763517	763522	4194304	256	0	0	28	24	75840	0x7f1f1ca96400	0x7f1e10e36080	411585	411585	65536	4456448	593793	75844876	12073442594212432	12073442594391101	12073442594656700	12073442594703364
66	64	void benchmark_func<double, 256, 8u, 12u>(double, double*) [clone .kd]	0	0	128	763517	763522	4194304	256	0	0	28	24	77056	0x7f1f1ca96300	0x7f1e10e360c0	401675	401675	65536	2621440	343958	43827032	12073442594728230	12073442594920378	12073442595179097	12073442595202562
67	65	void benchmark_func<__half2, 256, 8u, 12u>(__half2, __half2*) [clone .kd]	0	0	130	763517	763522	4194304	256	0	0	24	24	78272	0x7f1f1ca96a00	0x7f1e10e36100	219713	219713	65536	2555904	414424	53028728	12073442595250411	12073442595417975	12073442595553335	12073442595557261
68	66	void benchmark_func<int, 256, 8u, 12u>(int, int*) [clone .kd]	0	0	132	763517	763522	4194304	256	0	0	24	24	80000	0x7f1f1ca96900	0x7f1e10e36140	231835	231835	65536	3276800	511947	65632740	12073442595601042	12073442595781493	12073442595926453	12073442595930124
69	67	void benchmark_func<float, 256, 8u, 13u>(float, float*) [clone .kd]	0	0	134	763517	763522	4194304	256	0	0	24	24	81216	0x7f1f1ca96800	0x7f1e10e36180	208473	208473	65536	2621440	373879	47844520	12073442595993091	12073442596166291	12073442596294450	12073442596298438
70	68	void benchmark_func<HIP_vector_type<float, 2u>, 256, 8u, 13u>(HIP_vector_type<float, 2u>, HIP_vector_type<float, 2u>*) [clone .kd]	0	0	136	763517	763522	4194304	256	0	0	28	24	83456	0x7f1f1ca96700	0x7f1e10e361c0	408771	408771	65536	4718592	626189	80283920	12073442596349704	12073442596524049	12073442596788528	12073442596836869
71	69	void benchmark_func<double, 256, 8u, 13u>(double, double*) [clone .kd]	0	0	138	763517	763522	4194304	256	0	0	28	24	84928	0x7f1f1ca96600	0x7f1e10e36200	386953	386953	65536	2752512	391482	50163092	12073442596861495	12073442597051566	12073442597300685	12073442597351405
72	70	void benchmark_func<__half2, 256, 8u, 13u>(__half2, __half2*) [clone .kd]	0	0	140	763517	763522	4194304	256	0	0	24	24	86400	0x7f1f1ca96500	0x7f1e10e36240	211147	211147	65536	2686976	380330	48688196	12073442597376321	12073442597562603	12073442597692843	12073442597696847
73	71	void benchmark_func<int, 256, 8u, 13u>(int, int*) [clone .kd]	0	0	142	763517	763522	4194304	256	0	0	24	24	88128	0x7f1f1ca96400	0x7f1e10e36280	240985	240985	65536	3473408	523245	67297524	12073442597748423	12073442597922281	12073442598073161	12073442598077454
74	72	void benchmark_func<float, 256, 8u, 14u>(float, float*) [clone .kd]	0	0	144	763517	763522	4194304	256	0	0	24	24	89600	0x7f1f1ca96300	0x7f1e10e362c0	219995	219995	65536	2752512	392850	50259220	12073442598161561	12073442598329799	12073442598466118	12073442598470034
75	73	void benchmark_func<HIP_vector_type<float, 2u>, 256, 8u, 14u>(HIP_vector_type<float, 2u>, HIP_vector_type<float, 2u>*) [clone .kd]	0	0	146	763517	763522	4194304	256	0	0	28	24	92096	0x7f1f1ca96a00	0x7f1e10e36300	409625	409625	65536	4980736	651163	83336044	12073442598522051	12073442598698437	12073442598963556	12073442598984009
76	74	void benchmark_func<double, 256, 8u, 14u>(double, double*) [clone .kd]	0	0	148	763517	763522	4194304	256	0	0	28	24	93568	0x7f1f1ca96900	0x7f1e10e36340	393747	393747	65536	2883584	381654	49013972	12073442599042327	12073442599207394	12073442599461153	12073442599506480
77	75	void benchmark_func<__half2, 256, 8u, 14u>(__half2, __half2*) [clone .kd]	0	0	150	763517	763522	4194304	256	0	0	24	24	95040	0x7f1f1ca96800	0x7f1e10e36380	219753	219753	65536	2818048	392401	50235788	12073442599529954	12073442599714591	12073442599849791	12073442599853485
78	76	void benchmark_func<int, 256, 8u, 14u>(int, int*) [clone .kd]	0	0	152	763517	763522	4194304	256	0	0	24	24	96768	0x7f1f1ca96700	0x7f1e10e363c0	252275	252275	65536	3670016	551838	70822956	12073442599906924	12073442600083069	12073442600241628	12073442600245614
79	77	void benchmark_func<float, 256, 8u, 15u>(float, float*) [clone .kd]	0	0	154	763517	763522	4194304	256	0	0	24	24	98240	0x7f1f1ca96600	0x7f1e10e36400	219793	219793	65536	2883584	454836	58243924	12073442600310064	12073442600481147	12073442600616826	12073442600620721
80	78	void benchmark_func<HIP_vector_type<float, 2u>, 256, 8u, 15u>(HIP_vector_type<float, 2u>, HIP_vector_type<float, 2u>*) [clone .kd]	0	0	156	763517	763522	4194304	256	0	0	28	24	100736	0x7f1f1ca96500	0x7f1e10e36440	397507	397507	65536	5177344	683355	87566476	12073442600671946	12073442600847705	12073442601105304	12073442601154112
81	79	void benchmark_func<double, 256, 8u, 15u>(double, double*) [clone .kd]	0	0	158	763517	763522	4194304	256	0	0	28	24	102208	0x7f1f1ca96400	0x7f1e10e36480	394817	394817	65536	3014656	431916	55385880	12073442601179139	12073442601366742	12073442601621461	12073442601668688
82	80	void benchmark_func<__half2, 256, 8u, 15u>(__half2, __half2*) [clone .kd]	0	0	160	763517	763522	4194304	256	0	0	24	24	103680	0x7f1f1ca96300	0x7f1e10e364c0	220883	220883	65536	2949120	503110	64358272	12073442601698684	12073442601888659	12073442602025779	12073442602029900
83	81	void benchmark_func<int, 256, 8u, 15u>(int, int*) [clone .kd]	0	0	162	763517	763522	4194304	256	0	0	24	24	105664	0x7f1f1ca96a00	0x7f1e10e36500	263657	263657	65536	3866624	577610	73763388	12073442602082517	12073442602263057	12073442602429136	12073442602432758
84	82	void benchmark_func<float, 256, 8u, 16u>(float, float*) [clone .kd]	0	0	164	763517	763522	4194304	256	0	0	24	24	107136	0x7f1f1ca96900	0x7f1e10e36540	213171	213171	65536	3014656	412032	52847900	12073442602495214	12073442602660335	12073442602792334	12073442602796274
85	83	void benchmark_func<HIP_vector_type<float, 2u>, 256, 8u, 16u>(HIP_vector_type<float, 2u>, HIP_vector_type<float, 2u>*) [clone .kd]	0	0	166	763517	763522	4194304	256	0	0	28	24	109888	0x7f1f1ca96800	0x7f1e10e36580	400953	400953	65536	5439488	725196	92966364	12073442602839895	12073442603029613	12073442603289291	12073442603315629
86	84	void benchmark_func<double, 256, 8u, 16u>(double, double*) [clone .kd]	0	0	168	763517	763522	4194304	256	0	0	28	24	111360	0x7f1f1ca96700	0x7f1e10e365c0	391747	391747	65536	3145728	427845	54831804	12073442603358829	12073442603523530	12073442603776969	12073442603798617
87	85	void benchmark_func<__half2, 256, 8u, 16u>(__half2, __half2*) [clone .kd]	0	0	170	763517	763522	4194304	256	0	0	24	24	112832	0x7f1f1ca96600	0x7f1e10e36600	214761	214761	65536	3080192	445284	57024600	12073442603846205	12073442604007047	12073442604139687	12073442604143598
88	86	void benchmark_func<int, 256, 8u, 16u>(int, int*) [clone .kd]	0	0	172	763517	763522	4194304	256	0	0	24	24	114816	0x7f1f1ca96500	0x7f1e10e36640	275155	275155	65536	4063232	578487	74009416	12073442604186668	12073442604370085	12073442604544164	12073442604548069
89	87	void benchmark_func<float, 256, 8u, 17u>(float, float*) [clone .kd]	0	0	174	763517	763522	4194304	256	0	0	24	24	116288	0x7f1f1ca96400	0x7f1e10e36680	216225	216225	65536	3145728	454668	58180328	12073442604613741	12073442604779043	12073442604912642	12073442604916574
90	88	void benchmark_func<HIP_vector_type<float, 2u>, 256, 8u, 17u>(HIP_vector_type<float, 2u>, HIP_vector_type<float, 2u>*) [clone .kd]	0	0	176	763517	763522	4194304	256	0	0	28	24	119040	0x7f1f1ca96300	0x7f1e10e366c0	400059	400059	65536	5701632	755494	96449376	12073442604966888	12073442605154241	12073442605414080	12073442605440618
91	89	void benchmark_func<double, 256, 8u, 17u>(double, double*) [clone .kd]	0	0	178	763517	763522	4194304	256	0	0	28	24	120768	0x7f1f1ca96a00	0x7f1e10e36700	393593	393593	65536	3276800	434381	55782472	12073442605484449	12073442605648638	12073442605903037	12073442605924838
92	90	void benchmark_func<__half2, 256, 8u, 17u>(__half2, __half2*) [clone .kd]	0	0	180	763517	763522	4194304	256	0	0	24	24	122496	0x7f1f1ca96900	0x7f1e10e36740	216915	216915	65536	3211264	445162	56931524	12073442605967327	12073442606138076	12073442606272635	12073442606276441
93	91	void benchmark_func<int, 256, 8u, 17u>(int, int*) [clone .kd]	0	0	182	763517	763522	4194304	256	0	0	24	24	124736	0x7f1f1ca96800	0x7f1e10e36780	288913	288913	65536	4259840	574621	74006332	12073442606326504	12073442606502554	12073442606685433	12073442606689339
94	92	void benchmark_func<float, 256, 8u, 18u>(float, float*) [clone .kd]	0	0	184	763517	763522	4194304	256	0	0	24	24	126464	0x7f1f1ca96700	0x7f1e10e367c0	224147	224147	65536	3276800	505153	64605104	12073442606753418	12073442606919191	12073442607056790	12073442607060689
95	93	void benchmark_func<HIP_vector_type<float, 2u>, 256, 8u, 18u>(HIP_vector_type<float, 2u>, HIP_vector_type<float, 2u>*) [clone .kd]	0	0	186	763517	763522	4194304	256	0	0	20	24	127936	0x7f1f1ca96600	0x7f1e10e36800	411393	411393	65536	7733248	981784	125386296	12073442607115100	12073442607298069	12073442607565748	12073442607589321
96	94	void benchmark_func<double, 256, 8u, 18u>(double, double*) [clone .kd]	0	0	188	763517	763522	4194304	256	0	0	28	24	129664	0x7f1f1ca96500	0x7f1e10e36840	394339	394339	65536	3407872	476893	60999828	12073442607633583	12073442607796146	12073442608051985	12073442608076757
97	95	void benchmark_func<__half2, 256, 8u, 18u>(__half2, __half2*) [clone .kd]	0	0	190	763517	763522	4194304	256	0	0	24	24	131392	0x7f1f1ca96400	0x7f1e10e36880	223481	223481	65536	3342336	470506	60225608	12073442608124746	12073442608292784	12073442608429743	12073442608433620
98	96	void benchmark_func<int, 256, 8u, 18u>(int, int*) [clone .kd]	0	0	192	763517	763522	4194304	256	0	0	24	24	133632	0x7f1f1ca96300	0x7f1e10e368c0	301963	301963	65536	4456448	622492	79874504	12073442608486078	12073442608659022	12073442608851180	12073442608873979
99	97	void benchmark_func<float, 256, 8u, 20u>(float, float*) [clone .kd]	0	0	194	763517	763522	4194304	256	0	0	24	24	135360	0x7f1f1ca96a00	0x7f1e10e36900	223377	223377	65536	3538944	580976	74389392	12073442608932367	12073442609110699	12073442609249098	12073442609252873
100	98	void benchmark_func<HIP_vector_type<float, 2u>, 256, 8u, 20u>(HIP_vector_type<float, 2u>, HIP_vector_type<float, 2u>*) [clone .kd]	0	0	196	763517	763522	4194304	256	0	0	20	24	136832	0x7f1f1ca96900	0x7f1e10e36940	437779	437779	65536	8978432	1129592	144359996	12073442609303878	12073442609478857	12073442609764455	12073442609789720
101	99	void benchmark_func<double, 256, 8u, 20u>(double, double*) [clone .kd]	0	0	198	763517	763522	4194304	256	0	0	28	24	138560	0x7f1f1ca96800	0x7f1e10e36980	389473	389473	65536	3670016	530567	68144140	12073442609830676	12073442609992454	12073442610244293	12073442610273249
102	100	void benchmark_func<__half2, 256, 8u, 20u>(__half2, __half2*) [clone .kd]	0	0	200	763517	763522	4194304	256	0	0	24	24	140288	0x7f1f1ca96700	0x7f1e10e369c0	218891	218891	65536	3604480	502835	64327684	12073442610315698	12073442610480771	12073442610616291	12073442610620444
103	101	void benchmark_func<int, 256, 8u, 20u>(int, int*) [clone .kd]	0	0	202	763517	763522	4194304	256	0	0	24	24	142784	0x7f1f1ca96600	0x7f1e10e36a00	330369	330369	65536	4849664	713834	90731076	12073442610662973	12073442610844609	12073442611054688	12073442611081220
104	102	void benchmark_func<float, 256, 8u, 22u>(float, float*) [clone .kd]	0	0	204	763517	763522	4194304	256	0	0	24	24	144768	0x7f1f1ca96500	0x7f1e10e36a40	222691	222691	65536	3801088	587862	75238504	12073442611138948	12073442611305727	12073442611444286	12073442611448323
105	103	void benchmark_func<HIP_vector_type<float, 2u>, 256, 8u, 22u>(HIP_vector_type<float, 2u>, HIP_vector_type<float, 2u>*) [clone .kd]	0	0	206	763517	763522	4194304	256	0	0	20	24	145728	0x7f1f1ca96400	0x7f1e10e36a80	471569	471569	65536	14548992	1827596	234053648	12073442611500319	12073442611677245	12073442611985083	12073442612014304
106	104	void benchmark_func<double, 256, 8u, 22u>(double, double*) [clone .kd]	0	0	208	763517	763522	4194304	256	0	0	28	24	147712	0x7f1f1ca96300	0x7f1e10e36ac0	392179	392179	65536	3932160	554864	71115860	12073442612056894	12073442612222202	12073442612476600	12073442612502712
107	105	void benchmark_func<__half2, 256, 8u, 22u>(__half2, __half2*) [clone .kd]	0	0	210	763517	763522	4194304	256	0	0	24	24	149696	0x7f1f1ca96a00	0x7f1e10e36b00	218593	218593	65536	3866624	535839	68588396	12073442612544229	12073442612706359	12073442612841878	12073442612845800
108	106	void benchmark_func<int, 256, 8u, 22u>(int, int*) [clone .kd]	0	0	212	763517	763522	4194304	256	0	0	24	24	152192	0x7f1f1ca96900	0x7f1e10e36b40	357043	357043	65536	5242880	784556	100599908	12073442612895392	12073442613079637	12073442613308276	12073442613334788
109	107	void benchmark_func<float, 256, 8u, 24u>(float, float*) [clone .kd]	0	0	214	763517	763522	4194304	256	0	0	24	24	154176	0x7f1f1ca96800	0x7f1e10e36b80	221657	221657	65536	4063232	639262	81788196	12073442613390592	12073442613560594	12073442613697873	12073442613702071
110	108	void benchmark_func<HIP_vector_type<float, 2u>, 256, 8u, 24u>(HIP_vector_type<float, 2u>, HIP_vector_type<float, 2u>*) [clone .kd]	0	0	216	763517	763522	4194304	256	0	0	20	24	155648	0x7f1f1ca96700	0x7f1e10e36bc0	509539	509539	65536	10027008	1257905	161385132	12073442613747345	12073442613926992	12073442614260750	12073442614286828
111	109	void benchmark_func<double, 256, 8u, 24u>(double, double*) [clone .kd]	0	0	218	763517	763522	4194304	256	0	0	28	24	157632	0x7f1f1ca96600	0x7f1e10e36c00	391961	391961	65536	4194304	558151	71769680	12073442614330589	12073442614497549	12073442614751148	12073442614773171
112	110	void benchmark_func<__half2, 256, 8u, 24u>(__half2, __half2*) [clone .kd]	0	0	220	763517	763522	4194304	256	0	0	24	24	159616	0x7f1f1ca96500	0x7f1e10e36c40	223875	223875	65536	4128768	595188	76155112	12073442614819738	12073442614983146	12073442615122666	12073442615126979
113	111	void benchmark_func<int, 256, 8u, 24u>(int, int*) [clone .kd]	0	0	222	763517	763522	4194304	256	0	0	24	24	162368	0x7f1f1ca96400	0x7f1e10e36c80	384353	384353	65536	5636096	774194	98455948	12073442615177423	12073442615362463	12073442615609182	12073442615635073
114	112	void benchmark_func<float, 256, 8u, 28u>(float, float*) [clone .kd]	0	0	224	763517	763522	4194304	256	0	0	24	24	164608	0x7f1f1ca96300	0x7f1e10e36cc0	221307	221307	65536	4587520	685643	87677620	12073442615689214	12073442615856059	12073442615993339	12073442615996735
115	113	void benchmark_func<HIP_vector_type<float, 2u>, 256, 8u, 28u>(HIP_vector_type<float, 2u>, HIP_vector_type<float, 2u>*) [clone .kd]	0	0	226	763517	763522	4194304	256	0	0	20	24	166336	0x7f1f1ca96a00	0x7f1e10e36d00	575521	575521	65536	11075584	1393954	178242856	12073442616048772	12073442616227898	12073442616606456	12073442616632256
116	114	void benchmark_func<double, 256, 8u, 28u>(double, double*) [clone .kd]	0	0	228	763517	763522	4194304	256	0	0	28	24	168576	0x7f1f1ca96900	0x7f1e10e36d40	406235	406235	65536	4718592	623928	79938820	12073442616673172	12073442616836055	12073442617099894	12073442617128108
117	115	void benchmark_func<__half2, 256, 8u, 28u>(__half2, __half2*) [clone .kd]	0	0	230	763517	763522	4194304	256	0	0	24	24	170816	0x7f1f1ca96800	0x7f1e10e36d80	226753	226753	65536	4653056	725681	92893836	12073442617173622	12073442617338293	12073442617479412	12073442617482547
118	116	void benchmark_func<int, 256, 8u, 28u>(int, int*) [clone .kd]	0	0	232	763517	763522	4194304	256	0	0	24	24	174080	0x7f1f1ca96700	0x7f1e10e36dc0	433651	433651	65536	6422528	905612	115866660	12073442617527600	12073442617705811	12073442617985970	12073442618024093
119	117	void benchmark_func<float, 256, 8u, 32u>(float, float*) [clone .kd]	0	0	234	763517	763522	4194304	256	0	0	24	24	176576	0x7f1f1ca96600	0x7f1e10e36e00	218569	218569	65536	5111808	768215	98202884	12073442618074467	12073442618245168	12073442618380688	12073442618384212
120	118	void benchmark_func<HIP_vector_type<float, 2u>, 256, 8u, 32u>(HIP_vector_type<float, 2u>, HIP_vector_type<float, 2u>*) [clone .kd]	0	0	236	763517	763522	4194304	256	0	0	20	24	177792	0x7f1f1ca96500	0x7f1e10e36e40	679211	679211	65536	15007744	1880402	240810608	12073442618434957	12073442618610767	12073442619059245	12073442619084303
121	119	void benchmark_func<double, 256, 8u, 32u>(double, double*) [clone .kd]	0	0	238	763517	763522	4194304	256	0	0	28	24	180288	0x7f1f1ca96400	0x7f1e10e36e80	398881	398881	65536	5242880	704611	90052060	12073442619131531	12073442619301164	12073442619559242	12073442619582619
122	120	void benchmark_func<__half2, 256, 8u, 32u>(__half2, __half2*) [clone .kd]	0	0	240	763517	763522	4194304	256	0	0	24	24	182784	0x7f1f1ca96300	0x7f1e10e36ec0	220843	220843	65536	5177344	774816	99111148	12073442619629046	12073442619793001	12073442619930921	12073442619934283
123	121	void benchmark_func<int, 256, 8u, 32u>(int, int*) [clone .kd]	0	0	242	763517	763522	4194304	256	0	0	24	24	186304	0x7f1f1ca96a00	0x7f1e10e36f00	488281	488281	65536	7208960	1047910	133763824	12073442619977513	12073442620169320	12073442620485958	12073442620510724
124	122	void benchmark_func<float, 256, 8u, 40u>(float, float*) [clone .kd]	0	0	244	763517	763522	4194304	256	0	0	24	24	189312	0x7f1f1ca96900	0x7f1e10e36f40	243235	243235	65536	6160384	909256	116338184	12073442620570736	12073442620738117	12073442620891236	12073442620894878
125	123	void benchmark_func<HIP_vector_type<float, 2u>, 256, 8u, 40u>(HIP_vector_type<float, 2u>, HIP_vector_type<float, 2u>*) [clone .kd]	0	0	246	763517	763522	4194304	256	0	0	20	24	190784	0x7f1f1ca96800	0x7f1e10e36f80	787929	787929	65536	17104896	2144510	274463800	12073442620938509	12073442621127875	12073442621648513	12073442621673936
126	124	void benchmark_func<double, 256, 8u, 40u>(double, double*) [clone .kd]	0	0	248	763517	763522	4194304	256	0	0	28	24	193792	0x7f1f1ca96700	0x7f1e10e36fc0	456947	456947	65536	6291456	923958	117714476	12073442621718078	12073442621882592	12073442622181150	12073442622204592
127	125	void benchmark_func<__half2, 256, 8u, 40u>(__half2, __half2*) [clone .kd]	0	0	250	763517	763522	4194304	256	0	0	24	24	196800	0x7f1f1ca96600	0x7f1e10e37000	248689	248689	65536	6225920	945074	120853200	12073442622249916	12073442622415069	12073442622570908	12073442622574159
128	126	void benchmark_func<int, 256, 8u, 40u>(int, int*) [clone .kd]	0	0	252	763517	763522	4194304	256	0	0	24	24	201088	0x7f1f1ca96500	0x7f1e10e37040	594155	594155	65536	8781824	1269590	162592020	12073442622625955	12073442622804827	12073442623192186	12073442623214619
129	127	void benchmark_func<float, 256, 8u, 48u>(float, float*) [clone .kd]	0	0	254	763517	763522	4194304	256	0	0	24	24	204608	0x7f1f1ca96400	0x7f1e10e37080	280897	280897	65536	7208960	1092984	139736816	12073442623272426	12073442623441944	12073442623620344	12073442623623990
130	128	void benchmark_func<HIP_vector_type<float, 2u>, 256, 8u, 48u>(HIP_vector_type<float, 2u>, HIP_vector_type<float, 2u>*) [clone .kd]	0	0	256	763517	763522	4194304	256	0	0	20	24	206080	0x7f1f1ca96300	0x7f1e10e370c0	926707	926707	65536	19202048	2407988	308013352	12073442623672770	12073442623848663	12073442624461940	12073442624488095
131	129	void benchmark_func<double, 256, 8u, 48u>(double, double*) [clone .kd]	0	0	258	763517	763522	4194304	256	0	0	28	24	209600	0x7f1f1ca96a00	0x7f1e10e37100	498793	498793	65536	7340032	979130	125678504	12073442624521588	12073442624699539	12073442625026897	12073442625048507
132	130	void benchmark_func<__half2, 256, 8u, 48u>(__half2, __half2*) [clone .kd]	0	0	260	763517	763522	4194304	256	0	0	24	24	213120	0x7f1f1ca96900	0x7f1e10e37140	282491	282491	65536	7274496	1061868	136040388	12073442625093691	12073442625259056	12073442625438895	12073442625442309
133	131	void benchmark_func<int, 256, 8u, 48u>(int, int*) [clone .kd]	0	0	262	763517	763522	4194304	256	0	0	24	24	218176	0x7f1f1ca96800	0x7f1e10e37180	697625	697625	65536	10354688	1476768	190440372	12073442625493314	12073442625675854	12073442626132172	12073442626156206
134	132	void benchmark_func<float, 256, 8u, 56u>(float, float*) [clone .kd]	0	0	264	763517	763522	4194304	256	0	0	24	24	222208	0x7f1f1ca96700	0x7f1e10e371c0	313507	313507	65536	8257536	1236365	158408276	12073442626218081	12073442626384971	12073442626586410	12073442626609829
135	133	void benchmark_func<HIP_vector_type<float, 2u>, 256, 8u, 56u>(HIP_vector_type<float, 2u>, HIP_vector_type<float, 2u>*) [clone .kd]	0	0	266	763517	763522	4194304	256	0	0	20	24	223936	0x7f1f1ca96600	0x7f1e10e37200	1064233	1064233	65536	21299200	2669746	341697984	12073442626661495	12073442626828169	12073442627533126	12073442627562008
136	134	void benchmark_func<double, 256, 8u, 56u>(double, double*) [clone .kd]	0	0	268	763517	763522	4194304	256	0	0	28	24	227968	0x7f1f1ca96500	0x7f1e10e37240	567347	567347	65536	8388608	1128009	143915536	12073442627601431	12073442627778084	12073442628152643	12073442628177312
137	135	void benchmark_func<__half2, 256, 8u, 56u>(__half2, __half2*) [clone .kd]	0	0	270	763517	763522	4194304	256	0	0	24	24	232000	0x7f1f1ca96400	0x7f1e10e37280	317273	317273	65536	8323072	1251287	160169740	12073442628224068	12073442628389282	12073442628592161	12073442628616408
138	136	void benchmark_func<int, 256, 8u, 56u>(int, int*) [clone .kd]	0	0	272	763517	763522	4194304	256	0	0	24	24	237824	0x7f1f1ca96300	0x7f1e10e372c0	804651	804651	65536	11927552	1684583	215001824	12073442628662483	12073442628827040	12073442629353277	12073442629383924
139	137	void benchmark_func<float, 256, 8u, 64u>(float, float*) [clone .kd]	0	0	274	763517	763522	4194304	256	0	0	24	24	242368	0x7f1f1ca96a00	0x7f1e10e37300	350305	350305	65536	9306112	1443573	184791460	12073442629436842	12073442629605756	12073442629831355	12073442629852835
140	138	void benchmark_func<HIP_vector_type<float, 2u>, 256, 8u, 64u>(HIP_vector_type<float, 2u>, HIP_vector_type<float, 2u>*) [clone .kd]	0	0	276	763517	763522	4194304	256	0	0	20	24	243584	0x7f1f1ca96900	0x7f1e10e37340	1206883	1206883	65536	29163520	3651387	467413296	12073442629898450	12073442630065754	12073442630867030	12073442630890604
141	139	void benchmark_func<double, 256, 8u, 64u>(double, double*) [clone .kd]	0	0	278	763517	763522	4194304	256	0	0	28	24	248128	0x7f1f1ca96800	0x7f1e10e37380	639081	639081	65536	9437184	1268919	163317228	12073442630935998	12073442631112309	12073442631533267	12073442631558515
142	140	void benchmark_func<__half2, 256, 8u, 64u>(__half2, __half2*) [clone .kd]	0	0	280	763517	763522	4194304	256	0	0	24	24	252672	0x7f1f1ca96700	0x7f1e10e373c0	353803	353803	65536	9371648	1417658	181490992	12073442631603919	12073442631767346	12073442631995185	12073442632018500
143	141	void benchmark_func<int, 256, 8u, 64u>(int, int*) [clone .kd]	0	0	282	763517	763522	4194304	256	0	0	24	24	259264	0x7f1f1ca96600	0x7f1e10e37400	909673	909673	65536	13500416	1917098	246449432	12073442632070116	12073442632237744	12073442632836781	12073442632881514
144	142	void benchmark_func<float, 256, 8u, 80u>(float, float*) [clone .kd]	0	0	284	763517	763522	4194304	256	0	0	24	24	264832	0x7f1f1ca96500	0x7f1e10e37440	418163	418163	65536	11403264	1750889	224148336	12073442632916459	12073442633124780	12073442633395818	12073442633443548
145	143	void benchmark_func<HIP_vector_type<float, 2u>, 256, 8u, 80u>(HIP_vector_type<float, 2u>, HIP_vector_type<float, 2u>*) [clone .kd]	0	0	286	763517	763522	4194304	256	0	0	20	24	266304	0x7f1f1ca96400	0x7f1e10e37480	1487201	1487201	65536	33357824	4174473	534512792	12073442633468194	12073442633651657	12073442634639173	12073442634687650
146	144	void benchmark_func<double, 256, 8u, 80u>(double, double*) [clone .kd]	0	0	288	763517	763522	4194304	256	0	0	28	24	271872	0x7f1f1ca96300	0x7f1e10e374c0	779427	779427	65536	11534336	1571634	202350808	12073442634712036	12073442634904451	12073442635421569	12073442635473180
147	145	void benchmark_func<__half2, 256, 8u, 80u>(__half2, __half2*) [clone .kd]	0	0	290	763517	763522	4194304	256	0	0	24	24	277440	0x7f1f1ca96a00	0x7f1e10e37500	423713	423713	65536	11534336	1750354	223987228	12073442635495692	12073442635686848	12073442635961087	12073442636016169
148	146	void benchmark_func<int, 256, 8u, 80u>(int, int*) [clone .kd]	0	0	292	763517	763522	4194304	256	0	0	12	24	279936	0x7f1f1ca96900	0x7f1e10e37540	1125667	1125667	65536	19267584	2422070	310140532	12073442636045944	12073442636225085	12073442636965082	12073442637033219
149	147	void benchmark_func<float, 256, 8u, 96u>(float, float*) [clone .kd]	0	0	294	763517	763522	4194304	256	0	0	24	24	286528	0x7f1f1ca96800	0x7f1e10e37580	531873	531873	65536	13500416	2073641	265457452	12073442637072111	12073442637241561	12073442637587479	12073442637655145
150	148	void benchmark_func<HIP_vector_type<float, 2u>, 256, 8u, 96u>(HIP_vector_type<float, 2u>, HIP_vector_type<float, 2u>*) [clone .kd]	0	0	296	763517	763522	4194304	256	0	0	20	24	288000	0x7f1f1ca96700	0x7f1e10e375c0	1769603	1769603	65536	37552128	4706256	601629020	12073442637673068	12073442637866998	12073442639041232	12073442639114186
151	149	void benchmark_func<double, 256, 8u, 96u>(double, double*) [clone .kd]	0	0	298	763517	763522	4194304	256	0	0	32	24	294592	0x7f1f1ca96600	0x7f1e10e37600	917137	917137	65536	13631488	1866721	239089076	12073442639144022	12073442639326991	12073442639937868	12073442639984093
152	150	void benchmark_func<__half2, 256, 8u, 96u>(__half2, __half2*) [clone .kd]	0	0	300	763517	763522	4194304	256	0	0	24	24	301184	0x7f1f1ca96500	0x7f1e10e37640	493547	493547	65536	13631488	2078891	266034532	12073442640008058	12073442640206827	12073442640526986	12073442640575632
153	151	void benchmark_func<int, 256, 8u, 96u>(int, int*) [clone .kd]	0	0	302	763517	763522	4194304	256	0	0	12	24	304960	0x7f1f1ca96400	0x7f1e10e37680	1335529	1335529	65536	21692416	2739938	350954280	12073442640600008	12073442640784424	12073442641662980	12073442641711714
154	152	void benchmark_func<float, 256, 8u, 128u>(float, float*) [clone .kd]	0	0	304	763517	763522	4194304	256	0	0	24	24	313600	0x7f1f1ca96300	0x7f1e10e376c0	630443	630443	65536	17694720	2715899	347766668	12073442641747310	12073442641915779	12073442642327457	12073442642395264
155	153	void benchmark_func<HIP_vector_type<float, 2u>, 256, 8u, 128u>(HIP_vector_type<float, 2u>, HIP_vector_type<float, 2u>*) [clone .kd]	0	0	306	763517	763522	4194304	256	0	0	20	24	314816	0x7f1f1ca96a00	0x7f1e10e37700	2331801	2331801	65536	57475072	7191477	920872432	12073442642420330	12073442642607616	12073442644158649	12073442644227729
156	154	void benchmark_func<double, 256, 8u, 128u>(double, double*) [clone .kd]	0	0	308	763517	763522	4194304	256	0	0	20	24	317568	0x7f1f1ca96900	0x7f1e10e37740	1200603	1200603	65536	19660800	2481756	317459580	12073442644251313	12073442644446327	12073442645244404	12073442645314148
157	155	void benchmark_func<__half2, 256, 8u, 128u>(__half2, __half2*) [clone .kd]	0	0	310	763517	763522	4194304	256	0	0	12	24	320320	0x7f1f1ca96800	0x7f1e10e37780	639313	639313	65536	20381696	2578971	330056884	12073442645345637	12073442645529042	12073442645945040	12073442645992238
158	156	void benchmark_func<int, 256, 8u, 128u>(int, int*) [clone .kd]	0	0	312	763517	763522	4194304	256	0	0	12	24	324096	0x7f1f1ca96700	0x7f1e10e377c0	1757595	1757595	65536	28704768	3614964	462498544	12073442646024749	12073442646215759	12073442647375434	12073442647446731
159	157	void benchmark_func<float, 256, 8u, 256u>(float, float*) [clone .kd]	0	0	314	763517	763522	4194304	256	0	0	12	24	328896	0x7f1f1ca96600	0x7f1e10e37800	1197489	1197489	65536	36634624	4646341	594862460	12073442647490533	12073442647659113	12073442648445349	12073442648515508
160	158	void benchmark_func<HIP_vector_type<float, 2u>, 256, 8u, 256u>(HIP_vector_type<float, 2u>, HIP_vector_type<float, 2u>*) [clone .kd]	0	0	316	763517	763522	4194304	256	0	0	20	24	330112	0x7f1f1ca96500	0x7f1e10e37840	4585291	4585291	65536	105840640	13234943	1694739508	12073442648543009	12073442648735108	12073442651787414	12073442651857709
161	159	void benchmark_func<double, 256, 8u, 256u>(double, double*) [clone .kd]	0	0	318	763517	763522	4194304	256	0	0	20	24	332864	0x7f1f1ca96400	0x7f1e10e37880	2325833	2325833	65536	38535168	4829407	618342656	12073442651886492	12073442652089492	12073442653633645	12073442653704821
162	160	void benchmark_func<__half2, 256, 8u, 256u>(__half2, __half2*) [clone .kd]	0	0	320	763517	763522	4194304	256	0	0	12	24	335616	0x7f1f1ca96300	0x7f1e10e378c0	1202539	1202539	65536	39124992	4913654	629036332	12073442653734216	12073442653924044	12073442654713160	12073442654783646
163	161	void benchmark_func<int, 256, 8u, 256u>(int, int*) [clone .kd]	0	0	322	763517	763522	4194304	256	0	0	12	24	339392	0x7f1f1ca96a00	0x7f1e10e37900	3443105	3443105	65536	55771136	7008597	897236852	12073442654817750	12073442655000199	12073442657283388	12073442657353011
164	162	void benchmark_func<float, 256, 8u, 512u>(float, float*) [clone .kd]	0	0	324	763517	763522	4194304	256	0	0	12	24	344192	0x7f1f1ca96900	0x7f1e10e37940	2323339	2323339	65536	72548352	9111881	1166246124	12073442657397834	12073442657569467	12073442659105300	12073442659174316
165	163	void benchmark_func<HIP_vector_type<float, 2u>, 256, 8u, 512u>(HIP_vector_type<float, 2u>, HIP_vector_type<float, 2u>*) [clone .kd]	0	0	326	763517	763522	4194304	256	0	0	20	24	345408	0x7f1f1ca96800	0x7f1e10e37980	9087865	9087865	65536	210698240	26338872	3372660336	12073442659197419	12073442659389138	12073442665446550	12073442665515139
166	164	void benchmark_func<double, 256, 8u, 512u>(double, double*) [clone .kd]	0	0	328	763517	763522	4194304	256	0	0	20	24	348160	0x7f1f1ca96700	0x7f1e10e379c0	4573131	4573131	65536	76283904	9537857	1222046692	12073442665545496	12073442665730229	12073442668775655	12073442668845268
167	165	void benchmark_func<__half2, 256, 8u, 512u>(__half2, __half2*) [clone .kd]	0	0	330	763517	763522	4194304	256	0	0	12	24	350912	0x7f1f1ca96600	0x7f1e10e37a00	2328265	2328265	65536	77398016	9705065	1242214316	12073442668874292	12073442669074694	12073442670614687	12073442670684546
168	166	void benchmark_func<int, 256, 8u, 512u>(int, int*) [clone .kd]	0	0	332	763517	763522	4194304	256	0	0	12	24	0	0x7f1f1ca96500	0x7f1e10e37a40	6813611	6813611	65536	110821376	13882173	1777294828	12073442670714332	12073442670903325	12073442675431624	12073442675501969