pb_bufmgr.h File Reference

Buffer management. More...

Include dependency graph for pb_bufmgr.h:

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

Go to the source code of this file.

Data Structures
struct	pb_manager
	Abstract base class for all buffer managers. More...
Functions
struct pb_manager *	pb_malloc_bufmgr_create (void)
	Malloc buffer provider.
struct pb_manager *	pool_bufmgr_create (struct pb_manager *provider, size_t n, size_t size, const struct pb_desc *desc)
	Static buffer pool sub-allocator.
struct pb_manager *	mm_bufmgr_create (struct pb_manager *provider, size_t size, size_t align2)
	Static sub-allocator based the old memory manager.
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 *	pb_slab_manager_create (struct pb_manager *provider, size_t bufSize, size_t slabSize, const struct pb_desc *desc)
	Slab sub-allocator.
struct pb_manager *	pb_slab_range_manager_create (struct pb_manager *provider, size_t minBufSize, size_t maxBufSize, size_t slabSize, const struct pb_desc *desc)
	Allow a range of buffer size, by aggregating multiple slabs sub-allocators with different bucket sizes.
struct pb_manager *	pb_cache_manager_create (struct pb_manager *provider, unsigned usecs)
	Time-based buffer cache.
struct pb_manager *	fenced_bufmgr_create (struct pb_manager *provider, struct pipe_winsys *winsys)
	Fenced buffer manager.
struct pb_manager *	pb_alt_manager_create (struct pb_manager *provider1, struct pb_manager *provider2)
struct pb_manager *	pb_debug_manager_create (struct pb_manager *provider, size_t band_size)
	Debug buffer manager to detect buffer under- and overflows.

---

Detailed Description

Buffer management.

A buffer manager does only one basic thing: it creates buffers. Actually, "buffer factory" would probably a more accurate description.

You can chain buffer managers so that you can have a finer grained memory management and pooling.

For example, for a simple batch buffer manager you would chain:

• the native buffer manager, which provides DMA memory from the graphics memory space;
• the pool buffer manager, which keep around a pool of equally sized buffers to avoid latency associated with the native buffer manager;
• the fenced buffer manager, which will delay buffer destruction until the the moment the card finishing processing it.

Author:

José Fonseca <jrfonseca@tungstengraphics.com>

Definition in file pb_bufmgr.h.

---

Function Documentation

struct pb_manager* fenced_bufmgr_create	(	struct pb_manager *	provider,
		struct pipe_winsys *	winsys
	)			[read]

Fenced buffer manager.

This manager is just meant for convenience. It wraps the buffers returned by another manager in fenced buffers, so that

NOTE: the buffer manager that provides the buffers will be destroyed at the same time.

Definition at line 129 of file pb_bufmgr_fenced.c.

References fenced_pb_manager::base, CALLOC_STRUCT, pb_manager::create_buffer, pb_manager::destroy, fenced_buffer_list_create(), fenced_bufmgr_create_buffer(), fenced_bufmgr_destroy(), fenced_bufmgr_flush(), fenced_pb_manager::fenced_list, pb_manager::flush, FREE, and fenced_pb_manager::provider.

{
   struct fenced_pb_manager *fenced_mgr;

   if(!provider)
      return NULL;
   
   fenced_mgr = CALLOC_STRUCT(fenced_pb_manager);
   if (!fenced_mgr)
      return NULL;

   fenced_mgr->base.destroy = fenced_bufmgr_destroy;
   fenced_mgr->base.create_buffer = fenced_bufmgr_create_buffer;
   fenced_mgr->base.flush = fenced_bufmgr_flush;

   fenced_mgr->provider = provider;
   fenced_mgr->fenced_list = fenced_buffer_list_create(winsys);
   if(!fenced_mgr->fenced_list) {
      FREE(fenced_mgr);
      return NULL;
   }
      
   return &fenced_mgr->base;
}

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

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

struct pb_manager* pb_alt_manager_create	(	struct pb_manager *	provider1,
		struct pb_manager *	provider2
	)			[read]

Definition at line 101 of file pb_bufmgr_alt.c.

References pb_alt_manager::base, CALLOC_STRUCT, pb_manager::create_buffer, pb_manager::destroy, pb_manager::flush, pb_alt_manager_create_buffer(), pb_alt_manager_destroy(), pb_alt_manager_flush(), pb_alt_manager::provider1, and pb_alt_manager::provider2.

{
   struct pb_alt_manager *mgr;

   if(!provider1 || !provider2)
      return NULL;
   
   mgr = CALLOC_STRUCT(pb_alt_manager);
   if (!mgr)
      return NULL;

   mgr->base.destroy = pb_alt_manager_destroy;
   mgr->base.create_buffer = pb_alt_manager_create_buffer;
   mgr->base.flush = pb_alt_manager_flush;
   mgr->provider1 = provider1;
   mgr->provider2 = provider2;
      
   return &mgr->base;
}

