ws_dri_slabpool.c File Reference

Include dependency graph for ws_dri_slabpool.c:

Go to the source code of this file.

Data Structures
struct	_DriSlabBuffer
struct	_DriKernelBO
struct	_DriSlab
struct	_DriSlabSizeHeader
struct	_DriFreeSlabManager
struct	_DriSlabPool
Defines
#define	DRI_SLABPOOL_ALLOC_RETRIES   100
Functions
static int	driTimeAfterEq (struct timeval *arg1, struct timeval *arg2)
static void	driTimeAdd (struct timeval *arg, struct timeval *add)
static void	driFreeKernelBO (struct _DriKernelBO *kbo)
static void	driFreeTimeoutKBOsLocked (struct _DriFreeSlabManager *fMan, struct timeval *time)
static void	driSetKernelBOFree (struct _DriFreeSlabManager *fMan, struct _DriKernelBO *kbo)
static struct _DriKernelBO *	driAllocKernelBO (struct _DriSlabSizeHeader *header)
static int	driAllocSlab (struct _DriSlabSizeHeader *header)
static void	driSlabFreeBufferLocked (struct _DriSlabBuffer *buf)
static void	driSlabCheckFreeLocked (struct _DriSlabSizeHeader *header, int wait)
static struct _DriSlabBuffer *	driSlabAllocBuffer (struct _DriSlabSizeHeader *header)
static void *	pool_create (struct _DriBufferPool *driPool, unsigned long size, uint64_t flags, unsigned hint, unsigned alignment)
static int	pool_destroy (struct _DriBufferPool *driPool, void *private)
static int	pool_waitIdle (struct _DriBufferPool *driPool, void *private, pipe_mutex *mutex, int lazy)
static int	pool_map (struct _DriBufferPool *pool, void *private, unsigned flags, int hint, pipe_mutex *mutex, void **virtual)
static int	pool_unmap (struct _DriBufferPool *pool, void *private)
static unsigned long	pool_offset (struct _DriBufferPool *pool, void *private)
static unsigned long	pool_poolOffset (struct _DriBufferPool *pool, void *private)
static uint64_t	pool_flags (struct _DriBufferPool *pool, void *private)
static unsigned long	pool_size (struct _DriBufferPool *pool, void *private)
static int	pool_fence (struct _DriBufferPool *pool, void *private, struct _DriFenceObject *fence)
static drmBO *	pool_kernel (struct _DriBufferPool *pool, void *private)
static int	pool_validate (struct _DriBufferPool *pool, void *private, pipe_mutex *mutex)
struct _DriFreeSlabManager *	driInitFreeSlabManager (uint32_t checkIntervalMsec, uint32_t slabTimeoutMsec)
void	driFinishFreeSlabManager (struct _DriFreeSlabManager *fMan)
static void	driInitSizeHeader (struct _DriSlabPool *pool, uint32_t size, struct _DriSlabSizeHeader *header)
static void	driFinishSizeHeader (struct _DriSlabSizeHeader *header)
static void	pool_takedown (struct _DriBufferPool *driPool)
struct _DriBufferPool *	driSlabPoolInit (int fd, uint64_t flags, uint64_t validMask, uint32_t smallestSize, uint32_t numSizes, uint32_t desiredNumBuffers, uint32_t maxSlabSize, uint32_t pageAlignment, struct _DriFreeSlabManager *fMan)

---

Define Documentation

#define DRI_SLABPOOL_ALLOC_RETRIES   100

Definition at line 42 of file ws_dri_slabpool.c.

---

Function Documentation

static struct _DriKernelBO* driAllocKernelBO

(

struct _DriSlabSizeHeader *

header

)

[static, read]

Definition at line 222 of file ws_dri_slabpool.c.

References _DriKernelBO::bo, _DriSlabSizeHeader::bufSize, _DriFreeSlabManager::cached, _DriSlabPool::desiredNumBuffers, driFreeKernelBO(), _DriSlabPool::fd, _DriKernelBO::fd, _DriSlabPool::fMan, _DriKernelBO::head, list, _DriSlabPool::maxSlabSize, _DriFreeSlabManager::mutex, _DriKernelBO::pageAlignment, _DriSlabPool::pageAlignment, _DriSlabPool::pageSize, pipe_mutex_lock, pipe_mutex_unlock, _DriSlabPool::proposedFlags, _DriSlabSizeHeader::slabPool, _DriKernelBO::timeoutHead, _DriFreeSlabManager::unCached, and _DriKernelBO::virtual.

