u_mm.c File Reference

Include dependency graph for u_mm.c:

Go to the source code of this file.

Functions
void	mmDumpMemInfo (const struct mem_block *heap)
	For debuging purpose.
struct mem_block *	mmInit (int ofs, int size)
	input: total size in bytes return: a heap pointer if OK, NULL if error
static struct mem_block *	SliceBlock (struct mem_block *p, int startofs, int size, int reserved, int alignment)
struct mem_block *	mmAllocMem (struct mem_block *heap, int size, int align2, int startSearch)
	Allocate 'size' bytes with 2^align2 bytes alignment, restrict the search to free memory after 'startSearch' depth and back buffers should be in different 4mb banks to get better page hits if possible input: size = size of block align2 = 2^align2 bytes alignment startSearch = linear offset from start of heap to begin search return: pointer to the allocated block, 0 if error.
struct mem_block *	mmFindBlock (struct mem_block *heap, int start)
	Free block starts at offset input: pointer to a heap, start offset return: pointer to a block.
static int	Join2Blocks (struct mem_block *p)
int	mmFreeMem (struct mem_block *b)
	Free block starts at offset input: pointer to a block return: 0 if OK, -1 if error.
void	mmDestroy (struct mem_block *heap)
	destroy MM

---

Function Documentation

static int Join2Blocks

(

struct mem_block *

p

)

[static]

Definition at line 219 of file u_mm.c.

References assert, FREE, mem_block::free, mem_block::next, mem_block::next_free, mem_block::ofs, mem_block::prev, mem_block::prev_free, and mem_block::size.

{
   /* XXX there should be some assertions here */

   /* NOTE: heap->free == 0 */

   if (p->free && p->next->free) {
      struct mem_block *q = p->next;

      assert(p->ofs + p->size == q->ofs);
      p->size += q->size;

      p->next = q->next;
      q->next->prev = p;

      q->next_free->prev_free = q->prev_free; 
      q->prev_free->next_free = q->next_free;
     
      FREE(q);
      return 1;
   }
   return 0;
}

struct mem_block* mmAllocMem	(	struct mem_block *	heap,
		int	size,
		int	align2,
		int	startSearch
	)			[read]

Allocate 'size' bytes with 2^align2 bytes alignment, restrict the search to free memory after 'startSearch' depth and back buffers should be in different 4mb banks to get better page hits if possible input: size = size of block align2 = 2^align2 bytes alignment startSearch = linear offset from start of heap to begin search return: pointer to the allocated block, 0 if error.

Definition at line 168 of file u_mm.c.

References assert, mem_block::free, mem_block::next_free, mem_block::ofs, mem_block::size, and SliceBlock().

{
   struct mem_block *p;
   const int mask = (1 << align2)-1;
   int startofs = 0;
   int endofs;

   assert(size >= 0);
   assert(align2 >= 0);
   assert(align2 <= 12); /* sanity check, 2^12 (4KB) enough? */

   if (!heap || align2 < 0 || size <= 0)
      return NULL;

   for (p = heap->next_free; p != heap; p = p->next_free) {
      assert(p->free);

      startofs = (p->ofs + mask) & ~mask;
      if ( startofs < startSearch ) {
         startofs = startSearch;
      }
      endofs = startofs+size;
      if (endofs <= (p->ofs+p->size))
         break;
   }

   if (p == heap) 
      return NULL;

   assert(p->free);
   p = SliceBlock(p,startofs,size,0,mask+1);

   return p;
}

void mmDestroy

(

struct mem_block *

heap

)

destroy MM

Definition at line 273 of file u_mm.c.

References FREE, and mem_block::next.

{
   struct mem_block *p;

   if (!heap)
      return;

   for (p = heap->next; p != heap; ) {
      struct mem_block *next = p->next;
      FREE(p);
      p = next;
   }

   FREE(heap);
}

void mmDumpMemInfo

(

const struct mem_block *

heap

)

For debuging purpose.

Definition at line 34 of file u_mm.c.

References debug_printf(), mem_block::free, mem_block::next, mem_block::next_free, mem_block::ofs, mem_block::reserved, and mem_block::size.

{
   debug_printf("Memory heap %p:\n", (void *)heap);
   if (heap == 0) {
      debug_printf("  heap == 0\n");
   } else {
      const struct mem_block *p;

      for(p = heap->next; p != heap; p = p->next) {
         debug_printf("  Offset:%08x, Size:%08x, %c%c\n",p->ofs,p->size,
                 p->free ? 'F':'.',
                 p->reserved ? 'R':'.');
      }

      debug_printf("\nFree list:\n");

      for(p = heap->next_free; p != heap; p = p->next_free) {
         debug_printf(" FREE Offset:%08x, Size:%08x, %c%c\n",p->ofs,p->size,
                 p->free ? 'F':'.',
                 p->reserved ? 'R':'.');
      }

   }
   debug_printf("End of memory blocks\n");
}

