ws_dri_fencemgr.h File Reference

Include dependency graph for ws_dri_fencemgr.h:

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

Go to the source code of this file.

Data Structures
struct	_DriFenceMgrCreateInfo
Defines
#define	DRI_FENCE_CLASS_ORDERED   (1 << 0)
Functions
uint32_t	driFenceSignaledTypeCached (struct _DriFenceObject *fence)
int	driFenceSignaledType (struct _DriFenceObject *fence, uint32_t flush_type, uint32_t *signaled)
static int	driFenceSignaled (struct _DriFenceObject *fence, uint32_t flush_type)
static int	driFenceSignaledCached (struct _DriFenceObject *fence, uint32_t flush_type)
struct _DriFenceObject *	driFenceReference (struct _DriFenceObject *fence)
void	driFenceUnReference (struct _DriFenceObject **pFence)
int	driFenceFinish (struct _DriFenceObject *fence, uint32_t fence_type, int lazy_hint)
struct _DriFenceObject *	driFenceCreate (struct _DriFenceMgr *mgr, uint32_t fence_class, uint32_t fence_type, void *private, size_t private_size)
uint32_t	driFenceType (struct _DriFenceObject *fence)
struct _DriFenceMgr *	driFenceMgrCreate (const struct _DriFenceMgrCreateInfo *info)
void	driFenceMgrUnReference (struct _DriFenceMgr **pMgr)
struct _DriFenceMgr *	driFenceMgrTTMInit (int fd)

---

Define Documentation

#define DRI_FENCE_CLASS_ORDERED   (1 << 0)

Definition at line 95 of file ws_dri_fencemgr.h.

---

Function Documentation

struct _DriFenceObject* driFenceCreate	(	struct _DriFenceMgr *	mgr,
		uint32_t	fence_class,
		uint32_t	fence_type,
		void *	private,
		size_t	private_size
	)			[read]

Definition at line 277 of file ws_dri_fencemgr.c.

References _DriFenceObject::fence_class, _DriFenceObject::fence_type, _DriFenceMgrCreateInfo::finish, _DriFenceObject::head, _DriFenceMgr::heads, _DriFenceMgr::info, _DriFenceObject::mgr, _DriFenceMgr::mutex, _DriFenceObject::mutex, _DriFenceMgr::num_fences, pipe_mutex_init, pipe_mutex_lock, pipe_mutex_unlock, _DriFenceObject::private, _DriFenceMgr::refCount, _DriFenceObject::refCount, and _DriFenceObject::signaled_type.

{
    struct _DriFenceObject *fence;
    size_t fence_size = sizeof(*fence);

    if (private_size)
        fence_size = ((fence_size + 15) & ~15);

    fence = calloc(1, fence_size + private_size);

    if (!fence) {
        int ret = mgr->info.finish(mgr, private, fence_type, 0);

        if (ret)
            usleep(10000000);

        return NULL;
    }

    pipe_mutex_init(fence->mutex);
    pipe_mutex_lock(fence->mutex);
    pipe_mutex_lock(mgr->mutex);
    fence->refCount = 1;
    DRMLISTADDTAIL(&fence->head, &mgr->heads[fence_class]);
    fence->mgr = mgr;
    ++mgr->refCount;
    ++mgr->num_fences;
    pipe_mutex_unlock(mgr->mutex);
    fence->fence_class = fence_class;
    fence->fence_type = fence_type;
    fence->signaled_type = 0;
    fence->private = private;
    if (private_size) {
        fence->private = (void *)(((uint8_t *) fence) + fence_size);
        memcpy(fence->private, private, private_size);
    }

    pipe_mutex_unlock(fence->mutex);
    return fence;
}

int driFenceFinish	(	struct _DriFenceObject *	fence,
		uint32_t	fence_type,
		int	lazy_hint
	)

Definition at line 178 of file ws_dri_fencemgr.c.

