u_mm.h File Reference

Memory manager code. More...

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	mem_block
Functions
struct mem_block *	mmInit (int ofs, int size)
	input: total size in bytes return: a heap pointer if OK, NULL if error
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.
int	mmFreeMem (struct mem_block *b)
	Free block starts at offset input: pointer to a block return: 0 if OK, -1 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.
void	mmDestroy (struct mem_block *mmInit)
	destroy MM
void	mmDumpMemInfo (const struct mem_block *mmInit)
	For debuging purpose.

---

Detailed Description

Memory manager code.

Primarily used by device drivers to manage texture heaps, etc.

Definition in file u_mm.h.

---

Function Documentation

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 *

mmInit

)

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 *

mmInit

)

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;
}

---