home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Misc / MULT_S.LHA / MultiUser / Src / Library / Memory.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-03-07  |  2.8 KB  |  146 lines
  1. /************************************************************
  2. * MultiUser - MultiUser Task/File Support System                *
  3. * ---------------------------------------------------------    *
  4. * Memory management                                                        *
  5. * ---------------------------------------------------------    *
  6. * © Copyright 1993-1994 Geert Uytterhoeven                        *
  7. * All Rights Reserved.                                                    *
  8. ************************************************************/
  9.  
  10.  
  11. #include <exec/memory.h>
  12. #include <exec/semaphores.h>
  13. #include <proto/exec.h>
  14. #include <string.h>
  15.  
  16. #include "Memory.h"
  17.  
  18.  
  19.     /*
  20.      *        Memory Pool Characteristics
  21.      *
  22.      *        At the moment the memory overhead of each puddle seems to be 40 bytes.
  23.      *        I hope puddles of 4000 bytes will still fit in one 4K page in future
  24.      *        AmigaOS versions.
  25.      */
  26.  
  27. #define MEM_PUDDLESIZE    4000
  28. #define MEM_THRESHSIZE    4000
  29.  
  30.  
  31.     /*
  32.      *        Prototypes for the Memory Pool Support functions in amiga.lib
  33.      */
  34.  
  35. APTR __asm AsmCreatePool(register __d0 ULONG, register __d1 ULONG, register __d2 ULONG,
  36.                                  register __a6 struct ExecBase *);
  37. void __asm AsmDeletePool(register __a0 APTR, register __a6 struct ExecBase *);
  38. APTR __asm AsmAllocPooled(register __a0 APTR, register __d0 ULONG, register __a6 struct ExecBase *);
  39. void __asm AsmFreePooled(register __a0 APTR, register __a1 APTR, register __d0 ULONG,
  40.                                  register __a6 struct ExecBase *);
  41.  
  42.  
  43.     /*
  44.      *        Our Private Memory Pool
  45.      */
  46.  
  47. APTR Pool = NULL;
  48.  
  49.  
  50.     /*
  51.      *        Access Control Semaphore
  52.      */
  53.  
  54. struct SignalSemaphore Semaphore;
  55.  
  56.  
  57.     /*
  58.      *        Initialisation
  59.      */
  60.  
  61. BOOL InitMemory(void)
  62. {
  63.     InitSemaphore(&Semaphore);
  64.     ObtainSemaphore(&Semaphore);
  65.     Pool = AsmCreatePool(MEMF_PUBLIC, MEM_PUDDLESIZE, MEM_THRESHSIZE, SysBase);
  66.     ReleaseSemaphore(&Semaphore);
  67.     return((BOOL)(Pool ? TRUE : FALSE));
  68. }
  69.  
  70.  
  71.     /*
  72.      *        Clean Up
  73.      */
  74.  
  75. void CleanUpMemory(void)
  76. {
  77.     ObtainSemaphore(&Semaphore);
  78.     if (Pool) {
  79.         AsmDeletePool(Pool, SysBase);
  80.         Pool = NULL;
  81.     }
  82.     ReleaseSemaphore(&Semaphore);
  83. }
  84.  
  85.  
  86.     /*
  87.      *        Replacement for AllocMem()
  88.      */
  89.  
  90. APTR MAlloc(ULONG size)
  91. {
  92.     ULONG *block;
  93.  
  94.     ObtainSemaphore(&Semaphore);
  95.     if (block = AsmAllocPooled(Pool, size, SysBase))
  96.         memset(block, NULL, size);
  97.     ReleaseSemaphore(&Semaphore);
  98.     return(block);
  99. }
  100.  
  101.  
  102.     /*
  103.      *        Replacement for FreeMem()
  104.      */
  105.  
  106. void Free(APTR block, ULONG size)
  107. {
  108.     if (block) {
  109.         ObtainSemaphore(&Semaphore);
  110.         AsmFreePooled(Pool, block, size, SysBase);
  111.         ReleaseSemaphore(&Semaphore);
  112.     }
  113. }
  114.  
  115.  
  116.     /*
  117.      *        Replacement for AllocVec()
  118.      */
  119.  
  120. APTR MAllocV(ULONG size)
  121. {
  122.     ULONG *block;
  123.  
  124.     ObtainSemaphore(&Semaphore);
  125.     if (block = AsmAllocPooled(Pool, size+4, SysBase)) {
  126.         *(block++) = size;
  127.         memset(block, NULL, size);
  128.     }
  129.     ReleaseSemaphore(&Semaphore);
  130.     return(block);
  131. }
  132.  
  133.  
  134.     /*
  135.      *        Replacement for FreeVec()
  136.      */
  137.  
  138. void FreeV(APTR block)
  139. {
  140.     if (block) {
  141.         ObtainSemaphore(&Semaphore);
  142.         AsmFreePooled(Pool, (APTR)((ULONG)block-4), *(ULONG *)((ULONG)block-4), SysBase);
  143.         ReleaseSemaphore(&Semaphore);
  144.     }
  145. }
  146.