References driSignalPreviousFencesLocked(), _DriFenceObject::fence_class, _DriFenceMgrCreateInfo::finish, _DriFenceObject::head, _DriFenceMgr::info, _DriFenceObject::mgr, _DriFenceMgr::mutex, _DriFenceObject::mutex, pipe_mutex_lock, pipe_mutex_unlock, _DriFenceObject::private, and _DriFenceObject::signaled_type.

{
    struct _DriFenceMgr *mgr = fence->mgr;
    int ret = 0;

    pipe_mutex_lock(fence->mutex);

    if ((fence->signaled_type & fence_type) == fence_type)
        goto out0;

    ret = mgr->info.finish(mgr, fence->private, fence_type, lazy_hint);
    if (ret)
        goto out0;

    pipe_mutex_lock(mgr->mutex);
    pipe_mutex_unlock(fence->mutex);

    driSignalPreviousFencesLocked(mgr, &fence->head, fence->fence_class,
                                  fence_type);
    pipe_mutex_unlock(mgr->mutex);
    return 0;

  out0:
    pipe_mutex_unlock(fence->mutex);
    return ret;
}

struct _DriFenceMgr* driFenceMgrCreate

(

const struct _DriFenceMgrCreateInfo *

info

)

[read]

Definition at line 59 of file ws_dri_fencemgr.c.

References _DriFenceMgr::heads, _DriFenceMgr::info, _DriFenceMgr::mutex, _DriFenceMgrCreateInfo::num_classes, _DriFenceMgr::num_fences, pipe_mutex_init, pipe_mutex_lock, pipe_mutex_unlock, and _DriFenceMgr::refCount.

{
  struct _DriFenceMgr *tmp;
  uint32_t i;

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

  pipe_mutex_init(tmp->mutex);
  pipe_mutex_lock(tmp->mutex);
  tmp->refCount = 1;
  tmp->info = *info;
  tmp->num_fences = 0;
  tmp->heads = calloc(tmp->info.num_classes, sizeof(*tmp->heads));
  if (!tmp->heads)
      goto out_err;

  for (i=0; i<tmp->info.num_classes; ++i) {
      DRMINITLISTHEAD(&tmp->heads[i]);
  }
  pipe_mutex_unlock(tmp->mutex);
  return tmp;

  out_err:
  if (tmp)
      free(tmp);
  return NULL;
}

struct _DriFenceMgr* driFenceMgrTTMInit

(

int

fd

)

[read]

Definition at line 359 of file ws_dri_fencemgr.c.

References DRI_FENCE_CLASS_ORDERED, driFenceMgrCreate(), _DriFenceMgrCreateInfo::finish, _DriFenceMgrCreateInfo::flags, _DriFenceMgrCreateInfo::num_classes, _DriFenceMgr::private, _DriFenceMgrCreateInfo::signaled, tFinish(), tSignaled(), tUnref(), and _DriFenceMgrCreateInfo::unreference.

{
  struct _DriFenceMgrCreateInfo info;
  struct _DriFenceMgr *mgr;

  info.flags = DRI_FENCE_CLASS_ORDERED;
  info.num_classes = 4;
  info.signaled = tSignaled;
  info.finish = tFinish;
  info.unreference = tUnref;

  mgr = driFenceMgrCreate(&info);
  if (mgr == NULL)
    return NULL;

  mgr->private = (void *) (long) fd;
  return mgr;
}

void driFenceMgrUnReference

(

struct _DriFenceMgr **

pMgr

)

Definition at line 102 of file ws_dri_fencemgr.c.

References driFenceMgrUnrefUnlock(), and pipe_mutex_lock.

{
    pipe_mutex_lock((*pMgr)->mutex);
    driFenceMgrUnrefUnlock(pMgr);
}

struct _DriFenceObject* driFenceReference

(

struct _DriFenceObject *

fence

)

[read]

Definition at line 253 of file ws_dri_fencemgr.c.

References _DriFenceObject::mgr, _DriFenceMgr::mutex, pipe_mutex_lock, pipe_mutex_unlock, and _DriFenceObject::refCount.

