pb_bufmgr_slab.c File Reference

S-lab pool implementation. More...

Include dependency graph for pb_bufmgr_slab.c:

Go to the source code of this file.

Data Structures
struct	pb_slab_buffer
	Buffer in a slab. More...
struct	pb_slab
	Slab -- a contiguous piece of memory. More...
struct	pb_slab_manager
	It adds/removes slabs as needed in order to meet the allocation/destruction of individual buffers. More...
struct	pb_slab_range_manager
	Wrapper around several slabs, therefore capable of handling buffers of multiple sizes. More...
Functions
static struct pb_slab_buffer *	pb_slab_buffer (struct pb_buffer *buf)
static struct pb_slab_manager *	pb_slab_manager (struct pb_manager *mgr)
static struct pb_slab_range_manager *	pb_slab_range_manager (struct pb_manager *mgr)
static void	pb_slab_buffer_destroy (struct pb_buffer *_buf)
	Delete a buffer from the slab delayed list and put it on the slab FREE list.
static void *	pb_slab_buffer_map (struct pb_buffer *_buf, unsigned flags)
static void	pb_slab_buffer_unmap (struct pb_buffer *_buf)
static void	pb_slab_buffer_get_base_buffer (struct pb_buffer *_buf, struct pb_buffer **base_buf, unsigned *offset)
static enum pipe_error	pb_slab_create (struct pb_slab_manager *mgr)
	Create a new slab.
static struct pb_buffer *	pb_slab_manager_create_buffer (struct pb_manager *_mgr, size_t size, const struct pb_desc *desc)
static void	pb_slab_manager_flush (struct pb_manager *_mgr)
static void	pb_slab_manager_destroy (struct pb_manager *_mgr)
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.
static struct pb_buffer *	pb_slab_range_manager_create_buffer (struct pb_manager *_mgr, size_t size, const struct pb_desc *desc)
static void	pb_slab_range_manager_flush (struct pb_manager *_mgr)
static void	pb_slab_range_manager_destroy (struct pb_manager *_mgr)
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.
Variables
static struct pb_vtbl	pb_slab_buffer_vtbl

---

Detailed Description

S-lab pool implementation.

See also:

http://en.wikipedia.org/wiki/Slab_allocation

Author:

Thomas Hellstrom <thomas-at-tungstengraphics-dot-com>

Jose Fonseca <jrfonseca@tungstengraphics.com>

Definition in file pb_bufmgr_slab.c.

---

Function Documentation

static struct pb_slab_buffer* pb_slab_buffer

(

struct pb_buffer *

buf

)

[static, read]

Definition at line 168 of file pb_bufmgr_slab.c.

References assert.

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

static void pb_slab_buffer_destroy

(

struct pb_buffer *

_buf

)

[static]

Delete a buffer from the slab delayed list and put it on the slab FREE list.

Definition at line 196 of file pb_bufmgr_slab.c.

References assert, pb_buffer::base, pb_slab_buffer::base, pb_slab::bo, pb_slab::buffers, FREE, pb_slab::freeBuffers, pb_slab::head, pb_slab_buffer::head, list, LIST_ADDTAIL, LIST_DEL, LIST_DELINIT, pb_slab_buffer::mapCount, pb_slab::mgr, pb_slab_manager::mutex, list_head::next, pb_slab::numBuffers, pb_slab::numFree, pb_reference(), pb_slab_buffer(), pipe_mutex_lock, pipe_mutex_unlock, pipe_buffer::refcount, pb_slab_buffer::slab, and pb_slab_manager::slabs.

{
   struct pb_slab_buffer *buf = pb_slab_buffer(_buf);
   struct pb_slab *slab = buf->slab;
   struct pb_slab_manager *mgr = slab->mgr;
   struct list_head *list = &buf->head;

   pipe_mutex_lock(mgr->mutex);
   
   assert(buf->base.base.refcount == 0);
   
   buf->mapCount = 0;

   LIST_DEL(list);
   LIST_ADDTAIL(list, &slab->freeBuffers);
   slab->numFree++;

   if (slab->head.next == &slab->head)
      LIST_ADDTAIL(&slab->head, &mgr->slabs);

   /* If the slab becomes totally empty, free it */
   if (slab->numFree == slab->numBuffers) {
      list = &slab->head;
      LIST_DELINIT(list);
      pb_reference(&slab->bo, NULL);
      FREE(slab->buffers);
      FREE(slab);
   }

   pipe_mutex_unlock(mgr->mutex);
}

