home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 23 / AACD 23.iso / AACD / Programming / tek / mem / poolalloc.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-05-12  |  1.9 KB  |  97 lines
  1.  
  2. #include "tek/mem.h"
  3.  
  4. /* 
  5. **    TEKlib
  6. **    (C) 2001 TEK neoscientists
  7. **    all rights reserved.
  8. **
  9. **    TAPTR TPoolAlloc(TAPTR mp, TUINT size)
  10. **
  11. **    allocate memory from a pool.
  12. **
  13. */
  14.  
  15. TAPTR TPoolAlloc(TAPTR mp, TUINT size)
  16. {
  17.     if (mp && size)
  18.     {
  19.         TMEMPOOL *pool = (TMEMPOOL *) mp;
  20.         TNODE *nextnode, *node;
  21.         TBYTE *newchunk;
  22.         TUINT allocsize;
  23.         TBOOL addtail = TFALSE;
  24.         
  25.         size = ((size + pool->align) & ~pool->align) + sizeof(TPOOLNODE *); 
  26.         
  27.         if (size <= pool->thressize)
  28.         {
  29.             node = pool->list.head;
  30.             while ((nextnode = node->succ))
  31.             {
  32.                 if (((TPOOLNODE *) node)->memhead.freesize >= size)        /* have we got a chance? */
  33.                 {
  34.                     TPOOLNODE **mem = TStaticAlloc(&((TPOOLNODE *) node)->memhead, size);
  35.                     if (mem)
  36.                     {
  37.                         *mem++ = (TPOOLNODE *) node;
  38.                         return (TAPTR) mem;
  39.                     }
  40.                 }
  41.                 node = nextnode;
  42.             }
  43.  
  44.             allocsize = pool->chunksize;        /* regular chunk */
  45.         }
  46.         else
  47.         {
  48.             if (pool->dyngrow)
  49.             {
  50.                 pool->chunksize = ((TUINT) ((TFLOAT) size * pool->dynfactor) + pool->align) & ~pool->align;
  51.                 pool->thressize = (size + pool->align) & ~pool->align;
  52.  
  53.                 allocsize = pool->chunksize;    /* regular chunk, after chunk resizing */
  54.             }
  55.             else
  56.             {
  57.                 allocsize = (size + pool->align) & ~pool->align;     /* large chunk, realigned */
  58.                 addtail = TTRUE;
  59.             }
  60.         }
  61.  
  62.  
  63.         /*
  64.         **    allocate new chunk
  65.         */
  66.  
  67.         newchunk = TMMUAlloc(pool->handle.mmu, pool->poolnodesize + pool->memnodesize + allocsize);
  68.         if (newchunk)
  69.         {
  70.             TPOOLNODE **mem;
  71.  
  72.             TInitMemHead(&((TPOOLNODE *) newchunk)->memhead,
  73.                 (TAPTR) (newchunk + pool->poolnodesize),
  74.                 pool->memnodesize + allocsize, TNULL);
  75.  
  76.             ((TPOOLNODE *) newchunk)->numbytes = allocsize;
  77.  
  78.             mem = TStaticAlloc(&((TPOOLNODE *) newchunk)->memhead, size);
  79.  
  80.             if (addtail)
  81.             {
  82.                 TAddTail(&pool->list, (TNODE *) newchunk);
  83.             }
  84.             else
  85.             {
  86.                 TAddHead(&pool->list, (TNODE *) newchunk);
  87.             }
  88.  
  89.             *mem++ = (TPOOLNODE *) newchunk;
  90.  
  91.             return (TAPTR) mem;
  92.         }
  93.     }
  94.  
  95.     return TNULL;
  96. }
  97.