test/exec/allocmem.c

   1 /*
   2     Copyright © 1995-2015, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <aros/debug.h>
   7 #include <proto/exec.h>
   8
   9 #include <stdio.h>
  10 #include <string.h>
  11
  12 /*
  13  * Re-define output to bug in order to get exact measurements.
  14  * Console's history consumes memory, so this may look like a
  15  * memory leak.
  16  */
  17 #define output printf
  18
  19 static BOOL trash = FALSE;
  20 static BOOL leak  = FALSE;
  21
  22 static inline void AccessTest(ULONG *ptr)
  23 {
  24     if (!trash)
  25         return;
  26
  27     ptr[-1] = 0x40302010;       /* This should NOT cause mungwall warning */
  28     ptr[0]  = 0x01020304;       /* This SHOULD produce mungwall warning   */
  29 }
  30
  31 int main(int argc, char **argv)
  32 {
  33     LONG result = RETURN_OK;
  34     int i;
  35     APTR block0, start, block1;
  36
  37     /*
  38      * Do some memory trashing if started with "trash" argument.
  39      * It's not adviced to do this without mungwall enabled.
  40      * The actual purpose of this is to test mungwall functionality.
  41      */
  42     for (i = 1; i < argc; i++)
  43     {
  44         if (!strcmp(argv[i], "trash"))
  45             trash = TRUE;
  46         else if (!strcmp(argv[i], "leak"))
  47             leak = TRUE;
  48     }
  49
  50     /* We Forbid() in order to see how our allocations influence free memory size */
  51     Forbid();
  52
  53     output("Available memory: %lu bytes\n", (unsigned long)AvailMem(MEMF_ANY));
  54     output("Largest chunk: %lu bytes\n\n", (unsigned long)AvailMem(MEMF_ANY|MEMF_LARGEST));
  55
  56     output("Testing AllocMem(256, MEMF_ANY) ...\n");
  57     if ((block0 = AllocMem(256 * 1024, MEMF_ANY)) != NULL)
  58     {
  59         output("Allocated at 0x%p, available memory: %lu bytes\n", block0, (unsigned long)AvailMem(MEMF_ANY));
  60
  61         AccessTest(block0 + 256 * 1024);
  62
  63         if (!leak)
  64         {
  65             output("Freeing the block...\n");
  66             FreeMem(block0, 256 * 1024);
  67             output("Done, available memory: %lu bytes\n", (unsigned long)AvailMem(MEMF_ANY));
  68         }
  69     }
  70     else
  71     {
  72         output("Allocation failed!\n");
  73         result = RETURN_ERROR;
  74     }
  75
  76     start = block0 + 1027;      /* Add some non-round displacement to make life harder */
  77     output("\nTesting AllocAbs(4096, 0x%p) ...\n", start);
  78     if ((block1 = AllocAbs(4096, start)) != NULL)
  79     {
  80         output("Allocated at 0x%p, available memory: %lu bytes\n", block1, (unsigned long)AvailMem(MEMF_ANY));
  81
  82         AccessTest(start + 4096);
  83
  84         if (!leak)
  85         {
  86             output("Freeing the block...\n");
  87             FreeMem(block1, 4096 + start - block1);
  88             output("Done, available memory: %lu bytes\n", (unsigned long)AvailMem(MEMF_ANY));
  89         }
  90     }
  91     else
  92     {
  93         output("Allocation failed!\n");
  94         result = RETURN_ERROR;
  95     }
  96
  97     /* Only perform the second AllocAbs() if leak isn't specified,
  98        otherwise we just duplicate the previous test */
  99     if (!leak)
 100     {
 101         output("\nTesting AllocAbs(4096, 0x%p), but free using its requested start address...\n", start);
 102         if ((block1 = AllocAbs(4096, start)) != NULL)
 103         {
 104             output("Allocated at 0x%p, available memory: %lu bytes\n", block1, (unsigned long)AvailMem(MEMF_ANY));
 105
 106             AccessTest(start + 4096);
 107
 108             output("Freeing the block...\n");
 109             FreeMem(start, 4096);
 110             output("Done, available memory: %lu bytes\n", (unsigned long)AvailMem(MEMF_ANY));
 111         }
 112         else
 113         {
 114             output("Allocation failed!\n");
 115             result = RETURN_ERROR;
 116         }
 117     }
 118
 119     output("\nTesting AllocMem(4096, MEMF_ANY|MEMF_REVERSE) ...\n");
 120     if ((block0 = AllocMem(4096, MEMF_ANY|MEMF_REVERSE)) != NULL)
 121     {
 122         output("Allocated at 0x%p, available memory: %lu bytes\n", block0, (unsigned long)AvailMem(MEMF_ANY));
 123
 124         /* This test actually proves that we don't hit for example MMIO region */
 125         *((volatile ULONG *)block0) = 0xC0DEBAD;
 126         if (*((volatile ULONG *)block0) != 0xC0DEBAD)
 127         {
 128             output("Invalid memory allocated!!!\n");
 129             result = RETURN_ERROR;
 130         }
 131
 132         AccessTest(block0 + 4096);
 133
 134         if (!leak)
 135         {
 136             output("Freeing the block...\n");
 137             FreeMem(block0, 4096);
 138             output("Done, available memory: %lu bytes\n", (unsigned long)AvailMem(MEMF_ANY));
 139         }
 140     }
 141     else
 142     {
 143         output("Allocation failed!\n");
 144         result = RETURN_ERROR;
 145     }
 146
 147     output("\nFinal available memory: %lu bytes\n", (unsigned long)AvailMem(MEMF_ANY));
 148
 149     Permit();
 150     return result;
 151 }