static void pb_slab_buffer_get_base_buffer	(	struct pb_buffer *	_buf,
		struct pb_buffer **	base_buf,
		unsigned *	offset
	)			[static]

Definition at line 252 of file pb_bufmgr_slab.c.

References pb_slab::bo, pb_get_base_buffer(), pb_slab_buffer(), pb_slab_buffer::slab, and pb_slab_buffer::start.

{
   struct pb_slab_buffer *buf = pb_slab_buffer(_buf);
   pb_get_base_buffer(buf->slab->bo, base_buf, offset);
   *offset += buf->start;
}

static void* pb_slab_buffer_map	(	struct pb_buffer *	_buf,
		unsigned	flags
	)			[static]

Definition at line 230 of file pb_bufmgr_slab.c.

References pb_slab_buffer::mapCount, pb_slab_buffer(), pb_slab_buffer::slab, pb_slab_buffer::start, and pb_slab::virtual.

{
   struct pb_slab_buffer *buf = pb_slab_buffer(_buf);

   ++buf->mapCount;
   return (void *) ((uint8_t *) buf->slab->virtual + buf->start);
}

static void pb_slab_buffer_unmap

(

struct pb_buffer *

_buf

)

[static]

Definition at line 241 of file pb_bufmgr_slab.c.

References pb_slab_buffer::event, pb_slab_buffer::mapCount, pb_slab_buffer(), and pipe_condvar_broadcast.

{
   struct pb_slab_buffer *buf = pb_slab_buffer(_buf);

   --buf->mapCount;
   if (buf->mapCount == 0) 
       pipe_condvar_broadcast(buf->event);
}

static enum pipe_error pb_slab_create

(

struct pb_slab_manager *

mgr

)

[static]

Create a new slab.

Called when we ran out of free slabs.

Definition at line 277 of file pb_bufmgr_slab.c.

References pipe_buffer::alignment, pb_slab_buffer::base, pb_buffer::base, pb_slab::bo, pb_slab::buffers, pb_slab_manager::bufSize, CALLOC, CALLOC_STRUCT, pb_manager::create_buffer, pb_slab_manager::desc, pb_slab_buffer::event, FREE, pb_slab::freeBuffers, pb_slab_buffer::head, pb_slab::head, LIST_ADDTAIL, LIST_INITHEAD, pb_slab_buffer::mapCount, pb_slab::mgr, pb_slab::numBuffers, pb_slab::numFree, pb_map(), pb_reference(), pb_unmap(), PIPE_BUFFER_USAGE_CPU_READ, PIPE_BUFFER_USAGE_CPU_WRITE, pipe_condvar_init, PIPE_ERROR_OUT_OF_MEMORY, PIPE_OK, pb_slab_manager::provider, pipe_buffer::refcount, pipe_buffer::size, pb_slab_buffer::slab, pb_slab_manager::slabs, pb_slab_manager::slabSize, pb_slab_buffer::start, pipe_buffer::usage, pb_slab::virtual, and pb_buffer::vtbl.