{
    struct _DriSlabPool *slabPool = header->slabPool;
    struct _DriFreeSlabManager *fMan = slabPool->fMan;
    drmMMListHead *list, *next, *head;
    uint32_t size = header->bufSize * slabPool->desiredNumBuffers;
    struct _DriKernelBO *kbo;
    struct _DriKernelBO *kboTmp;
    int ret;

    /*
     * FIXME: We should perhaps allow some variation in slabsize in order
     * to efficiently reuse slabs.
     */

    size = (size <= slabPool->maxSlabSize) ? size : slabPool->maxSlabSize;
    size = (size + slabPool->pageSize - 1) & ~(slabPool->pageSize - 1);
    pipe_mutex_lock(fMan->mutex);

    kbo = NULL;

  retry:
    head = (slabPool->proposedFlags & DRM_BO_FLAG_CACHED) ?
        &fMan->cached : &fMan->unCached;

    for (list = head->next, next = list->next;
         list != head;
         list = next, next = list->next) {

        kboTmp = DRMLISTENTRY(struct _DriKernelBO, list, head);

        if ((kboTmp->bo.size == size) &&
            (slabPool->pageAlignment == 0 ||
             (kboTmp->pageAlignment % slabPool->pageAlignment) == 0)) {

            if (!kbo)
                kbo = kboTmp;

            if ((kbo->bo.proposedFlags ^ slabPool->proposedFlags) == 0)
                break;

        }
    }

    if (kbo) {
        DRMLISTDELINIT(&kbo->head);
        DRMLISTDELINIT(&kbo->timeoutHead);
    }

    pipe_mutex_unlock(fMan->mutex);

    if (kbo) {
        uint64_t new_mask = kbo->bo.proposedFlags ^ slabPool->proposedFlags;

        ret = 0;
        if (new_mask) {
            ret = drmBOSetStatus(kbo->fd, &kbo->bo, slabPool->proposedFlags,
                                 new_mask, DRM_BO_HINT_DONT_FENCE, 0, 0);
        }
        if (ret == 0)
            return kbo;

        driFreeKernelBO(kbo);
        kbo = NULL;
        goto retry;
    }

    kbo = calloc(1, sizeof(struct _DriKernelBO));
    if (!kbo)
        return NULL;

    kbo->fd = slabPool->fd;
    DRMINITLISTHEAD(&kbo->head);
    DRMINITLISTHEAD(&kbo->timeoutHead);
    ret = drmBOCreate(kbo->fd, size, slabPool->pageAlignment, NULL,
                      slabPool->proposedFlags,
                      DRM_BO_HINT_DONT_FENCE, &kbo->bo);
    if (ret)
        goto out_err0;

    ret = drmBOMap(kbo->fd, &kbo->bo,
                   DRM_BO_FLAG_READ | DRM_BO_FLAG_WRITE,
                   0, &kbo->virtual);

    if (ret)
        goto out_err1;

    ret = drmBOUnmap(kbo->fd, &kbo->bo);
    if (ret)
        goto out_err1;

    return kbo;

  out_err1:
    drmBOUnreference(kbo->fd, &kbo->bo);
  out_err0:
    free(kbo);
    return NULL;
}

static int driAllocSlab

(

struct _DriSlabSizeHeader *

header

)

[static]

Definition at line 325 of file ws_dri_slabpool.c.

References _DriKernelBO::bo, _DriSlab::buffers, _DriSlabSizeHeader::bufSize, driAllocKernelBO(), driSetKernelBOFree(), ENOMEM, _DriSlabBuffer::event, _DriSlabPool::fMan, _DriSlab::freeBuffers, _DriSlabBuffer::head, _DriSlab::head, _DriSlab::header, _DriSlabBuffer::isSlabBuffer, _DriSlab::kbo, _DriSlabBuffer::mapCount, _DriSlab::numBuffers, _DriSlab::numFree, _DriSlabBuffer::parent, pipe_condvar_init, _DriSlabSizeHeader::slabPool, _DriSlabSizeHeader::slabs, and _DriSlabBuffer::start.

{
    struct _DriSlab *slab;
    struct _DriSlabBuffer *buf;
    uint32_t numBuffers;
    int ret;
    int i;

    slab = calloc(1, sizeof(*slab));
    if (!slab)
        return -ENOMEM;

    slab->kbo = driAllocKernelBO(header);
    if (!slab->kbo) {
        ret = -ENOMEM;
        goto out_err0;
    }

    numBuffers = slab->kbo->bo.size / header->bufSize;

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

    DRMINITLISTHEAD(&slab->head);
    DRMINITLISTHEAD(&slab->freeBuffers);
    slab->numBuffers = numBuffers;
    slab->numFree = 0;
    slab->header = header;

    buf = slab->buffers;
    for (i=0; i < numBuffers; ++i) {
        buf->parent = slab;
        buf->start = i* header->bufSize;
        buf->mapCount = 0;
        buf->isSlabBuffer = 1;
        pipe_condvar_init(buf->event);
        DRMLISTADDTAIL(&buf->head, &slab->freeBuffers);
        slab->numFree++;
        buf++;
    }

    DRMLISTADDTAIL(&slab->head, &header->slabs);

    return 0;

  out_err1:
    driSetKernelBOFree(header->slabPool->fMan, slab->kbo);
    free(slab->buffers);
  out_err0:
    free(slab);
    return ret;
}

void driFinishFreeSlabManager

(

struct _DriFreeSlabManager *

fMan

)

Definition at line 823 of file ws_dri_slabpool.c.

