rom/exec/allocate.c

   1 /*
   2     Copyright © 1995-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Allocate memory from a specific MemHeader.
   6 */
   7
   8 #define MDEBUG 1
   9
  10 #include <aros/debug.h>
  11 #include <exec/alerts.h>
  12 #include <aros/libcall.h>
  13 #include <aros/macros.h>
  14 #include <exec/memory.h>
  15 #include <proto/exec.h>
  16
  17 #include "exec_intern.h"
  18 #include "exec_util.h"
  19 #include "memory.h"
  20
  21 /*****************************************************************************
  22
  23     NAME */
  24
  25 AROS_LH2(APTR, Allocate,
  26
  27 /*  SYNOPSIS */
  28         AROS_LHA(struct MemHeader *, freeList, A0),
  29         AROS_LHA(ULONG,              byteSize, D0),
  30
  31 /*  LOCATION */
  32         struct ExecBase *, SysBase, 31, Exec)
  33
  34 /*  FUNCTION
  35         Allocate memory out of a private region handled by the MemHeader
  36         structure.
  37
  38     INPUTS
  39         freeList - Pointer to the MemHeader structure which holds the memory
  40         byteSize - Number of bytes you want to get
  41
  42     RESULT
  43         A pointer to the number of bytes you wanted or NULL if the memory
  44         couldn't be allocated
  45
  46     NOTES
  47         The memory is aligned to sizeof(struct MemChunk). All requests
  48         are rounded up to a multiple of that size.
  49
  50     EXAMPLE
  51         #define POOLSIZE 4096
  52         \* Get a MemHeader structure and some private memory *\
  53         mh=(struct MemHeader *)
  54             AllocMem(sizeof(struct MemHeader)+POOLSIZE,MEMF_ANY);
  55         if(mh!=NULL)
  56         {
  57             \* Build a private pool *\
  58             mh->mh_First=(struct MemChunk *)(mh+1);
  59             mh->mh_First->mc_Next=NULL;
  60             mh->mh_First->mc_Bytes=POOLSIZE;
  61             mh->mh_Free=POOLSIZE;
  62             {
  63                 \* Use the pool *\
  64                 UBYTE *mem1,*mem2;
  65                 mem1=Allocate(mh,1000);
  66                 mem2=Allocate(mh,2000);
  67                 \* Do something with memory... *\
  68             }
  69             \* Free everything at once *\
  70             FreeMem(mh,sizeof(struct MemHeader)+POOLSIZE);
  71         }
  72
  73     BUGS
  74         Does not work with managed memory blocks because of backwards
  75         compatibility issues
  76
  77     SEE ALSO
  78         Deallocate()
  79
  80     INTERNALS
  81
  82 ******************************************************************************/
  83 {
  84     AROS_LIBFUNC_INIT
  85
  86     struct TraceLocation tp = CURRENT_LOCATION("Allocate");
  87     APTR res;
  88
  89     D(bug("[exec] Allocate(0x%p, %u)\n", freeList, byteSize));
  90     ASSERT_VALID_PTR(freeList);
  91
  92     /* Zero bytes requested? May return everything ;-). */
  93     if(!byteSize)
  94         return NULL;
  95
  96     /* Is there enough free memory in the list? */
  97     if(freeList->mh_Free<byteSize)
  98         return NULL;
  99
 100     res = stdAlloc(freeList, byteSize, 0, &tp, SysBase);
 101
 102     if ((PrivExecBase(SysBase)->IntFlags & EXECF_MungWall) && res) {
 103         MUNGE_BLOCK(res, MEMFILL_ALLOC, byteSize);
 104     }
 105
 106     return res;
 107
 108     AROS_LIBFUNC_EXIT
 109 } /* Allocate() */