pb_buffer_fenced.h File Reference

Buffer fencing. More...

Include dependency graph for pb_buffer_fenced.h:

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

Go to the source code of this file.

Functions
struct fenced_buffer_list *	fenced_buffer_list_create (struct pipe_winsys *winsys)
	Create a fenced buffer list.
void	fenced_buffer_list_check_free (struct fenced_buffer_list *fenced_list, int wait)
	Walk the fenced buffer list to check and free signalled buffers.
void	fenced_buffer_list_destroy (struct fenced_buffer_list *fenced_list)
struct pb_buffer *	fenced_buffer_create (struct fenced_buffer_list *fenced, struct pb_buffer *buffer)
	Wrap a buffer in a fenced buffer.
void	buffer_fence (struct pb_buffer *buf, struct pipe_fence_handle *fence)
	Set a buffer's fence.
Variables
struct pb_vtbl	fenced_buffer_vtbl
	The fenced buffer's virtual function table.

---

Detailed Description

Buffer fencing.

"Fenced buffers" is actually a misnomer. They should be referred as "fenceable buffers", i.e, buffers that can be fenced, but I couldn't find the word "fenceable" in the dictionary.

A "fenced buffer" is a decorator around a normal buffer, which adds two special properties:

• the ability for the destruction to be delayed by a fence;
• reference counting.

Usually DMA buffers have a life-time that will extend the life-time of its handle. The end-of-life is dictated by the fence signalling.

Between the handle's destruction, and the fence signalling, the buffer is stored in a fenced buffer list.

Author:

José Fonseca <jrfonseca@tungstengraphics.com>

Definition in file pb_buffer_fenced.h.

---

Function Documentation

void buffer_fence	(	struct pb_buffer *	buf,
		struct pipe_fence_handle *	fence
	)

Set a buffer's fence.

NOTE: Although it takes a generic pb_buffer argument, it will fail on everything but buffers returned by fenced_buffer_create.

Definition at line 403 of file pb_buffer_fenced.c.

References _fenced_buffer_add(), _fenced_buffer_remove(), assert, fenced_buffer::fence, pipe_winsys::fence_reference, fenced_buffer(), fenced_buffer::flags, fenced_buffer::list, fenced_buffer_list::mutex, PIPE_BUFFER_USAGE_GPU_READ_WRITE, pipe_mutex_lock, pipe_mutex_unlock, pb_buffer::vtbl, and fenced_buffer_list::winsys.

{
   struct fenced_buffer *fenced_buf;
   struct fenced_buffer_list *fenced_list;
   struct pipe_winsys *winsys;
   /* FIXME: receive this as a parameter */
   unsigned flags = fence ? PIPE_BUFFER_USAGE_GPU_READ_WRITE : 0;

   /* This is a public function, so be extra cautious with the buffer passed, 
    * as happens frequently to receive null buffers, or pointer to buffers 
    * other than fenced buffers. */
   assert(buf);
   if(!buf)
      return;
   assert(buf->vtbl == &fenced_buffer_vtbl);
   if(buf->vtbl != &fenced_buffer_vtbl)
      return;
   
   if(!fence)
      return;

   fenced_buf = fenced_buffer(buf);
   fenced_list = fenced_buf->list;
   winsys = fenced_list->winsys;
   
   if(fence == fenced_buf->fence) {
      fenced_buf->flags |= flags & PIPE_BUFFER_USAGE_GPU_READ_WRITE;
      return;
   }
   
   pipe_mutex_lock(fenced_list->mutex);
   if (fenced_buf->fence)
      _fenced_buffer_remove(fenced_list, fenced_buf);
   winsys->fence_reference(winsys, &fenced_buf->fence, fence);
   fenced_buf->flags |= flags & PIPE_BUFFER_USAGE_GPU_READ_WRITE;
   _fenced_buffer_add(fenced_buf);
   pipe_mutex_unlock(fenced_list->mutex);
}

struct pb_buffer* fenced_buffer_create	(	struct fenced_buffer_list *	fenced,
		struct pb_buffer *	buffer
	)			[read]

Wrap a buffer in a fenced buffer.

NOTE: this will not increase the buffer reference count.

Definition at line 368 of file pb_buffer_fenced.c.

