![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to testacc.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Isaki's NoNo m68k/m88k emulator] / nono / m680x0|
Return to testacc.cpp CVS log | Up to [Isaki's NoNo m68k/m88k emulator] / nono / m680x0 |
1.1 root 1: //
2: // nono
3: // Copyright (C) 2017 [email protected]
4: //
5:
6: #include "header.h"
7: #include <csignal>
8: #include "m68030core.h"
9: #include "m68030acc.h"
10:
11: // パフォーマンステストの秒数
12: #define PERF_SEC (3)
13:
14: void usage();
15:
16: m68kcpu *cpu;
17:
18: int argc; // getopt(3) 処理後の argc
19: const char **argv; // getopt(3) 処理後の argv
20: const char *testname; // 現在のテスト名
21: int total_errcnt; // 総エラー数
22: int errcnt; // 現在のセクションのエラー数
23: char where[256]; // エラー発生箇所
24: volatile int perf_signaled; // パフォーマンス測定用
25: struct timeval perf_start; // パフォーマンス測定開始時刻
26: uint64 perf_count; // パフォーマンス測定用。処理回数
27:
28: // 整数(32bitまで)を検査する
29: void
30: xp_equal(uint32 expected, uint32 actual, const char *name)
31: {
32: if (expected != actual) {
33: if (errcnt == 0) {
34: printf("\n");
35: }
36: printf(" %s: %s expects 0x%08x but 0x%08x\n",
37: where, name, expected, actual);
38: errcnt++;
39: }
40: }
41:
42: // 値(32bitまで)と CCR を検査する
43: void
44: xp_equal(uint32 actValue, m68030ccr& actCCR, uint32 expValue,
45: bool expX, bool expN, bool expZ, bool expV, bool expC)
46: {
47: if (expValue != actValue ||
48: expX != actCCR.IsX() ||
49: expN != actCCR.IsN() ||
50: expZ != actCCR.IsZ() ||
51: expV != actCCR.IsV() ||
52: expC != actCCR.IsC())
53: {
54: if (errcnt == 0) {
55: printf("\n");
56: }
57: printf("%s %s expects %08x %c%c%c%c%c but %08x %c%c%c%c%c\n",
58: testname, where,
59: expValue,
60: (expX ? 'X' : '-'),
61: (expN ? 'N' : '-'),
62: (expZ ? 'Z' : '-'),
63: (expV ? 'V' : '-'),
64: (expC ? 'C' : '-'),
65: actValue,
66: (actCCR.IsX() ? 'X' : '-'),
67: (actCCR.IsN() ? 'N' : '-'),
68: (actCCR.IsZ() ? 'Z' : '-'),
69: (actCCR.IsV() ? 'V' : '-'),
70: (actCCR.IsC() ? 'C' : '-')
71: );
72: errcnt++;
73: }
74: }
75:
76: // 値(64bit)と CCR を検査する
77: void
78: xp_equal64(uint64 actValue, m68030ccr& actCCR, uint64 expValue,
79: bool expX, bool expN, bool expZ, bool expV, bool expC)
80: {
81: if (expValue != actValue ||
82: expX != actCCR.IsX() ||
83: expN != actCCR.IsN() ||
84: expZ != actCCR.IsZ() ||
85: expV != actCCR.IsV() ||
86: expC != actCCR.IsC())
87: {
88: if (errcnt == 0) {
89: printf("\n");
90: }
91: printf("%s %s expects %08x_%08x %c%c%c%c%c but %08x_%08x %c%c%c%c%c\n",
92: testname, where,
93: (uint32)(expValue >> 32),
94: (uint32)(expValue & 0xffffffff),
95: (expX ? 'X' : '-'),
96: (expN ? 'N' : '-'),
97: (expZ ? 'Z' : '-'),
98: (expV ? 'V' : '-'),
99: (expC ? 'C' : '-'),
100: (uint32)(actValue >> 32),
101: (uint32)(actValue & 0xffffffff),
102: (actCCR.IsX() ? 'X' : '-'),
103: (actCCR.IsN() ? 'N' : '-'),
104: (actCCR.IsZ() ? 'Z' : '-'),
105: (actCCR.IsV() ? 'V' : '-'),
106: (actCCR.IsC() ? 'C' : '-')
107: );
108: errcnt++;
109: }
110: }
111:
112: // このテストを実行するかどうか
113: // 引数なしなら全部実行。
114: // 引数ありなら一致すれば実行。
115: bool
116: check_exec(const char *name)
117: {
118: if (argc == 0) {
119: return true;
120: }
121:
122: // "test_"/"perf_" を除いた後ろが完全一致するか
123: name += 5;
124: for (int i = 0; i < argc; i++) {
125: if (strcmp(name, argv[i]) == 0) {
126: return true;
127: }
128: }
129:
130: // サイズ部を除いて一致するか
131: // add に対して addx が一致しないようにアンダーバーまでで調べる
132: char name2[strlen(name) + 1];
133: strcpy(name2, name);
134: char *u = strchr(name2, '_');
135: if (u) {
136: *u = '\0';
137: }
138: for (int i = 0; i < argc; i++) {
139: if (strcmp(name2, argv[i]) == 0) {
140: return true;
141: }
142: }
143:
144: return false;
145: }
146:
147: #define start_test() \
148: if (!check_exec(__FUNCTION__)) \
149: return; \
150: start_test_func(__FUNCTION__)
151:
152: void
153: start_test_func(const char *name)
154: {
155: testname = name;
156: printf("%s ", testname);
157: fflush(stdout);
158: errcnt = 0;
159: }
160:
161: void
162: end_test()
163: {
164: if (errcnt == 0) {
165: printf("ok\n");
166: } else {
167: printf("%d error(s)\n", errcnt);
168: }
169: total_errcnt += errcnt;
170: }
171:
172: #define START_PERF \
173: if (!check_exec(__FUNCTION__)) \
174: return; \
175: start_perf_func(__FUNCTION__)
176:
177: #define END_PERF \
178: end_perf_func()
179:
180: void
181: signal_alarm(int signo)
182: {
183: perf_signaled = 1;
184: }
185:
186: void
187: start_perf_func(const char *name)
188: {
189: testname = name;
190: printf("%s\t... ", testname);
191: fflush(stdout);
192:
193: perf_count = 0;
194: perf_signaled = 0;
195: signal(SIGALRM, signal_alarm);
196: struct itimerval it = {};
197: it.it_value.tv_sec = PERF_SEC;
198:
199: gettimeofday(&perf_start, NULL);
200: setitimer(ITIMER_REAL, &it, NULL);
201: }
202:
203: void
204: end_perf_func()
205: {
206: struct timeval end, result;
207:
208: gettimeofday(&end, NULL);
209: timersub(&end, &perf_start, &result);
210:
211: uint64 usec = (uint64)result.tv_sec * 1000000 + (uint64)result.tv_usec;
212: printf("%" PRIu64 " times/usec\n", perf_count / usec);
213: }
214:
215: // 乱数
216: uint32
217: xor32()
218: {
219: static uint32 y = 2463534242;
220: y = y ^ (y << 13);
221: y = y ^ (y >> 17);
222: y = y ^ (y << 5);
223: return y;
224: }
225:
226: // sz ビット目(最下位を0とする)を立てた値を返す
227: // sz は 0..63
228: uint64
229: BIT(int sz)
230: {
231: return (1ULL << sz);
232: }
233:
234: // 下位 sz ビットがすべて 1 の値を返す
235: uint32
236: MASK(int sz)
237: {
238: return (1ULL << sz) - 1;
239: }
240:
241: // value を sz ビット符号付き整数とした時、負かどうかを返す
242: // sz は 8, 16, 32
243: bool
244: ISNEG(uint64 value, int sz)
245: {
246: return ((value & BIT(sz - 1)) != 0);
247: }
248:
249: //
250: // add,sub
251: //
252:
253: uint32 add_table[] = {
254: 0x00000000,
255: 0x00000001,
256: 0x0000007f,
257: 0x00000080,
258: 0x000000ff,
259: 0x00007fff,
260: 0x00008000,
261: 0x0000ffff,
262: 0x7fffffff,
263: 0x80000000,
264: 0xffffffff,
265: };
266:
267: void
268: test_add(int sz)
269: {
270: for (int i = 0; i < countof(add_table); i++) {
271: for (int j = 0; j < countof(add_table); j++) {
272: uint64 src = add_table[i] & MASK(sz);
273: uint64 dst = add_table[j] & MASK(sz);
274:
275: uint64 tmp = src + dst;
276: uint64 res = tmp & MASK(sz);
277: sprintf(where, "%0*" PRIx64 " + %0*" PRIx64,
278: (sz / 4), src, (sz / 4), dst);
279: bool C = tmp & BIT(sz);
280: bool V = ((res ^ src) & (res ^ dst)) & BIT(sz - 1);
281:
282: uint32 actual;
283: if (sz == 8) {
284: actual = acc_add_8(cpu, src, dst);
285: } else if (sz == 16) {
286: actual = acc_add_16(cpu, src, dst);
287: } else {
288: actual = acc_add_32(cpu, src, dst);
289: }
290:
291: xp_equal(actual, CCR, res,
292: C, ISNEG(res, sz), (res == 0), V, C);
293: }
294: }
295: }
296:
297: void
298: test_add_8()
299: {
300: start_test();
301: test_add(8);
302: end_test();
303: }
304:
305: void
306: test_add_16()
307: {
308: start_test();
309: test_add(16);
310: end_test();
311: }
312:
313: void
314: test_add_32()
315: {
316: start_test();
317: test_add(32);
318: end_test();
319: }
320:
321: void
322: test_sub(int sz)
323: {
324: for (int i = 0; i < countof(add_table); i++) {
325: for (int j = 0; j < countof(add_table); j++) {
326: uint64 src = add_table[i] & MASK(sz);
327: uint64 dst = add_table[j] & MASK(sz);
328:
329: uint64 tmp;
330: if (sz == 8) {
331: tmp = (uint64)dst - (uint64)src;
332: } else if (sz == 16) {
333: tmp = (uint64)dst - (uint64)src;
334: } else {
335: tmp = (uint64)dst - (uint64)src;
336: }
337: uint64 res = tmp & MASK(sz);
338: sprintf(where, "%0*" PRIx64 " - %0*" PRIx64,
339: (sz / 4), dst, (sz / 4), src);
340: bool C = tmp & BIT(sz);
341: bool V = ((src ^ dst) & (res ^ dst)) & BIT(sz - 1);
342:
343: uint32 actual;
344: if (sz == 8) {
345: actual = acc_sub_8(cpu, src, dst);
346: } else if (sz == 16) {
347: actual = acc_sub_16(cpu, src, dst);
348: } else {
349: actual = acc_sub_32(cpu, src, dst);
350: }
351:
352: xp_equal(actual, CCR, res,
353: C, ISNEG(res, sz), (res == 0), V, C);
354: }
355: }
356: }
357:
358: void
359: test_sub_8()
360: {
361: start_test();
362: test_sub(8);
363: end_test();
364: }
365:
366: void
367: test_sub_16()
368: {
369: start_test();
370: test_sub(16);
371: end_test();
372: }
373:
374: void
375: test_sub_32()
376: {
377: start_test();
378: test_sub(32);
379: end_test();
380: }
381:
382:
383: //
384: // addx
385: //
386: struct {
387: uint32 src, dst;
388: bool inX;
389: uint32 res;
390: bool expN, expZ, expV, expC;
391: } addx32_table[] = {
392: // src dst X res N Z V C
393: { 0x00000000, 0xffffffff, 0, 0xffffffff, 1, 0, 0, 0 },
394: { 0x00000000, 0xffffffff, 1, 0x00000000, 0, 1, 0, 1 },
395: { 0x7fffffff, 0x00000001, 0, 0x80000000, 1, 0, 1, 0 },
396: { 0x7fffffff, 0x00000000, 1, 0x80000000, 1, 0, 1, 0 },
397: { 0x7fffffff, 0x80000000, 1, 0x00000000, 0, 1, 0, 1 },
398: };
399:
400: void
401: test_addx_32()
402: {
403: start_test();
404: for (int i = 0; i < countof(addx32_table); i++) {
405: uint32 src = addx32_table[i].src;
406: uint32 dst = addx32_table[i].dst;
407: bool inX = addx32_table[i].inX;
408: uint32 res = addx32_table[i].res;
409: bool expN = addx32_table[i].expN;
410: bool expZ = addx32_table[i].expZ;
411: bool expV = addx32_table[i].expV;
412: bool expC = addx32_table[i].expC;
413: sprintf(where, "%08x + %08x + %d", src, dst, inX);
414:
415: CCR.PutX(inX);
416: CCR.PutZ(true);
417: uint32 actual = acc_addx_32(cpu, src, dst);
418: xp_equal(actual, CCR, res, expC, expN, expZ, expV, expC);
419: }
420: end_test();
421: }
422:
423: //
424: // rotate/shift
425: //
426:
427: // ローテート/シフト系のパフォーマンス測定
428: #define DEFINE_PERF_ROTATE(name) \
429: void \
430: __CONCAT(perf_,name)() \
431: { \
432: START_PERF; \
433: volatile uint32 dst = 0; \
434: for (; perf_signaled == 0;) { \
435: for (int count = 0; count < 32; count++) { \
436: uint32 src = xor32(); \
437: dst ^= __CONCAT(acc_,name)(cpu, src, count); \
438: perf_count++; \
439: } \
440: } \
441: END_PERF; \
442: }
443: DEFINE_PERF_ROTATE(asl_32)
444: DEFINE_PERF_ROTATE(lsl_32)
445: DEFINE_PERF_ROTATE(roxl_32)
446: DEFINE_PERF_ROTATE(rol_32)
447: DEFINE_PERF_ROTATE(asr_32)
448: DEFINE_PERF_ROTATE(lsr_32)
449: DEFINE_PERF_ROTATE(roxr_32)
450: DEFINE_PERF_ROTATE(ror_32)
451:
452: void
453: perf_add_32()
454: {
455: START_PERF;
456: volatile uint32 dst = 0;
457: for (; perf_signaled == 0; ) {
458: uint32 src = xor32();
459: dst = acc_add_32(cpu, src, dst);
460: perf_count++;
461: }
462: END_PERF;
463: }
464:
465: int
466: main(int ac, char *av[])
467: {
468: int c;
469: bool do_test;
470: bool do_perf;
471:
472: do_test = true;
473: do_perf = true;
474:
475: while ((c = getopt(ac, av, "tp")) != -1) {
476: switch (c) {
477: case 't': // test only
478: do_perf = false;
479: break;
480: case 'p': // perf only
481: do_test = false;
482: break;
483: default:
484: usage();
485: }
486: }
487: ac -= optind;
488: av += optind;
489: argc = ac;
490: argv = (const char **)av;
491:
492: // 本当はコンストラクタを呼ぶべきだが、そうすると必要なオブジェクトが
493: // 芋づる式に増えて正しく解決するのは面倒。ここのテストではとりあえず
494: // 存在しててアクセスできればいい程度なのでこれで誤魔化してある。
495: cpu = (m68kcpu *)calloc(sizeof(*cpu), 1);
496:
497: if (do_test) {
498: test_add_8();
499: test_add_16();
500: test_add_32();
501: test_sub_8();
502: test_sub_16();
503: test_sub_32();
504: test_addx_32();
505: }
506:
507: if (do_perf) {
508: perf_asl_32();
509: perf_lsl_32();
510: perf_roxl_32();
511: perf_rol_32();
512: perf_asr_32();
513: perf_lsr_32();
514: perf_roxr_32();
515: perf_ror_32();
516: perf_add_32();
517: }
518:
519: return 0;
520: }
521:
522: void
523: usage()
524: {
525: fprintf(stderr, "usage: %s [-t] [-p]\n", getprogname());
526: exit(1);
527: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.