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 inline void AccessTest(ULONG *ptr, BOOL trash)
  20 {
  21     if (!trash)
  22         return;
  23
  24     ptr[-1] = 0x40302010;       /* This should NOT cause mungwall warning */
  25     ptr[0]  = 0x01020304;       /* This SHOULD produce mungwall warning   */
  26 }
  27
  28 static LONG test_allocabs(APTR block0, BOOL trash, BOOL leak, BOOL notlsf)
  29 {
  30     LONG result = RETURN_OK;
  31     APTR start, block1;
  32     const ULONG allocsize = 4096;
  33
  34     start = block0 + 1027;  /* Add some non-round displacement to make life harder */
  35     output("\nTesting AllocAbs(%lu, 0x%p) ...\n", (unsigned long)allocsize, start);
  36     if ((block1 = AllocAbs(allocsize, start)) != NULL)
  37     {
  38         output("Allocated at 0x%p, available memory: %lu bytes\n", block1, (unsigned long)AvailMem(MEMF_ANY));
  39
  40         AccessTest(start + allocsize, trash);
  41
  42         if (!leak)
  43         {
  44             output("Freeing the block at 0x%p of %lu bytes...\n", block1, (unsigned long)(allocsize + start - block1));
  45             FreeMem(block1, allocsize + start - block1);
  46             output("Done, available memory: %lu bytes\n", (unsigned long)AvailMem(MEMF_ANY));
  47         }
  48     }
  49     else
  50     {
  51         output("Allocation failed!\n");
  52         result = RETURN_ERROR;
  53     }
  54
  55     /* Only perform the second AllocAbs() if leak isn't specified,
  56        otherwise we just duplicate the previous test */
  57     if (!leak)
  58     {
  59         output("\nTesting AllocAbs(%lu, 0x%p), but free using its requested start address...\n", (unsigned long)allocsize, start);
  60         if ((block1 = AllocAbs(allocsize, start)) != NULL)
  61         {
  62             output("Allocated at 0x%p, available memory: %lu bytes\n", block1, (unsigned long)AvailMem(MEMF_ANY));
  63
  64             AccessTest(start + allocsize, trash);
  65
  66             output("Freeing the block at 0x%p of %lu bytes...\n", start, (unsigned long)allocsize);
  67             if (notlsf)
  68             {
  69                 FreeMem(start, allocsize);
  70                 output("Done, available memory: %lu bytes\n", (unsigned long)AvailMem(MEMF_ANY));
  71             }
  72             else
  73             {
  74                 FreeMem(block1, allocsize + start - block1);
  75                 output("NOT SUPPORTED UNDER TLSF, freeing using returned address\n");
  76                 output("Done, available memory: %lu bytes\n", (unsigned long)AvailMem(MEMF_ANY));
  77             }
  78         }
  79         else
  80         {
  81             output("Allocation failed!\n");
  82             result = RETURN_ERROR;
  83         }
  84     }
  85
  86     return result;
  87 }
  88
  89 int main(int argc, char **argv)
  90 {
  91     LONG result = RETURN_OK;
  92     int i;
  93     APTR block0;
  94     BOOL trash  = FALSE;
  95     BOOL leak   = FALSE;
  96     BOOL notlsf = FALSE;
  97
  98     /*
  99      * Do some memory trashing if started with "trash" argument.
 100      * It's not adviced to do this without mungwall enabled.
 101      * The actual purpose of this is to test mungwall functionality.
 102      */
 103     for (i = 1; i < argc; i++)
 104     {
 105         if (!strcmp(argv[i], "trash"))
 106             trash = TRUE;
 107         else if (!strcmp(argv[i], "leak"))
 108             leak = TRUE;
 109         else if (!strcmp(argv[i], "notlsf"))
 110             notlsf = TRUE;
 111
 112     }
 113
 114     /* We Forbid() in order to see how our allocations influence free memory size */
 115     Forbid();
 116
 117     output("Available memory: %lu bytes\n", (unsigned long)AvailMem(MEMF_ANY));
 118     output("Largest chunk: %lu bytes\n\n", (unsigned long)AvailMem(MEMF_ANY|MEMF_LARGEST));
 119
 120     output("Testing AllocMem(256 * 1024, MEMF_ANY) ...\n");
 121     if ((block0 = AllocMem(256 * 1024, MEMF_ANY)) != NULL)
 122     {
 123         output("Allocated at 0x%p, available memory: %lu bytes\n", block0, (unsigned long)AvailMem(MEMF_ANY));
 124
 125         AccessTest(block0 + 256 * 1024, trash);
 126
 127         if (!leak)
 128         {
 129             output("Freeing the block...\n");
 130             FreeMem(block0, 256 * 1024);
 131             output("Done, available memory: %lu bytes\n", (unsigned long)AvailMem(MEMF_ANY));
 132         }
 133     }
 134     else
 135     {
 136         output("Allocation failed!\n");
 137         result = RETURN_ERROR;
 138     }
 139
 140     if(test_allocabs(block0, trash, leak, notlsf) != RETURN_OK)
 141         result = RETURN_ERROR;
 142
 143     output("\nTesting AllocMem(4096, MEMF_ANY|MEMF_REVERSE) ...\n");
 144     if ((block0 = AllocMem(4096, MEMF_ANY|MEMF_REVERSE)) != NULL)
 145     {
 146         output("Allocated at 0x%p, available memory: %lu bytes\n", block0, (unsigned long)AvailMem(MEMF_ANY));
 147
 148         /* This test actually proves that we don't hit for example MMIO region */
 149         *((volatile ULONG *)block0) = 0xC0DEBAD;
 150         if (*((volatile ULONG *)block0) != 0xC0DEBAD)
 151         {
 152             output("Invalid memory allocated!!!\n");
 153             result = RETURN_ERROR;
 154         }
 155
 156         AccessTest(block0 + 4096, trash);
 157
 158         if (!leak)
 159         {
 160             output("Freeing the block...\n");
 161             FreeMem(block0, 4096);
 162             output("Done, available memory: %lu bytes\n", (unsigned long)AvailMem(MEMF_ANY));
 163         }
 164     }
 165     else
 166     {
 167         output("Allocation failed!\n");
 168         result = RETURN_ERROR;
 169     }
 170
 171     output("\nFinal available memory: %lu bytes\n", (unsigned long)AvailMem(MEMF_ANY));
 172
 173     Permit();
 174     return result;
 175 }