References pipe_buffer::alignment, pb_buffer::base, fenced_buffer::base, fenced_buffer::buffer, CALLOC_STRUCT, fenced_buffer::head, fenced_buffer::list, LIST_ADDTAIL, fenced_buffer_list::mutex, pb_reference(), pipe_mutex_lock, pipe_mutex_unlock, pipe_buffer::refcount, pipe_buffer::size, pipe_buffer::usage, and pb_buffer::vtbl.

{
   struct fenced_buffer *buf;
   
   if(!buffer)
      return NULL;
   
   buf = CALLOC_STRUCT(fenced_buffer);
   if(!buf) {
      pb_reference(&buffer, NULL);
      return NULL;
   }
   
   buf->base.base.refcount = 1;
   buf->base.base.alignment = buffer->base.alignment;
   buf->base.base.usage = buffer->base.usage;
   buf->base.base.size = buffer->base.size;
   
   buf->base.vtbl = &fenced_buffer_vtbl;
   buf->buffer = buffer;
   buf->list = fenced_list;
   
#ifdef DEBUG
   pipe_mutex_lock(fenced_list->mutex);
   LIST_ADDTAIL(&buf->head, &fenced_list->unfenced);
   ++fenced_list->numUnfenced;
   pipe_mutex_unlock(fenced_list->mutex);
#endif

   return &buf->base;
}

void fenced_buffer_list_check_free	(	struct fenced_buffer_list *	fenced_list,
		int	wait
	)

Walk the fenced buffer list to check and free signalled buffers.

Definition at line 470 of file pb_buffer_fenced.c.

References _fenced_buffer_list_check_free(), fenced_buffer_list::mutex, pipe_mutex_lock, and pipe_mutex_unlock.

{
   pipe_mutex_lock(fenced_list->mutex);
   _fenced_buffer_list_check_free(fenced_list, wait);
   pipe_mutex_unlock(fenced_list->mutex);
}

struct fenced_buffer_list* fenced_buffer_list_create

(

struct pipe_winsys *

winsys

)

[read]

Create a fenced buffer list.

See also fenced_bufmgr_create for a more convenient way to use this.

Definition at line 445 of file pb_buffer_fenced.c.

References CALLOC_STRUCT, fenced_buffer_list::delayed, LIST_INITHEAD, fenced_buffer_list::mutex, fenced_buffer_list::numDelayed, pipe_mutex_init, and fenced_buffer_list::winsys.

{
   struct fenced_buffer_list *fenced_list;

   fenced_list = CALLOC_STRUCT(fenced_buffer_list);
   if (!fenced_list)
      return NULL;

   fenced_list->winsys = winsys;

   LIST_INITHEAD(&fenced_list->delayed);
   fenced_list->numDelayed = 0;
   
#ifdef DEBUG
   LIST_INITHEAD(&fenced_list->unfenced);
   fenced_list->numUnfenced = 0;
#endif

   pipe_mutex_init(fenced_list->mutex);

   return fenced_list;
}

void fenced_buffer_list_destroy

(

struct fenced_buffer_list *

fenced_list

)

Definition at line 525 of file pb_buffer_fenced.c.

References _fenced_buffer_list_check_free(), FREE, fenced_buffer_list::mutex, fenced_buffer_list::numDelayed, pipe_mutex_lock, and pipe_mutex_unlock.

{
   pipe_mutex_lock(fenced_list->mutex);

   /* Wait on outstanding fences */
   while (fenced_list->numDelayed) {
      pipe_mutex_unlock(fenced_list->mutex);
#if defined(PIPE_OS_LINUX)
      sched_yield();
#endif
      _fenced_buffer_list_check_free(fenced_list, 1);
      pipe_mutex_lock(fenced_list->mutex);
   }

#ifdef DEBUG
   //assert(!fenced_list->numUnfenced);
#endif
      
   pipe_mutex_unlock(fenced_list->mutex);
   
   FREE(fenced_list);
}

---

Variable Documentation

struct pb_vtbl fenced_buffer_vtbl

The fenced buffer's virtual function table.

NOTE: Made public for debugging purposes.

Definition at line 359 of file pb_buffer_fenced.c.

---