References assert, _DriFreeSlabManager::cached, _DriFreeSlabManager::checkInterval, driFreeTimeoutKBOsLocked(), driTimeAdd(), _DriFreeSlabManager::mutex, _DriFreeSlabManager::nextCheck, pipe_mutex_lock, pipe_mutex_unlock, _DriFreeSlabManager::timeoutList, and _DriFreeSlabManager::unCached.

{
    struct timeval time;

    time = fMan->nextCheck;
    driTimeAdd(&time, &fMan->checkInterval);

    pipe_mutex_lock(fMan->mutex);
    driFreeTimeoutKBOsLocked(fMan, &time);
    pipe_mutex_unlock(fMan->mutex);

    assert(fMan->timeoutList.next == &fMan->timeoutList);
    assert(fMan->unCached.next == &fMan->unCached);
    assert(fMan->cached.next == &fMan->cached);

    free(fMan);
}

static void driFinishSizeHeader

(

struct _DriSlabSizeHeader *

header

)

[static]

Definition at line 860 of file ws_dri_slabpool.c.

References _DriSlabSizeHeader::delayedBuffers, driFenceFinish(), driFenceUnReference(), driSlabFreeBufferLocked(), _DriSlabBuffer::fence, _DriSlabBuffer::fenceType, _DriSlabBuffer::head, list, _DriSlabSizeHeader::mutex, _DriSlabSizeHeader::numDelayed, pipe_mutex_lock, and pipe_mutex_unlock.

{
    drmMMListHead *list, *next;
    struct _DriSlabBuffer *buf;

    pipe_mutex_lock(header->mutex);
    for (list = header->delayedBuffers.next, next = list->next;
         list != &header->delayedBuffers;
         list = next, next = list->next) {

        buf = DRMLISTENTRY(struct _DriSlabBuffer, list , head);
        if (buf->fence) {
            (void) driFenceFinish(buf->fence, buf->fenceType, 0);
            driFenceUnReference(&buf->fence);
        }
        header->numDelayed--;
        driSlabFreeBufferLocked(buf);
    }
    pipe_mutex_unlock(header->mutex);
}

static void driFreeKernelBO

(

struct _DriKernelBO *

kbo

)

[static]

Definition at line 148 of file ws_dri_slabpool.c.

References _DriKernelBO::bo, and _DriKernelBO::fd.

{
    if (!kbo)
        return;

    (void) drmBOUnreference(kbo->fd, &kbo->bo);
    free(kbo);
}

static void driFreeTimeoutKBOsLocked	(	struct _DriFreeSlabManager *	fMan,
		struct timeval *	time
	)			[static]

Definition at line 159 of file ws_dri_slabpool.c.

References _DriFreeSlabManager::checkInterval, driFreeKernelBO(), driTimeAdd(), driTimeAfterEq(), _DriKernelBO::head, list, _DriFreeSlabManager::nextCheck, _DriKernelBO::timeFreed, _DriKernelBO::timeoutHead, and _DriFreeSlabManager::timeoutList.

{
    drmMMListHead *list, *next;
    struct _DriKernelBO *kbo;

    if (!driTimeAfterEq(time, &fMan->nextCheck))
        return;

    for (list = fMan->timeoutList.next, next = list->next;
         list != &fMan->timeoutList;
         list = next, next = list->next) {

        kbo = DRMLISTENTRY(struct _DriKernelBO, list, timeoutHead);

        if (!driTimeAfterEq(time, &kbo->timeFreed))
            break;

        DRMLISTDELINIT(&kbo->timeoutHead);
        DRMLISTDELINIT(&kbo->head);
        driFreeKernelBO(kbo);
    }

    fMan->nextCheck = *time;
    driTimeAdd(&fMan->nextCheck, &fMan->checkInterval);
}

struct _DriFreeSlabManager* driInitFreeSlabManager	(	uint32_t	checkIntervalMsec,
		uint32_t	slabTimeoutMsec
	)			[read]

Definition at line 794 of file ws_dri_slabpool.c.

References _DriFreeSlabManager::cached, _DriFreeSlabManager::checkInterval, driTimeAdd(), _DriFreeSlabManager::mutex, _DriFreeSlabManager::nextCheck, pipe_mutex_init, pipe_mutex_lock, pipe_mutex_unlock, _DriFreeSlabManager::slabTimeout, _DriFreeSlabManager::timeoutList, and _DriFreeSlabManager::unCached.

{
    struct _DriFreeSlabManager *tmp;

    tmp = calloc(1, sizeof(*tmp));
    if (!tmp)
        return NULL;

    pipe_mutex_init(tmp->mutex);
    pipe_mutex_lock(tmp->mutex);
    tmp->slabTimeout.tv_usec = slabTimeoutMsec*1000;
    tmp->slabTimeout.tv_sec = tmp->slabTimeout.tv_usec / 1000000;
    tmp->slabTimeout.tv_usec -=  tmp->slabTimeout.tv_sec*1000000;

    tmp->checkInterval.tv_usec = checkIntervalMsec*1000;
    tmp->checkInterval.tv_sec = tmp->checkInterval.tv_usec / 1000000;
    tmp->checkInterval.tv_usec -=  tmp->checkInterval.tv_sec*1000000;

    gettimeofday(&tmp->nextCheck, NULL);
    driTimeAdd(&tmp->nextCheck, &tmp->checkInterval);
    DRMINITLISTHEAD(&tmp->timeoutList);
    DRMINITLISTHEAD(&tmp->unCached);
    DRMINITLISTHEAD(&tmp->cached);
    pipe_mutex_unlock(tmp->mutex);

    return tmp;
}