struct pb_manager* pb_cache_manager_create	(	struct pb_manager *	provider,
		unsigned	usecs
	)			[read]

Time-based buffer cache.

This manager keeps a cache of destroyed buffers during a time interval.

Definition at line 342 of file pb_bufmgr_cache.c.

References pb_cache_manager::base, CALLOC_STRUCT, pb_manager::create_buffer, pb_cache_manager::delayed, pb_manager::destroy, pb_manager::flush, LIST_INITHEAD, pb_cache_manager::mutex, pb_cache_manager::numDelayed, pb_cache_manager_create_buffer(), pb_cache_manager_destroy(), pb_cache_manager_flush(), pipe_mutex_init, pb_cache_manager::provider, and pb_cache_manager::usecs.

{
   struct pb_cache_manager *mgr;

   if(!provider)
      return NULL;
   
   mgr = CALLOC_STRUCT(pb_cache_manager);
   if (!mgr)
      return NULL;

   mgr->base.destroy = pb_cache_manager_destroy;
   mgr->base.create_buffer = pb_cache_manager_create_buffer;
   mgr->base.flush = pb_cache_manager_flush;
   mgr->provider = provider;
   mgr->usecs = usecs;
   LIST_INITHEAD(&mgr->delayed);
   mgr->numDelayed = 0;
   pipe_mutex_init(mgr->mutex);
      
   return &mgr->base;
}

struct pb_manager* pb_debug_manager_create	(	struct pb_manager *	provider,
		size_t	band_size
	)			[read]

Debug buffer manager to detect buffer under- and overflows.

Band size should be a multiple of the largest alignment

Definition at line 358 of file pb_bufmgr_debug.c.

