pb_bufmgr_mm.c File Reference

Buffer manager using the old texture memory manager. More...

Include dependency graph for pb_bufmgr_mm.c:

Go to the source code of this file.

Data Structures
struct	mm_pb_manager
struct	mm_buffer
Defines
#define	SUPER(__derived)   (&(__derived)->base)
	Convenience macro (type safe).
Functions
static struct mm_pb_manager *	mm_pb_manager (struct pb_manager *mgr)
static struct mm_buffer *	mm_buffer (struct pb_buffer *buf)
static void	mm_buffer_destroy (struct pb_buffer *buf)
static void *	mm_buffer_map (struct pb_buffer *buf, unsigned flags)
static void	mm_buffer_unmap (struct pb_buffer *buf)
static void	mm_buffer_get_base_buffer (struct pb_buffer *buf, struct pb_buffer **base_buf, unsigned *offset)
static struct pb_buffer *	mm_bufmgr_create_buffer (struct pb_manager *mgr, size_t size, const struct pb_desc *desc)
static void	mm_bufmgr_flush (struct pb_manager *mgr)
static void	mm_bufmgr_destroy (struct pb_manager *mgr)
struct pb_manager *	mm_bufmgr_create_from_buffer (struct pb_buffer *buffer, size_t size, size_t align2)
	Same as mm_bufmgr_create.
struct pb_manager *	mm_bufmgr_create (struct pb_manager *provider, size_t size, size_t align2)
	Static sub-allocator based the old memory manager.
Variables
static struct pb_vtbl	mm_buffer_vtbl

---

Detailed Description

Buffer manager using the old texture memory manager.

Author:

José Fonseca <jrfonseca@tungstengraphics.com>

Definition in file pb_bufmgr_mm.c.

---

Define Documentation

#define SUPER

(

__derived

)

(&(__derived)->base)

Convenience macro (type safe).

Definition at line 49 of file pb_bufmgr_mm.c.

---

Function Documentation

static struct mm_buffer* mm_buffer

(

struct pb_buffer *

buf

)

[static, read]

Definition at line 87 of file pb_bufmgr_mm.c.

References assert.

{
   assert(buf);
   return (struct mm_buffer *)buf;
}

static void mm_buffer_destroy

(

struct pb_buffer *

buf

)

[static]

Definition at line 95 of file pb_bufmgr_mm.c.

References assert, pb_buffer::base, mm_buffer::block, FREE, mm_buffer::mgr, mm_buffer(), mmFreeMem(), mm_pb_manager::mutex, pipe_mutex_lock, pipe_mutex_unlock, and pipe_buffer::refcount.

{
   struct mm_buffer *mm_buf = mm_buffer(buf);
   struct mm_pb_manager *mm = mm_buf->mgr;
   
   assert(buf->base.refcount == 0);
   
   pipe_mutex_lock(mm->mutex);
   mmFreeMem(mm_buf->block);
   FREE(buf);
   pipe_mutex_unlock(mm->mutex);
}

static void mm_buffer_get_base_buffer	(	struct pb_buffer *	buf,
		struct pb_buffer **	base_buf,
		unsigned *	offset
	)			[static]

Definition at line 128 of file pb_bufmgr_mm.c.

References mm_buffer::block, mm_pb_manager::buffer, mm_buffer::mgr, mm_buffer(), mem_block::ofs, and pb_get_base_buffer().

{
   struct mm_buffer *mm_buf = mm_buffer(buf);
   struct mm_pb_manager *mm = mm_buf->mgr;
   pb_get_base_buffer(mm->buffer, base_buf, offset);
   *offset += mm_buf->block->ofs;
}

static void* mm_buffer_map	(	struct pb_buffer *	buf,
		unsigned	flags
	)			[static]

Definition at line 110 of file pb_bufmgr_mm.c.

References mm_buffer::block, mm_pb_manager::map, mm_buffer::mgr, mm_buffer(), and mem_block::ofs.

{
   struct mm_buffer *mm_buf = mm_buffer(buf);
   struct mm_pb_manager *mm = mm_buf->mgr;

   return (unsigned char *) mm->map + mm_buf->block->ofs;
}

static void mm_buffer_unmap

(

struct pb_buffer *

buf

)

[static]

Definition at line 121 of file pb_bufmgr_mm.c.

{
   /* No-op */
}

struct pb_manager* mm_bufmgr_create	(	struct pb_manager *	provider,
		size_t	size,
		size_t	align2
	)			[read]

Static sub-allocator based the old memory manager.

It managers buffers of different sizes. It does so by allocating a buffer with the size of the heap, and then using the old mm memory manager to manage that heap.

Definition at line 271 of file pb_bufmgr_mm.c.

References pb_desc::alignment, pb_manager::create_buffer, mm_bufmgr_create_from_buffer(), and pb_reference().

{
   struct pb_buffer *buffer;
   struct pb_manager *mgr;
   struct pb_desc desc;

   if(!provider)
      return NULL;
   
   memset(&desc, 0, sizeof(desc));
   desc.alignment = 1 << align2;
   
   buffer = provider->create_buffer(provider, size, &desc); 
   if (!buffer)
      return NULL;
   
   mgr = mm_bufmgr_create_from_buffer(buffer, size, align2);
   if (!mgr) {
      pb_reference(&buffer, NULL);
      return NULL;
   }

  return mgr;
}

static struct pb_buffer* mm_bufmgr_create_buffer	(	struct pb_manager *	mgr,
		size_t	size,
		const struct pb_desc *	desc
	)			[static, read]

Definition at line 149 of file pb_bufmgr_mm.c.