{
   struct pb_slab *slab;
   struct pb_slab_buffer *buf;
   unsigned numBuffers;
   unsigned i;
   enum pipe_error ret;

   slab = CALLOC_STRUCT(pb_slab);
   if (!slab)
      return PIPE_ERROR_OUT_OF_MEMORY;

   slab->bo = mgr->provider->create_buffer(mgr->provider, mgr->slabSize, &mgr->desc);
   if(!slab->bo) {
      ret = PIPE_ERROR_OUT_OF_MEMORY;
      goto out_err0;
   }

   /* Note down the slab virtual address. All mappings are accessed directly 
    * through this address so it is required that the buffer is pinned. */
   slab->virtual = pb_map(slab->bo, 
                          PIPE_BUFFER_USAGE_CPU_READ |
                          PIPE_BUFFER_USAGE_CPU_WRITE);
   if(!slab->virtual) {
      ret = PIPE_ERROR_OUT_OF_MEMORY;
      goto out_err1;
   }
   pb_unmap(slab->bo);

   numBuffers = slab->bo->base.size / mgr->bufSize;

   slab->buffers = CALLOC(numBuffers, sizeof(*slab->buffers));
   if (!slab->buffers) {
      ret = PIPE_ERROR_OUT_OF_MEMORY;
      goto out_err1;
   }

   LIST_INITHEAD(&slab->head);
   LIST_INITHEAD(&slab->freeBuffers);
   slab->numBuffers = numBuffers;
   slab->numFree = 0;
   slab->mgr = mgr;

   buf = slab->buffers;
   for (i=0; i < numBuffers; ++i) {
      buf->base.base.refcount = 0;
      buf->base.base.size = mgr->bufSize;
      buf->base.base.alignment = 0;
      buf->base.base.usage = 0;
      buf->base.vtbl = &pb_slab_buffer_vtbl;
      buf->slab = slab;
      buf->start = i* mgr->bufSize;
      buf->mapCount = 0;
      pipe_condvar_init(buf->event);
      LIST_ADDTAIL(&buf->head, &slab->freeBuffers);
      slab->numFree++;
      buf++;
   }

   /* Add this slab to the list of partial slabs */
   LIST_ADDTAIL(&slab->head, &mgr->slabs);

   return PIPE_OK;

out_err1: 
   pb_reference(&slab->bo, NULL);
out_err0: 
   FREE(slab);
   return ret;
}

static struct pb_slab_manager* pb_slab_manager

(

struct pb_manager *

mgr

)

[static, read]

Definition at line 176 of file pb_bufmgr_slab.c.

References assert.

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

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

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

Definition at line 350 of file pb_bufmgr_slab.c.

References pipe_buffer::alignment, pb_desc::alignment, assert, pb_buffer::base, pb_slab_buffer::base, pb_slab_manager::bufSize, pb_slab_manager::desc, pb_slab::freeBuffers, list, LIST_DELINIT, LIST_ENTRY, pb_slab_manager::mutex, list_head::next, pb_slab::numFree, pb_check_alignment(), pb_check_usage(), pb_slab_create(), pb_slab_manager(), pipe_mutex_lock, pipe_mutex_unlock, pipe_buffer::refcount, pb_slab_manager::slabs, pipe_buffer::usage, and pb_desc::usage.

{
   struct pb_slab_manager *mgr = pb_slab_manager(_mgr);
   static struct pb_slab_buffer *buf;
   struct pb_slab *slab;
   struct list_head *list;

   /* check size */
   assert(size <= mgr->bufSize);
   if(size > mgr->bufSize)
      return NULL;
   
   /* check if we can provide the requested alignment */
   assert(pb_check_alignment(desc->alignment, mgr->desc.alignment));
   if(!pb_check_alignment(desc->alignment, mgr->desc.alignment))
      return NULL;
   assert(pb_check_alignment(desc->alignment, mgr->bufSize));
   if(!pb_check_alignment(desc->alignment, mgr->bufSize))
      return NULL;

   assert(pb_check_usage(desc->usage, mgr->desc.usage));
   if(!pb_check_usage(desc->usage, mgr->desc.usage))
      return NULL;

   pipe_mutex_lock(mgr->mutex);
   
   /* Create a new slab, if we run out of partial slabs */
   if (mgr->slabs.next == &mgr->slabs) {
      (void) pb_slab_create(mgr);
      if (mgr->slabs.next == &mgr->slabs) {
         pipe_mutex_unlock(mgr->mutex);
         return NULL;
      }
   }
   
   /* Allocate the buffer from a partial (or just created) slab */
   list = mgr->slabs.next;
   slab = LIST_ENTRY(struct pb_slab, list, head);
   
   /* If totally full remove from the partial slab list */
   if (--slab->numFree == 0)
      LIST_DELINIT(list);

   list = slab->freeBuffers.next;
   LIST_DELINIT(list);

   pipe_mutex_unlock(mgr->mutex);
   buf = LIST_ENTRY(struct pb_slab_buffer, list, head);
   
   ++buf->base.base.refcount;
   buf->base.base.alignment = desc->alignment;
   buf->base.base.usage = desc->usage;
   
   return &buf->base;
}