static void driInitSizeHeader	(	struct _DriSlabPool *	pool,
		uint32_t	size,
		struct _DriSlabSizeHeader *	header
	)			[static]

Definition at line 842 of file ws_dri_slabpool.c.

References _DriSlabSizeHeader::bufSize, _DriSlabSizeHeader::delayedBuffers, _DriSlabSizeHeader::freeSlabs, _DriSlabSizeHeader::mutex, _DriSlabSizeHeader::numDelayed, pipe_mutex_init, pipe_mutex_lock, pipe_mutex_unlock, _DriSlabSizeHeader::slabPool, and _DriSlabSizeHeader::slabs.

{
    pipe_mutex_init(header->mutex);
    pipe_mutex_lock(header->mutex);

    DRMINITLISTHEAD(&header->slabs);
    DRMINITLISTHEAD(&header->freeSlabs);
    DRMINITLISTHEAD(&header->delayedBuffers);

    header->numDelayed = 0;
    header->slabPool = pool;
    header->bufSize = size;

    pipe_mutex_unlock(header->mutex);
}

static void driSetKernelBOFree	(	struct _DriFreeSlabManager *	fMan,
		struct _DriKernelBO *	kbo
	)			[static]

Definition at line 194 of file ws_dri_slabpool.c.

References _DriKernelBO::bo, _DriFreeSlabManager::cached, driFreeTimeoutKBOsLocked(), driTimeAdd(), _DriKernelBO::head, _DriFreeSlabManager::mutex, pipe_mutex_lock, pipe_mutex_unlock, _DriFreeSlabManager::slabTimeout, _DriKernelBO::timeFreed, _DriKernelBO::timeoutHead, _DriFreeSlabManager::timeoutList, and _DriFreeSlabManager::unCached.

{
    struct timeval time;

    pipe_mutex_lock(fMan->mutex);
    gettimeofday(&time, NULL);
    driTimeAdd(&time, &fMan->slabTimeout);

    kbo->timeFreed = time;

    if (kbo->bo.flags & DRM_BO_FLAG_CACHED)
        DRMLISTADD(&kbo->head, &fMan->cached);
    else
        DRMLISTADD(&kbo->head, &fMan->unCached);

    DRMLISTADDTAIL(&kbo->timeoutHead, &fMan->timeoutList);
    driFreeTimeoutKBOsLocked(fMan, &time);

    pipe_mutex_unlock(fMan->mutex);
}

static struct _DriSlabBuffer* driSlabAllocBuffer

(

struct _DriSlabSizeHeader *

header

)

[static, read]

Definition at line 490 of file ws_dri_slabpool.c.

References DRI_SLABPOOL_ALLOC_RETRIES, driAllocSlab(), driSlabCheckFreeLocked(), _DriSlab::freeBuffers, _DriSlab::head, list, _DriSlabSizeHeader::mutex, _DriSlab::numFree, pipe_mutex_lock, pipe_mutex_unlock, and _DriSlabSizeHeader::slabs.

{
    static struct _DriSlabBuffer *buf;
    struct _DriSlab *slab;
    drmMMListHead *list;
    int count = DRI_SLABPOOL_ALLOC_RETRIES;

    pipe_mutex_lock(header->mutex);
    while(header->slabs.next == &header->slabs && count > 0) {
        driSlabCheckFreeLocked(header, 0);
        if (header->slabs.next != &header->slabs)
          break;

        pipe_mutex_unlock(header->mutex);
        if (count != DRI_SLABPOOL_ALLOC_RETRIES)
            usleep(1);
        pipe_mutex_lock(header->mutex);
        (void) driAllocSlab(header);
        count--;
    }

    list = header->slabs.next;
    if (list == &header->slabs) {
        pipe_mutex_unlock(header->mutex);
        return NULL;
    }
    slab = DRMLISTENTRY(struct _DriSlab, list, head);
    if (--slab->numFree == 0)
        DRMLISTDELINIT(list);

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

    pipe_mutex_unlock(header->mutex);
    buf = DRMLISTENTRY(struct _DriSlabBuffer, list, head);
    return buf;
}

static void driSlabCheckFreeLocked	(	struct _DriSlabSizeHeader *	header,
		int	wait
	)			[static]

Definition at line 427 of file ws_dri_slabpool.c.

References _DriSlabSizeHeader::delayedBuffers, driFenceFinish(), driFenceSignaled(), driFenceSignaledCached(), driFenceUnReference(), driSlabFreeBufferLocked(), _DriSlabBuffer::fence, _DriSlabBuffer::fenceType, _DriSlab::head, list, _DriSlabSizeHeader::numDelayed, and _DriSlabBuffer::parent.

