ws_dri_bufpool.h File Reference

Include dependency graph for ws_dri_bufpool.h:

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

Go to the source code of this file.

Data Structures
struct	_DriBufferPool
Defines
#define	BM_CKFATAL(val)
Typedefs
typedef struct _DriBufferPool	DriBufferPool
Functions
void	bmError (int val, const char *file, const char *function, int line)
struct _DriBufferPool *	driDRMPoolInit (int fd)
struct _DriBufferPool *	driMallocPoolInit (void)
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)
void	driFinishFreeSlabManager (struct _DriFreeSlabManager *fMan)
struct _DriFreeSlabManager *	driInitFreeSlabManager (uint32_t checkIntervalMsec, uint32_t slabTimeoutMsec)

---

Define Documentation

#define BM_CKFATAL

(

val

)

Value:

do{                                                            \
    int tstVal = (val);                                        \
    if (tstVal)                                                \
      bmError(tstVal, __FILE__, __FUNCTION__, __LINE__);       \
  } while(0);

Definition at line 69 of file ws_dri_bufpool.h.

---

Typedef Documentation

typedef struct _DriBufferPool DriBufferPool

---

Function Documentation

void bmError	(	int	val,
		const char *	file,
		const char *	function,
		int	line
	)

Definition at line 301 of file ws_dri_bufmgr.c.

{
   printf("Fatal video memory manager error \"%s\".\n"
          "Check kernel logs or set the LIBGL_DEBUG\n"
          "environment variable to \"verbose\" for more info.\n"
          "Detected in file %s, line %d, function %s.\n",
          strerror(-val), file, line, function);
#ifndef NDEBUG
   abort();
#else
   abort();
#endif

struct _DriBufferPool* driDRMPoolInit

(

int

fd

)

[read]

Definition at line 241 of file ws_dri_drmpool.c.

References _DriBufferPool::create, _DriBufferPool::data, _DriBufferPool::destroy, _DriBufferPool::fd, _DriBufferPool::fence, _DriBufferPool::flags, _DriBufferPool::kernel, _DriBufferPool::map, _DriBufferPool::offset, pool_create(), pool_destroy(), pool_fence(), pool_flags(), pool_kernel(), pool_map(), pool_offset(), pool_poolOffset(), pool_reference(), pool_size(), pool_takedown(), pool_unmap(), pool_unreference(), pool_waitIdle(), _DriBufferPool::poolOffset, _DriBufferPool::reference, _DriBufferPool::size, _DriBufferPool::takeDown, _DriBufferPool::unmap, _DriBufferPool::unreference, _DriBufferPool::validate, and _DriBufferPool::waitIdle.

{
   struct _DriBufferPool *pool;

   pool = (struct _DriBufferPool *) malloc(sizeof(*pool));

   if (!pool)
      return NULL;

   pool->fd = fd;
   pool->map = &pool_map;
   pool->unmap = &pool_unmap;
   pool->destroy = &pool_destroy;
   pool->offset = &pool_offset;
   pool->poolOffset = &pool_poolOffset;
   pool->flags = &pool_flags;
   pool->size = &pool_size;
   pool->create = &pool_create;
   pool->fence = &pool_fence;
   pool->kernel = &pool_kernel;
   pool->validate = NULL;
   pool->waitIdle = &pool_waitIdle;
   pool->takeDown = &pool_takedown;
   pool->reference = &pool_reference;
   pool->unreference = &pool_unreference;
   pool->data = NULL;
   return pool;
}

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

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

struct _DriBufferPool* driMallocPoolInit

(

void

)

[read]

Definition at line 137 of file ws_dri_mallocpool.c.

References _DriBufferPool::create, _DriBufferPool::data, _DriBufferPool::destroy, _DriBufferPool::fd, _DriBufferPool::fence, _DriBufferPool::flags, _DriBufferPool::kernel, _DriBufferPool::map, _DriBufferPool::offset, pool_create(), pool_destroy(), pool_fence(), pool_flags(), pool_kernel(), pool_map(), pool_offset(), pool_poolOffset(), pool_size(), pool_takedown(), pool_unmap(), pool_waitIdle(), _DriBufferPool::poolOffset, _DriBufferPool::size, _DriBufferPool::takeDown, _DriBufferPool::unmap, _DriBufferPool::validate, and _DriBufferPool::waitIdle.

{
   struct _DriBufferPool *pool;

   pool = (struct _DriBufferPool *) malloc(sizeof(*pool));
   if (!pool)
       return NULL;

   pool->data = NULL;
   pool->fd = -1;
   pool->map = &pool_map;
   pool->unmap = &pool_unmap;
   pool->destroy = &pool_destroy;
   pool->offset = &pool_offset;
   pool->poolOffset = &pool_poolOffset;
   pool->flags = &pool_flags;
   pool->size = &pool_size;
   pool->create = &pool_create;
   pool->fence = &pool_fence;
   pool->kernel = &pool_kernel;
   pool->validate = NULL;
   pool->waitIdle = &pool_waitIdle;
   pool->takeDown = &pool_takedown;
   return pool;
}

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

---