test/exec/allocmem.c

   1 #include <aros/debug.h>
   2 #include <proto/exec.h>
   3
   4 #include <stdio.h>
   5 #include <string.h>
   6
   7 /*
   8  * Re-define output to bug in order to get exact measurements.
   9  * Console's history consumes memory, so this may look like a
  10  * memory leak.
  11  */
  12 #define output printf
  13
  14 static BOOL trash = FALSE;
  15 static BOOL leak  = FALSE;
  16
  17 static inline void AccessTest(ULONG *ptr)
  18 {
  19     if (!trash)
  20         return;
  21
  22     ptr[-1] = 0x40302010;       /* This should NOT cause mungwall warning */
  23     ptr[0]  = 0x01020304;       /* This SHOULD produce mungwall warning   */
  24 }
  25
  26 int main(int argc, char **argv)
  27 {
  28     int i;
  29     APTR block0, start, block1;
  30
  31     /*
  32      * Do some memory trashing if started with "trash" argument.
  33      * It's not adviced to do this without mungwall enabled.
  34      * The actual purpose of this is to test mungwall functionality.
  35      */
  36     for (i = 1; i < argc; i++)
  37     {
  38         if (!strcmp(argv[i], "trash"))
  39             trash = TRUE;
  40         else if (!strcmp(argv[i], "leak"))
  41             leak = TRUE;
  42     }
  43
  44     /* We Forbid() in order to see how our allocations influence free memory size */
  45     Forbid();
  46
  47     output("Available memory: %lu bytes\n", (unsigned long)AvailMem(MEMF_ANY));
  48
  49     output("Allocating 256 KB...\n");
  50     block0 = AllocMem(256 * 1024, MEMF_ANY);
  51     output("Allocated at 0x%p, available memory: %lu bytes\n", block0, (unsigned long)AvailMem(MEMF_ANY));
  52
  53     AccessTest(block0 + 256 * 1024);
  54
  55     if (!leak)
  56     {
  57         output("Freeing the block...\n");
  58         FreeMem(block0, 256 * 1024);
  59         output("Done, available memory: %lu bytes\n", (unsigned long)AvailMem(MEMF_ANY));
  60     }
  61
  62     start = block0 + 1027;      /* Add some none-round displacement to make the life harder */
  63     output("Now trying AllocAbs() 4 KB at 0x%p\n", start);
  64     block1 = AllocAbs(4096, start);
  65     output("Allocated at 0x%p, available memory: %lu bytes\n", block1, (unsigned long)AvailMem(MEMF_ANY));
  66
  67     AccessTest(start + 4096);
  68
  69     if (!leak)
  70     {
  71         output("Freeing the block...\n");
  72         FreeMem(block1, 4096 + start - block1);
  73         output("Done, available memory: %lu bytes\n", (unsigned long)AvailMem(MEMF_ANY));
  74     }
  75
  76     output("Now repeat this AllocAbs(), but free using our requested start address...\n");
  77     block1 = AllocAbs(4096, start);
  78     output("Allocated at 0x%p, available memory: %lu bytes\n", block1, (unsigned long)AvailMem(MEMF_ANY));
  79
  80     if (block1)
  81     {
  82         AccessTest(start + 4096);
  83
  84         if (!leak)
  85         {
  86             output("Freeing the block...\n");
  87             FreeMem(start, 4096);
  88             output("Done, available memory: %lu bytes\n", (unsigned long)AvailMem(MEMF_ANY));
  89         }
  90     }
  91
  92     output("And now trying MEMF_REVERSE...\n");
  93     block0 = AllocMem(4096, MEMF_REVERSE);
  94     output("Allocated at 0x%p, available memory: %lu bytes\n", block0, (unsigned long)AvailMem(MEMF_ANY));
  95
  96     /* This test actually proves that we don't hit for example MMIO region */
  97     *((volatile ULONG *)block0) = 0xC0DEBAD;
  98     if (*((volatile ULONG *)block0) != 0xC0DEBAD)
  99         output("It's not a memory!!!\n");
 100
 101     AccessTest(block0 + 4096);
 102
 103     if (!leak)
 104     {
 105         output("Freeing the block...\n");
 106         FreeMem(block0, 4096);
 107         output("Done, available memory: %lu bytes\n", (unsigned long)AvailMem(MEMF_ANY));
 108     }
 109
 110     Permit();
 111     return 0;
 112 }