{
  drmMMListHead *list, *prev, *first;
   struct _DriSlabBuffer *buf;
   struct _DriSlab *slab;
   int firstWasSignaled = 1;
   int signaled;
   int i;
   int ret;

   /*
    * Rerun the freeing test if the youngest tested buffer
    * was signaled, since there might be more idle buffers
    * in the delay list.
    */

   while (firstWasSignaled) {
       firstWasSignaled = 0;
       signaled = 0;
       first = header->delayedBuffers.next;

       /* Only examine the oldest 1/3 of delayed buffers:
        */
       if (header->numDelayed > 3) {
           for (i = 0; i < header->numDelayed; i += 3) {
               first = first->next;
           }
       }

       for (list = first, prev = list->prev;
            list != &header->delayedBuffers;
            list = prev, prev = list->prev) {
           buf = DRMLISTENTRY(struct _DriSlabBuffer, list, head);
           slab = buf->parent;

           if (!signaled) {
               if (wait) {
                   ret = driFenceFinish(buf->fence, buf->fenceType, 0);
                   if (ret)
                       break;
                   signaled = 1;
                   wait = 0;
               } else {
                   signaled = driFenceSignaled(buf->fence, buf->fenceType);
               }
               if (signaled) {
                   if (list == first)
                       firstWasSignaled = 1;
                   driFenceUnReference(&buf->fence);
                   header->numDelayed--;
                   driSlabFreeBufferLocked(buf);
               }
           } else if (driFenceSignaledCached(buf->fence, buf->fenceType)) {
               driFenceUnReference(&buf->fence);
               header->numDelayed--;
               driSlabFreeBufferLocked(buf);
           }
       }
   }
}

static void driSlabFreeBufferLocked

(

struct _DriSlabBuffer *

buf

)

[static]

Definition at line 387 of file ws_dri_slabpool.c.

References _DriSlab::buffers, driSetKernelBOFree(), _DriSlabPool::fMan, _DriSlab::freeBuffers, _DriSlabSizeHeader::freeSlabs, _DriSlab::head, _DriSlabBuffer::head, _DriSlab::header, _DriSlab::kbo, list, _DriSlab::numBuffers, _DriSlab::numFree, _DriSlabBuffer::parent, _DriSlabSizeHeader::slabPool, and _DriSlabSizeHeader::slabs.

{
    struct _DriSlab *slab = buf->parent;
    struct _DriSlabSizeHeader *header = slab->header;
    drmMMListHead *list = &buf->head;

    DRMLISTDEL(list);
    DRMLISTADDTAIL(list, &slab->freeBuffers);
    slab->numFree++;

    if (slab->head.next == &slab->head)
        DRMLISTADDTAIL(&slab->head, &header->slabs);

    if (slab->numFree == slab->numBuffers) {
        list = &slab->head;
        DRMLISTDEL(list);
        DRMLISTADDTAIL(list, &header->freeSlabs);
    }

    if (header->slabs.next == &header->slabs ||
        slab->numFree != slab->numBuffers) {

        drmMMListHead *next;
        struct _DriFreeSlabManager *fMan = header->slabPool->fMan;

        for (list = header->freeSlabs.next, next = list->next;
             list != &header->freeSlabs;
             list = next, next = list->next) {

            slab = DRMLISTENTRY(struct _DriSlab, list, head);

            DRMLISTDELINIT(list);
            driSetKernelBOFree(fMan, slab->kbo);
            free(slab->buffers);
            free(slab);
        }
    }
}

struct _DriBufferPool* driSlabPoolInit	(	int	fd,
		uint64_t	flags,
		uint64_t	validMask,
		uint32_t	smallestSize,
		uint32_t	numSizes,
		uint32_t	desiredNumBuffers,
		uint32_t	maxSlabSize,
		uint32_t	pageAlignment,
		struct _DriFreeSlabManager *	fMan
	)			[read]

Definition at line 898 of file ws_dri_slabpool.c.

References _DriSlabPool::bucketSizes, _DriBufferPool::create, _DriBufferPool::data, _DriSlabPool::desiredNumBuffers, _DriBufferPool::destroy, driInitSizeHeader(), _DriSlabPool::fd, _DriBufferPool::fence, _DriBufferPool::flags, _DriSlabPool::fMan, _DriSlabPool::headers, _DriBufferPool::kernel, _DriBufferPool::map, _DriSlabPool::maxSlabSize, _DriSlabPool::numBuckets, _DriBufferPool::offset, _DriSlabPool::pageAlignment, _DriSlabPool::pageSize, pool_create(), pool_destroy(), pool_fence(), pool_flags(), pool_kernel(), pool_map(), pool_offset(), pool_poolOffset(), pool_size(), pool_takedown(), pool_unmap(), pool_validate(), pool_waitIdle(), _DriBufferPool::poolOffset, _DriSlabPool::proposedFlags, _DriBufferPool::size, _DriBufferPool::takeDown, _DriBufferPool::unmap, _DriBufferPool::validate, _DriSlabPool::validMask, and _DriBufferPool::waitIdle.

