source: SVN/cambria/redboot/packages/redboot/current/src/memtester_tests.c @ 1

Last change on this file since 1 was 1, checked in by Tim Harvey, 2 years ago

restored latest version of files from server backup

Signed-off-by: Tim Harvey <tharvey@…>

File size: 14.8 KB
Line 
1/*
2 * Very simple but very effective user-space memory tester.
3 * Originally by Simon Kirby <sim@stormix.com> <sim@neato.org>
4 * Version 2 by Charles Cazabon <charlesc-memtester@pyropus.ca>
5 * Version 3 not publicly released.
6 * Version 4 rewrite:
7 * Copyright (C) 2004-2012 Charles Cazabon <charlesc-memtester@pyropus.ca>
8 * Licensed under the terms of the GNU General Public License version 2 (only).
9 * See the file COPYING for details.
10 *
11 * This file contains the functions for the actual tests, called from the
12 * main routine in memtester.c.  See other comments in that file.
13 *
14 */
15#define MEMTESTER_TESTS_C
16#include <redboot.h>
17//#include <sys/types.h>
18//#include <stdio.h>
19//#include <stdlib.h>
20//#include <limits.h>
21
22#include "memtester_types.h"
23#include "memtester_sizes.h"
24#include "memtester.h"
25
26char progress[] = "-\\|/";
27#define PROGRESSLEN 4
28#define PROGRESSOFTEN 2500
29#define ONE 0x00000001L
30
31#define mt_fflush(fp)
32#define mt_printf       diag_printf
33#define mt_putchar(c)   _mt_putchar((c))
34#define mt_rand_ul()    rand_ul()       // maps to "rand32()" or "rand64()"
35
36static long     holdrand;
37static void srand (unsigned int seed)
38{
39    #ifdef _MT
40        _getptd()->_holdrand = (unsigned long)seed;
41    #else /* _MT */
42        holdrand = (long)seed;
43    #endif /* _MT */
44}
45
46static int rand (void)
47{
48   #ifdef _MT
49    _ptiddata ptd = _getptd();
50    return( ((ptd->_holdrand = ptd->_holdrand * 214013L + 2531011L) >> 16) &
51    0x7fff );
52   #else /* _MT */
53    return(((holdrand = holdrand * 214013L + 2531011L) >> 16) & 0x7fff);
54   #endif /* _MT */
55}
56
57
58static void
59_mt_putchar(char c)
60{
61        mt_printf("%c", c);
62}
63
64
65
66/* Function definitions. */
67
68int compare_regions(ulv *bufa, ulv *bufb, size_t count) {
69    int r = 0;
70    size_t i;
71    ulv *p1 = bufa;
72    ulv *p2 = bufb;
73    off_t physaddr;
74
75    for (i = 0; i < count; i++, p1++, p2++) {
76        if (*p1 != *p2) {
77            if (use_phys) {
78                physaddr = physaddrbase + (i * sizeof(ul));
79                mt_printf( 
80                        "FAILURE: 0x%08lx != 0x%08lx at physical address "
81                        "0x%08lx.\n", 
82                        (ul) *p1, (ul) *p2, physaddr);
83            } else {
84                mt_printf( 
85                        "FAILURE: 0x%08lx != 0x%08lx at offset 0x%08lx.\n", 
86                        (ul) *p1, (ul) *p2, (ul) (i * sizeof(ul)));
87            }
88            /* mt_printf("Skipping to next test..."); */
89            r = -1;
90        }
91    }
92    return r;
93}
94
95int test_stuck_address(ulv *bufa, size_t count) {
96    ulv *p1 = bufa;
97    unsigned int j;
98    size_t i;
99    off_t physaddr;
100
101    mt_printf("           ");
102    mt_fflush(stdout);
103    for (j = 0; j < 16; j++) {
104        mt_printf("\b\b\b\b\b\b\b\b\b\b\b");
105        p1 = (ulv *) bufa;
106        mt_printf("setting %3u", j);
107        mt_fflush(stdout);
108        for (i = 0; i < count; i++) {
109            *p1 = ((j + i) % 2) == 0 ? (ul) p1 : ~((ul) p1);
110            *p1++;
111        }
112        mt_printf("\b\b\b\b\b\b\b\b\b\b\b");
113        mt_printf("testing %3u", j);
114        mt_fflush(stdout);
115        p1 = (ulv *) bufa;
116        for (i = 0; i < count; i++, p1++) {
117            if (*p1 != (((j + i) % 2) == 0 ? (ul) p1 : ~((ul) p1))) {
118                if (use_phys) {
119                    physaddr = physaddrbase + (i * sizeof(ul));
120                    mt_printf( 
121                            "FAILURE: possible bad address line at physical "
122                            "address 0x%08lx.\n", 
123                            physaddr);
124                } else {
125                    mt_printf( 
126                            "FAILURE: possible bad address line at offset "
127                            "0x%08lx.\n", 
128                            (ul) (i * sizeof(ul)));
129                }
130                mt_printf("Skipping to next test...\n");
131                mt_fflush(stdout);
132                return -1;
133            }
134        }
135    }
136    mt_printf("\b\b\b\b\b\b\b\b\b\b\b           \b\b\b\b\b\b\b\b\b\b\b");
137    mt_fflush(stdout);
138    return 0;
139}
140
141int test_random_value(ulv *bufa, ulv *bufb, size_t count) {
142    ulv *p1 = bufa;
143    ulv *p2 = bufb;
144    ul j = 0;
145    size_t i;
146
147    mt_putchar(' ');
148    mt_fflush(stdout);
149    for (i = 0; i < count; i++) {
150        *p1++ = *p2++ = mt_rand_ul();
151        if (!(i % PROGRESSOFTEN)) {
152            mt_putchar('\b');
153            mt_putchar(progress[++j % PROGRESSLEN]);
154            mt_fflush(stdout);
155        }
156    }
157    mt_printf("\b \b");
158    mt_fflush(stdout);
159    return compare_regions(bufa, bufb, count);
160}
161
162int test_xor_comparison(ulv *bufa, ulv *bufb, size_t count) {
163    ulv *p1 = bufa;
164    ulv *p2 = bufb;
165    size_t i;
166    ul q = mt_rand_ul();
167
168    for (i = 0; i < count; i++) {
169        *p1++ ^= q;
170        *p2++ ^= q;
171    }
172    return compare_regions(bufa, bufb, count);
173}
174
175int test_sub_comparison(ulv *bufa, ulv *bufb, size_t count) {
176    ulv *p1 = bufa;
177    ulv *p2 = bufb;
178    size_t i;
179    ul q = mt_rand_ul();
180
181    for (i = 0; i < count; i++) {
182        *p1++ -= q;
183        *p2++ -= q;
184    }
185    return compare_regions(bufa, bufb, count);
186}
187
188int test_mul_comparison(ulv *bufa, ulv *bufb, size_t count) {
189    ulv *p1 = bufa;
190    ulv *p2 = bufb;
191    size_t i;
192    ul q = mt_rand_ul();
193
194    for (i = 0; i < count; i++) {
195        *p1++ *= q;
196        *p2++ *= q;
197    }
198    return compare_regions(bufa, bufb, count);
199}
200
201int test_div_comparison(ulv *bufa, ulv *bufb, size_t count) {
202    ulv *p1 = bufa;
203    ulv *p2 = bufb;
204    size_t i;
205    ul q = mt_rand_ul();
206
207    for (i = 0; i < count; i++) {
208        if (!q) {
209            q++;
210        }
211        *p1++ /= q;
212        *p2++ /= q;
213    }
214    return compare_regions(bufa, bufb, count);
215}
216
217int test_or_comparison(ulv *bufa, ulv *bufb, size_t count) {
218    ulv *p1 = bufa;
219    ulv *p2 = bufb;
220    size_t i;
221    ul q = mt_rand_ul();
222
223    for (i = 0; i < count; i++) {
224        *p1++ |= q;
225        *p2++ |= q;
226    }
227    return compare_regions(bufa, bufb, count);
228}
229
230int test_and_comparison(ulv *bufa, ulv *bufb, size_t count) {
231    ulv *p1 = bufa;
232    ulv *p2 = bufb;
233    size_t i;
234    ul q = mt_rand_ul();
235
236    for (i = 0; i < count; i++) {
237        *p1++ &= q;
238        *p2++ &= q;
239    }
240    return compare_regions(bufa, bufb, count);
241}
242
243int test_seqinc_comparison(ulv *bufa, ulv *bufb, size_t count) {
244    ulv *p1 = bufa;
245    ulv *p2 = bufb;
246    size_t i;
247    ul q = mt_rand_ul();
248
249    for (i = 0; i < count; i++) {
250        *p1++ = *p2++ = (i + q);
251    }
252    return compare_regions(bufa, bufb, count);
253}
254
255int test_solidbits_comparison(ulv *bufa, ulv *bufb, size_t count) {
256    ulv *p1 = bufa;
257    ulv *p2 = bufb;
258    unsigned int j;
259    ul q;
260    size_t i;
261
262    mt_printf("           ");
263    mt_fflush(stdout);
264    for (j = 0; j < 64; j++) {
265        mt_printf("\b\b\b\b\b\b\b\b\b\b\b");
266        q = (j % 2) == 0 ? UL_ONEBITS : 0;
267        mt_printf("setting %3u", j);
268        mt_fflush(stdout);
269        p1 = (ulv *) bufa;
270        p2 = (ulv *) bufb;
271        for (i = 0; i < count; i++) {
272            *p1++ = *p2++ = (i % 2) == 0 ? q : ~q;
273        }
274        mt_printf("\b\b\b\b\b\b\b\b\b\b\b");
275        mt_printf("testing %3u", j);
276        mt_fflush(stdout);
277        if (compare_regions(bufa, bufb, count)) {
278            return -1;
279        }
280    }
281    mt_printf("\b\b\b\b\b\b\b\b\b\b\b           \b\b\b\b\b\b\b\b\b\b\b");
282    mt_fflush(stdout);
283    return 0;
284}
285
286int test_checkerboard_comparison(ulv *bufa, ulv *bufb, size_t count) {
287    ulv *p1 = bufa;
288    ulv *p2 = bufb;
289    unsigned int j;
290    ul q;
291    size_t i;
292
293    mt_printf("           ");
294    mt_fflush(stdout);
295    for (j = 0; j < 64; j++) {
296        mt_printf("\b\b\b\b\b\b\b\b\b\b\b");
297        q = (j % 2) == 0 ? CHECKERBOARD1 : CHECKERBOARD2;
298        mt_printf("setting %3u", j);
299        mt_fflush(stdout);
300        p1 = (ulv *) bufa;
301        p2 = (ulv *) bufb;
302        for (i = 0; i < count; i++) {
303            *p1++ = *p2++ = (i % 2) == 0 ? q : ~q;
304        }
305        mt_printf("\b\b\b\b\b\b\b\b\b\b\b");
306        mt_printf("testing %3u", j);
307        mt_fflush(stdout);
308        if (compare_regions(bufa, bufb, count)) {
309            return -1;
310        }
311    }
312    mt_printf("\b\b\b\b\b\b\b\b\b\b\b           \b\b\b\b\b\b\b\b\b\b\b");
313    mt_fflush(stdout);
314    return 0;
315}
316
317int test_blockseq_comparison(ulv *bufa, ulv *bufb, size_t count) {
318    ulv *p1 = bufa;
319    ulv *p2 = bufb;
320    unsigned int j;
321    size_t i;
322
323    mt_printf("           ");
324    mt_fflush(stdout);
325    for (j = 0; j < 256; j++) {
326        mt_printf("\b\b\b\b\b\b\b\b\b\b\b");
327        p1 = (ulv *) bufa;
328        p2 = (ulv *) bufb;
329        mt_printf("setting %3u", j);
330        mt_fflush(stdout);
331        for (i = 0; i < count; i++) {
332            *p1++ = *p2++ = (ul) UL_BYTE(j);
333        }
334        mt_printf("\b\b\b\b\b\b\b\b\b\b\b");
335        mt_printf("testing %3u", j);
336        mt_fflush(stdout);
337        if (compare_regions(bufa, bufb, count)) {
338            return -1;
339        }
340    }
341    mt_printf("\b\b\b\b\b\b\b\b\b\b\b           \b\b\b\b\b\b\b\b\b\b\b");
342    mt_fflush(stdout);
343    return 0;
344}
345
346int test_walkbits0_comparison(ulv *bufa, ulv *bufb, size_t count) {
347    ulv *p1 = bufa;
348    ulv *p2 = bufb;
349    unsigned int j;
350    size_t i;
351
352    mt_printf("           ");
353    mt_fflush(stdout);
354    for (j = 0; j < UL_LEN * 2; j++) {
355        mt_printf("\b\b\b\b\b\b\b\b\b\b\b");
356        p1 = (ulv *) bufa;
357        p2 = (ulv *) bufb;
358        mt_printf("setting %3u", j);
359        mt_fflush(stdout);
360        for (i = 0; i < count; i++) {
361            if (j < UL_LEN) { /* Walk it up. */
362                *p1++ = *p2++ = ONE << j;
363            } else { /* Walk it back down. */
364                *p1++ = *p2++ = ONE << (UL_LEN * 2 - j - 1);
365            }
366        }
367        mt_printf("\b\b\b\b\b\b\b\b\b\b\b");
368        mt_printf("testing %3u", j);
369        mt_fflush(stdout);
370        if (compare_regions(bufa, bufb, count)) {
371            return -1;
372        }
373    }
374    mt_printf("\b\b\b\b\b\b\b\b\b\b\b           \b\b\b\b\b\b\b\b\b\b\b");
375    mt_fflush(stdout);
376    return 0;
377}
378
379int test_walkbits1_comparison(ulv *bufa, ulv *bufb, size_t count) {
380    ulv *p1 = bufa;
381    ulv *p2 = bufb;
382    unsigned int j;
383    size_t i;
384
385    mt_printf("           ");
386    mt_fflush(stdout);
387    for (j = 0; j < UL_LEN * 2; j++) {
388        mt_printf("\b\b\b\b\b\b\b\b\b\b\b");
389        p1 = (ulv *) bufa;
390        p2 = (ulv *) bufb;
391        mt_printf("setting %3u", j);
392        mt_fflush(stdout);
393        for (i = 0; i < count; i++) {
394            if (j < UL_LEN) { /* Walk it up. */
395                *p1++ = *p2++ = UL_ONEBITS ^ (ONE << j);
396            } else { /* Walk it back down. */
397                *p1++ = *p2++ = UL_ONEBITS ^ (ONE << (UL_LEN * 2 - j - 1));
398            }
399        }
400        mt_printf("\b\b\b\b\b\b\b\b\b\b\b");
401        mt_printf("testing %3u", j);
402        mt_fflush(stdout);
403        if (compare_regions(bufa, bufb, count)) {
404            return -1;
405        }
406    }
407    mt_printf("\b\b\b\b\b\b\b\b\b\b\b           \b\b\b\b\b\b\b\b\b\b\b");
408    mt_fflush(stdout);
409    return 0;
410}
411
412int test_bitspread_comparison(ulv *bufa, ulv *bufb, size_t count) {
413    ulv *p1 = bufa;
414    ulv *p2 = bufb;
415    unsigned int j;
416    size_t i;
417
418    mt_printf("           ");
419    mt_fflush(stdout);
420    for (j = 0; j < UL_LEN * 2; j++) {
421        mt_printf("\b\b\b\b\b\b\b\b\b\b\b");
422        p1 = (ulv *) bufa;
423        p2 = (ulv *) bufb;
424        mt_printf("setting %3u", j);
425        mt_fflush(stdout);
426        for (i = 0; i < count; i++) {
427            if (j < UL_LEN) { /* Walk it up. */
428                *p1++ = *p2++ = (i % 2 == 0)
429                    ? (ONE << j) | (ONE << (j + 2))
430                    : UL_ONEBITS ^ ((ONE << j)
431                                    | (ONE << (j + 2)));
432            } else { /* Walk it back down. */
433                *p1++ = *p2++ = (i % 2 == 0)
434                    ? (ONE << (UL_LEN * 2 - 1 - j)) | (ONE << (UL_LEN * 2 + 1 - j))
435                    : UL_ONEBITS ^ (ONE << (UL_LEN * 2 - 1 - j)
436                                    | (ONE << (UL_LEN * 2 + 1 - j)));
437            }
438        }
439        mt_printf("\b\b\b\b\b\b\b\b\b\b\b");
440        mt_printf("testing %3u", j);
441        mt_fflush(stdout);
442        if (compare_regions(bufa, bufb, count)) {
443            return -1;
444        }
445    }
446    mt_printf("\b\b\b\b\b\b\b\b\b\b\b           \b\b\b\b\b\b\b\b\b\b\b");
447    mt_fflush(stdout);
448    return 0;
449}
450
451int test_bitflip_comparison(ulv *bufa, ulv *bufb, size_t count) {
452    ulv *p1 = bufa;
453    ulv *p2 = bufb;
454    unsigned int j, k;
455    ul q;
456    size_t i;
457
458    mt_printf("           ");
459    mt_fflush(stdout);
460    for (k = 0; k < UL_LEN; k++) {
461        q = ONE << k;
462        for (j = 0; j < 8; j++) {
463            mt_printf("\b\b\b\b\b\b\b\b\b\b\b");
464            q = ~q;
465            mt_printf("setting %3u", k * 8 + j);
466            mt_fflush(stdout);
467            p1 = (ulv *) bufa;
468            p2 = (ulv *) bufb;
469            for (i = 0; i < count; i++) {
470                *p1++ = *p2++ = (i % 2) == 0 ? q : ~q;
471            }
472            mt_printf("\b\b\b\b\b\b\b\b\b\b\b");
473            mt_printf("testing %3u", k * 8 + j);
474            mt_fflush(stdout);
475            if (compare_regions(bufa, bufb, count)) {
476                return -1;
477            }
478        }
479    }
480    mt_printf("\b\b\b\b\b\b\b\b\b\b\b           \b\b\b\b\b\b\b\b\b\b\b");
481    mt_fflush(stdout);
482    return 0;
483}
484
485#ifdef TEST_NARROW_WRITES   
486int test_8bit_wide_random(ulv* bufa, ulv* bufb, size_t count) {
487    u8v *p1, *t;
488    ulv *p2;
489    int attempt;
490    unsigned int b, j = 0;
491    size_t i;
492
493    mt_putchar(' ');
494    mt_fflush(stdout);
495    for (attempt = 0; attempt < 2;  attempt++) {
496        if (attempt & 1) {
497            p1 = (u8v *) bufa;
498            p2 = bufb;
499        } else {
500            p1 = (u8v *) bufb;
501            p2 = bufa;
502        }
503        for (i = 0; i < count; i++) {
504            t = mword8.bytes;
505            *p2++ = mword8.val = mt_rand_ul();
506            for (b=0; b < UL_LEN/8; b++) {
507                *p1++ = *t++;
508            }
509            if (!(i % PROGRESSOFTEN)) {
510                mt_putchar('\b');
511                mt_putchar(progress[++j % PROGRESSLEN]);
512                mt_fflush(stdout);
513            }
514        }
515        if (compare_regions(bufa, bufb, count)) {
516            return -1;
517        }
518    }
519    mt_printf("\b \b");
520    mt_fflush(stdout);
521    return 0;
522}
523
524int test_16bit_wide_random(ulv* bufa, ulv* bufb, size_t count) {
525    u16v *p1, *t;
526    ulv *p2;
527    int attempt;
528    unsigned int b, j = 0;
529    size_t i;
530
531    mt_putchar( ' ' );
532    mt_fflush( stdout );
533    for (attempt = 0; attempt < 2; attempt++) {
534        if (attempt & 1) {
535            p1 = (u16v *) bufa;
536            p2 = bufb;
537        } else {
538            p1 = (u16v *) bufb;
539            p2 = bufa;
540        }
541        for (i = 0; i < count; i++) {
542            t = mword16.u16s;
543            *p2++ = mword16.val = mt_rand_ul();
544            for (b = 0; b < UL_LEN/16; b++) {
545                *p1++ = *t++;
546            }
547            if (!(i % PROGRESSOFTEN)) {
548                mt_putchar('\b');
549                mt_putchar(progress[++j % PROGRESSLEN]);
550                mt_fflush(stdout);
551            }
552        }
553        if (compare_regions(bufa, bufb, count)) {
554            return -1;
555        }
556    }
557    mt_printf("\b \b");
558    mt_fflush(stdout);
559    return 0;
560}
561#endif
Note: See TracBrowser for help on using the repository browser.