Remove testing data

1 files changed, 0 insertions, 347 deletions

diff --git a/examples/redis-unstable/src/memtest.c b/examples/redis-unstable/src/memtest.c
deleted file mode 100644
index e21cc9c..0000000
--- a/examples/redis-unstable/src/memtest.c
+++ /dev/null
@@ -1,347 +0,0 @@
-/*
- * Copyright (c) 2009-Present, Redis Ltd.
- * All rights reserved.
- *
- * Licensed under your choice of (a) the Redis Source Available License 2.0
- * (RSALv2); or (b) the Server Side Public License v1 (SSPLv1); or (c) the
- * GNU Affero General Public License v3 (AGPLv3).
- */
-#include <stdint.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <limits.h>
-#include <errno.h>
-#include <termios.h>
-#include <sys/ioctl.h>
-#if defined(__sun)
-#include <stropts.h>
-#endif
-#include "config.h"
-#include "redisassert.h"
-
-#if (ULONG_MAX == 4294967295UL)
-#define MEMTEST_32BIT
-#elif (ULONG_MAX == 18446744073709551615ULL)
-#define MEMTEST_64BIT
-#else
-#error "ULONG_MAX value not supported."
-#endif
-
-#ifdef MEMTEST_32BIT
-#define ULONG_ONEZERO 0xaaaaaaaaUL
-#define ULONG_ZEROONE 0x55555555UL
-#else
-#define ULONG_ONEZERO 0xaaaaaaaaaaaaaaaaUL
-#define ULONG_ZEROONE 0x5555555555555555UL
-#endif
-
-static struct winsize ws;
-size_t progress_printed; /* Printed chars in screen-wide progress bar. */
-size_t progress_full; /* How many chars to write to fill the progress bar. */
-
-void memtest_progress_start(char *title, int pass) {
-    int j;
-
-    printf("\x1b[H\x1b[2J");    /* Cursor home, clear screen. */
-    /* Fill with dots. */
-    for (j = 0; j < ws.ws_col*(ws.ws_row-2); j++) printf(".");
-    printf("Please keep the test running several minutes per GB of memory.\n");
-    printf("Also check http://www.memtest86.com/ and http://pyropus.ca/software/memtester/");
-    printf("\x1b[H\x1b[2K");          /* Cursor home, clear current line.  */
-    printf("%s [%d]\n", title, pass); /* Print title. */
-    progress_printed = 0;
-    progress_full = (size_t)ws.ws_col*(ws.ws_row-3);
-    fflush(stdout);
-}
-
-void memtest_progress_end(void) {
-    printf("\x1b[H\x1b[2J");    /* Cursor home, clear screen. */
-}
-
-void memtest_progress_step(size_t curr, size_t size, char c) {
-    size_t chars = ((unsigned long long)curr*progress_full)/size, j;
-
-    for (j = 0; j < chars-progress_printed; j++) printf("%c",c);
-    progress_printed = chars;
-    fflush(stdout);
-}
-
-/* Test that addressing is fine. Every location is populated with its own
- * address, and finally verified. This test is very fast but may detect
- * ASAP big issues with the memory subsystem. */
-int memtest_addressing(unsigned long *l, size_t bytes, int interactive) {
-    unsigned long words = bytes/sizeof(unsigned long);
-    unsigned long j, *p;
-
-    /* Fill */
-    p = l;
-    for (j = 0; j < words; j++) {
-        *p = (unsigned long)p;
-        p++;
-        if ((j & 0xffff) == 0 && interactive)
-            memtest_progress_step(j,words*2,'A');
-    }
-    /* Test */
-    p = l;
-    for (j = 0; j < words; j++) {
-        if (*p != (unsigned long)p) {
-            if (interactive) {
-                printf("\n*** MEMORY ADDRESSING ERROR: %p contains %lu\n",
-                    (void*) p, *p);
-                exit(1);
-            }
-            return 1;
-        }
-        p++;
-        if ((j & 0xffff) == 0 && interactive)
-            memtest_progress_step(j+words,words*2,'A');
-    }
-    return 0;
-}
-
-/* Fill words stepping a single page at every write, so we continue to
- * touch all the pages in the smallest amount of time reducing the
- * effectiveness of caches, and making it hard for the OS to transfer
- * pages on the swap.
- *
- * In this test we can't call rand() since the system may be completely
- * unable to handle library calls, so we have to resort to our own
- * PRNG that only uses local state. We use an xorshift* PRNG. */
-#define xorshift64star_next() do { \
-        rseed ^= rseed >> 12; \
-        rseed ^= rseed << 25; \
-        rseed ^= rseed >> 27; \
-        rout = rseed * UINT64_C(2685821657736338717); \
-} while(0)
-
-void memtest_fill_random(unsigned long *l, size_t bytes, int interactive) {
-    unsigned long step = 4096/sizeof(unsigned long);
-    unsigned long words = bytes/sizeof(unsigned long)/2;
-    unsigned long iwords = words/step;  /* words per iteration */
-    unsigned long off, w, *l1, *l2;
-    uint64_t rseed = UINT64_C(0xd13133de9afdb566); /* Just a random seed. */
-    uint64_t rout = 0;
-
-    assert((bytes & 4095) == 0);
-    for (off = 0; off < step; off++) {
-        l1 = l+off;
-        l2 = l1+words;
-        for (w = 0; w < iwords; w++) {
-            xorshift64star_next();
-            *l1 = *l2 = (unsigned long) rout;
-            l1 += step;
-            l2 += step;
-            if ((w & 0xffff) == 0 && interactive)
-                memtest_progress_step(w+iwords*off,words,'R');
-        }
-    }
-}
-
-/* Like memtest_fill_random() but uses the two specified values to fill
- * memory, in an alternated way (v1|v2|v1|v2|...) */
-void memtest_fill_value(unsigned long *l, size_t bytes, unsigned long v1,
-                        unsigned long v2, char sym, int interactive)
-{
-    unsigned long step = 4096/sizeof(unsigned long);
-    unsigned long words = bytes/sizeof(unsigned long)/2;
-    unsigned long iwords = words/step;  /* words per iteration */
-    unsigned long off, w, *l1, *l2, v;
-
-    assert((bytes & 4095) == 0);
-    for (off = 0; off < step; off++) {
-        l1 = l+off;
-        l2 = l1+words;
-        v = (off & 1) ? v2 : v1;
-        for (w = 0; w < iwords; w++) {
-#ifdef MEMTEST_32BIT
-            *l1 = *l2 = ((unsigned long)     v) |
-                        (((unsigned long)    v) << 16);
-#else
-            *l1 = *l2 = ((unsigned long)     v) |
-                        (((unsigned long)    v) << 16) |
-                        (((unsigned long)    v) << 32) |
-                        (((unsigned long)    v) << 48);
-#endif
-            l1 += step;
-            l2 += step;
-            if ((w & 0xffff) == 0 && interactive)
-                memtest_progress_step(w+iwords*off,words,sym);
-        }
-    }
-}
-
-int memtest_compare(unsigned long *l, size_t bytes, int interactive) {
-    unsigned long words = bytes/sizeof(unsigned long)/2;
-    unsigned long w, *l1, *l2;
-
-    assert((bytes & 4095) == 0);
-    l1 = l;
-    l2 = l1+words;
-    for (w = 0; w < words; w++) {
-        if (*l1 != *l2) {
-            if (interactive) {
-                printf("\n*** MEMORY ERROR DETECTED: %p != %p (%lu vs %lu)\n",
-                    (void*)l1, (void*)l2, *l1, *l2);
-                exit(1);
-            }
-            return 1;
-        }
-        l1 ++;
-        l2 ++;
-        if ((w & 0xffff) == 0 && interactive)
-            memtest_progress_step(w,words,'=');
-    }
-    return 0;
-}
-
-int memtest_compare_times(unsigned long *m, size_t bytes, int pass, int times,
-                          int interactive)
-{
-    int j;
-    int errors = 0;
-
-    for (j = 0; j < times; j++) {
-        if (interactive) memtest_progress_start("Compare",pass);
-        errors += memtest_compare(m,bytes,interactive);
-        if (interactive) memtest_progress_end();
-    }
-    return errors;
-}
-
-/* Test the specified memory. The number of bytes must be multiple of 4096.
- * If interactive is true the program exists with an error and prints
- * ASCII arts to show progresses. Instead when interactive is 0, it can
- * be used as an API call, and returns 1 if memory errors were found or
- * 0 if there were no errors detected. */
-int memtest_test(unsigned long *m, size_t bytes, int passes, int interactive) {
-    int pass = 0;
-    int errors = 0;
-
-    while (pass != passes) {
-        pass++;
-
-        if (interactive) memtest_progress_start("Addressing test",pass);
-        errors += memtest_addressing(m,bytes,interactive);
-        if (interactive) memtest_progress_end();
-
-        if (interactive) memtest_progress_start("Random fill",pass);
-        memtest_fill_random(m,bytes,interactive);
-        if (interactive) memtest_progress_end();
-        errors += memtest_compare_times(m,bytes,pass,4,interactive);
-
-        if (interactive) memtest_progress_start("Solid fill",pass);
-        memtest_fill_value(m,bytes,0,(unsigned long)-1,'S',interactive);
-        if (interactive) memtest_progress_end();
-        errors += memtest_compare_times(m,bytes,pass,4,interactive);
-
-        if (interactive) memtest_progress_start("Checkerboard fill",pass);
-        memtest_fill_value(m,bytes,ULONG_ONEZERO,ULONG_ZEROONE,'C',interactive);
-        if (interactive) memtest_progress_end();
-        errors += memtest_compare_times(m,bytes,pass,4,interactive);
-    }
-    return errors;
-}
-
-/* A version of memtest_test() that tests memory in small pieces
- * in order to restore the memory content at exit.
- *
- * One problem we have with this approach, is that the cache can avoid
- * real memory accesses, and we can't test big chunks of memory at the
- * same time, because we need to backup them on the stack (the allocator
- * may not be usable or we may be already in an out of memory condition).
- * So what we do is to try to trash the cache with useless memory accesses
- * between the fill and compare cycles. */
-#define MEMTEST_BACKUP_WORDS (1024*(1024/sizeof(long)))
-/* Random accesses of MEMTEST_DECACHE_SIZE are performed at the start and
- * end of the region between fill and compare cycles in order to trash
- * the cache. */
-#define MEMTEST_DECACHE_SIZE (1024*8)
-
-REDIS_NO_SANITIZE("undefined")
-int memtest_preserving_test(unsigned long *m, size_t bytes, int passes) {
-    unsigned long backup[MEMTEST_BACKUP_WORDS];
-    unsigned long *p = m;
-    unsigned long *end = (unsigned long*) (((unsigned char*)m)+(bytes-MEMTEST_DECACHE_SIZE));
-    size_t left = bytes;
-    int errors = 0;
-
-    if (bytes & 4095) return 0; /* Can't test across 4k page boundaries. */
-    if (bytes < 4096*2) return 0; /* Can't test a single page. */
-
-    while(left) {
-        /* If we have to test a single final page, go back a single page
-         * so that we can test two pages, since the code can't test a single
-         * page but at least two. */
-        if (left == 4096) {
-            left += 4096;
-            p -= 4096/sizeof(unsigned long);
-        }
-
-        int pass = 0;
-        size_t len = (left > sizeof(backup)) ? sizeof(backup) : left;
-
-        /* Always test an even number of pages. */
-        if (len/4096 % 2) len -= 4096;
-
-        memcpy(backup,p,len); /* Backup. */
-        while(pass != passes) {
-            pass++;
-            errors += memtest_addressing(p,len,0);
-            memtest_fill_random(p,len,0);
-            if (bytes >= MEMTEST_DECACHE_SIZE) {
-                memtest_compare_times(m,MEMTEST_DECACHE_SIZE,pass,1,0);
-                memtest_compare_times(end,MEMTEST_DECACHE_SIZE,pass,1,0);
-            }
-            errors += memtest_compare_times(p,len,pass,4,0);
-            memtest_fill_value(p,len,0,(unsigned long)-1,'S',0);
-            if (bytes >= MEMTEST_DECACHE_SIZE) {
-                memtest_compare_times(m,MEMTEST_DECACHE_SIZE,pass,1,0);
-                memtest_compare_times(end,MEMTEST_DECACHE_SIZE,pass,1,0);
-            }
-            errors += memtest_compare_times(p,len,pass,4,0);
-            memtest_fill_value(p,len,ULONG_ONEZERO,ULONG_ZEROONE,'C',0);
-            if (bytes >= MEMTEST_DECACHE_SIZE) {
-                memtest_compare_times(m,MEMTEST_DECACHE_SIZE,pass,1,0);
-                memtest_compare_times(end,MEMTEST_DECACHE_SIZE,pass,1,0);
-            }
-            errors += memtest_compare_times(p,len,pass,4,0);
-        }
-        memcpy(p,backup,len); /* Restore. */
-        left -= len;
-        p += len/sizeof(unsigned long);
-    }
-    return errors;
-}
-
-/* Perform an interactive test allocating the specified number of megabytes. */
-void memtest_alloc_and_test(size_t megabytes, int passes) {
-    size_t bytes = megabytes*1024*1024;
-    unsigned long *m = malloc(bytes);
-
-    if (m == NULL) {
-        fprintf(stderr,"Unable to allocate %zu megabytes: %s",
-            megabytes, strerror(errno));
-        exit(1);
-    }
-    memtest_test(m,bytes,passes,1);
-    free(m);
-}
-
-void memtest(size_t megabytes, int passes) {
-#if !defined(__HAIKU__)
-    if (ioctl(1, TIOCGWINSZ, &ws) == -1) {
-        ws.ws_col = 80;
-        ws.ws_row = 20;
-    }
-#else
-    ws.ws_col = 80;
-    ws.ws_row = 20;
-#endif
-    memtest_alloc_and_test(megabytes,passes);
-    printf("\nYour memory passed this test.\n");
-    printf("Please if you are still in doubt use the following two tools:\n");
-    printf("1) memtest86: http://www.memtest86.com/\n");
-    printf("2) memtester: http://pyropus.ca/software/memtester/\n");
-    exit(0);
-}