1 /**************************************************************************
3 * Copyright 2007-2010 VMware, Inc.
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
26 **************************************************************************/
30 * Implementation of fenced buffers.
32 * \author Jose Fonseca <jfonseca-at-vmware-dot-com>
33 * \author Thomas Hellström <thellstrom-at-vmware-dot-com>
37 #include "pipe/p_config.h"
39 #if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS)
44 #include "pipe/p_compiler.h"
45 #include "pipe/p_defines.h"
46 #include "util/u_debug.h"
47 #include "os/os_thread.h"
48 #include "util/u_memory.h"
49 #include "util/list.h"
51 #include "pb_buffer.h"
52 #include "pb_buffer_fenced.h"
53 #include "pb_bufmgr.h"
58 * Convenience macro (type safe).
60 #define SUPER(__derived) (&(__derived)->base)
65 struct pb_manager base
;
66 struct pb_manager
*provider
;
67 struct pb_fence_ops
*ops
;
70 * Maximum buffer size that can be safely allocated.
72 pb_size max_buffer_size
;
75 * Maximum cpu memory we can allocate before we start waiting for the
78 pb_size max_cpu_total_size
;
81 * Following members are mutable and protected by this mutex.
88 * All fenced buffers are placed in this listed, ordered from the oldest
89 * fence to the newest fence.
91 struct list_head fenced
;
94 struct list_head unfenced
;
98 * How much temporary CPU memory is being used to hold unvalidated buffers.
100 pb_size cpu_total_size
;
107 * Wrapper around a pipe buffer which adds fencing and reference counting.
115 struct pb_buffer base
;
116 struct fenced_manager
*mgr
;
119 * Following members are mutable and protected by fenced_manager::mutex.
122 struct list_head head
;
125 * Buffer with storage.
127 struct pb_buffer
*buffer
;
132 * Temporary CPU storage data. Used when there isn't enough GPU memory to
138 * A bitmask of PB_USAGE_CPU/GPU_READ/WRITE describing the current
145 struct pb_validate
*vl
;
146 unsigned validation_flags
;
148 struct pipe_fence_handle
*fence
;
152 static INLINE
struct fenced_manager
*
153 fenced_manager(struct pb_manager
*mgr
)
156 return (struct fenced_manager
*)mgr
;
160 static INLINE
struct fenced_buffer
*
161 fenced_buffer(struct pb_buffer
*buf
)
164 return (struct fenced_buffer
*)buf
;
169 fenced_buffer_destroy_cpu_storage_locked(struct fenced_buffer
*fenced_buf
);
171 static enum pipe_error
172 fenced_buffer_create_cpu_storage_locked(struct fenced_manager
*fenced_mgr
,
173 struct fenced_buffer
*fenced_buf
);
176 fenced_buffer_destroy_gpu_storage_locked(struct fenced_buffer
*fenced_buf
);
178 static enum pipe_error
179 fenced_buffer_create_gpu_storage_locked(struct fenced_manager
*fenced_mgr
,
180 struct fenced_buffer
*fenced_buf
,
183 static enum pipe_error
184 fenced_buffer_copy_storage_to_gpu_locked(struct fenced_buffer
*fenced_buf
);
186 static enum pipe_error
187 fenced_buffer_copy_storage_to_cpu_locked(struct fenced_buffer
*fenced_buf
);
191 * Dump the fenced buffer list.
193 * Useful to understand failures to allocate buffers.
196 fenced_manager_dump_locked(struct fenced_manager
*fenced_mgr
)
199 struct pb_fence_ops
*ops
= fenced_mgr
->ops
;
200 struct list_head
*curr
, *next
;
201 struct fenced_buffer
*fenced_buf
;
203 debug_printf("%10s %7s %8s %7s %10s %s\n",
204 "buffer", "size", "refcount", "storage", "fence", "signalled");
206 curr
= fenced_mgr
->unfenced
.next
;
208 while(curr
!= &fenced_mgr
->unfenced
) {
209 fenced_buf
= LIST_ENTRY(struct fenced_buffer
, curr
, head
);
210 assert(!fenced_buf
->fence
);
211 debug_printf("%10p %7u %8u %7s\n",
213 fenced_buf
->base
.size
,
214 p_atomic_read(&fenced_buf
->base
.reference
.count
),
215 fenced_buf
->buffer
? "gpu" : (fenced_buf
->data
? "cpu" : "none"));
220 curr
= fenced_mgr
->fenced
.next
;
222 while(curr
!= &fenced_mgr
->fenced
) {
224 fenced_buf
= LIST_ENTRY(struct fenced_buffer
, curr
, head
);
225 assert(fenced_buf
->buffer
);
226 signaled
= ops
->fence_signalled(ops
, fenced_buf
->fence
, 0);
227 debug_printf("%10p %7u %8u %7s %10p %s\n",
229 fenced_buf
->base
.size
,
230 p_atomic_read(&fenced_buf
->base
.reference
.count
),
232 (void *) fenced_buf
->fence
,
233 signaled
== 0 ? "y" : "n");
244 fenced_buffer_destroy_locked(struct fenced_manager
*fenced_mgr
,
245 struct fenced_buffer
*fenced_buf
)
247 assert(!pipe_is_referenced(&fenced_buf
->base
.reference
));
249 assert(!fenced_buf
->fence
);
250 assert(fenced_buf
->head
.prev
);
251 assert(fenced_buf
->head
.next
);
252 LIST_DEL(&fenced_buf
->head
);
253 assert(fenced_mgr
->num_unfenced
);
254 --fenced_mgr
->num_unfenced
;
256 fenced_buffer_destroy_gpu_storage_locked(fenced_buf
);
257 fenced_buffer_destroy_cpu_storage_locked(fenced_buf
);
264 * Add the buffer to the fenced list.
266 * Reference count should be incremented before calling this function.
269 fenced_buffer_add_locked(struct fenced_manager
*fenced_mgr
,
270 struct fenced_buffer
*fenced_buf
)
272 assert(pipe_is_referenced(&fenced_buf
->base
.reference
));
273 assert(fenced_buf
->flags
& PB_USAGE_GPU_READ_WRITE
);
274 assert(fenced_buf
->fence
);
276 p_atomic_inc(&fenced_buf
->base
.reference
.count
);
278 LIST_DEL(&fenced_buf
->head
);
279 assert(fenced_mgr
->num_unfenced
);
280 --fenced_mgr
->num_unfenced
;
281 LIST_ADDTAIL(&fenced_buf
->head
, &fenced_mgr
->fenced
);
282 ++fenced_mgr
->num_fenced
;
287 * Remove the buffer from the fenced list, and potentially destroy the buffer
288 * if the reference count reaches zero.
290 * Returns TRUE if the buffer was detroyed.
292 static INLINE boolean
293 fenced_buffer_remove_locked(struct fenced_manager
*fenced_mgr
,
294 struct fenced_buffer
*fenced_buf
)
296 struct pb_fence_ops
*ops
= fenced_mgr
->ops
;
298 assert(fenced_buf
->fence
);
299 assert(fenced_buf
->mgr
== fenced_mgr
);
301 ops
->fence_reference(ops
, &fenced_buf
->fence
, NULL
);
302 fenced_buf
->flags
&= ~PB_USAGE_GPU_READ_WRITE
;
304 assert(fenced_buf
->head
.prev
);
305 assert(fenced_buf
->head
.next
);
307 LIST_DEL(&fenced_buf
->head
);
308 assert(fenced_mgr
->num_fenced
);
309 --fenced_mgr
->num_fenced
;
311 LIST_ADDTAIL(&fenced_buf
->head
, &fenced_mgr
->unfenced
);
312 ++fenced_mgr
->num_unfenced
;
314 if (p_atomic_dec_zero(&fenced_buf
->base
.reference
.count
)) {
315 fenced_buffer_destroy_locked(fenced_mgr
, fenced_buf
);
324 * Wait for the fence to expire, and remove it from the fenced list.
326 * This function will release and re-acquire the mutex, so any copy of mutable
327 * state must be discarded after calling it.
329 static INLINE
enum pipe_error
330 fenced_buffer_finish_locked(struct fenced_manager
*fenced_mgr
,
331 struct fenced_buffer
*fenced_buf
)
333 struct pb_fence_ops
*ops
= fenced_mgr
->ops
;
334 enum pipe_error ret
= PIPE_ERROR
;
337 debug_warning("waiting for GPU");
340 assert(pipe_is_referenced(&fenced_buf
->base
.reference
));
341 assert(fenced_buf
->fence
);
343 if(fenced_buf
->fence
) {
344 struct pipe_fence_handle
*fence
= NULL
;
348 ops
->fence_reference(ops
, &fence
, fenced_buf
->fence
);
350 pipe_mutex_unlock(fenced_mgr
->mutex
);
352 finished
= ops
->fence_finish(ops
, fenced_buf
->fence
, 0);
354 pipe_mutex_lock(fenced_mgr
->mutex
);
356 assert(pipe_is_referenced(&fenced_buf
->base
.reference
));
359 * Only proceed if the fence object didn't change in the meanwhile.
360 * Otherwise assume the work has been already carried out by another
361 * thread that re-aquired the lock before us.
363 proceed
= fence
== fenced_buf
->fence
? TRUE
: FALSE
;
365 ops
->fence_reference(ops
, &fence
, NULL
);
367 if(proceed
&& finished
== 0) {
369 * Remove from the fenced list
374 destroyed
= fenced_buffer_remove_locked(fenced_mgr
, fenced_buf
);
376 /* TODO: remove consequents buffers with the same fence? */
379 (void) destroyed
; /* silence unused var warning for non-debug build */
381 fenced_buf
->flags
&= ~PB_USAGE_GPU_READ_WRITE
;
392 * Remove as many fenced buffers from the fenced list as possible.
394 * Returns TRUE if at least one buffer was removed.
397 fenced_manager_check_signalled_locked(struct fenced_manager
*fenced_mgr
,
400 struct pb_fence_ops
*ops
= fenced_mgr
->ops
;
401 struct list_head
*curr
, *next
;
402 struct fenced_buffer
*fenced_buf
;
403 struct pipe_fence_handle
*prev_fence
= NULL
;
406 curr
= fenced_mgr
->fenced
.next
;
408 while(curr
!= &fenced_mgr
->fenced
) {
409 fenced_buf
= LIST_ENTRY(struct fenced_buffer
, curr
, head
);
411 if(fenced_buf
->fence
!= prev_fence
) {
415 signaled
= ops
->fence_finish(ops
, fenced_buf
->fence
, 0);
418 * Don't return just now. Instead preemptively check if the
419 * following buffers' fences already expired, without further waits.
424 signaled
= ops
->fence_signalled(ops
, fenced_buf
->fence
, 0);
431 prev_fence
= fenced_buf
->fence
;
434 /* This buffer's fence object is identical to the previous buffer's
435 * fence object, so no need to check the fence again.
437 assert(ops
->fence_signalled(ops
, fenced_buf
->fence
, 0) == 0);
440 fenced_buffer_remove_locked(fenced_mgr
, fenced_buf
);
453 * Try to free some GPU memory by backing it up into CPU memory.
455 * Returns TRUE if at least one buffer was freed.
458 fenced_manager_free_gpu_storage_locked(struct fenced_manager
*fenced_mgr
)
460 struct list_head
*curr
, *next
;
461 struct fenced_buffer
*fenced_buf
;
463 curr
= fenced_mgr
->unfenced
.next
;
465 while(curr
!= &fenced_mgr
->unfenced
) {
466 fenced_buf
= LIST_ENTRY(struct fenced_buffer
, curr
, head
);
469 * We can only move storage if the buffer is not mapped and not
472 if(fenced_buf
->buffer
&&
473 !fenced_buf
->mapcount
&&
477 ret
= fenced_buffer_create_cpu_storage_locked(fenced_mgr
, fenced_buf
);
479 ret
= fenced_buffer_copy_storage_to_cpu_locked(fenced_buf
);
481 fenced_buffer_destroy_gpu_storage_locked(fenced_buf
);
484 fenced_buffer_destroy_cpu_storage_locked(fenced_buf
);
497 * Destroy CPU storage for this buffer.
500 fenced_buffer_destroy_cpu_storage_locked(struct fenced_buffer
*fenced_buf
)
502 if(fenced_buf
->data
) {
503 align_free(fenced_buf
->data
);
504 fenced_buf
->data
= NULL
;
505 assert(fenced_buf
->mgr
->cpu_total_size
>= fenced_buf
->size
);
506 fenced_buf
->mgr
->cpu_total_size
-= fenced_buf
->size
;
512 * Create CPU storage for this buffer.
514 static enum pipe_error
515 fenced_buffer_create_cpu_storage_locked(struct fenced_manager
*fenced_mgr
,
516 struct fenced_buffer
*fenced_buf
)
518 assert(!fenced_buf
->data
);
522 if (fenced_mgr
->cpu_total_size
+ fenced_buf
->size
> fenced_mgr
->max_cpu_total_size
)
523 return PIPE_ERROR_OUT_OF_MEMORY
;
525 fenced_buf
->data
= align_malloc(fenced_buf
->size
, fenced_buf
->desc
.alignment
);
526 if(!fenced_buf
->data
)
527 return PIPE_ERROR_OUT_OF_MEMORY
;
529 fenced_mgr
->cpu_total_size
+= fenced_buf
->size
;
536 * Destroy the GPU storage.
539 fenced_buffer_destroy_gpu_storage_locked(struct fenced_buffer
*fenced_buf
)
541 if(fenced_buf
->buffer
) {
542 pb_reference(&fenced_buf
->buffer
, NULL
);
548 * Try to create GPU storage for this buffer.
550 * This function is a shorthand around pb_manager::create_buffer for
551 * fenced_buffer_create_gpu_storage_locked()'s benefit.
553 static INLINE boolean
554 fenced_buffer_try_create_gpu_storage_locked(struct fenced_manager
*fenced_mgr
,
555 struct fenced_buffer
*fenced_buf
)
557 struct pb_manager
*provider
= fenced_mgr
->provider
;
559 assert(!fenced_buf
->buffer
);
561 fenced_buf
->buffer
= provider
->create_buffer(fenced_mgr
->provider
,
564 return fenced_buf
->buffer
? TRUE
: FALSE
;
569 * Create GPU storage for this buffer.
571 static enum pipe_error
572 fenced_buffer_create_gpu_storage_locked(struct fenced_manager
*fenced_mgr
,
573 struct fenced_buffer
*fenced_buf
,
576 assert(!fenced_buf
->buffer
);
579 * Check for signaled buffers before trying to allocate.
581 fenced_manager_check_signalled_locked(fenced_mgr
, FALSE
);
583 fenced_buffer_try_create_gpu_storage_locked(fenced_mgr
, fenced_buf
);
586 * Keep trying while there is some sort of progress:
587 * - fences are expiring,
588 * - or buffers are being being swapped out from GPU memory into CPU memory.
590 while(!fenced_buf
->buffer
&&
591 (fenced_manager_check_signalled_locked(fenced_mgr
, FALSE
) ||
592 fenced_manager_free_gpu_storage_locked(fenced_mgr
))) {
593 fenced_buffer_try_create_gpu_storage_locked(fenced_mgr
, fenced_buf
);
596 if(!fenced_buf
->buffer
&& wait
) {
598 * Same as before, but this time around, wait to free buffers if
601 while(!fenced_buf
->buffer
&&
602 (fenced_manager_check_signalled_locked(fenced_mgr
, TRUE
) ||
603 fenced_manager_free_gpu_storage_locked(fenced_mgr
))) {
604 fenced_buffer_try_create_gpu_storage_locked(fenced_mgr
, fenced_buf
);
608 if(!fenced_buf
->buffer
) {
610 fenced_manager_dump_locked(fenced_mgr
);
613 return PIPE_ERROR_OUT_OF_MEMORY
;
620 static enum pipe_error
621 fenced_buffer_copy_storage_to_gpu_locked(struct fenced_buffer
*fenced_buf
)
625 assert(fenced_buf
->data
);
626 assert(fenced_buf
->buffer
);
628 map
= pb_map(fenced_buf
->buffer
, PB_USAGE_CPU_WRITE
, NULL
);
632 memcpy(map
, fenced_buf
->data
, fenced_buf
->size
);
634 pb_unmap(fenced_buf
->buffer
);
640 static enum pipe_error
641 fenced_buffer_copy_storage_to_cpu_locked(struct fenced_buffer
*fenced_buf
)
645 assert(fenced_buf
->data
);
646 assert(fenced_buf
->buffer
);
648 map
= pb_map(fenced_buf
->buffer
, PB_USAGE_CPU_READ
, NULL
);
652 memcpy(fenced_buf
->data
, map
, fenced_buf
->size
);
654 pb_unmap(fenced_buf
->buffer
);
661 fenced_buffer_destroy(struct pb_buffer
*buf
)
663 struct fenced_buffer
*fenced_buf
= fenced_buffer(buf
);
664 struct fenced_manager
*fenced_mgr
= fenced_buf
->mgr
;
666 assert(!pipe_is_referenced(&fenced_buf
->base
.reference
));
668 pipe_mutex_lock(fenced_mgr
->mutex
);
670 fenced_buffer_destroy_locked(fenced_mgr
, fenced_buf
);
672 pipe_mutex_unlock(fenced_mgr
->mutex
);
677 fenced_buffer_map(struct pb_buffer
*buf
,
678 unsigned flags
, void *flush_ctx
)
680 struct fenced_buffer
*fenced_buf
= fenced_buffer(buf
);
681 struct fenced_manager
*fenced_mgr
= fenced_buf
->mgr
;
682 struct pb_fence_ops
*ops
= fenced_mgr
->ops
;
685 pipe_mutex_lock(fenced_mgr
->mutex
);
687 assert(!(flags
& PB_USAGE_GPU_READ_WRITE
));
692 while((fenced_buf
->flags
& PB_USAGE_GPU_WRITE
) ||
693 ((fenced_buf
->flags
& PB_USAGE_GPU_READ
) &&
694 (flags
& PB_USAGE_CPU_WRITE
))) {
697 * Don't wait for the GPU to finish accessing it, if blocking is forbidden.
699 if((flags
& PB_USAGE_DONTBLOCK
) &&
700 ops
->fence_signalled(ops
, fenced_buf
->fence
, 0) != 0) {
704 if (flags
& PB_USAGE_UNSYNCHRONIZED
) {
709 * Wait for the GPU to finish accessing. This will release and re-acquire
710 * the mutex, so all copies of mutable state must be discarded.
712 fenced_buffer_finish_locked(fenced_mgr
, fenced_buf
);
715 if(fenced_buf
->buffer
) {
716 map
= pb_map(fenced_buf
->buffer
, flags
, flush_ctx
);
719 assert(fenced_buf
->data
);
720 map
= fenced_buf
->data
;
724 ++fenced_buf
->mapcount
;
725 fenced_buf
->flags
|= flags
& PB_USAGE_CPU_READ_WRITE
;
729 pipe_mutex_unlock(fenced_mgr
->mutex
);
736 fenced_buffer_unmap(struct pb_buffer
*buf
)
738 struct fenced_buffer
*fenced_buf
= fenced_buffer(buf
);
739 struct fenced_manager
*fenced_mgr
= fenced_buf
->mgr
;
741 pipe_mutex_lock(fenced_mgr
->mutex
);
743 assert(fenced_buf
->mapcount
);
744 if(fenced_buf
->mapcount
) {
745 if (fenced_buf
->buffer
)
746 pb_unmap(fenced_buf
->buffer
);
747 --fenced_buf
->mapcount
;
748 if(!fenced_buf
->mapcount
)
749 fenced_buf
->flags
&= ~PB_USAGE_CPU_READ_WRITE
;
752 pipe_mutex_unlock(fenced_mgr
->mutex
);
756 static enum pipe_error
757 fenced_buffer_validate(struct pb_buffer
*buf
,
758 struct pb_validate
*vl
,
761 struct fenced_buffer
*fenced_buf
= fenced_buffer(buf
);
762 struct fenced_manager
*fenced_mgr
= fenced_buf
->mgr
;
765 pipe_mutex_lock(fenced_mgr
->mutex
);
769 fenced_buf
->vl
= NULL
;
770 fenced_buf
->validation_flags
= 0;
775 assert(flags
& PB_USAGE_GPU_READ_WRITE
);
776 assert(!(flags
& ~PB_USAGE_GPU_READ_WRITE
));
777 flags
&= PB_USAGE_GPU_READ_WRITE
;
779 /* Buffer cannot be validated in two different lists */
780 if(fenced_buf
->vl
&& fenced_buf
->vl
!= vl
) {
781 ret
= PIPE_ERROR_RETRY
;
785 if(fenced_buf
->vl
== vl
&&
786 (fenced_buf
->validation_flags
& flags
) == flags
) {
787 /* Nothing to do -- buffer already validated */
793 * Create and update GPU storage.
795 if(!fenced_buf
->buffer
) {
796 assert(!fenced_buf
->mapcount
);
798 ret
= fenced_buffer_create_gpu_storage_locked(fenced_mgr
, fenced_buf
, TRUE
);
803 ret
= fenced_buffer_copy_storage_to_gpu_locked(fenced_buf
);
805 fenced_buffer_destroy_gpu_storage_locked(fenced_buf
);
809 if(fenced_buf
->mapcount
) {
810 debug_printf("warning: validating a buffer while it is still mapped\n");
813 fenced_buffer_destroy_cpu_storage_locked(fenced_buf
);
817 ret
= pb_validate(fenced_buf
->buffer
, vl
, flags
);
822 fenced_buf
->validation_flags
|= flags
;
825 pipe_mutex_unlock(fenced_mgr
->mutex
);
832 fenced_buffer_fence(struct pb_buffer
*buf
,
833 struct pipe_fence_handle
*fence
)
835 struct fenced_buffer
*fenced_buf
= fenced_buffer(buf
);
836 struct fenced_manager
*fenced_mgr
= fenced_buf
->mgr
;
837 struct pb_fence_ops
*ops
= fenced_mgr
->ops
;
839 pipe_mutex_lock(fenced_mgr
->mutex
);
841 assert(pipe_is_referenced(&fenced_buf
->base
.reference
));
842 assert(fenced_buf
->buffer
);
844 if(fence
!= fenced_buf
->fence
) {
845 assert(fenced_buf
->vl
);
846 assert(fenced_buf
->validation_flags
);
848 if (fenced_buf
->fence
) {
850 destroyed
= fenced_buffer_remove_locked(fenced_mgr
, fenced_buf
);
854 ops
->fence_reference(ops
, &fenced_buf
->fence
, fence
);
855 fenced_buf
->flags
|= fenced_buf
->validation_flags
;
856 fenced_buffer_add_locked(fenced_mgr
, fenced_buf
);
859 pb_fence(fenced_buf
->buffer
, fence
);
861 fenced_buf
->vl
= NULL
;
862 fenced_buf
->validation_flags
= 0;
865 pipe_mutex_unlock(fenced_mgr
->mutex
);
870 fenced_buffer_get_base_buffer(struct pb_buffer
*buf
,
871 struct pb_buffer
**base_buf
,
874 struct fenced_buffer
*fenced_buf
= fenced_buffer(buf
);
875 struct fenced_manager
*fenced_mgr
= fenced_buf
->mgr
;
877 pipe_mutex_lock(fenced_mgr
->mutex
);
880 * This should only be called when the buffer is validated. Typically
881 * when processing relocations.
883 assert(fenced_buf
->vl
);
884 assert(fenced_buf
->buffer
);
886 if(fenced_buf
->buffer
)
887 pb_get_base_buffer(fenced_buf
->buffer
, base_buf
, offset
);
893 pipe_mutex_unlock(fenced_mgr
->mutex
);
897 static const struct pb_vtbl
898 fenced_buffer_vtbl
= {
899 fenced_buffer_destroy
,
902 fenced_buffer_validate
,
904 fenced_buffer_get_base_buffer
909 * Wrap a buffer in a fenced buffer.
911 static struct pb_buffer
*
912 fenced_bufmgr_create_buffer(struct pb_manager
*mgr
,
914 const struct pb_desc
*desc
)
916 struct fenced_manager
*fenced_mgr
= fenced_manager(mgr
);
917 struct fenced_buffer
*fenced_buf
;
921 * Don't stall the GPU, waste time evicting buffers, or waste memory
922 * trying to create a buffer that will most likely never fit into the
925 if(size
> fenced_mgr
->max_buffer_size
) {
929 fenced_buf
= CALLOC_STRUCT(fenced_buffer
);
933 pipe_reference_init(&fenced_buf
->base
.reference
, 1);
934 fenced_buf
->base
.alignment
= desc
->alignment
;
935 fenced_buf
->base
.usage
= desc
->usage
;
936 fenced_buf
->base
.size
= size
;
937 fenced_buf
->size
= size
;
938 fenced_buf
->desc
= *desc
;
940 fenced_buf
->base
.vtbl
= &fenced_buffer_vtbl
;
941 fenced_buf
->mgr
= fenced_mgr
;
943 pipe_mutex_lock(fenced_mgr
->mutex
);
946 * Try to create GPU storage without stalling,
948 ret
= fenced_buffer_create_gpu_storage_locked(fenced_mgr
, fenced_buf
, FALSE
);
951 * Attempt to use CPU memory to avoid stalling the GPU.
954 ret
= fenced_buffer_create_cpu_storage_locked(fenced_mgr
, fenced_buf
);
958 * Create GPU storage, waiting for some to be available.
961 ret
= fenced_buffer_create_gpu_storage_locked(fenced_mgr
, fenced_buf
, TRUE
);
971 assert(fenced_buf
->buffer
|| fenced_buf
->data
);
973 LIST_ADDTAIL(&fenced_buf
->head
, &fenced_mgr
->unfenced
);
974 ++fenced_mgr
->num_unfenced
;
975 pipe_mutex_unlock(fenced_mgr
->mutex
);
977 return &fenced_buf
->base
;
980 pipe_mutex_unlock(fenced_mgr
->mutex
);
988 fenced_bufmgr_flush(struct pb_manager
*mgr
)
990 struct fenced_manager
*fenced_mgr
= fenced_manager(mgr
);
992 pipe_mutex_lock(fenced_mgr
->mutex
);
993 while(fenced_manager_check_signalled_locked(fenced_mgr
, TRUE
))
995 pipe_mutex_unlock(fenced_mgr
->mutex
);
997 assert(fenced_mgr
->provider
->flush
);
998 if(fenced_mgr
->provider
->flush
)
999 fenced_mgr
->provider
->flush(fenced_mgr
->provider
);
1004 fenced_bufmgr_destroy(struct pb_manager
*mgr
)
1006 struct fenced_manager
*fenced_mgr
= fenced_manager(mgr
);
1008 pipe_mutex_lock(fenced_mgr
->mutex
);
1010 /* Wait on outstanding fences */
1011 while (fenced_mgr
->num_fenced
) {
1012 pipe_mutex_unlock(fenced_mgr
->mutex
);
1013 #if defined(PIPE_OS_LINUX) || defined(PIPE_OS_BSD) || defined(PIPE_OS_SOLARIS)
1016 pipe_mutex_lock(fenced_mgr
->mutex
);
1017 while(fenced_manager_check_signalled_locked(fenced_mgr
, TRUE
))
1022 /*assert(!fenced_mgr->num_unfenced);*/
1025 pipe_mutex_unlock(fenced_mgr
->mutex
);
1026 pipe_mutex_destroy(fenced_mgr
->mutex
);
1028 if(fenced_mgr
->provider
)
1029 fenced_mgr
->provider
->destroy(fenced_mgr
->provider
);
1031 fenced_mgr
->ops
->destroy(fenced_mgr
->ops
);
1038 fenced_bufmgr_create(struct pb_manager
*provider
,
1039 struct pb_fence_ops
*ops
,
1040 pb_size max_buffer_size
,
1041 pb_size max_cpu_total_size
)
1043 struct fenced_manager
*fenced_mgr
;
1048 fenced_mgr
= CALLOC_STRUCT(fenced_manager
);
1052 fenced_mgr
->base
.destroy
= fenced_bufmgr_destroy
;
1053 fenced_mgr
->base
.create_buffer
= fenced_bufmgr_create_buffer
;
1054 fenced_mgr
->base
.flush
= fenced_bufmgr_flush
;
1056 fenced_mgr
->provider
= provider
;
1057 fenced_mgr
->ops
= ops
;
1058 fenced_mgr
->max_buffer_size
= max_buffer_size
;
1059 fenced_mgr
->max_cpu_total_size
= max_cpu_total_size
;
1061 LIST_INITHEAD(&fenced_mgr
->fenced
);
1062 fenced_mgr
->num_fenced
= 0;
1064 LIST_INITHEAD(&fenced_mgr
->unfenced
);
1065 fenced_mgr
->num_unfenced
= 0;
1067 pipe_mutex_init(fenced_mgr
->mutex
);
1069 return &fenced_mgr
->base
;