{
    pipe_mutex_lock(fence->mgr->mutex);
    ++fence->refCount;
    pipe_mutex_unlock(fence->mgr->mutex);
    return fence;
}

static int driFenceSignaled	(	struct _DriFenceObject *	fence,
		uint32_t	flush_type
	)			[static]

Definition at line 30 of file ws_dri_fencemgr.h.

References driFenceSignaledType().

{
    uint32_t signaled_types;
    int ret = driFenceSignaledType(fence, flush_type, &signaled_types);
    if (ret)
        return 0;
    return ((signaled_types & flush_type) == flush_type);
}

static int driFenceSignaledCached	(	struct _DriFenceObject *	fence,
		uint32_t	flush_type
	)			[static]

Definition at line 40 of file ws_dri_fencemgr.h.

References driFenceSignaledTypeCached().

{
    uint32_t signaled_types =
        driFenceSignaledTypeCached(fence);

    return ((signaled_types & flush_type) == flush_type);
}

int driFenceSignaledType	(	struct _DriFenceObject *	fence,
		uint32_t	flush_type,
		uint32_t *	signaled
	)

Definition at line 218 of file ws_dri_fencemgr.c.

References driSignalPreviousFencesLocked(), _DriFenceObject::fence_class, _DriFenceObject::head, _DriFenceMgr::info, _DriFenceObject::mgr, _DriFenceMgr::mutex, _DriFenceObject::mutex, pipe_mutex_lock, pipe_mutex_unlock, _DriFenceObject::private, _DriFenceMgrCreateInfo::signaled, and _DriFenceObject::signaled_type.

{
    int ret = 0;
    struct _DriFenceMgr *mgr;

    pipe_mutex_lock(fence->mutex);
    mgr = fence->mgr;
    *signaled = fence->signaled_type;
    if ((fence->signaled_type & flush_type) == flush_type)
        goto out0;

    ret = mgr->info.signaled(mgr, fence->private, flush_type, signaled);
    if (ret) {
        *signaled = fence->signaled_type;
        goto out0;
    }

    if ((fence->signaled_type | *signaled) == fence->signaled_type)
        goto out0;

    pipe_mutex_lock(mgr->mutex);
    pipe_mutex_unlock(fence->mutex);

    driSignalPreviousFencesLocked(mgr, &fence->head, fence->fence_class,
                                  *signaled);

    pipe_mutex_unlock(mgr->mutex);
    return 0;
  out0:
    pipe_mutex_unlock(fence->mutex);
    return ret;
}

uint32_t driFenceSignaledTypeCached

(

struct _DriFenceObject *

fence

)

Definition at line 206 of file ws_dri_fencemgr.c.

References _DriFenceObject::mutex, pipe_mutex_lock, pipe_mutex_unlock, and _DriFenceObject::signaled_type.

{
    uint32_t ret;

    pipe_mutex_lock(fence->mutex);
    ret = fence->signaled_type;
    pipe_mutex_unlock(fence->mutex);

    return ret;
}

uint32_t driFenceType

(

struct _DriFenceObject *

fence

)

Definition at line 53 of file ws_dri_fencemgr.c.

References _DriFenceObject::fence_type.

{
  return fence->fence_type;
}

void driFenceUnReference

(

struct _DriFenceObject **

pFence

)

Definition at line 262 of file ws_dri_fencemgr.c.

References driFenceMgrUnrefUnlock(), driFenceUnReferenceLocked(), _DriFenceMgr::mutex, pipe_mutex_lock, and _DriFenceMgr::refCount.

{
    struct _DriFenceMgr *mgr;

    if (*pFence == NULL)
        return;

    mgr = (*pFence)->mgr;
    pipe_mutex_lock(mgr->mutex);
    ++mgr->refCount;
    driFenceUnReferenceLocked(pFence);
    driFenceMgrUnrefUnlock(&mgr);
}

---