home *** CD-ROM | disk | FTP | other *** search
/ Amiga MA Magazine 1998 #6 / amigamamagazinepolishissue1998.iso / varia / toolmanager / source / global_memory.c < prev    next >
C/C++ Source or Header  |  1977-12-31  |  5KB  |  204 lines
  1. /*
  2.  * global_memory.c  V3.0
  3.  *
  4.  * ToolManager global memory management routines
  5.  *
  6.  * Copyright (C) 1990-97 Stefan Becker
  7.  *
  8.  * This source code is for educational purposes only. You may study it
  9.  * and copy ideas or algorithms from it for your own projects. It is
  10.  * not allowed to use any of the source codes (in full or in parts)
  11.  * in other programs. Especially it is not allowed to create variants
  12.  * of ToolManager or ToolManager-like programs from this source code.
  13.  *
  14.  */
  15.  
  16. #ifdef DEBUG
  17. /* Debugging versions of memory functions. These work with Mungwall */
  18.  
  19. /* Local data structures */
  20. struct MemoryData {
  21.  struct MinNode md_Node;
  22.  ULONG          md_Size;
  23.  /* Rest of memory block follows here */
  24. };
  25.  
  26. /* Local data */
  27. static struct MinList MemoryList;
  28. static BOOL           Initialized = FALSE;
  29.  
  30. /* Initialize memory managment */
  31. #define DEBUGFUNCTION InitMemory
  32. BOOL InitMemory(void)
  33. {
  34.  /* Initialize list */
  35.  NewList((struct List *) &MemoryList);
  36.  
  37.  /* Set flag */
  38.  Initialized = TRUE;
  39.  
  40.  INFORMATION_LOG(LOG0(Memory tracking enabled))
  41.  
  42.  return(TRUE);
  43. }
  44.  
  45. /* Shut down memory management */
  46. #undef  DEBUGFUNCTION
  47. #define DEBUGFUNCTION DeleteMemory
  48. void DeleteMemory(void)
  49. {
  50.  /* List empty? */
  51.  if ((Initialized == FALSE) || IsListEmpty((struct List *) &MemoryList)) {
  52.  
  53.   INFORMATION_LOG(LOG0(All memory was released))
  54.  
  55.  } else {
  56.   struct MemoryData *md;
  57.  
  58.   ERROR_LOG(LOG0(The following memory has not been released))
  59.  
  60.   while (md = (struct MemoryData *) RemHead((struct List *) &MemoryList)) {
  61.  
  62.    ERROR_LOG(LOG2(Not released, "Block 0x%08lx Size %ld",
  63.                   md + 1, md->md_Size))
  64.    FreeVector(md + 1);
  65.   }
  66.  }
  67.  
  68.  /* Reset flag */
  69.  Initialized = FALSE;
  70. }
  71.  
  72. /* Get memory (no size tracking) */
  73. void *GetMemory(ULONG size)
  74. {
  75.  return(GetVector(size));
  76. }
  77.  
  78. /* Free memory (no size tracking) */
  79. #undef  DEBUGFUNCTION
  80. #define DEBUGFUNCTION FreeMemory
  81. void FreeMemory(void *ptr, ULONG size)
  82. {
  83.  struct MemoryData *md = (struct MemoryData *) ptr - 1;
  84.  
  85.  /* Check sizes */
  86.  if (size == (md->md_Size - sizeof(struct MemoryData))) {
  87.  
  88.   MEMORY_LOG(LOG2(Arguments, "Block 0x%08lx Size %ld", ptr, size))
  89.  
  90.  } else {
  91.  
  92.   ERROR_LOG(LOG3(Error, "Block 0x%08lx Size %ld != Orig %ld",
  93.                  ptr, size, md->md_Size))
  94.  }
  95.  
  96.  /* Remove memory block */
  97.  Remove((struct Node *) md);
  98.  FreeMem(md, md->md_Size);
  99. }
  100.  
  101. /* Get memory (with size tracking) */
  102. #undef  DEBUGFUNCTION
  103. #define DEBUGFUNCTION GetVector
  104. void *GetVector(ULONG size)
  105. {
  106.  struct MemoryData *md;
  107.  
  108.  /* Add size for our data structure */
  109.  size += sizeof(struct MemoryData);
  110.  
  111.  /* Allocate memory, save size and move pointer to real mem. block */
  112.  if (md = AllocMem(size, MEMF_PUBLIC)) {
  113.   md->md_Size = size;
  114.  
  115.   /* Add block to memory list */
  116.   AddTail((struct List *) &MemoryList, (struct Node *) md++);
  117.  }
  118.  
  119.  MEMORY_LOG(LOG2(Result, "Block 0x%08lx Size %ld",
  120.                  md, size - sizeof(struct MemoryData)))
  121.  
  122.  /* Return pointer to memory block */
  123.  return(md);
  124. }
  125.  
  126. /* Free memory (with size tracking) */
  127. #undef  DEBUGFUNCTION
  128. #define DEBUGFUNCTION FreeVector
  129. void FreeVector(void *ptr)
  130. {
  131.  struct MemoryData *md = (struct MemoryData *) ptr - 1;
  132.  
  133.  MEMORY_LOG(LOG2(Arguments, "Block 0x%08lx Size %ld",
  134.                  ptr, md->md_Size - sizeof(struct MemoryData)))
  135.  
  136.  /* Remove memory block */
  137.  Remove((struct Node *) md);
  138.  FreeMem(md, md->md_Size);
  139. }
  140.  
  141. #else
  142. /* The production code uses memory pools */
  143.  
  144. /* Local data structures */
  145. struct Vector {
  146.  ULONG v_Size;
  147.  /* Rest of memory block follows here */
  148. };
  149.  
  150. /* Local data */
  151. static void *MemoryPool = NULL;
  152.  
  153. /* Initialize memory managment */
  154. BOOL InitMemory(void)
  155. {
  156.  /* Allocate memory pool */
  157.  return(MemoryPool = CreatePool(MEMF_PUBLIC, 8 * 1024, 6 * 1024));
  158. }
  159.  
  160. /* Shut down memory management */
  161. void DeleteMemory(void)
  162. {
  163.  if (MemoryPool) {
  164.   DeletePool(MemoryPool);
  165.   MemoryPool = NULL;
  166.  }
  167. }
  168.  
  169. /* Get memory (no size tracking) */
  170. void *GetMemory(ULONG size)
  171. {
  172.  return(AllocPooled(MemoryPool, size));
  173. }
  174.  
  175. /* Free memory (no size tracking) */
  176. void FreeMemory(void *ptr, ULONG size)
  177. {
  178.  FreePooled(MemoryPool, ptr, size);
  179. }
  180.  
  181. /* Get memory (with size tracking) */
  182. void *GetVector(ULONG size)
  183. {
  184.  struct Vector *v;
  185.  
  186.  /* Add size for our data structure */
  187.  size += sizeof(struct Vector);
  188.  
  189.  /* Allocate memory from pool, save size and move pointer to real mem. block */
  190.  if (v = AllocPooled(MemoryPool, size)) (v++)->v_Size = size;
  191.  
  192.  /* Return pointer to memory block */
  193.  return(v);
  194. }
  195.  
  196. /* Free memory (with size tracking) */
  197. void FreeVector(void *ptr)
  198. {
  199.  ULONG size = (--((struct Vector *) ptr))->v_Size;
  200.  
  201.  FreePooled(MemoryPool, ptr, size);
  202. }
  203. #endif
  204.