{
    struct _DriBufferPool *driPool;
    struct _DriSlabPool *pool;
    uint32_t i;

    driPool = calloc(1, sizeof(*driPool));
    if (!driPool)
        return NULL;

    pool = calloc(1, sizeof(*pool));
    if (!pool)
        goto out_err0;

    pool->bucketSizes = calloc(numSizes, sizeof(*pool->bucketSizes));
    if (!pool->bucketSizes)
        goto out_err1;

    pool->headers = calloc(numSizes, sizeof(*pool->headers));
    if (!pool->headers)
        goto out_err2;

    pool->fMan = fMan;
    pool->proposedFlags = flags;
    pool->validMask = validMask;
    pool->numBuckets = numSizes;
    pool->pageSize = getpagesize();
    pool->fd = fd;
    pool->pageAlignment = pageAlignment;
    pool->maxSlabSize = maxSlabSize;
    pool->desiredNumBuffers = desiredNumBuffers;

    for (i=0; i<pool->numBuckets; ++i) {
        pool->bucketSizes[i] = (smallestSize << i);
        driInitSizeHeader(pool, pool->bucketSizes[i],
                          &pool->headers[i]);
    }

    driPool->data = (void *) pool;
    driPool->map = &pool_map;
    driPool->unmap = &pool_unmap;
    driPool->destroy = &pool_destroy;
    driPool->offset = &pool_offset;
    driPool->poolOffset = &pool_poolOffset;
    driPool->flags = &pool_flags;
    driPool->size = &pool_size;
    driPool->create = &pool_create;
    driPool->fence = &pool_fence;
    driPool->kernel = &pool_kernel;
    driPool->validate = &pool_validate;
    driPool->waitIdle = &pool_waitIdle;
    driPool->takeDown = &pool_takedown;

    return driPool;

  out_err2:
    free(pool->bucketSizes);
  out_err1:
    free(pool);
  out_err0:
    free(driPool);

    return NULL;
}

static void driTimeAdd	(	struct timeval *	arg,
		struct timeval *	add
	)			[static]

Definition at line 136 of file ws_dri_slabpool.c.

{
    unsigned int sec;

    arg->tv_sec += add->tv_sec;
    arg->tv_usec += add->tv_usec;
    sec = arg->tv_usec / 1000000;
    arg->tv_sec += sec;
    arg->tv_usec -= sec*1000000;
}

static int driTimeAfterEq	(	struct timeval *	arg1,
		struct timeval *	arg2
	)			[static]

Definition at line 128 of file ws_dri_slabpool.c.

{
    return ((arg1->tv_sec > arg2->tv_sec) ||
            ((arg1->tv_sec == arg2->tv_sec) &&
             (arg1->tv_usec > arg2->tv_usec)));
}

static void* pool_create	(	struct _DriBufferPool *	driPool,
		unsigned long	size,
		uint64_t	flags,
		unsigned	hint,
		unsigned	alignment
	)			[static]

Definition at line 529 of file ws_dri_slabpool.c.

References _DriBufferPool::data, driSlabAllocBuffer(), _DriSlabPool::fd, _DriSlabPool::headers, _DriSlabPool::numBuckets, and _DriSlabPool::pageSize.

{
    struct _DriSlabPool *pool = (struct _DriSlabPool *) driPool->data;
    struct _DriSlabSizeHeader *header;
    struct _DriSlabBuffer *buf;
    void *dummy;
    int i;
    int ret;

    /*
     * FIXME: Check for compatibility.
     */

    header = pool->headers;
    for (i=0; i<pool->numBuckets; ++i) {
      if (header->bufSize >= size)
        break;
      header++;
    }

    if (i < pool->numBuckets)
        return driSlabAllocBuffer(header);


    /*
     * Fall back to allocate a buffer object directly from DRM.
     * and wrap it in a driBO structure.
     */


    buf = calloc(1, sizeof(*buf));

    if (!buf)
        return NULL;

    buf->bo = calloc(1, sizeof(*buf->bo));
    if (!buf->bo)
        goto out_err0;

    if (alignment) {
        if ((alignment < pool->pageSize) && (pool->pageSize % alignment))
            goto out_err1;
        if ((alignment > pool->pageSize) && (alignment % pool->pageSize))
            goto out_err1;
    }

    ret = drmBOCreate(pool->fd, size, alignment / pool->pageSize, NULL,
                        flags, hint, buf->bo);
    if (ret)
        goto out_err1;

    ret  = drmBOMap(pool->fd, buf->bo, DRM_BO_FLAG_READ | DRM_BO_FLAG_WRITE,
                    0, &dummy);
    if (ret)
        goto out_err2;

    ret = drmBOUnmap(pool->fd, buf->bo);
    if (ret)
        goto out_err2;

    return buf;
  out_err2:
    drmBOUnreference(pool->fd, buf->bo);
  out_err1:
    free(buf->bo);
  out_err0:
    free(buf);
    return NULL;
}

static int pool_destroy	(	struct _DriBufferPool *	driPool,
		void *	private
	)			[static]

