@samitouri / QOSamiQemu
Code Commits Issues Pulls Sessions CI/CD
master
master
c 475 lines 15.7 KB
Raw
1 /*
2 * Copyright(c) 2019-2022 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 #include <stdio.h>
19 #include <stdint.h>
20
21 int err;
22
23 #include "hex_test.h"
24
25 #define DEBUG 0
26 #define DEBUG_PRINTF(...) \
27 do { \
28 if (DEBUG) { \
29 printf(__VA_ARGS__); \
30 } \
31 } while (0)
32
33
34 #define NBYTES (1 << 8)
35 #define NHALFS (NBYTES / sizeof(short))
36 #define NWORDS (NBYTES / sizeof(int))
37 #define NDOBLS (NBYTES / sizeof(long long))
38
39 int64_t dbuf[NDOBLS] __attribute__((aligned(1 << 12))) = {0};
40 int32_t wbuf[NWORDS] __attribute__((aligned(1 << 12))) = {0};
41 int16_t hbuf[NHALFS] __attribute__((aligned(1 << 12))) = {0};
42 uint8_t bbuf[NBYTES] __attribute__((aligned(1 << 12))) = {0};
43
44 /*
45 * We use the C preporcessor to deal with the combinations of types
46 */
47
48 #define INIT(BUF, N) \
49 void init_##BUF(void) \
50 { \
51 for (int i = 0; i < N; i++) { \
52 BUF[i] = i; \
53 } \
54 } \
55
56 INIT(bbuf, NBYTES)
57 INIT(hbuf, NHALFS)
58 INIT(wbuf, NWORDS)
59 INIT(dbuf, NDOBLS)
60
61 /*
62 * Macros for performing circular load
63 * RES result
64 * ADDR address
65 * START start address of buffer
66 * LEN length of buffer (in bytes)
67 * INC address increment (in bytes for IMM, elements for REG)
68 */
69 #define CIRC_LOAD_IMM(SIZE, RES, ADDR, START, LEN, INC) \
70 __asm__( \
71 "r4 = %3\n\t" \
72 "m0 = r4\n\t" \
73 "cs0 = %2\n\t" \
74 "%0 = mem" #SIZE "(%1++#" #INC ":circ(M0))\n\t" \
75 : "=r"(RES), "+r"(ADDR) \
76 : "r"(START), "r"(LEN) \
77 : "r4", "m0", "cs0")
78 #define CIRC_LOAD_IMM_b(RES, ADDR, START, LEN, INC) \
79 CIRC_LOAD_IMM(b, RES, ADDR, START, LEN, INC)
80 #define CIRC_LOAD_IMM_ub(RES, ADDR, START, LEN, INC) \
81 CIRC_LOAD_IMM(ub, RES, ADDR, START, LEN, INC)
82 #define CIRC_LOAD_IMM_h(RES, ADDR, START, LEN, INC) \
83 CIRC_LOAD_IMM(h, RES, ADDR, START, LEN, INC)
84 #define CIRC_LOAD_IMM_uh(RES, ADDR, START, LEN, INC) \
85 CIRC_LOAD_IMM(uh, RES, ADDR, START, LEN, INC)
86 #define CIRC_LOAD_IMM_w(RES, ADDR, START, LEN, INC) \
87 CIRC_LOAD_IMM(w, RES, ADDR, START, LEN, INC)
88 #define CIRC_LOAD_IMM_d(RES, ADDR, START, LEN, INC) \
89 CIRC_LOAD_IMM(d, RES, ADDR, START, LEN, INC)
90
91 /*
92 * The mreg has the following pieces
93 * mreg[31:28] increment[10:7]
94 * mreg[27:24] K value (used Hexagon v3 and earlier)
95 * mreg[23:17] increment[6:0]
96 * mreg[16:0] circular buffer length
97 */
98 static int32_t build_mreg(int32_t inc, int32_t K, int32_t len)
99 {
100 return ((inc & 0x780) << 21) |
101 ((K & 0xf) << 24) |
102 ((inc & 0x7f) << 17) |
103 (len & 0x1ffff);
104 }
105
106 #define CIRC_LOAD_REG(SIZE, RES, ADDR, START, LEN, INC) \
107 __asm__( \
108 "r4 = %2\n\t" \
109 "m1 = r4\n\t" \
110 "cs1 = %3\n\t" \
111 "%0 = mem" #SIZE "(%1++I:circ(M1))\n\t" \
112 : "=r"(RES), "+r"(ADDR) \
113 : "r"(build_mreg((INC), 0, (LEN))), \
114 "r"(START) \
115 : "r4", "m1", "cs1")
116 #define CIRC_LOAD_REG_b(RES, ADDR, START, LEN, INC) \
117 CIRC_LOAD_REG(b, RES, ADDR, START, LEN, INC)
118 #define CIRC_LOAD_REG_ub(RES, ADDR, START, LEN, INC) \
119 CIRC_LOAD_REG(ub, RES, ADDR, START, LEN, INC)
120 #define CIRC_LOAD_REG_h(RES, ADDR, START, LEN, INC) \
121 CIRC_LOAD_REG(h, RES, ADDR, START, LEN, INC)
122 #define CIRC_LOAD_REG_uh(RES, ADDR, START, LEN, INC) \
123 CIRC_LOAD_REG(uh, RES, ADDR, START, LEN, INC)
124 #define CIRC_LOAD_REG_w(RES, ADDR, START, LEN, INC) \
125 CIRC_LOAD_REG(w, RES, ADDR, START, LEN, INC)
126 #define CIRC_LOAD_REG_d(RES, ADDR, START, LEN, INC) \
127 CIRC_LOAD_REG(d, RES, ADDR, START, LEN, INC)
128
129 /*
130 * Macros for performing circular store
131 * VAL value to store
132 * ADDR address
133 * START start address of buffer
134 * LEN length of buffer (in bytes)
135 * INC address increment (in bytes for IMM, elements for REG)
136 */
137 #define CIRC_STORE_IMM(SIZE, PART, VAL, ADDR, START, LEN, INC) \
138 __asm__( \
139 "r4 = %3\n\t" \
140 "m0 = r4\n\t" \
141 "cs0 = %1\n\t" \
142 "mem" #SIZE "(%0++#" #INC ":circ(M0)) = %2" PART "\n\t" \
143 : "+r"(ADDR) \
144 : "r"(START), "r"(VAL), "r"(LEN) \
145 : "r4", "m0", "cs0", "memory")
146 #define CIRC_STORE_IMM_b(VAL, ADDR, START, LEN, INC) \
147 CIRC_STORE_IMM(b, "", VAL, ADDR, START, LEN, INC)
148 #define CIRC_STORE_IMM_h(VAL, ADDR, START, LEN, INC) \
149 CIRC_STORE_IMM(h, "", VAL, ADDR, START, LEN, INC)
150 #define CIRC_STORE_IMM_f(VAL, ADDR, START, LEN, INC) \
151 CIRC_STORE_IMM(h, ".H", VAL, ADDR, START, LEN, INC)
152 #define CIRC_STORE_IMM_w(VAL, ADDR, START, LEN, INC) \
153 CIRC_STORE_IMM(w, "", VAL, ADDR, START, LEN, INC)
154 #define CIRC_STORE_IMM_d(VAL, ADDR, START, LEN, INC) \
155 CIRC_STORE_IMM(d, "", VAL, ADDR, START, LEN, INC)
156
157 #define CIRC_STORE_NEW_IMM(SIZE, VAL, ADDR, START, LEN, INC) \
158 __asm__( \
159 "r4 = %3\n\t" \
160 "m0 = r4\n\t" \
161 "cs0 = %1\n\t" \
162 "{\n\t" \
163 " r5 = %2\n\t" \
164 " mem" #SIZE "(%0++#" #INC ":circ(M0)) = r5.new\n\t" \
165 "}\n\t" \
166 : "+r"(ADDR) \
167 : "r"(START), "r"(VAL), "r"(LEN) \
168 : "r4", "r5", "m0", "cs0", "memory")
169 #define CIRC_STORE_IMM_bnew(VAL, ADDR, START, LEN, INC) \
170 CIRC_STORE_NEW_IMM(b, VAL, ADDR, START, LEN, INC)
171 #define CIRC_STORE_IMM_hnew(VAL, ADDR, START, LEN, INC) \
172 CIRC_STORE_NEW_IMM(h, VAL, ADDR, START, LEN, INC)
173 #define CIRC_STORE_IMM_wnew(VAL, ADDR, START, LEN, INC) \
174 CIRC_STORE_NEW_IMM(w, VAL, ADDR, START, LEN, INC)
175
176 #define CIRC_STORE_REG(SIZE, PART, VAL, ADDR, START, LEN, INC) \
177 __asm__( \
178 "r4 = %1\n\t" \
179 "m1 = r4\n\t" \
180 "cs1 = %2\n\t" \
181 "mem" #SIZE "(%0++I:circ(M1)) = %3" PART "\n\t" \
182 : "+r"(ADDR) \
183 : "r"(build_mreg((INC), 0, (LEN))), \
184 "r"(START), \
185 "r"(VAL) \
186 : "r4", "m1", "cs1", "memory")
187 #define CIRC_STORE_REG_b(VAL, ADDR, START, LEN, INC) \
188 CIRC_STORE_REG(b, "", VAL, ADDR, START, LEN, INC)
189 #define CIRC_STORE_REG_h(VAL, ADDR, START, LEN, INC) \
190 CIRC_STORE_REG(h, "", VAL, ADDR, START, LEN, INC)
191 #define CIRC_STORE_REG_f(VAL, ADDR, START, LEN, INC) \
192 CIRC_STORE_REG(h, ".H", VAL, ADDR, START, LEN, INC)
193 #define CIRC_STORE_REG_w(VAL, ADDR, START, LEN, INC) \
194 CIRC_STORE_REG(w, "", VAL, ADDR, START, LEN, INC)
195 #define CIRC_STORE_REG_d(VAL, ADDR, START, LEN, INC) \
196 CIRC_STORE_REG(d, "", VAL, ADDR, START, LEN, INC)
197
198 #define CIRC_STORE_NEW_REG(SIZE, VAL, ADDR, START, LEN, INC) \
199 __asm__( \
200 "r4 = %1\n\t" \
201 "m1 = r4\n\t" \
202 "cs1 = %2\n\t" \
203 "{\n\t" \
204 " r5 = %3\n\t" \
205 " mem" #SIZE "(%0++I:circ(M1)) = r5.new\n\t" \
206 "}\n\t" \
207 : "+r"(ADDR) \
208 : "r"(build_mreg((INC), 0, (LEN))), \
209 "r"(START), \
210 "r"(VAL) \
211 : "r4", "r5", "m1", "cs1", "memory")
212 #define CIRC_STORE_REG_bnew(VAL, ADDR, START, LEN, INC) \
213 CIRC_STORE_NEW_REG(b, VAL, ADDR, START, LEN, INC)
214 #define CIRC_STORE_REG_hnew(VAL, ADDR, START, LEN, INC) \
215 CIRC_STORE_NEW_REG(h, VAL, ADDR, START, LEN, INC)
216 #define CIRC_STORE_REG_wnew(VAL, ADDR, START, LEN, INC) \
217 CIRC_STORE_NEW_REG(w, VAL, ADDR, START, LEN, INC)
218
219
220 /* We'll test increments +1 and -1 */
221 void __check_load(int line, int32_t i, int64_t res, int32_t inc, int32_t size)
222 {
223 int32_t expect = (i * inc);
224 while (expect >= size) {
225 expect -= size;
226 }
227 while (expect < 0) {
228 expect += size;
229 }
230 __check32(line, res, expect);
231 }
232
233 #define check_load(I, RES, INC, SZ) __check_load(__LINE__, I, RES, INC, SZ)
234
235 #define TEST_LOAD_IMM(SZ, TYPE, BUF, BUFSIZE, INC, FMT) \
236 void circ_test_load_imm_##SZ(void) \
237 { \
238 TYPE *p = (TYPE *)BUF; \
239 int32_t size = 10; \
240 for (int i = 0; i < BUFSIZE; i++) { \
241 TYPE element; \
242 CIRC_LOAD_IMM_##SZ(element, p, BUF, size * sizeof(TYPE), (INC)); \
243 DEBUG_PRINTF("i = %2d, p = 0x%p, element = %2" #FMT "\n", \
244 i, p, element); \
245 check_load(i, element, ((INC) / (int)sizeof(TYPE)), size); \
246 } \
247 p = (TYPE *)BUF; \
248 for (int i = 0; i < BUFSIZE; i++) { \
249 TYPE element; \
250 CIRC_LOAD_IMM_##SZ(element, p, BUF, size * sizeof(TYPE), -(INC)); \
251 DEBUG_PRINTF("i = %2d, p = 0x%p, element = %2" #FMT "\n", \
252 i, p, element); \
253 check_load(i, element, (-(INC) / (int)sizeof(TYPE)), size); \
254 } \
255 }
256
257 TEST_LOAD_IMM(b, int8_t, bbuf, NBYTES, 1, d)
258 TEST_LOAD_IMM(ub, uint8_t, bbuf, NBYTES, 1, d)
259 TEST_LOAD_IMM(h, int16_t, hbuf, NHALFS, 2, d)
260 TEST_LOAD_IMM(uh, uint16_t, hbuf, NHALFS, 2, d)
261 TEST_LOAD_IMM(w, int32_t, wbuf, NWORDS, 4, d)
262 TEST_LOAD_IMM(d, int64_t, dbuf, NDOBLS, 8, lld)
263
264 #define TEST_LOAD_REG(SZ, TYPE, BUF, BUFSIZE, FMT) \
265 void circ_test_load_reg_##SZ(void) \
266 { \
267 TYPE *p = (TYPE *)BUF; \
268 int32_t size = 13; \
269 for (int i = 0; i < BUFSIZE; i++) { \
270 TYPE element; \
271 CIRC_LOAD_REG_##SZ(element, p, BUF, size * sizeof(TYPE), 1); \
272 DEBUG_PRINTF("i = %2d, p = 0x%p, element = %2" #FMT "\n", \
273 i, p, element); \
274 check_load(i, element, 1, size); \
275 } \
276 p = (TYPE *)BUF; \
277 for (int i = 0; i < BUFSIZE; i++) { \
278 TYPE element; \
279 CIRC_LOAD_REG_##SZ(element, p, BUF, size * sizeof(TYPE), -1); \
280 DEBUG_PRINTF("i = %2d, p = 0x%p, element = %2" #FMT "\n", \
281 i, p, element); \
282 check_load(i, element, -1, size); \
283 } \
284 }
285
286 TEST_LOAD_REG(b, int8_t, bbuf, NBYTES, d)
287 TEST_LOAD_REG(ub, uint8_t, bbuf, NBYTES, d)
288 TEST_LOAD_REG(h, int16_t, hbuf, NHALFS, d)
289 TEST_LOAD_REG(uh, uint16_t, hbuf, NHALFS, d)
290 TEST_LOAD_REG(w, int32_t, wbuf, NWORDS, d)
291 TEST_LOAD_REG(d, int64_t, dbuf, NDOBLS, lld)
292
293 /* The circular stores will wrap around somewhere inside the buffer */
294 #define CIRC_VAL(SZ, TYPE, BUFSIZE) \
295 TYPE circ_val_##SZ(int i, int32_t inc, int32_t size) \
296 { \
297 int mod = BUFSIZE % size; \
298 int elem = i * inc; \
299 if (elem < 0) { \
300 if (-elem <= size - mod) { \
301 return (elem + BUFSIZE - mod); \
302 } else { \
303 return (elem + BUFSIZE + size - mod); \
304 } \
305 } else if (elem < mod) {\
306 return (elem + BUFSIZE - mod); \
307 } else { \
308 return (elem + BUFSIZE - size - mod); \
309 } \
310 }
311
312 CIRC_VAL(b, uint8_t, NBYTES)
313 CIRC_VAL(h, int16_t, NHALFS)
314 CIRC_VAL(w, int32_t, NWORDS)
315 CIRC_VAL(d, int64_t, NDOBLS)
316
317 /*
318 * Circular stores should only write to the first "size" elements of the buffer
319 * the remainder of the elements should have BUF[i] == i
320 */
321 #define CHECK_STORE(SZ, BUF, BUFSIZE, FMT) \
322 void check_store_##SZ(int32_t inc, int32_t size) \
323 { \
324 for (int i = 0; i < size; i++) { \
325 DEBUG_PRINTF(#BUF "[%3d] = 0x%02" #FMT ", guess = 0x%02" #FMT "\n", \
326 i, BUF[i], circ_val_##SZ(i, inc, size)); \
327 check64(BUF[i], circ_val_##SZ(i, inc, size)); \
328 } \
329 for (int i = size; i < BUFSIZE; i++) { \
330 check64(BUF[i], i); \
331 } \
332 }
333
334 CHECK_STORE(b, bbuf, NBYTES, x)
335 CHECK_STORE(h, hbuf, NHALFS, x)
336 CHECK_STORE(w, wbuf, NWORDS, x)
337 CHECK_STORE(d, dbuf, NDOBLS, llx)
338
339 #define CIRC_TEST_STORE_IMM(SZ, CHK, TYPE, BUF, BUFSIZE, SHIFT, INC) \
340 void circ_test_store_imm_##SZ(void) \
341 { \
342 uint32_t size = 27; \
343 TYPE *p = BUF; \
344 TYPE val = 0; \
345 init_##BUF(); \
346 for (int i = 0; i < BUFSIZE; i++) { \
347 CIRC_STORE_IMM_##SZ(val << SHIFT, p, BUF, size * sizeof(TYPE), INC); \
348 val++; \
349 } \
350 check_store_##CHK(((INC) / (int)sizeof(TYPE)), size); \
351 p = BUF; \
352 val = 0; \
353 init_##BUF(); \
354 for (int i = 0; i < BUFSIZE; i++) { \
355 CIRC_STORE_IMM_##SZ(val << SHIFT, p, BUF, size * sizeof(TYPE), \
356 -(INC)); \
357 val++; \
358 } \
359 check_store_##CHK((-(INC) / (int)sizeof(TYPE)), size); \
360 }
361
362 CIRC_TEST_STORE_IMM(b, b, uint8_t, bbuf, NBYTES, 0, 1)
363 CIRC_TEST_STORE_IMM(h, h, int16_t, hbuf, NHALFS, 0, 2)
364 CIRC_TEST_STORE_IMM(f, h, int16_t, hbuf, NHALFS, 16, 2)
365 CIRC_TEST_STORE_IMM(w, w, int32_t, wbuf, NWORDS, 0, 4)
366 CIRC_TEST_STORE_IMM(d, d, int64_t, dbuf, NDOBLS, 0, 8)
367 CIRC_TEST_STORE_IMM(bnew, b, uint8_t, bbuf, NBYTES, 0, 1)
368 CIRC_TEST_STORE_IMM(hnew, h, int16_t, hbuf, NHALFS, 0, 2)
369 CIRC_TEST_STORE_IMM(wnew, w, int32_t, wbuf, NWORDS, 0, 4)
370
371 #define CIRC_TEST_STORE_REG(SZ, CHK, TYPE, BUF, BUFSIZE, SHIFT) \
372 void circ_test_store_reg_##SZ(void) \
373 { \
374 TYPE *p = BUF; \
375 uint32_t size = 19; \
376 TYPE val = 0; \
377 init_##BUF(); \
378 for (int i = 0; i < BUFSIZE; i++) { \
379 CIRC_STORE_REG_##SZ(val << SHIFT, p, BUF, size * sizeof(TYPE), 1); \
380 val++; \
381 } \
382 check_store_##CHK(1, size); \
383 p = BUF; \
384 val = 0; \
385 init_##BUF(); \
386 for (int i = 0; i < BUFSIZE; i++) { \
387 CIRC_STORE_REG_##SZ(val << SHIFT, p, BUF, size * sizeof(TYPE), -1); \
388 val++; \
389 } \
390 check_store_##CHK(-1, size); \
391 }
392
393 CIRC_TEST_STORE_REG(b, b, uint8_t, bbuf, NBYTES, 0)
394 CIRC_TEST_STORE_REG(h, h, int16_t, hbuf, NHALFS, 0)
395 CIRC_TEST_STORE_REG(f, h, int16_t, hbuf, NHALFS, 16)
396 CIRC_TEST_STORE_REG(w, w, int32_t, wbuf, NWORDS, 0)
397 CIRC_TEST_STORE_REG(d, d, int64_t, dbuf, NDOBLS, 0)
398 CIRC_TEST_STORE_REG(bnew, b, uint8_t, bbuf, NBYTES, 0)
399 CIRC_TEST_STORE_REG(hnew, h, int16_t, hbuf, NHALFS, 0)
400 CIRC_TEST_STORE_REG(wnew, w, int32_t, wbuf, NWORDS, 0)
401
402 /* Test the old scheme used in Hexagon V3 */
403 static void circ_test_v3(void)
404 {
405 int *p = wbuf;
406 int32_t size = 15;
407 /* set high bit in K to test unsigned extract in fcirc */
408 int32_t K = 8; /* 1024 bytes */
409 int32_t element;
410
411 init_wbuf();
412
413 for (int i = 0; i < NWORDS; i++) {
414 __asm__(
415 "r4 = %2\n\t"
416 "m1 = r4\n\t"
417 "%0 = memw(%1++I:circ(M1))\n\t"
418 : "=r"(element), "+r"(p)
419 : "r"(build_mreg(1, K, size * sizeof(int)))
420 : "r4", "m1");
421 DEBUG_PRINTF("i = %2d, p = 0x%p, element = %2d\n", i, p, element);
422 check_load(i, element, 1, size);
423 }
424 }
425
426 int main()
427 {
428 init_bbuf();
429 init_hbuf();
430 init_wbuf();
431 init_dbuf();
432
433 DEBUG_PRINTF("NBYTES = %d\n", NBYTES);
434 DEBUG_PRINTF("Address of dbuf = 0x%p\n", dbuf);
435 DEBUG_PRINTF("Address of wbuf = 0x%p\n", wbuf);
436 DEBUG_PRINTF("Address of hbuf = 0x%p\n", hbuf);
437 DEBUG_PRINTF("Address of bbuf = 0x%p\n", bbuf);
438
439 circ_test_load_imm_b();
440 circ_test_load_imm_ub();
441 circ_test_load_imm_h();
442 circ_test_load_imm_uh();
443 circ_test_load_imm_w();
444 circ_test_load_imm_d();
445
446 circ_test_load_reg_b();
447 circ_test_load_reg_ub();
448 circ_test_load_reg_h();
449 circ_test_load_reg_uh();
450 circ_test_load_reg_w();
451 circ_test_load_reg_d();
452
453 circ_test_store_imm_b();
454 circ_test_store_imm_h();
455 circ_test_store_imm_f();
456 circ_test_store_imm_w();
457 circ_test_store_imm_d();
458 circ_test_store_imm_bnew();
459 circ_test_store_imm_hnew();
460 circ_test_store_imm_wnew();
461
462 circ_test_store_reg_b();
463 circ_test_store_reg_h();
464 circ_test_store_reg_f();
465 circ_test_store_reg_w();
466 circ_test_store_reg_d();
467 circ_test_store_reg_bnew();
468 circ_test_store_reg_hnew();
469 circ_test_store_reg_wnew();
470
471 circ_test_v3();
472
473 puts(err ? "FAIL" : "PASS");
474 return err ? 1 : 0;
475 }