static void pb_slab_manager_destroy

(

struct pb_manager *

_mgr

)

[static]

Definition at line 421 of file pb_bufmgr_slab.c.

References FREE, and pb_slab_manager().

{
   struct pb_slab_manager *mgr = pb_slab_manager(_mgr);

   /* TODO: cleanup all allocated buffers */
   FREE(mgr);
}

static void pb_slab_manager_flush

(

struct pb_manager *

_mgr

)

[static]

Definition at line 410 of file pb_bufmgr_slab.c.

References assert, pb_manager::flush, pb_slab_manager(), and pb_slab_manager::provider.

{
   struct pb_slab_manager *mgr = pb_slab_manager(_mgr);

   assert(mgr->provider->flush);
   if(mgr->provider->flush)
      mgr->provider->flush(mgr->provider);
}

static struct pb_slab_range_manager* pb_slab_range_manager

(

struct pb_manager *

mgr

)

[static, read]

Definition at line 184 of file pb_bufmgr_slab.c.

References assert.

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

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

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

Definition at line 460 of file pb_bufmgr_slab.c.

References pb_slab_range_manager::buckets, pb_manager::create_buffer, pb_slab_range_manager::minBufSize, pb_slab_range_manager::numBuckets, pb_slab_range_manager(), and pb_slab_range_manager::provider.

{
   struct pb_slab_range_manager *mgr = pb_slab_range_manager(_mgr);
   size_t bufSize;
   unsigned i;

   bufSize = mgr->minBufSize;
   for (i = 0; i < mgr->numBuckets; ++i) {
      if(bufSize >= size)
         return mgr->buckets[i]->create_buffer(mgr->buckets[i], size, desc);
      bufSize *= 2;
   }

   /* Fall back to allocate a buffer object directly from the provider. */
   return mgr->provider->create_buffer(mgr->provider, size, desc);
}

static void pb_slab_range_manager_destroy

(

struct pb_manager *

_mgr

)

[static]

Definition at line 494 of file pb_bufmgr_slab.c.

References pb_slab_range_manager::buckets, pb_slab_range_manager::bucketSizes, pb_manager::destroy, FREE, pb_slab_range_manager::numBuckets, and pb_slab_range_manager().

{
   struct pb_slab_range_manager *mgr = pb_slab_range_manager(_mgr);
   unsigned i;
   
   for (i = 0; i < mgr->numBuckets; ++i)
      mgr->buckets[i]->destroy(mgr->buckets[i]);
   FREE(mgr->buckets);
   FREE(mgr->bucketSizes);
   FREE(mgr);
}

static void pb_slab_range_manager_flush

(

struct pb_manager *

_mgr

)

[static]

Definition at line 481 of file pb_bufmgr_slab.c.

References assert, pb_manager::flush, pb_slab_range_manager(), and pb_slab_range_manager::provider.

{
   struct pb_slab_range_manager *mgr = pb_slab_range_manager(_mgr);

   /* Individual slabs don't hold any temporary buffers so no need to call them */
   
   assert(mgr->provider->flush);
   if(mgr->provider->flush)
      mgr->provider->flush(mgr->provider);
}

---

Variable Documentation

struct pb_vtbl pb_slab_buffer_vtbl [static]

Initial value:

 {
      pb_slab_buffer_destroy,
      pb_slab_buffer_map,
      pb_slab_buffer_unmap,
      pb_slab_buffer_get_base_buffer
}

Definition at line 263 of file pb_bufmgr_slab.c.

---