Definition at line 601 of file ws_dri_slabpool.c.

References _DriSlabBuffer::bo, _DriBufferPool::data, _DriSlabSizeHeader::delayedBuffers, driFenceSignaledCached(), driFenceUnReference(), driSlabFreeBufferLocked(), _DriSlabPool::fd, _DriSlabBuffer::fence, _DriSlabBuffer::fenceType, _DriSlabBuffer::head, _DriSlab::header, _DriSlabBuffer::isSlabBuffer, _DriSlabBuffer::mapCount, _DriSlabSizeHeader::mutex, _DriSlabSizeHeader::numDelayed, _DriSlabBuffer::parent, pipe_mutex_lock, pipe_mutex_unlock, and _DriSlabBuffer::unFenced.

{
    struct _DriSlabBuffer *buf =
        (struct _DriSlabBuffer *) private;
    struct _DriSlab *slab;
    struct _DriSlabSizeHeader *header;

    if (!buf->isSlabBuffer) {
        struct _DriSlabPool *pool = (struct _DriSlabPool *) driPool->data;
        int ret;

        ret = drmBOUnreference(pool->fd, buf->bo);
        free(buf->bo);
        free(buf);
        return ret;
    }

    slab = buf->parent;
    header = slab->header;

    pipe_mutex_lock(header->mutex);
    buf->unFenced = 0;
    buf->mapCount = 0;

    if (buf->fence && !driFenceSignaledCached(buf->fence, buf->fenceType)) {
        DRMLISTADDTAIL(&buf->head, &header->delayedBuffers);
        header->numDelayed++;
    } else {
        if (buf->fence)
            driFenceUnReference(&buf->fence);
        driSlabFreeBufferLocked(buf);
    }

    pipe_mutex_unlock(header->mutex);
    return 0;
}

static int pool_fence	(	struct _DriBufferPool *	pool,
		void *	private,
		struct _DriFenceObject *	fence
	)			[static]

Definition at line 747 of file ws_dri_slabpool.c.

References _DriKernelBO::bo, _DriSlabBuffer::bo, driFenceReference(), driFenceUnReference(), _DriSlabBuffer::event, _DriSlabBuffer::fence, _DriSlabBuffer::fenceType, _DriSlabBuffer::isSlabBuffer, _DriSlab::kbo, _DriSlabBuffer::parent, pipe_condvar_broadcast, and _DriSlabBuffer::unFenced.

{
   struct _DriSlabBuffer *buf = (struct _DriSlabBuffer *) private;
   drmBO *bo;

   if (buf->fence)
      driFenceUnReference(&buf->fence);

   buf->fence = driFenceReference(fence);
   bo = (buf->isSlabBuffer) ?
     &buf->parent->kbo->bo:
     buf->bo;
   buf->fenceType = bo->fenceFlags;

   buf->unFenced = 0;
   pipe_condvar_broadcast(buf->event);

   return 0;
}

static uint64_t pool_flags	(	struct _DriBufferPool *	pool,
		void *	private
	)			[static]

Definition at line 726 of file ws_dri_slabpool.c.

References _DriKernelBO::bo, _DriSlabBuffer::bo, _DriSlabBuffer::isSlabBuffer, _DriSlab::kbo, and _DriSlabBuffer::parent.

{
   struct _DriSlabBuffer *buf = (struct _DriSlabBuffer *) private;

   if (!buf->isSlabBuffer)
       return buf->bo->flags;

   return buf->parent->kbo->bo.flags;
}

static drmBO* pool_kernel	(	struct _DriBufferPool *	pool,
		void *	private
	)			[static]

Definition at line 769 of file ws_dri_slabpool.c.

References _DriSlabBuffer::bo, _DriKernelBO::bo, _DriSlabBuffer::isSlabBuffer, _DriSlab::kbo, and _DriSlabBuffer::parent.

{
   struct _DriSlabBuffer *buf = (struct _DriSlabBuffer *) private;

   return (buf->isSlabBuffer) ? &buf->parent->kbo->bo : buf->bo;
}

static int pool_map	(	struct _DriBufferPool *	pool,
		void *	private,
		unsigned	flags,
		int	hint,
		pipe_mutex *	mutex,
		void **	virtual
	)			[static]

Definition at line 657 of file ws_dri_slabpool.c.

References _DriSlabBuffer::bo, driFenceSignaled(), driFenceSignaledCached(), _DriSlabBuffer::fence, _DriSlabBuffer::fenceType, _DriSlabBuffer::isSlabBuffer, _DriSlab::kbo, _DriSlabBuffer::mapCount, _DriSlabBuffer::parent, pool_waitIdle(), _DriSlabBuffer::start, _DriSlabBuffer::unFenced, and _DriKernelBO::virtual.