{

struct pb_manager* pb_malloc_bufmgr_create

(

void

)

[read]

Malloc buffer provider.

Simple wrapper around pb_malloc_buffer_create for convenience.

Definition at line 163 of file pb_buffer_malloc.c.

{
  return &pb_malloc_bufmgr;
}

struct pb_manager* pb_slab_manager_create	(	struct pb_manager *	provider,
		size_t	bufSize,
		size_t	slabSize,
		const struct pb_desc *	desc
	)			[read]

Slab sub-allocator.

Definition at line 431 of file pb_bufmgr_slab.c.

References pb_slab_manager::base, pb_slab_manager::bufSize, CALLOC_STRUCT, pb_manager::create_buffer, pb_slab_manager::desc, pb_manager::destroy, pb_manager::flush, LIST_INITHEAD, pb_slab_manager::mutex, pb_slab_manager_create_buffer(), pb_slab_manager_destroy(), pb_slab_manager_flush(), pipe_mutex_init, pb_slab_manager::provider, pb_slab_manager::slabs, and pb_slab_manager::slabSize.

{
   struct pb_slab_manager *mgr;

   mgr = CALLOC_STRUCT(pb_slab_manager);
   if (!mgr)
      return NULL;

   mgr->base.destroy = pb_slab_manager_destroy;
   mgr->base.create_buffer = pb_slab_manager_create_buffer;
   mgr->base.flush = pb_slab_manager_flush;

   mgr->provider = provider;
   mgr->bufSize = bufSize;
   mgr->slabSize = slabSize;
   mgr->desc = *desc;

   LIST_INITHEAD(&mgr->slabs);
   
   pipe_mutex_init(mgr->mutex);

   return &mgr->base;
}

struct pb_manager* pb_slab_range_manager_create	(	struct pb_manager *	provider,
		size_t	minBufSize,
		size_t	maxBufSize,
		size_t	slabSize,
		const struct pb_desc *	desc
	)			[read]

Allow a range of buffer size, by aggregating multiple slabs sub-allocators with different bucket sizes.

Definition at line 508 of file pb_bufmgr_slab.c.

References pb_slab_range_manager::base, pb_slab_range_manager::buckets, CALLOC, CALLOC_STRUCT, pb_manager::create_buffer, pb_manager::destroy, pb_manager::flush, FREE, pb_slab_range_manager::maxBufSize, pb_slab_range_manager::minBufSize, pb_slab_range_manager::numBuckets, pb_slab_manager_create(), pb_slab_range_manager_create_buffer(), pb_slab_range_manager_destroy(), pb_slab_range_manager_flush(), and pb_slab_range_manager::provider.

{
   struct pb_slab_range_manager *mgr;
   size_t bufSize;
   unsigned i;

   if(!provider)
      return NULL;
   
   mgr = CALLOC_STRUCT(pb_slab_range_manager);
   if (!mgr)
      goto out_err0;

   mgr->base.destroy = pb_slab_range_manager_destroy;
   mgr->base.create_buffer = pb_slab_range_manager_create_buffer;
   mgr->base.flush = pb_slab_range_manager_flush;

   mgr->provider = provider;
   mgr->minBufSize = minBufSize;
   mgr->maxBufSize = maxBufSize;

   mgr->numBuckets = 1;
   bufSize = minBufSize;
   while(bufSize < maxBufSize) {
      bufSize *= 2;
      ++mgr->numBuckets;
   }
   
   mgr->buckets = CALLOC(mgr->numBuckets, sizeof(*mgr->buckets));
   if (!mgr->buckets)
      goto out_err1;

   bufSize = minBufSize;
   for (i = 0; i < mgr->numBuckets; ++i) {
      mgr->buckets[i] = pb_slab_manager_create(provider, bufSize, slabSize, desc);
      if(!mgr->buckets[i])
         goto out_err2;
      bufSize *= 2;
   }

   return &mgr->base;

out_err2: 
   for (i = 0; i < mgr->numBuckets; ++i)
      if(mgr->buckets[i])
            mgr->buckets[i]->destroy(mgr->buckets[i]);
   FREE(mgr->buckets);
out_err1: 
   FREE(mgr);
out_err0:
   return NULL;
}

struct pb_manager* pool_bufmgr_create	(	struct pb_manager *	provider,
		size_t	n,
		size_t	size,
		const struct pb_desc *	desc
	)			[read]

Static buffer pool sub-allocator.

Manages the allocation of equally sized buffers. It does so by allocating a single big buffer and divide it equally sized buffers.

It is meant to manage the allocation of batch buffer pools.

Definition at line 230 of file pb_bufmgr_pool.c.

References pipe_buffer::alignment, pb_desc::alignment, pb_buffer::base, pool_buffer::base, pool_pb_manager::base, pool_pb_manager::bufAlign, pool_pb_manager::buffer, pool_pb_manager::bufs, pool_pb_manager::bufSize, CALLOC, CALLOC_STRUCT, pb_manager::create_buffer, pb_manager::destroy, pb_manager::flush, FREE, pool_pb_manager::free, pool_buffer::head, LIST_ADDTAIL, LIST_INITHEAD, pool_pb_manager::map, pool_buffer::mgr, pool_pb_manager::mutex, pool_pb_manager::numFree, pool_pb_manager::numTot, pb_map(), pb_reference(), pb_unmap(), PIPE_BUFFER_USAGE_CPU_READ, PIPE_BUFFER_USAGE_CPU_WRITE, pipe_mutex_init, pool_bufmgr_create_buffer(), pool_bufmgr_destroy(), pool_bufmgr_flush(), pipe_buffer::refcount, pipe_buffer::size, pool_buffer::start, SUPER, pipe_buffer::usage, and pb_buffer::vtbl.

{
   struct pool_pb_manager *pool;
   struct pool_buffer *pool_buf;
   size_t i;

   if(!provider)
      return NULL;
   
   pool = CALLOC_STRUCT(pool_pb_manager);
   if (!pool)
      return NULL;

   pool->base.destroy = pool_bufmgr_destroy;
   pool->base.create_buffer = pool_bufmgr_create_buffer;
   pool->base.flush = pool_bufmgr_flush;

   LIST_INITHEAD(&pool->free);

   pool->numTot = numBufs;
   pool->numFree = numBufs;
   pool->bufSize = bufSize;
   pool->bufAlign = desc->alignment; 
   
   pipe_mutex_init(pool->mutex);

   pool->buffer = provider->create_buffer(provider, numBufs*bufSize, desc); 
   if (!pool->buffer)
      goto failure;

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

   pool->bufs = (struct pool_buffer *)CALLOC(numBufs, sizeof(*pool->bufs));
   if (!pool->bufs)
      goto failure;

   pool_buf = pool->bufs;
   for (i = 0; i < numBufs; ++i) {
      pool_buf->base.base.refcount = 0;
      pool_buf->base.base.alignment = 0;
      pool_buf->base.base.usage = 0;
      pool_buf->base.base.size = bufSize;
      pool_buf->base.vtbl = &pool_buffer_vtbl;
      pool_buf->mgr = pool;
      pool_buf->start = i * bufSize;
      LIST_ADDTAIL(&pool_buf->head, &pool->free);
      pool_buf++;
   }

   return SUPER(pool);
   
failure:
   if(pool->bufs)
      FREE(pool->bufs);
   if(pool->map)
      pb_unmap(pool->buffer);
   if(pool->buffer)
      pb_reference(&pool->buffer, NULL);
   if(pool)
      FREE(pool);
   return NULL;
}

---