1 /*
2 * Copyright(c) 2021-2023 Qualcomm Innovation Center, Inc. All Rights Reserved.
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, see <http://www.gnu.org/licenses/>.
16 */
17
18 #ifndef HVX_MISC_H
19 #define HVX_MISC_H
20
check(int line,int i,int j,uint64_t result,uint64_t expect)21 static inline void check(int line, int i, int j,
22 uint64_t result, uint64_t expect)
23 {
24 if (result != expect) {
25 printf("ERROR at line %d: [%d][%d] 0x%016llx != 0x%016llx\n",
26 line, i, j, result, expect);
27 err++;
28 }
29 }
30
31 #define MAX_VEC_SIZE_BYTES 128
32
33 typedef union {
34 uint64_t ud[MAX_VEC_SIZE_BYTES / 8];
35 int64_t d[MAX_VEC_SIZE_BYTES / 8];
36 uint32_t uw[MAX_VEC_SIZE_BYTES / 4];
37 int32_t w[MAX_VEC_SIZE_BYTES / 4];
38 uint16_t uh[MAX_VEC_SIZE_BYTES / 2];
39 int16_t h[MAX_VEC_SIZE_BYTES / 2];
40 uint8_t ub[MAX_VEC_SIZE_BYTES / 1];
41 int8_t b[MAX_VEC_SIZE_BYTES / 1];
42 } MMVector;
43
44 #define BUFSIZE 16
45 #define OUTSIZE 16
46 #define MASKMOD 3
47
48 MMVector buffer0[BUFSIZE] __attribute__((aligned(MAX_VEC_SIZE_BYTES)));
49 MMVector buffer1[BUFSIZE] __attribute__((aligned(MAX_VEC_SIZE_BYTES)));
50 MMVector mask[BUFSIZE] __attribute__((aligned(MAX_VEC_SIZE_BYTES)));
51 MMVector output[OUTSIZE] __attribute__((aligned(MAX_VEC_SIZE_BYTES)));
52 MMVector expect[OUTSIZE] __attribute__((aligned(MAX_VEC_SIZE_BYTES)));
53
54 #define CHECK_OUTPUT_FUNC(FIELD, FIELDSZ) \
55 static inline void check_output_##FIELD(int line, size_t num_vectors) \
56 { \
57 for (int i = 0; i < num_vectors; i++) { \
58 for (int j = 0; j < MAX_VEC_SIZE_BYTES / FIELDSZ; j++) { \
59 check(line, i, j, output[i].FIELD[j], expect[i].FIELD[j]); \
60 } \
61 } \
62 }
63
64 CHECK_OUTPUT_FUNC(d, 8)
65 CHECK_OUTPUT_FUNC(w, 4)
66 CHECK_OUTPUT_FUNC(h, 2)
67 CHECK_OUTPUT_FUNC(b, 1)
68
init_buffers(void)69 static inline void init_buffers(void)
70 {
71 int counter0 = 0;
72 int counter1 = 17;
73 for (int i = 0; i < BUFSIZE; i++) {
74 for (int j = 0; j < MAX_VEC_SIZE_BYTES; j++) {
75 buffer0[i].b[j] = counter0++;
76 buffer1[i].b[j] = counter1++;
77 }
78 for (int j = 0; j < MAX_VEC_SIZE_BYTES / 4; j++) {
79 mask[i].w[j] = (i + j % MASKMOD == 0) ? 0 : 1;
80 }
81 }
82 }
83
84 #define VEC_OP1(ASM, EL, IN, OUT) \
85 asm("v2 = vmem(%0 + #0)\n\t" \
86 "v2" #EL " = " #ASM "(v2" #EL ")\n\t" \
87 "vmem(%1 + #0) = v2\n\t" \
88 : : "r"(IN), "r"(OUT) : "v2", "memory")
89
90 #define VEC_OP2(ASM, EL, IN0, IN1, OUT) \
91 asm("v2 = vmem(%0 + #0)\n\t" \
92 "v3 = vmem(%1 + #0)\n\t" \
93 "v2" #EL " = " #ASM "(v2" #EL ", v3" #EL ")\n\t" \
94 "vmem(%2 + #0) = v2\n\t" \
95 : : "r"(IN0), "r"(IN1), "r"(OUT) : "v2", "v3", "memory")
96
97 #define TEST_VEC_OP1(NAME, ASM, EL, FIELD, FIELDSZ, OP) \
98 static inline void test_##NAME(void) \
99 { \
100 void *pin = buffer0; \
101 void *pout = output; \
102 for (int i = 0; i < BUFSIZE; i++) { \
103 VEC_OP1(ASM, EL, pin, pout); \
104 pin += sizeof(MMVector); \
105 pout += sizeof(MMVector); \
106 } \
107 for (int i = 0; i < BUFSIZE; i++) { \
108 for (int j = 0; j < MAX_VEC_SIZE_BYTES / FIELDSZ; j++) { \
109 expect[i].FIELD[j] = OP buffer0[i].FIELD[j]; \
110 } \
111 } \
112 check_output_##FIELD(__LINE__, BUFSIZE); \
113 }
114
115 #define TEST_VEC_OP2(NAME, ASM, EL, FIELD, FIELDSZ, OP) \
116 static inline void test_##NAME(void) \
117 { \
118 void *p0 = buffer0; \
119 void *p1 = buffer1; \
120 void *pout = output; \
121 for (int i = 0; i < BUFSIZE; i++) { \
122 VEC_OP2(ASM, EL, p0, p1, pout); \
123 p0 += sizeof(MMVector); \
124 p1 += sizeof(MMVector); \
125 pout += sizeof(MMVector); \
126 } \
127 for (int i = 0; i < BUFSIZE; i++) { \
128 for (int j = 0; j < MAX_VEC_SIZE_BYTES / FIELDSZ; j++) { \
129 expect[i].FIELD[j] = buffer0[i].FIELD[j] OP buffer1[i].FIELD[j]; \
130 } \
131 } \
132 check_output_##FIELD(__LINE__, BUFSIZE); \
133 }
134
135 #define THRESHOLD 31
136
137 #define PRED_OP2(ASM, IN0, IN1, OUT, INV) \
138 asm("r4 = #%3\n\t" \
139 "v1.b = vsplat(r4)\n\t" \
140 "v2 = vmem(%0 + #0)\n\t" \
141 "q0 = vcmp.gt(v2.b, v1.b)\n\t" \
142 "v3 = vmem(%1 + #0)\n\t" \
143 "q1 = vcmp.gt(v3.b, v1.b)\n\t" \
144 "q2 = " #ASM "(q0, " INV "q1)\n\t" \
145 "r4 = #0xff\n\t" \
146 "v1.b = vsplat(r4)\n\t" \
147 "if (q2) vmem(%2 + #0) = v1\n\t" \
148 : : "r"(IN0), "r"(IN1), "r"(OUT), "i"(THRESHOLD) \
149 : "r4", "v1", "v2", "v3", "q0", "q1", "q2", "memory")
150
151 #define TEST_PRED_OP2(NAME, ASM, OP, INV) \
152 static inline void test_##NAME(bool invert) \
153 { \
154 void *p0 = buffer0; \
155 void *p1 = buffer1; \
156 void *pout = output; \
157 memset(output, 0, sizeof(expect)); \
158 for (int i = 0; i < BUFSIZE; i++) { \
159 PRED_OP2(ASM, p0, p1, pout, INV); \
160 p0 += sizeof(MMVector); \
161 p1 += sizeof(MMVector); \
162 pout += sizeof(MMVector); \
163 } \
164 for (int i = 0; i < BUFSIZE; i++) { \
165 for (int j = 0; j < MAX_VEC_SIZE_BYTES; j++) { \
166 bool p0 = (buffer0[i].b[j] > THRESHOLD); \
167 bool p1 = (buffer1[i].b[j] > THRESHOLD); \
168 if (invert) { \
169 expect[i].b[j] = (p0 OP !p1) ? 0xff : 0x00; \
170 } else { \
171 expect[i].b[j] = (p0 OP p1) ? 0xff : 0x00; \
172 } \
173 } \
174 } \
175 check_output_b(__LINE__, BUFSIZE); \
176 }
177
178 #endif
179