struct mem_block* mmFindBlock	(	struct mem_block *	heap,
		int	start
	)			[read]

Free block starts at offset input: pointer to a heap, start offset return: pointer to a block.

Definition at line 205 of file u_mm.c.

References mem_block::next, and mem_block::ofs.

{
   struct mem_block *p;

   for (p = heap->next; p != heap; p = p->next) {
      if (p->ofs == start) 
         return p;
   }

   return NULL;
}

int mmFreeMem

(

struct mem_block *

b

)

Free block starts at offset input: pointer to a block return: 0 if OK, -1 if error.

Definition at line 244 of file u_mm.c.

References debug_printf(), mem_block::free, mem_block::heap, Join2Blocks(), mem_block::next_free, mem_block::prev, mem_block::prev_free, and mem_block::reserved.

{
   if (!b)
      return 0;

   if (b->free) {
      debug_printf("block already free\n");
      return -1;
   }
   if (b->reserved) {
      debug_printf("block is reserved\n");
      return -1;
   }

   b->free = 1;
   b->next_free = b->heap->next_free;
   b->prev_free = b->heap;
   b->next_free->prev_free = b;
   b->prev_free->next_free = b;

   Join2Blocks(b);
   if (b->prev != b->heap)
      Join2Blocks(b->prev);

   return 0;
}

struct mem_block* mmInit	(	int	ofs,
		int	size
	)			[read]

input: total size in bytes return: a heap pointer if OK, NULL if error

Definition at line 61 of file u_mm.c.

References block(), CALLOC_STRUCT, mem_block::free, FREE, mem_block::heap, mem_block::next, mem_block::next_free, mem_block::ofs, mem_block::prev, mem_block::prev_free, and mem_block::size.

{
   struct mem_block *heap, *block;
  
   if (size <= 0) 
      return NULL;

   heap = CALLOC_STRUCT(mem_block);
   if (!heap) 
      return NULL;
   
   block = CALLOC_STRUCT(mem_block);
   if (!block) {
      FREE(heap);
      return NULL;
   }

   heap->next = block;
   heap->prev = block;
   heap->next_free = block;
   heap->prev_free = block;

   block->heap = heap;
   block->next = heap;
   block->prev = heap;
   block->next_free = heap;
   block->prev_free = heap;

   block->ofs = ofs;
   block->size = size;
   block->free = 1;

   return heap;
}

static struct mem_block* SliceBlock	(	struct mem_block *	p,
		int	startofs,
		int	size,
		int	reserved,
		int	alignment
	)			[static, read]

Definition at line 98 of file u_mm.c.

References CALLOC_STRUCT, mem_block::free, mem_block::heap, mem_block::next, mem_block::next_free, mem_block::ofs, mem_block::prev, mem_block::prev_free, mem_block::reserved, and mem_block::size.

{
   struct mem_block *newblock;

   /* break left  [p, newblock, p->next], then p = newblock */
   if (startofs > p->ofs) {
      newblock = CALLOC_STRUCT(mem_block);
      if (!newblock)
         return NULL;
      newblock->ofs = startofs;
      newblock->size = p->size - (startofs - p->ofs);
      newblock->free = 1;
      newblock->heap = p->heap;

      newblock->next = p->next;
      newblock->prev = p;
      p->next->prev = newblock;
      p->next = newblock;

      newblock->next_free = p->next_free;
      newblock->prev_free = p;
      p->next_free->prev_free = newblock;
      p->next_free = newblock;

      p->size -= newblock->size;
      p = newblock;
   }

   /* break right, also [p, newblock, p->next] */
   if (size < p->size) {
      newblock = CALLOC_STRUCT(mem_block);
      if (!newblock)
         return NULL;
      newblock->ofs = startofs + size;
      newblock->size = p->size - size;
      newblock->free = 1;
      newblock->heap = p->heap;

      newblock->next = p->next;
      newblock->prev = p;
      p->next->prev = newblock;
      p->next = newblock;

      newblock->next_free = p->next_free;
      newblock->prev_free = p;
      p->next_free->prev_free = newblock;
      p->next_free = newblock;
         
      p->size = size;
   }

   /* p = middle block */
   p->free = 0;

   /* Remove p from the free list: 
    */
   p->next_free->prev_free = p->prev_free;
   p->prev_free->next_free = p->next_free;

   p->next_free = 0;
   p->prev_free = 0;

   p->reserved = reserved;
   return p;
}

---