Test: fixed osx "leaks" support in test.

[redis.git] / src / memtest.c

diff --git a/src/memtest.c b/src/memtest.c
index 56d566abd18206c9fd4c64976cd2dbf791283416..56162ff4fbcdb77c78e742a41386704bab89a046 100644 (file)
--- a/src/memtest.c
+++ b/src/memtest.c
@@ -1,3 +1,32 @@
+/*
+ * Copyright (c) 2009-2012, Salvatore Sanfilippo <antirez at gmail dot com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the name of Redis nor the names of its contributors may be used
+ *     to endorse or promote products derived from this software without
+ *     specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+

 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>


@@ -15,6 +44,14 @@
 #error "ULONG_MAX value not supported."
 #endif
 
 #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. */
 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. */


@@ -24,11 +61,13 @@ void memtest_progress_start(char *title, int pass) {
 
     printf("\x1b[H\x1b[2J");    /* Cursor home, clear screen. */
     /* Fill with dots. */
 
     printf("\x1b[H\x1b[2J");    /* Cursor home, clear screen. */
     /* Fill with dots. */

-    for (j = 0; j < ws.ws_col*ws.ws_row; j++) printf(".");
+    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;
     printf("\x1b[H\x1b[2K");          /* Cursor home, clear current line.  */
     printf("%s [%d]\n", title, pass); /* Print title. */
     progress_printed = 0;

-    progress_full = ws.ws_col*(ws.ws_row-1);
+    progress_full = ws.ws_col*(ws.ws_row-3);

     fflush(stdout);
 }
 
     fflush(stdout);
 }
 


@@ -37,7 +76,7 @@ void memtest_progress_end(void) {
 }
 
 void memtest_progress_step(size_t curr, size_t size, char c) {
 }
 
 void memtest_progress_step(size_t curr, size_t size, char c) {

-    size_t chars = (curr*progress_full)/size, j;
+    size_t chars = ((unsigned long long)curr*progress_full)/size, j;

 
     for (j = 0; j < chars-progress_printed; j++) {
         printf("%c",c);
 
     for (j = 0; j < chars-progress_printed; j++) {
         printf("%c",c);


@@ -46,11 +85,38 @@ void memtest_progress_step(size_t curr, size_t size, char c) {
     fflush(stdout);
 }
 
     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. */
+void memtest_addressing(unsigned long *l, size_t bytes) {
+    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) memtest_progress_step(j,words*2,'A');
+    }
+    /* Test */
+    p = l;
+    for (j = 0; j < words; j++) {
+        if (*p != (unsigned long)p) {
+            printf("\n*** MEMORY ADDRESSING ERROR: %p contains %lu\n",
+                (void*) p, *p);
+            exit(1);
+        }
+        p++;
+        if ((j & 0xffff) == 0) memtest_progress_step(j+words,words*2,'A');
+    }
+}
+

 /* 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. */
 /* 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. */

-void memtest_fill(unsigned long *l, size_t bytes) {
+void memtest_fill_random(unsigned long *l, size_t bytes) {

     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 step = 4096/sizeof(unsigned long);
     unsigned long words = bytes/sizeof(unsigned long)/2;
     unsigned long iwords = words/step;  /* words per iteration */


@@ -73,7 +139,40 @@ void memtest_fill(unsigned long *l, size_t bytes) {
             l1 += step;
             l2 += step;
             if ((w & 0xffff) == 0)
             l1 += step;
             l2 += step;
             if ((w & 0xffff) == 0)

-                memtest_progress_step(w+iwords*off,words,'+');
+                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)
+{
+    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)
+                memtest_progress_step(w+iwords*off,words,sym);

         }
     }
 }
         }
     }
 }


@@ -97,10 +196,20 @@ void memtest_compare(unsigned long *l, size_t bytes) {
     }
 }
 
     }
 }
 

+void memtest_compare_times(unsigned long *m, size_t bytes, int pass, int times) {
+    int j;
+
+    for (j = 0; j < times; j++) {
+        memtest_progress_start("Compare",pass);
+        memtest_compare(m,bytes);
+        memtest_progress_end();
+    }
+}
+

 void memtest_test(size_t megabytes, int passes) {
     size_t bytes = megabytes*1024*1024;
     unsigned long *m = malloc(bytes);
 void memtest_test(size_t megabytes, int passes) {
     size_t bytes = megabytes*1024*1024;
     unsigned long *m = malloc(bytes);

-    int pass = 0, j;
+    int pass = 0;

 
     if (m == NULL) {
         fprintf(stderr,"Unable to allocate %zu megabytes: %s",
 
     if (m == NULL) {
         fprintf(stderr,"Unable to allocate %zu megabytes: %s",


@@ -109,14 +218,25 @@ void memtest_test(size_t megabytes, int passes) {
     }
     while (pass != passes) {
         pass++;
     }
     while (pass != passes) {
         pass++;

+
+        memtest_progress_start("Addressing test",pass);
+        memtest_addressing(m,bytes);
+        memtest_progress_end();
+

         memtest_progress_start("Random fill",pass);
         memtest_progress_start("Random fill",pass);

-        memtest_fill(m,bytes);
+        memtest_fill_random(m,bytes);

         memtest_progress_end();
         memtest_progress_end();

-        for (j = 0; j < 4; j++) {
-            memtest_progress_start("Compare",pass);
-            memtest_compare(m,bytes);
-            memtest_progress_end();
-        }
+        memtest_compare_times(m,bytes,pass,4);
+
+        memtest_progress_start("Solid fill",pass);
+        memtest_fill_value(m,bytes,0,(unsigned long)-1,'S');
+        memtest_progress_end();
+        memtest_compare_times(m,bytes,pass,4);
+
+        memtest_progress_start("Checkerboard fill",pass);
+        memtest_fill_value(m,bytes,ULONG_ONEZERO,ULONG_ZEROONE,'C');
+        memtest_progress_end();
+        memtest_compare_times(m,bytes,pass,4);

     }
 }
 
     }
 }
 


@@ -127,7 +247,7 @@ void memtest(size_t megabytes, int passes) {
     }
     memtest_test(megabytes,passes);
     printf("\nYour memory passed this test.\n");
     }
     memtest_test(megabytes,passes);
     printf("\nYour memory passed this test.\n");

-    printf("Please if you are stil in doubt use the following two tools:\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);
     printf("1) memtest86: http://www.memtest86.com/\n");
     printf("2) memtester: http://pyropus.ca/software/memtester/\n");
     exit(0);