Debian Codegraph @

gcc/testsuite/gcc.target/i386/amxfp8-dphf8ps-2.c

raw
1 /* { dg-do run { target { ! ia32 } } } */
2 /* { dg-require-effective-target amx_fp8 } */
3 /* { dg-options "-O2 -mamx-fp8" } */
4
5 #define AMX_FP8
6 #define DO_TEST test_amx_fp8_dphf8ps
7 void test_amx_fp8_dphf8ps ();
8
9 #include "amx-helper.h"
10 #include "fp8-helper.h"
11 #include "fp-emulation.h"
12
13 void
14 calc_matrix_dphf8ps (__tile *dst, __tile *src1, __tile *src2)
15 {
16 unsigned char *src1_buf = (unsigned char *)src1->buf;
17 unsigned char *src2_buf = (unsigned char *)src2->buf;
18 float *dst_buf = (float *)dst->buf;
19
20 int M = src1->rows;
21 int N = src1->colsb / 4;
22 int K = src2->colsb / 4;
23
24 int* valueState_a = (int*)malloc(sizeof(int));
25 int* valueState_b = (int*)malloc(sizeof(int));
26 int* valueState = (int *)malloc(M * K * sizeof(int));
27 __int128_t *temp = (__int128_t *)malloc(M * K * sizeof(__int128_t));
28
29 for (int i = 0; i < M; i++)
30 {
31 for (int j = 0; j < N; j++)
32 for (int k = 0; k < K; k++)
33 {
34 int64_t s1e0 = shift_fp8_to_int64(src1_buf[4 * i * N + 4 * j + 0], 0, valueState_a);
35 int64_t s2e0 = shift_fp8_to_int64(src2_buf[4 * j * K + 4 * k + 0], 0, valueState_b);
36 int valueState_e0 = state_handler(*valueState_a, *valueState_b, s1e0, s2e0, '*');
37
38 int64_t s1e1 = shift_fp8_to_int64(src1_buf[4 * i * N + 4 * j + 1], 0, valueState_a);
39 int64_t s2e1 = shift_fp8_to_int64(src2_buf[4 * j * K + 4 * k + 1], 0, valueState_b);
40 int valueState_e1 = state_handler(*valueState_a, *valueState_b, s1e1, s2e1, '*');
41
42 int64_t s1e2 = shift_fp8_to_int64(src1_buf[4 * i * N + 4 * j + 2], 0, valueState_a);
43 int64_t s2e2 = shift_fp8_to_int64(src2_buf[4 * j * K + 4 * k + 2], 0, valueState_b);
44 int valueState_e2 = state_handler(*valueState_a, *valueState_b, s1e2, s2e2, '*');
45
46 int64_t s1e3 = shift_fp8_to_int64(src1_buf[4 * i * N + 4 * j + 3], 0, valueState_a);
47 int64_t s2e3 = shift_fp8_to_int64(src2_buf[4 * j * K + 4 * k + 3], 0, valueState_b);
48 int valueState_e3 = state_handler(*valueState_a, *valueState_b, s1e3, s2e3, '*');
49
50 valueState[i * K + k] = state_handler(
51 state_handler(
52 state_handler(
53 state_handler(
54 valueState_e0, valueState_e1, (__int128_t)s1e0 * s2e0, s1e1 * s2e1, '+'),
55 valueState_e2, (__int128_t)s1e0 * s2e0 + s1e1 * s2e1, s1e2 * s2e2, '+'),
56 valueState_e3, (__int128_t)s1e0 * s2e0 + s1e1 * s2e1 + s1e2 * s2e2, s1e3 * s2e3, '+'),
57 valueState[i * K + k], (__int128_t)s1e0 * s2e0 + s1e1 * s2e1 + s1e2 * s2e2 + s1e3 * s2e3, temp[i * K + k], '+');
58
59 temp[i * K + k] += (__int128_t)s1e0 * (__int128_t)s2e0
60 + (__int128_t)s1e1 * (__int128_t)s2e1
61 + (__int128_t)s1e2 * (__int128_t)s2e2
62 + (__int128_t)s1e3 * (__int128_t)s2e3;
63 }
64 }
65
66 for (int i = 0; i < M; i++)
67 for (int k = 0; k < K; k++)
68 {
69 float tmp_float = shift_int128_to_fp32(temp[i * K + k], 0, 0);
70 if (isnan(dst_buf[i * K + k]) || isnan(tmp_float))
71 dst_buf[i * K + k] = -nanf("");
72 else switch(valueState[i * K + k])
73 {
74 case -3:
75 dst_buf[i * K + k] = -INFINITY;
76 break;
77 case 3:
78 dst_buf[i * K + k] = 1.0 / 0.0;
79 break;
80 case 2:
81 case -2:
82 dst_buf[i * K + k] = -nanf("");
83 break;
84 case -1:
85 case 0:
86 case 1:
87 default:
88 dst_buf[i * K + k] += tmp_float;
89 break;
90 }
91 }
92
93 free(valueState_a);
94 free(valueState_b);
95 free(valueState);
96 free(temp);
97 }
98
99 void test_amx_fp8_dphf8ps ()
100 {
101 __tilecfg_u cfg;
102 __tile dst, dst_ref, src1, src2;
103 uint8_t tmp_dst_zero_buf[1024], tmp_src_buf[1024];
104
105 init_fp32_max_tile_zero_buffer (tmp_dst_zero_buf);
106 init_fp8_max_tile_buffer(tmp_src_buf);
107
108 init_tile_config (&cfg);
109 init_tile_reg_and_src_with_buffer (1, dst, tmp_dst_zero_buf);
110 init_tile_reg_and_src_with_buffer (2, src1, tmp_src_buf);
111 init_tile_reg_and_src_with_buffer (3, src2, tmp_src_buf);
112
113 calc_matrix_dphf8ps (&dst, &src1, &src2);
114
115 _tile_dphf8ps (1, 2, 3);
116 _tile_stored (1, dst_ref.buf, _STRIDE);
117
118 if (!check_float_tile_register (&dst_ref, &dst))
119 abort ();
120 }