References mm_pb_manager::align2, pipe_buffer::alignment, pb_desc::alignment, assert, pb_buffer::base, mm_buffer::base, mm_buffer::block, CALLOC_STRUCT, debug_printf(), FREE, mm_pb_manager::heap, mm_buffer::mgr, mm_pb_manager(), mmAllocMem(), mmDumpMemInfo(), mm_pb_manager::mutex, mem_block::ofs, pb_check_alignment(), pipe_mutex_lock, pipe_mutex_unlock, pipe_buffer::refcount, mem_block::size, mm_pb_manager::size, pipe_buffer::size, SUPER, pb_desc::usage, pipe_buffer::usage, and pb_buffer::vtbl.

{
   struct mm_pb_manager *mm = mm_pb_manager(mgr);
   struct mm_buffer *mm_buf;

   /* We don't handle alignments larger then the one initially setup */
   assert(pb_check_alignment(desc->alignment, 1 << mm->align2));
   if(!pb_check_alignment(desc->alignment, 1 << mm->align2))
      return NULL;
   
   pipe_mutex_lock(mm->mutex);

   mm_buf = CALLOC_STRUCT(mm_buffer);
   if (!mm_buf) {
      pipe_mutex_unlock(mm->mutex);
      return NULL;
   }

   mm_buf->base.base.refcount = 1;
   mm_buf->base.base.alignment = desc->alignment;
   mm_buf->base.base.usage = desc->usage;
   mm_buf->base.base.size = size;
   
   mm_buf->base.vtbl = &mm_buffer_vtbl;
   
   mm_buf->mgr = mm;
   
   mm_buf->block = mmAllocMem(mm->heap, size, mm->align2, 0);
   if(!mm_buf->block) {
      debug_printf("warning: heap full\n");
#if 0
      mmDumpMemInfo(mm->heap);
#endif
      FREE(mm_buf);
      pipe_mutex_unlock(mm->mutex);
      return NULL;
   }
   
   /* Some sanity checks */
   assert(0 <= (unsigned)mm_buf->block->ofs && (unsigned)mm_buf->block->ofs < mm->size);
   assert(size <= (unsigned)mm_buf->block->size && (unsigned)mm_buf->block->ofs + (unsigned)mm_buf->block->size <= mm->size);
   
   pipe_mutex_unlock(mm->mutex);
   return SUPER(mm_buf);
}

struct pb_manager* mm_bufmgr_create_from_buffer	(	struct pb_buffer *	buffer,
		size_t	size,
		size_t	align2
	)			[read]

Same as mm_bufmgr_create.

Buffer will be release when the manager is destroyed.

Definition at line 224 of file pb_bufmgr_mm.c.

References mm_pb_manager::align2, mm_pb_manager::base, mm_pb_manager::buffer, CALLOC_STRUCT, pb_manager::create_buffer, pb_manager::destroy, pb_manager::flush, FREE, mm_pb_manager::heap, mm_pb_manager::map, mm_bufmgr_create_buffer(), mm_bufmgr_destroy(), mm_bufmgr_flush(), mmDestroy(), mmInit(), mm_pb_manager::mutex, pb_map(), pb_unmap(), PIPE_BUFFER_USAGE_CPU_READ, PIPE_BUFFER_USAGE_CPU_WRITE, pipe_mutex_init, mm_pb_manager::size, and SUPER.

{
   struct mm_pb_manager *mm;

   if(!buffer)
      return NULL;
   
   mm = CALLOC_STRUCT(mm_pb_manager);
   if (!mm)
      return NULL;

   mm->base.destroy = mm_bufmgr_destroy;
   mm->base.create_buffer = mm_bufmgr_create_buffer;
   mm->base.flush = mm_bufmgr_flush;

   mm->size = size;
   mm->align2 = align2; /* 64-byte alignment */

   pipe_mutex_init(mm->mutex);

   mm->buffer = buffer; 

   mm->map = pb_map(mm->buffer, 
                    PIPE_BUFFER_USAGE_CPU_READ |
                    PIPE_BUFFER_USAGE_CPU_WRITE);
   if(!mm->map)
      goto failure;

   mm->heap = mmInit(0, size); 
   if (!mm->heap)
      goto failure;

   return SUPER(mm);
   
failure:
if(mm->heap)
   mmDestroy(mm->heap);
   if(mm->map)
      pb_unmap(mm->buffer);
   if(mm)
      FREE(mm);
   return NULL;
}

static void mm_bufmgr_destroy

(

struct pb_manager *

mgr

)

[static]

Definition at line 206 of file pb_bufmgr_mm.c.

References mm_pb_manager::buffer, FREE, mm_pb_manager::heap, mm_pb_manager(), mmDestroy(), mm_pb_manager::mutex, pb_reference(), pb_unmap(), pipe_mutex_lock, and pipe_mutex_unlock.

{
   struct mm_pb_manager *mm = mm_pb_manager(mgr);
   
   pipe_mutex_lock(mm->mutex);

   mmDestroy(mm->heap);
   
   pb_unmap(mm->buffer);
   pb_reference(&mm->buffer, NULL);
   
   pipe_mutex_unlock(mm->mutex);
   
   FREE(mgr);
}

static void mm_bufmgr_flush

(

struct pb_manager *

mgr

)

[static]

Definition at line 199 of file pb_bufmgr_mm.c.

{
   /* No-op */
}

static struct mm_pb_manager* mm_pb_manager

(

struct pb_manager *

mgr

)

[static, read]

Definition at line 69 of file pb_bufmgr_mm.c.

References assert.

{
   assert(mgr);
   return (struct mm_pb_manager *)mgr;
}

---

Variable Documentation

struct pb_vtbl mm_buffer_vtbl [static]

Initial value:

 {
      mm_buffer_destroy,
      mm_buffer_map,
      mm_buffer_unmap,
      mm_buffer_get_base_buffer
}

Definition at line 140 of file pb_bufmgr_mm.c.

---