{
   struct _DriSlabBuffer *buf = (struct _DriSlabBuffer *) private;
   int busy;

   if (buf->isSlabBuffer)
       busy = buf->unFenced || (buf->fence && !driFenceSignaledCached(buf->fence, buf->fenceType));
   else
       busy = buf->fence && !driFenceSignaled(buf->fence, buf->fenceType);


   if (busy) {
       if (hint & DRM_BO_HINT_DONT_BLOCK)
           return -EBUSY;
       else {
           (void) pool_waitIdle(pool, private, mutex, 0);
       }
   }

   ++buf->mapCount;
   *virtual = (buf->isSlabBuffer) ?
       (void *) ((uint8_t *) buf->parent->kbo->virtual + buf->start) :
       (void *) buf->bo->virtual;

   return 0;
}

static unsigned long pool_offset	(	struct _DriBufferPool *	pool,
		void *	private
	)			[static]

Definition at line 698 of file ws_dri_slabpool.c.

References assert, _DriKernelBO::bo, _DriSlabBuffer::bo, _DriSlab::header, _DriSlabBuffer::isSlabBuffer, _DriSlab::kbo, _DriSlabBuffer::parent, _DriSlabPool::proposedFlags, _DriSlabSizeHeader::slabPool, and _DriSlabBuffer::start.

{
   struct _DriSlabBuffer *buf = (struct _DriSlabBuffer *) private;
   struct _DriSlab *slab;
   struct _DriSlabSizeHeader *header;

   if (!buf->isSlabBuffer) {
       assert(buf->bo->proposedFlags & DRM_BO_FLAG_NO_MOVE);
       return buf->bo->offset;
   }

   slab = buf->parent;
   header = slab->header;

   (void) header;
   assert(header->slabPool->proposedFlags & DRM_BO_FLAG_NO_MOVE);
   return slab->kbo->bo.offset + buf->start;
}

static unsigned long pool_poolOffset	(	struct _DriBufferPool *	pool,
		void *	private
	)			[static]

Definition at line 718 of file ws_dri_slabpool.c.

References _DriSlabBuffer::start.

{
   struct _DriSlabBuffer *buf = (struct _DriSlabBuffer *) private;

   return buf->start;
}

static unsigned long pool_size	(	struct _DriBufferPool *	pool,
		void *	private
	)			[static]

Definition at line 737 of file ws_dri_slabpool.c.

References _DriSlabBuffer::bo, _DriSlabSizeHeader::bufSize, _DriSlab::header, _DriSlabBuffer::isSlabBuffer, and _DriSlabBuffer::parent.

{
   struct _DriSlabBuffer *buf = (struct _DriSlabBuffer *) private;
   if (!buf->isSlabBuffer)
       return buf->bo->size;

   return buf->parent->header->bufSize;
}

static void pool_takedown

(

struct _DriBufferPool *

driPool

)

[static]

Definition at line 882 of file ws_dri_slabpool.c.

References _DriSlabPool::bucketSizes, _DriBufferPool::data, driFinishSizeHeader(), _DriSlabPool::headers, and _DriSlabPool::numBuckets.

{
   struct _DriSlabPool *pool = driPool->data;
   int i;

   for (i=0; i<pool->numBuckets; ++i) {
     driFinishSizeHeader(&pool->headers[i]);
   }

   free(pool->headers);
   free(pool->bucketSizes);
   free(pool);
   free(driPool);
}

static int pool_unmap	(	struct _DriBufferPool *	pool,
		void *	private
	)			[static]

Definition at line 686 of file ws_dri_slabpool.c.

References _DriSlabBuffer::event, _DriSlabBuffer::isSlabBuffer, _DriSlabBuffer::mapCount, and pipe_condvar_broadcast.

{
   struct _DriSlabBuffer *buf = (struct _DriSlabBuffer *) private;

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

   return 0;
}

static int pool_validate	(	struct _DriBufferPool *	pool,
		void *	private,
		pipe_mutex *	mutex
	)			[static]

Definition at line 777 of file ws_dri_slabpool.c.

References _DriSlabBuffer::event, _DriSlabBuffer::isSlabBuffer, _DriSlabBuffer::mapCount, pipe_condvar_wait, and _DriSlabBuffer::unFenced.

{
   struct _DriSlabBuffer *buf = (struct _DriSlabBuffer *) private;

   if (!buf->isSlabBuffer)
       return 0;

   while(buf->mapCount != 0)
      pipe_condvar_wait(buf->event, *mutex);

   buf->unFenced = 1;
   return 0;
}

static int pool_waitIdle	(	struct _DriBufferPool *	driPool,
		void *	private,
		pipe_mutex *	mutex,
		int	lazy
	)			[static]

Definition at line 639 of file ws_dri_slabpool.c.

References driFenceFinish(), driFenceUnReference(), _DriSlabBuffer::event, _DriSlabBuffer::fence, _DriSlabBuffer::fenceType, pipe_condvar_wait, and _DriSlabBuffer::unFenced.

{
   struct _DriSlabBuffer *buf = (struct _DriSlabBuffer *) private;

   while(buf->unFenced)
       pipe_condvar_wait(buf->event, *mutex);

   if (!buf->fence)
     return 0;

   driFenceFinish(buf->fence, buf->fenceType, lazy);
   driFenceUnReference(&buf->fence);

   return 0;
}

---