635 lines
13 KiB
C
635 lines
13 KiB
C
/* SPDX-License-Identifier: GPL-2.0 */
|
|
/*
|
|
* Very simple but very effective user-space memory tester.
|
|
* Originally by Simon Kirby <sim@stormix.com> <sim@neato.org>
|
|
* Version 2 by Charles Cazabon <charlesc-memtester@pyropus.ca>
|
|
* Version 3 not publicly released.
|
|
* Version 4 rewrite:
|
|
* Copyright (C) 2004-2012 Charles Cazabon <charlesc-memtester@pyropus.ca>
|
|
* Licensed under the terms of the GNU General Public License version 2 (only).
|
|
* See the file COPYING for details.
|
|
*
|
|
* This file contains the functions for the actual tests, called from the
|
|
* main routine in memtester.c. See other comments in that file.
|
|
*
|
|
*/
|
|
|
|
#include "memtester.h"
|
|
#include "sizes.h"
|
|
#include "types.h"
|
|
#include "../io_map.h"
|
|
|
|
union {
|
|
unsigned char bytes[UL_LEN / 8];
|
|
u32 val;
|
|
} mword8;
|
|
|
|
union {
|
|
unsigned short u16s[UL_LEN / 16];
|
|
u32 val;
|
|
} mword16;
|
|
|
|
char progress[] = "-\\|/";
|
|
#define PROGRESSLEN 4
|
|
#define PROGRESSOFTEN 2500
|
|
#define ONE 0x00000001L
|
|
|
|
#define fflush(n)
|
|
|
|
/* Function definitions. */
|
|
int compare_regions(u32v *bufa, u32v *bufb, size_t count)
|
|
{
|
|
int r = 0;
|
|
size_t i;
|
|
u32v *p1 = bufa;
|
|
u32v *p2 = bufb;
|
|
off_t physaddr;
|
|
|
|
for (i = 0; i < count; i++, p1++, p2++) {
|
|
if (*p1 != *p2) {
|
|
if (use_phys) {
|
|
physaddr = physaddrbase + (i * sizeof(u32v));
|
|
fprintf(stderr,
|
|
"FAILURE: 0x%08lx != 0x%08lx at physical address "
|
|
"0x%08lx.\n",
|
|
(ul)*p1, (ul)*p2, physaddr);
|
|
} else {
|
|
fprintf(stderr,
|
|
"FAILURE: 0x%08lx != 0x%08lx at offset 0x%08lx.\n",
|
|
(ul)*p1, (ul)*p2,
|
|
(ul)(i * sizeof(u32v)));
|
|
}
|
|
/* printf("Skipping to next test..."); */
|
|
r = -1;
|
|
}
|
|
}
|
|
return r;
|
|
}
|
|
|
|
int test_stuck_address(u32v *bufa, size_t count)
|
|
{
|
|
u32v *p1 = bufa;
|
|
unsigned int j;
|
|
size_t i;
|
|
off_t physaddr;
|
|
|
|
printf(" ");
|
|
fflush(stdout);
|
|
for (j = 0; j < 16; j++) {
|
|
printf("\b\b\b\b\b\b\b\b\b\b\b");
|
|
p1 = (u32v *)bufa;
|
|
printf("setting %3u", j);
|
|
fflush(stdout);
|
|
for (i = 0; i < count; i++) {
|
|
*p1 = ((j + i) % 2) == 0 ? (u32)(ul)p1 : ~((u32)(ul)p1);
|
|
*p1++;
|
|
}
|
|
printf("\b\b\b\b\b\b\b\b\b\b\b");
|
|
printf("testing %3u", j);
|
|
fflush(stdout);
|
|
p1 = (u32v *)bufa;
|
|
for (i = 0; i < count; i++, p1++) {
|
|
if (*p1 != (((j + i) % 2) == 0 ?
|
|
(u32)(ul)p1 : ~((u32)(ul)p1))) {
|
|
if (use_phys) {
|
|
physaddr =
|
|
physaddrbase + (i * sizeof(u32v));
|
|
fprintf(stderr,
|
|
"FAILURE: possible bad address line at physical "
|
|
"address 0x%08lx.\n", physaddr);
|
|
} else {
|
|
fprintf(stderr,
|
|
"FAILURE: possible bad address line at offset "
|
|
"0x%08lx.\n",
|
|
(ul)(i * sizeof(u32v)));
|
|
}
|
|
printf("Skipping to next test...\n");
|
|
fflush(stdout);
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
printf("\b\b\b\b\b\b\b\b\b\b\b \b\b\b\b\b\b\b\b\b\b\b");
|
|
fflush(stdout);
|
|
return 0;
|
|
}
|
|
|
|
int test_random_value(u32v *bufa, u32v *bufb, size_t count,
|
|
ul fix_bit, ul fix_level)
|
|
{
|
|
u32v *p1 = bufa;
|
|
u32v *p2 = bufb;
|
|
ul j = 0;
|
|
size_t i;
|
|
|
|
putc(' ');
|
|
fflush(stdout);
|
|
for (i = 0; i < count; i++) {
|
|
*p1++ = *p2++ = rand_ul();
|
|
if (!(i % PROGRESSOFTEN)) {
|
|
putc('\b');
|
|
putc(progress[++j % PROGRESSLEN]);
|
|
fflush(stdout);
|
|
}
|
|
}
|
|
printf("\b \b");
|
|
fflush(stdout);
|
|
return compare_regions(bufa, bufb, count);
|
|
}
|
|
|
|
int test_xor_comparison(u32v *bufa, u32v *bufb, size_t count,
|
|
ul fix_bit, ul fix_level)
|
|
|
|
{
|
|
u32v *p1 = bufa;
|
|
u32v *p2 = bufb;
|
|
size_t i;
|
|
u32 q = rand_ul();
|
|
|
|
for (i = 0; i < count; i++) {
|
|
*p1++ ^= q;
|
|
*p2++ ^= q;
|
|
}
|
|
return compare_regions(bufa, bufb, count);
|
|
}
|
|
|
|
int test_sub_comparison(u32v *bufa, u32v *bufb, size_t count,
|
|
ul fix_bit, ul fix_level)
|
|
{
|
|
u32v *p1 = bufa;
|
|
u32v *p2 = bufb;
|
|
size_t i;
|
|
u32 q = rand_ul();
|
|
|
|
for (i = 0; i < count; i++) {
|
|
*p1++ -= q;
|
|
*p2++ -= q;
|
|
}
|
|
return compare_regions(bufa, bufb, count);
|
|
}
|
|
|
|
int test_mul_comparison(u32v *bufa, u32v *bufb, size_t count,
|
|
ul fix_bit, ul fix_level)
|
|
{
|
|
u32v *p1 = bufa;
|
|
u32v *p2 = bufb;
|
|
size_t i;
|
|
u32 q = rand_ul();
|
|
|
|
for (i = 0; i < count; i++) {
|
|
*p1++ *= q;
|
|
*p2++ *= q;
|
|
}
|
|
return compare_regions(bufa, bufb, count);
|
|
}
|
|
|
|
int test_div_comparison(u32v *bufa, u32v *bufb, size_t count,
|
|
ul fix_bit, ul fix_level)
|
|
{
|
|
u32v *p1 = bufa;
|
|
u32v *p2 = bufb;
|
|
size_t i;
|
|
u32 q = rand_ul();
|
|
|
|
for (i = 0; i < count; i++) {
|
|
if (!q)
|
|
q++;
|
|
*p1++ /= q;
|
|
*p2++ /= q;
|
|
}
|
|
return compare_regions(bufa, bufb, count);
|
|
}
|
|
|
|
int test_or_comparison(u32v *bufa, u32v *bufb, size_t count,
|
|
ul fix_bit, ul fix_level)
|
|
{
|
|
u32v *p1 = bufa;
|
|
u32v *p2 = bufb;
|
|
size_t i;
|
|
u32 q = rand_ul();
|
|
|
|
for (i = 0; i < count; i++) {
|
|
*p1++ |= q;
|
|
*p2++ |= q;
|
|
}
|
|
return compare_regions(bufa, bufb, count);
|
|
}
|
|
|
|
int test_and_comparison(u32v *bufa, u32v *bufb, size_t count,
|
|
ul fix_bit, ul fix_level)
|
|
{
|
|
u32v *p1 = bufa;
|
|
u32v *p2 = bufb;
|
|
size_t i;
|
|
u32 q = rand_ul();
|
|
|
|
for (i = 0; i < count; i++) {
|
|
*p1++ &= q;
|
|
*p2++ &= q;
|
|
}
|
|
return compare_regions(bufa, bufb, count);
|
|
}
|
|
|
|
int test_seqinc_comparison(u32v *bufa, u32v *bufb, size_t count,
|
|
ul fix_bit, ul fix_level)
|
|
{
|
|
u32v *p1 = bufa;
|
|
u32v *p2 = bufb;
|
|
size_t i;
|
|
u32 q = rand_ul();
|
|
|
|
for (i = 0; i < count; i++)
|
|
*p1++ = *p2++ = (i + q);
|
|
return compare_regions(bufa, bufb, count);
|
|
}
|
|
|
|
int test_solidbits_comparison(u32v *bufa, u32v *bufb, size_t count,
|
|
ul fix_bit, ul fix_level)
|
|
{
|
|
u32v *p1 = bufa;
|
|
u32v *p2 = bufb;
|
|
unsigned int j;
|
|
u32 q;
|
|
u32 data[4];
|
|
size_t i;
|
|
|
|
printf(" ");
|
|
fflush(stdout);
|
|
for (j = 0; j < 64; j++) {
|
|
printf("\b\b\b\b\b\b\b\b\b\b\b");
|
|
q = (j % 2) == 0 ? UL_ONEBITS : 0;
|
|
if (fix_level)
|
|
q |= fix_bit;
|
|
else
|
|
q &= ~fix_bit;
|
|
data[0] = data[2] = q;
|
|
data[1] = data[3] = ~q;
|
|
data_cpu_2_io(data, sizeof(data));
|
|
printf("setting %3u", j);
|
|
fflush(stdout);
|
|
p1 = (u32v *)bufa;
|
|
p2 = (u32v *)bufb;
|
|
for (i = 0; i < count; i++)
|
|
*p1++ = *p2++ = data[i & 3];
|
|
printf("\b\b\b\b\b\b\b\b\b\b\b");
|
|
printf("testing %3u", j);
|
|
fflush(stdout);
|
|
if (compare_regions(bufa, bufb, count))
|
|
return -1;
|
|
}
|
|
printf("\b\b\b\b\b\b\b\b\b\b\b \b\b\b\b\b\b\b\b\b\b\b");
|
|
fflush(stdout);
|
|
return 0;
|
|
}
|
|
|
|
int test_checkerboard_comparison(u32v *bufa, u32v *bufb, size_t count,
|
|
ul fix_bit, ul fix_level)
|
|
{
|
|
u32v *p1 = bufa;
|
|
u32v *p2 = bufb;
|
|
unsigned int j;
|
|
u32 q;
|
|
u32 data[4];
|
|
size_t i;
|
|
|
|
printf(" ");
|
|
fflush(stdout);
|
|
for (j = 0; j < 64; j++) {
|
|
printf("\b\b\b\b\b\b\b\b\b\b\b");
|
|
q = (j % 2) == 0 ? CHECKERBOARD1 : CHECKERBOARD2;
|
|
if (fix_level)
|
|
q |= fix_bit;
|
|
else
|
|
q &= ~fix_bit;
|
|
|
|
data[0] = data[2] = q;
|
|
data[1] = data[3] = ~q;
|
|
data_cpu_2_io(data, sizeof(data));
|
|
printf("setting %3u", j);
|
|
fflush(stdout);
|
|
p1 = (u32v *)bufa;
|
|
p2 = (u32v *)bufb;
|
|
for (i = 0; i < count; i++)
|
|
*p1++ = *p2++ = data[i & 3];
|
|
printf("\b\b\b\b\b\b\b\b\b\b\b");
|
|
printf("testing %3u", j);
|
|
fflush(stdout);
|
|
if (compare_regions(bufa, bufb, count))
|
|
return -1;
|
|
}
|
|
printf("\b\b\b\b\b\b\b\b\b\b\b \b\b\b\b\b\b\b\b\b\b\b");
|
|
fflush(stdout);
|
|
return 0;
|
|
}
|
|
|
|
int test_blockseq_comparison(u32v *bufa, u32v *bufb, size_t count,
|
|
ul fix_bit, ul fix_level)
|
|
{
|
|
u32v *p1 = bufa;
|
|
u32v *p2 = bufb;
|
|
unsigned int j;
|
|
u32 data[4];
|
|
u32 q;
|
|
size_t i;
|
|
|
|
printf(" ");
|
|
fflush(stdout);
|
|
for (j = 0; j < 256; j++) {
|
|
printf("\b\b\b\b\b\b\b\b\b\b\b");
|
|
p1 = (u32v *)bufa;
|
|
p2 = (u32v *)bufb;
|
|
printf("setting %3u", j);
|
|
fflush(stdout);
|
|
q = (u32)UL_BYTE(j);
|
|
if (fix_level)
|
|
q |= fix_bit;
|
|
else
|
|
q &= ~fix_bit;
|
|
|
|
data[0] = q;
|
|
data[1] = q;
|
|
data[2] = q;
|
|
data[3] = q;
|
|
|
|
data_cpu_2_io(data, sizeof(data));
|
|
|
|
for (i = 0; i < count; i++)
|
|
*p1++ = *p2++ = data[i & 3];
|
|
printf("\b\b\b\b\b\b\b\b\b\b\b");
|
|
printf("testing %3u", j);
|
|
fflush(stdout);
|
|
if (compare_regions(bufa, bufb, count))
|
|
return -1;
|
|
}
|
|
printf("\b\b\b\b\b\b\b\b\b\b\b \b\b\b\b\b\b\b\b\b\b\b");
|
|
fflush(stdout);
|
|
return 0;
|
|
}
|
|
|
|
int test_walkbits0_comparison(u32v *bufa, u32v *bufb, size_t count,
|
|
ul fix_bit, ul fix_level)
|
|
{
|
|
u32v *p1 = bufa;
|
|
u32v *p2 = bufb;
|
|
unsigned int j;
|
|
u32 data[4];
|
|
u32 q;
|
|
size_t i;
|
|
|
|
printf(" ");
|
|
fflush(stdout);
|
|
for (j = 0; j < UL_LEN * 2; j++) {
|
|
printf("\b\b\b\b\b\b\b\b\b\b\b");
|
|
p1 = (u32v *)bufa;
|
|
p2 = (u32v *)bufb;
|
|
printf("setting %3u", j);
|
|
fflush(stdout);
|
|
if (j < UL_LEN)
|
|
q = ONE << j;
|
|
else
|
|
q = ONE << (UL_LEN * 2 - j - 1);
|
|
|
|
if (fix_level)
|
|
q |= fix_bit;
|
|
else
|
|
q &= ~fix_bit;
|
|
|
|
data[0] = q;
|
|
data[1] = q;
|
|
data[2] = q;
|
|
data[3] = q;
|
|
data_cpu_2_io(data, sizeof(data));
|
|
|
|
for (i = 0; i < count; i++) {
|
|
*p1++ = *p2++ = data[i & 3];
|
|
}
|
|
printf("\b\b\b\b\b\b\b\b\b\b\b");
|
|
printf("testing %3u", j);
|
|
fflush(stdout);
|
|
if (compare_regions(bufa, bufb, count))
|
|
return -1;
|
|
}
|
|
printf("\b\b\b\b\b\b\b\b\b\b\b \b\b\b\b\b\b\b\b\b\b\b");
|
|
fflush(stdout);
|
|
return 0;
|
|
}
|
|
|
|
int test_walkbits1_comparison(u32v *bufa, u32v *bufb, size_t count,
|
|
ul fix_bit, ul fix_level)
|
|
{
|
|
u32v *p1 = bufa;
|
|
u32v *p2 = bufb;
|
|
unsigned int j;
|
|
u32 data[4];
|
|
u32 q;
|
|
size_t i;
|
|
|
|
printf(" ");
|
|
fflush(stdout);
|
|
for (j = 0; j < UL_LEN * 2; j++) {
|
|
printf("\b\b\b\b\b\b\b\b\b\b\b");
|
|
p1 = (u32v *)bufa;
|
|
p2 = (u32v *)bufb;
|
|
printf("setting %3u", j);
|
|
fflush(stdout);
|
|
if (j < UL_LEN)
|
|
q = UL_ONEBITS ^ (ONE << j);
|
|
else
|
|
q = UL_ONEBITS ^ (ONE << (UL_LEN * 2 - j - 1));
|
|
if (fix_level)
|
|
q |= fix_bit;
|
|
else
|
|
q &= ~fix_bit;
|
|
|
|
data[0] = q;
|
|
data[1] = q;
|
|
data[2] = q;
|
|
data[3] = q;
|
|
data_cpu_2_io(data, sizeof(data));
|
|
|
|
for (i = 0; i < count; i++) {
|
|
*p1++ = *p2++ = data[i & 3];
|
|
}
|
|
printf("\b\b\b\b\b\b\b\b\b\b\b");
|
|
printf("testing %3u", j);
|
|
fflush(stdout);
|
|
if (compare_regions(bufa, bufb, count))
|
|
return -1;
|
|
}
|
|
printf("\b\b\b\b\b\b\b\b\b\b\b \b\b\b\b\b\b\b\b\b\b\b");
|
|
fflush(stdout);
|
|
return 0;
|
|
}
|
|
|
|
int test_bitspread_comparison(u32v *bufa, u32v *bufb, size_t count,
|
|
ul fix_bit, ul fix_level)
|
|
{
|
|
u32v *p1 = bufa;
|
|
u32v *p2 = bufb;
|
|
unsigned int j;
|
|
u32 data[4];
|
|
size_t i;
|
|
|
|
printf(" ");
|
|
fflush(stdout);
|
|
for (j = 0; j < UL_LEN * 2; j++) {
|
|
printf("\b\b\b\b\b\b\b\b\b\b\b");
|
|
p1 = (u32v *)bufa;
|
|
p2 = (u32v *)bufb;
|
|
printf("setting %3u", j);
|
|
fflush(stdout);
|
|
if (j < UL_LEN) {
|
|
data[0] = (ONE << j) | (ONE << (j + 2));
|
|
data[1] = UL_ONEBITS ^ ((ONE << j) | (ONE << (j + 2)));
|
|
} else {
|
|
data[0] = (ONE << (UL_LEN * 2 - 1 - j)) |
|
|
(ONE << (UL_LEN * 2 + 1 - j));
|
|
data[1] = UL_ONEBITS ^ (ONE << (UL_LEN * 2 - 1 - j)
|
|
| (ONE << (UL_LEN * 2 + 1 - j)));
|
|
}
|
|
if (fix_level) {
|
|
data[0] |= fix_bit;
|
|
data[1] |= fix_bit;
|
|
} else {
|
|
data[0] &= ~fix_bit;
|
|
data[1] &= ~fix_bit;
|
|
}
|
|
data[2] = data[0];
|
|
data[3] = data[1];
|
|
data_cpu_2_io(data, sizeof(data));
|
|
|
|
for (i = 0; i < count; i++) {
|
|
*p1++ = *p2++ = data[i & 3];
|
|
}
|
|
printf("\b\b\b\b\b\b\b\b\b\b\b");
|
|
printf("testing %3u", j);
|
|
fflush(stdout);
|
|
if (compare_regions(bufa, bufb, count))
|
|
return -1;
|
|
}
|
|
printf("\b\b\b\b\b\b\b\b\b\b\b \b\b\b\b\b\b\b\b\b\b\b");
|
|
fflush(stdout);
|
|
return 0;
|
|
}
|
|
|
|
int test_bitflip_comparison(u32v *bufa, u32v *bufb, size_t count,
|
|
ul fix_bit, ul fix_level)
|
|
{
|
|
u32v *p1 = bufa;
|
|
u32v *p2 = bufb;
|
|
unsigned int j, k;
|
|
u32 q;
|
|
u32 data[4];
|
|
size_t i;
|
|
|
|
printf(" ");
|
|
fflush(stdout);
|
|
for (k = 0; k < UL_LEN; k++) {
|
|
q = ONE << k;
|
|
for (j = 0; j < 8; j++) {
|
|
printf("\b\b\b\b\b\b\b\b\b\b\b");
|
|
q = ~q;
|
|
printf("setting %3u", k * 8 + j);
|
|
fflush(stdout);
|
|
if (fix_level)
|
|
q |= fix_bit;
|
|
else
|
|
q &= ~fix_bit;
|
|
|
|
data[0] = data[2] = q;
|
|
data[1] = data[3] = ~q;
|
|
data_cpu_2_io(data, sizeof(data));
|
|
p1 = (u32v *)bufa;
|
|
p2 = (u32v *)bufb;
|
|
for (i = 0; i < count; i++)
|
|
*p1++ = *p2++ = data[i & 3];
|
|
printf("\b\b\b\b\b\b\b\b\b\b\b");
|
|
printf("testing %3u", k * 8 + j);
|
|
fflush(stdout);
|
|
if (compare_regions(bufa, bufb, count))
|
|
return -1;
|
|
}
|
|
}
|
|
printf("\b\b\b\b\b\b\b\b\b\b\b \b\b\b\b\b\b\b\b\b\b\b");
|
|
fflush(stdout);
|
|
return 0;
|
|
}
|
|
|
|
#ifdef TEST_NARROW_WRITES
|
|
int test_8bit_wide_random(u32v *bufa, u32v *bufb, size_t count,
|
|
ul fix_bit, ul fix_level)
|
|
{
|
|
u8v *p1, *t;
|
|
u32v *p2;
|
|
int attempt;
|
|
unsigned int b, j = 0;
|
|
size_t i;
|
|
|
|
putc(' ');
|
|
fflush(stdout);
|
|
for (attempt = 0; attempt < 2; attempt++) {
|
|
if (attempt & 1) {
|
|
p1 = (u8v *)bufa;
|
|
p2 = bufb;
|
|
} else {
|
|
p1 = (u8v *)bufb;
|
|
p2 = bufa;
|
|
}
|
|
for (i = 0; i < count; i++) {
|
|
t = mword8.bytes;
|
|
*p2++ = mword8.val = rand_ul();
|
|
for (b = 0; b < UL_LEN / 8; b++)
|
|
*p1++ = *t++;
|
|
if (!(i % PROGRESSOFTEN)) {
|
|
putc('\b');
|
|
putc(progress[++j % PROGRESSLEN]);
|
|
fflush(stdout);
|
|
}
|
|
}
|
|
if (compare_regions(bufa, bufb, count))
|
|
return -1;
|
|
}
|
|
printf("\b \b");
|
|
fflush(stdout);
|
|
return 0;
|
|
}
|
|
|
|
int test_16bit_wide_random(u32v *bufa, u32v *bufb, size_t count,
|
|
ul fix_bit, ul fix_level)
|
|
{
|
|
u16v *p1, *t;
|
|
u32v *p2;
|
|
int attempt;
|
|
unsigned int b, j = 0;
|
|
size_t i;
|
|
|
|
putc(' ');
|
|
fflush(stdout);
|
|
for (attempt = 0; attempt < 2; attempt++) {
|
|
if (attempt & 1) {
|
|
p1 = (u16v *)bufa;
|
|
p2 = bufb;
|
|
} else {
|
|
p1 = (u16v *)bufb;
|
|
p2 = bufa;
|
|
}
|
|
for (i = 0; i < count; i++) {
|
|
t = mword16.u16s;
|
|
*p2++ = mword16.val = rand_ul();
|
|
for (b = 0; b < UL_LEN / 16; b++)
|
|
*p1++ = *t++;
|
|
if (!(i % PROGRESSOFTEN)) {
|
|
putc('\b');
|
|
putc(progress[++j % PROGRESSLEN]);
|
|
fflush(stdout);
|
|
}
|
|
}
|
|
if (compare_regions(bufa, bufb, count))
|
|
return -1;
|
|
}
|
|
printf("\b \b");
|
|
fflush(stdout);
|
|
return 0;
|
|
}
|
|
#endif
|