Debian Codegraph @

src/gallium/winsys/svga/drm/pb_buffer_simple_fenced.c

raw
1 /*
2 * Copyright (c) 2007-2024 Broadcom. All Rights Reserved.
3 * The term “Broadcom” refers to Broadcom Inc.
4 * and/or its subsidiaries.
5 * SPDX-License-Identifier: MIT
6 */
7
8 /**
9 * \file
10 * Implementation of fenced buffers.
11 *
12 * \author Jose Fonseca <jfonseca-at-vmware-dot-com>
13 * \author Thomas Hellström <thellstrom-at-vmware-dot-com>
14 */
15
16
17 #include "util/detect.h"
18
19 #if DETECT_OS_LINUX || DETECT_OS_BSD || DETECT_OS_SOLARIS
20 #include <unistd.h>
21 #include <sched.h>
22 #endif
23 #include <inttypes.h>
24
25 #include "util/compiler.h"
26 #include "pipe/p_defines.h"
27 #include "util/u_debug.h"
28 #include "util/u_thread.h"
29 #include "util/u_memory.h"
30 #include "util/list.h"
31
32 #include "pipebuffer/pb_buffer.h"
33 #include "pipebuffer/pb_bufmgr.h"
34 #include "pipebuffer/pb_buffer_fenced.h"
35 #include "vmw_screen.h"
36
37
38 /**
39 * Convenience macro (type safe).
40 */
41 #define SUPER(__derived) (&(__derived)->base)
42
43
44 struct fenced_manager
45 {
46 struct pb_manager base;
47 struct pb_manager *provider;
48 struct pb_fence_ops *ops;
49
50 /**
51 * Following members are mutable and protected by this mutex.
52 */
53 mtx_t mutex;
54
55 /**
56 * Fenced buffer list.
57 *
58 * All fenced buffers are placed in this listed, ordered from the oldest
59 * fence to the newest fence.
60 */
61 struct list_head fenced;
62 pb_size num_fenced;
63
64 struct list_head unfenced;
65 pb_size num_unfenced;
66
67 };
68
69
70 /**
71 * Fenced buffer.
72 *
73 * Wrapper around a pipe buffer which adds fencing and reference counting.
74 */
75 struct fenced_buffer
76 {
77 /*
78 * Immutable members.
79 */
80
81 struct pb_buffer base;
82 struct fenced_manager *mgr;
83
84 /*
85 * Following members are mutable and protected by fenced_manager::mutex.
86 */
87
88 struct list_head head;
89
90 /**
91 * Buffer with storage.
92 */
93 struct pb_buffer *buffer;
94 pb_size size;
95
96 /**
97 * A bitmask of PB_USAGE_CPU/GPU_READ/WRITE describing the current
98 * buffer usage.
99 */
100 unsigned flags;
101
102 unsigned mapcount;
103
104 struct pb_validate *vl;
105 unsigned validation_flags;
106
107 struct pipe_fence_handle *fence;
108 };
109
110
111 static inline struct fenced_manager *
112 fenced_manager(struct pb_manager *mgr)
113 {
114 assert(mgr);
115 return (struct fenced_manager *)mgr;
116 }
117
118
119 static inline struct fenced_buffer *
120 fenced_buffer(struct pb_buffer *buf)
121 {
122 assert(buf);
123 return (struct fenced_buffer *)buf;
124 }
125
126
127 static void
128 fenced_buffer_destroy_gpu_storage_locked(struct fenced_buffer *fenced_buf);
129
130 static enum pipe_error
131 fenced_buffer_create_gpu_storage_locked(struct fenced_manager *fenced_mgr,
132 struct fenced_buffer *fenced_buf,
133 const struct pb_desc *desc,
134 bool wait);
135 /**
136 * Dump the fenced buffer list.
137 *
138 * Useful to understand failures to allocate buffers.
139 */
140 static void
141 fenced_manager_dump_locked(struct fenced_manager *fenced_mgr)
142 {
143 #if MESA_DEBUG
144 struct pb_fence_ops *ops = fenced_mgr->ops;
145 struct list_head *curr, *next;
146 struct fenced_buffer *fenced_buf;
147
148 debug_printf("%10s %7s %8s %7s %10s %s\n",
149 "buffer", "size", "refcount", "storage", "fence", "signalled");
150
151 curr = fenced_mgr->unfenced.next;
152 next = curr->next;
153 while (curr != &fenced_mgr->unfenced) {
154 fenced_buf = list_entry(curr, struct fenced_buffer, head);
155 assert(!fenced_buf->fence);
156 debug_printf("%10p %"PRIu64" %8u %7s\n",
157 (void *) fenced_buf,
158 fenced_buf->base.base.size,
159 p_atomic_read(&fenced_buf->base.base.reference.count),
160 fenced_buf->buffer ? "gpu" : "none");
161 curr = next;
162 next = curr->next;
163 }
164
165 curr = fenced_mgr->fenced.next;
166 next = curr->next;
167 while (curr != &fenced_mgr->fenced) {
168 int signaled;
169 fenced_buf = list_entry(curr, struct fenced_buffer, head);
170 assert(fenced_buf->buffer);
171 signaled = ops->fence_signalled(ops, fenced_buf->fence, 0);
172 debug_printf("%10p %"PRIu64" %8u %7s %10p %s\n",
173 (void *) fenced_buf,
174 fenced_buf->base.base.size,
175 p_atomic_read(&fenced_buf->base.base.reference.count),
176 "gpu",
177 (void *) fenced_buf->fence,
178 signaled == 0 ? "y" : "n");
179 curr = next;
180 next = curr->next;
181 }
182 #else
183 (void)fenced_mgr;
184 #endif
185 }
186
187
188 static inline void
189 fenced_buffer_destroy_locked(struct fenced_manager *fenced_mgr,
190 struct fenced_buffer *fenced_buf)
191 {
192 assert(!pipe_is_referenced(&fenced_buf->base.base.reference));
193
194 assert(!fenced_buf->fence);
195 assert(fenced_buf->head.prev);
196 assert(fenced_buf->head.next);
197 list_del(&fenced_buf->head);
198 assert(fenced_mgr->num_unfenced);
199 --fenced_mgr->num_unfenced;
200
201 fenced_buffer_destroy_gpu_storage_locked(fenced_buf);
202
203 FREE(fenced_buf);
204 }
205
206
207 /**
208 * Add the buffer to the fenced list.
209 *
210 * Reference count should be incremented before calling this function.
211 */
212 static inline void
213 fenced_buffer_add_locked(struct fenced_manager *fenced_mgr,
214 struct fenced_buffer *fenced_buf)
215 {
216 assert(pipe_is_referenced(&fenced_buf->base.base.reference));
217 assert(fenced_buf->flags & PB_USAGE_GPU_READ_WRITE);
218 assert(fenced_buf->fence);
219
220 p_atomic_inc(&fenced_buf->base.base.reference.count);
221
222 list_del(&fenced_buf->head);
223 assert(fenced_mgr->num_unfenced);
224 --fenced_mgr->num_unfenced;
225 list_addtail(&fenced_buf->head, &fenced_mgr->fenced);
226 ++fenced_mgr->num_fenced;
227 }
228
229
230 /**
231 * Remove the buffer from the fenced list, and potentially destroy the buffer
232 * if the reference count reaches zero.
233 *
234 * Returns TRUE if the buffer was detroyed.
235 */
236 static inline bool
237 fenced_buffer_remove_locked(struct fenced_manager *fenced_mgr,
238 struct fenced_buffer *fenced_buf)
239 {
240 struct pb_fence_ops *ops = fenced_mgr->ops;
241
242 assert(fenced_buf->fence);
243 assert(fenced_buf->mgr == fenced_mgr);
244
245 ops->fence_reference(ops, &fenced_buf->fence, NULL);
246 fenced_buf->flags &= ~PB_USAGE_GPU_READ_WRITE;
247
248 assert(fenced_buf->head.prev);
249 assert(fenced_buf->head.next);
250
251 list_del(&fenced_buf->head);
252 assert(fenced_mgr->num_fenced);
253 --fenced_mgr->num_fenced;
254
255 list_addtail(&fenced_buf->head, &fenced_mgr->unfenced);
256 ++fenced_mgr->num_unfenced;
257
258 if (p_atomic_dec_zero(&fenced_buf->base.base.reference.count)) {
259 fenced_buffer_destroy_locked(fenced_mgr, fenced_buf);
260 return true;
261 }
262
263 return false;
264 }
265
266
267 /**
268 * Wait for the fence to expire, and remove it from the fenced list.
269 *
270 * This function will release and re-acquire the mutex, so any copy of mutable
271 * state must be discarded after calling it.
272 */
273 static inline enum pipe_error
274 fenced_buffer_finish_locked(struct fenced_manager *fenced_mgr,
275 struct fenced_buffer *fenced_buf)
276 {
277 struct pb_fence_ops *ops = fenced_mgr->ops;
278 enum pipe_error ret = PIPE_ERROR;
279
280 #if 0
281 debug_warning("waiting for GPU");
282 #endif
283
284 assert(pipe_is_referenced(&fenced_buf->base.base.reference));
285 assert(fenced_buf->fence);
286
287 if (fenced_buf->fence) {
288 struct pipe_fence_handle *fence = NULL;
289 int finished;
290 bool proceed;
291
292 ops->fence_reference(ops, &fence, fenced_buf->fence);
293
294 mtx_unlock(&fenced_mgr->mutex);
295
296 finished = ops->fence_finish(ops, fenced_buf->fence, 0);
297
298 mtx_lock(&fenced_mgr->mutex);
299
300 assert(pipe_is_referenced(&fenced_buf->base.base.reference));
301
302 /*
303 * Only proceed if the fence object didn't change in the meanwhile.
304 * Otherwise assume the work has been already carried out by another
305 * thread that re-acquired the lock before us.
306 */
307 proceed = fence == fenced_buf->fence ? true : false;
308
309 ops->fence_reference(ops, &fence, NULL);
310
311 if (proceed && finished == 0) {
312 /*
313 * Remove from the fenced list
314 */
315
316 bool destroyed;
317
318 destroyed = fenced_buffer_remove_locked(fenced_mgr, fenced_buf);
319
320 /* TODO: remove consequents buffers with the same fence? */
321
322 assert(!destroyed);
323 (void) destroyed;
324
325 fenced_buf->flags &= ~PB_USAGE_GPU_READ_WRITE;
326
327 ret = PIPE_OK;
328 }
329 }
330
331 return ret;
332 }
333
334
335 /**
336 * Remove as many fenced buffers from the fenced list as possible.
337 *
338 * Returns TRUE if at least one buffer was removed.
339 */
340 static bool
341 fenced_manager_check_signalled_locked(struct fenced_manager *fenced_mgr,
342 bool wait)
343 {
344 struct pb_fence_ops *ops = fenced_mgr->ops;
345 struct list_head *curr, *next;
346 struct fenced_buffer *fenced_buf;
347 struct pipe_fence_handle *prev_fence = NULL;
348 bool ret = false;
349
350 curr = fenced_mgr->fenced.next;
351 next = curr->next;
352 while (curr != &fenced_mgr->fenced) {
353 fenced_buf = list_entry(curr, struct fenced_buffer, head);
354
355 if (fenced_buf->fence != prev_fence) {
356 int signaled;
357
358 if (wait) {
359 signaled = ops->fence_finish(ops, fenced_buf->fence, 0);
360
361 /*
362 * Don't return just now. Instead preemptively check if the
363 * following buffers' fences already expired,
364 * without further waits.
365 */
366 wait = false;
367 } else {
368 signaled = ops->fence_signalled(ops, fenced_buf->fence, 0);
369 }
370
371 if (signaled != 0) {
372 return ret;
373 }
374
375 prev_fence = fenced_buf->fence;
376 } else {
377 /* This buffer's fence object is identical to the previous buffer's
378 * fence object, so no need to check the fence again.
379 */
380 assert(ops->fence_signalled(ops, fenced_buf->fence, 0) == 0);
381 }
382
383 fenced_buffer_remove_locked(fenced_mgr, fenced_buf);
384
385 ret = true;
386
387 curr = next;
388 next = curr->next;
389 }
390
391 return ret;
392 }
393
394
395 /**
396 * Destroy the GPU storage.
397 */
398 static void
399 fenced_buffer_destroy_gpu_storage_locked(struct fenced_buffer *fenced_buf)
400 {
401 if (fenced_buf->buffer) {
402 pb_reference(&fenced_buf->buffer, NULL);
403 }
404 }
405
406
407 /**
408 * Try to create GPU storage for this buffer.
409 *
410 * This function is a shorthand around pb_manager::create_buffer for
411 * fenced_buffer_create_gpu_storage_locked()'s benefit.
412 */
413 static inline bool
414 fenced_buffer_try_create_gpu_storage_locked(struct fenced_manager *fenced_mgr,
415 struct fenced_buffer *fenced_buf,
416 const struct pb_desc *desc)
417 {
418 struct pb_manager *provider = fenced_mgr->provider;
419
420 assert(!fenced_buf->buffer);
421
422 fenced_buf->buffer = provider->create_buffer(fenced_mgr->provider,
423 fenced_buf->size, desc);
424 return fenced_buf->buffer ? true : false;
425 }
426
427
428 /**
429 * Create GPU storage for this buffer.
430 */
431 static enum pipe_error
432 fenced_buffer_create_gpu_storage_locked(struct fenced_manager *fenced_mgr,
433 struct fenced_buffer *fenced_buf,
434 const struct pb_desc *desc,
435 bool wait)
436 {
437 assert(!fenced_buf->buffer);
438
439 /*
440 * Check for signaled buffers before trying to allocate.
441 */
442 fenced_manager_check_signalled_locked(fenced_mgr, false);
443
444 fenced_buffer_try_create_gpu_storage_locked(fenced_mgr, fenced_buf, desc);
445
446 /*
447 * Keep trying while there is some sort of progress:
448 * - fences are expiring,
449 * - or buffers are being being swapped out from GPU memory into CPU memory.
450 */
451 while (!fenced_buf->buffer &&
452 (fenced_manager_check_signalled_locked(fenced_mgr, false))) {
453 fenced_buffer_try_create_gpu_storage_locked(fenced_mgr, fenced_buf,
454 desc);
455 }
456
457 if (!fenced_buf->buffer && wait) {
458 /*
459 * Same as before, but this time around, wait to free buffers if
460 * necessary.
461 */
462 while (!fenced_buf->buffer &&
463 (fenced_manager_check_signalled_locked(fenced_mgr, true))) {
464 fenced_buffer_try_create_gpu_storage_locked(fenced_mgr, fenced_buf,
465 desc);
466 }
467 }
468
469 if (!fenced_buf->buffer) {
470 if (0)
471 fenced_manager_dump_locked(fenced_mgr);
472
473 /* give up */
474 return PIPE_ERROR_OUT_OF_MEMORY;
475 }
476
477 return PIPE_OK;
478 }
479
480
481 static void
482 fenced_buffer_destroy(void *winsys, struct pb_buffer *buf)
483 {
484 struct fenced_buffer *fenced_buf = fenced_buffer(buf);
485 struct fenced_manager *fenced_mgr = fenced_buf->mgr;
486
487 assert(!pipe_is_referenced(&fenced_buf->base.base.reference));
488
489 mtx_lock(&fenced_mgr->mutex);
490
491 fenced_buffer_destroy_locked(fenced_mgr, fenced_buf);
492
493 mtx_unlock(&fenced_mgr->mutex);
494 }
495
496
497 static void *
498 fenced_buffer_map(struct pb_buffer *buf,
499 unsigned flags, void *flush_ctx)
500 {
501 struct fenced_buffer *fenced_buf = fenced_buffer(buf);
502 struct fenced_manager *fenced_mgr = fenced_buf->mgr;
503 struct pb_fence_ops *ops = fenced_mgr->ops;
504 void *map = NULL;
505
506 mtx_lock(&fenced_mgr->mutex);
507
508 assert(!(flags & PB_USAGE_GPU_READ_WRITE));
509
510 /*
511 * Serialize writes.
512 */
513 while ((fenced_buf->flags & PB_USAGE_GPU_WRITE) ||
514 ((fenced_buf->flags & PB_USAGE_GPU_READ) &&
515 (flags & PB_USAGE_CPU_WRITE))) {
516
517 /*
518 * Don't wait for the GPU to finish accessing it,
519 * if blocking is forbidden.
520 */
521 if ((flags & PB_USAGE_DONTBLOCK) &&
522 ops->fence_signalled(ops, fenced_buf->fence, 0) != 0) {
523 goto done;
524 }
525
526 if (flags & PB_USAGE_UNSYNCHRONIZED) {
527 break;
528 }
529
530 /*
531 * Wait for the GPU to finish accessing. This will release and re-acquire
532 * the mutex, so all copies of mutable state must be discarded.
533 */
534 fenced_buffer_finish_locked(fenced_mgr, fenced_buf);
535 }
536
537 map = pb_map(fenced_buf->buffer, flags, flush_ctx);
538
539 if (map) {
540 ++fenced_buf->mapcount;
541 fenced_buf->flags |= flags & PB_USAGE_CPU_READ_WRITE;
542 }
543
544 done:
545 mtx_unlock(&fenced_mgr->mutex);
546
547 return map;
548 }
549
550
551 static void
552 fenced_buffer_unmap(struct pb_buffer *buf)
553 {
554 struct fenced_buffer *fenced_buf = fenced_buffer(buf);
555 struct fenced_manager *fenced_mgr = fenced_buf->mgr;
556
557 mtx_lock(&fenced_mgr->mutex);
558
559 assert(fenced_buf->mapcount);
560 if (fenced_buf->mapcount) {
561 if (fenced_buf->buffer)
562 pb_unmap(fenced_buf->buffer);
563 --fenced_buf->mapcount;
564 if (!fenced_buf->mapcount)
565 fenced_buf->flags &= ~PB_USAGE_CPU_READ_WRITE;
566 }
567
568 mtx_unlock(&fenced_mgr->mutex);
569 }
570
571
572 static enum pipe_error
573 fenced_buffer_validate(struct pb_buffer *buf,
574 struct pb_validate *vl,
575 unsigned flags)
576 {
577 struct fenced_buffer *fenced_buf = fenced_buffer(buf);
578 struct fenced_manager *fenced_mgr = fenced_buf->mgr;
579 enum pipe_error ret;
580
581 mtx_lock(&fenced_mgr->mutex);
582
583 if (!vl) {
584 /* invalidate */
585 fenced_buf->vl = NULL;
586 fenced_buf->validation_flags = 0;
587 ret = PIPE_OK;
588 goto done;
589 }
590
591 assert(flags & PB_USAGE_GPU_READ_WRITE);
592 assert(!(flags & ~PB_USAGE_GPU_READ_WRITE));
593 flags &= PB_USAGE_GPU_READ_WRITE;
594
595 /* Buffer cannot be validated in two different lists */
596 if (fenced_buf->vl && fenced_buf->vl != vl) {
597 ret = PIPE_ERROR_RETRY;
598 goto done;
599 }
600
601 if (fenced_buf->vl == vl &&
602 (fenced_buf->validation_flags & flags) == flags) {
603 /* Nothing to do -- buffer already validated */
604 ret = PIPE_OK;
605 goto done;
606 }
607
608 ret = pb_validate(fenced_buf->buffer, vl, flags);
609 if (ret != PIPE_OK)
610 goto done;
611
612 fenced_buf->vl = vl;
613 fenced_buf->validation_flags |= flags;
614
615 done:
616 mtx_unlock(&fenced_mgr->mutex);
617
618 return ret;
619 }
620
621
622 static void
623 fenced_buffer_fence(struct pb_buffer *buf,
624 struct pipe_fence_handle *fence)
625 {
626 struct fenced_buffer *fenced_buf = fenced_buffer(buf);
627 struct fenced_manager *fenced_mgr = fenced_buf->mgr;
628 struct pb_fence_ops *ops = fenced_mgr->ops;
629
630 mtx_lock(&fenced_mgr->mutex);
631
632 assert(pipe_is_referenced(&fenced_buf->base.base.reference));
633 assert(fenced_buf->buffer);
634
635 if (fence != fenced_buf->fence) {
636 assert(fenced_buf->vl);
637 assert(fenced_buf->validation_flags);
638
639 if (fenced_buf->fence) {
640 bool destroyed;
641 destroyed = fenced_buffer_remove_locked(fenced_mgr, fenced_buf);
642 assert(!destroyed);
643 (void) destroyed;
644 }
645 if (fence) {
646 ops->fence_reference(ops, &fenced_buf->fence, fence);
647 fenced_buf->flags |= fenced_buf->validation_flags;
648 fenced_buffer_add_locked(fenced_mgr, fenced_buf);
649 }
650
651 pb_fence(fenced_buf->buffer, fence);
652
653 fenced_buf->vl = NULL;
654 fenced_buf->validation_flags = 0;
655 }
656
657 mtx_unlock(&fenced_mgr->mutex);
658 }
659
660
661 static void
662 fenced_buffer_get_base_buffer(struct pb_buffer *buf,
663 struct pb_buffer **base_buf,
664 pb_size *offset)
665 {
666 struct fenced_buffer *fenced_buf = fenced_buffer(buf);
667 struct fenced_manager *fenced_mgr = fenced_buf->mgr;
668
669 mtx_lock(&fenced_mgr->mutex);
670
671 assert(fenced_buf->buffer);
672
673 if (fenced_buf->buffer) {
674 pb_get_base_buffer(fenced_buf->buffer, base_buf, offset);
675 } else {
676 *base_buf = buf;
677 *offset = 0;
678 }
679
680 mtx_unlock(&fenced_mgr->mutex);
681 }
682
683
684 static const struct pb_vtbl
685 fenced_buffer_vtbl = {
686 fenced_buffer_destroy,
687 fenced_buffer_map,
688 fenced_buffer_unmap,
689 fenced_buffer_validate,
690 fenced_buffer_fence,
691 fenced_buffer_get_base_buffer
692 };
693
694
695 /**
696 * Wrap a buffer in a fenced buffer.
697 */
698 static struct pb_buffer *
699 fenced_bufmgr_create_buffer(struct pb_manager *mgr,
700 pb_size size,
701 const struct pb_desc *desc)
702 {
703 struct fenced_manager *fenced_mgr = fenced_manager(mgr);
704 struct fenced_buffer *fenced_buf;
705 enum pipe_error ret;
706
707 fenced_buf = CALLOC_STRUCT(fenced_buffer);
708 if (!fenced_buf)
709 goto no_buffer;
710
711 pipe_reference_init(&fenced_buf->base.base.reference, 1);
712 fenced_buf->base.base.alignment_log2 = util_logbase2(desc->alignment);
713 fenced_buf->base.base.usage = desc->usage;
714 fenced_buf->base.base.size = size;
715 fenced_buf->size = size;
716
717 fenced_buf->base.vtbl = &fenced_buffer_vtbl;
718 fenced_buf->mgr = fenced_mgr;
719
720 mtx_lock(&fenced_mgr->mutex);
721
722 /*
723 * Try to create GPU storage without stalling,
724 */
725 ret = fenced_buffer_create_gpu_storage_locked(fenced_mgr, fenced_buf,
726 desc, true);
727
728 /*
729 * Give up.
730 */
731 if (ret != PIPE_OK) {
732 goto no_storage;
733 }
734
735 assert(fenced_buf->buffer);
736
737 list_addtail(&fenced_buf->head, &fenced_mgr->unfenced);
738 ++fenced_mgr->num_unfenced;
739 mtx_unlock(&fenced_mgr->mutex);
740
741 return &fenced_buf->base;
742
743 no_storage:
744 mtx_unlock(&fenced_mgr->mutex);
745 FREE(fenced_buf);
746 no_buffer:
747 return NULL;
748 }
749
750
751 static void
752 fenced_bufmgr_flush(struct pb_manager *mgr)
753 {
754 struct fenced_manager *fenced_mgr = fenced_manager(mgr);
755
756 mtx_lock(&fenced_mgr->mutex);
757 while (fenced_manager_check_signalled_locked(fenced_mgr, true))
758 ;
759 mtx_unlock(&fenced_mgr->mutex);
760
761 assert(fenced_mgr->provider->flush);
762 if (fenced_mgr->provider->flush)
763 fenced_mgr->provider->flush(fenced_mgr->provider);
764 }
765
766
767 static void
768 fenced_bufmgr_destroy(struct pb_manager *mgr)
769 {
770 struct fenced_manager *fenced_mgr = fenced_manager(mgr);
771
772 mtx_lock(&fenced_mgr->mutex);
773
774 /* Wait on outstanding fences */
775 while (fenced_mgr->num_fenced) {
776 mtx_unlock(&fenced_mgr->mutex);
777 #if DETECT_OS_LINUX || DETECT_OS_BSD || DETECT_OS_SOLARIS
778 sched_yield();
779 #endif
780 mtx_lock(&fenced_mgr->mutex);
781 while (fenced_manager_check_signalled_locked(fenced_mgr, true))
782 ;
783 }
784
785 #if MESA_DEBUG
786 /*assert(!fenced_mgr->num_unfenced);*/
787 #endif
788
789 mtx_unlock(&fenced_mgr->mutex);
790 mtx_destroy(&fenced_mgr->mutex);
791
792 FREE(fenced_mgr);
793 }
794
795
796 struct pb_manager *
797 simple_fenced_bufmgr_create(struct pb_manager *provider,
798 struct pb_fence_ops *ops)
799 {
800 struct fenced_manager *fenced_mgr;
801
802 if (!provider)
803 return NULL;
804
805 fenced_mgr = CALLOC_STRUCT(fenced_manager);
806 if (!fenced_mgr)
807 return NULL;
808
809 fenced_mgr->base.destroy = fenced_bufmgr_destroy;
810 fenced_mgr->base.create_buffer = fenced_bufmgr_create_buffer;
811 fenced_mgr->base.flush = fenced_bufmgr_flush;
812
813 fenced_mgr->provider = provider;
814 fenced_mgr->ops = ops;
815
816 list_inithead(&fenced_mgr->fenced);
817 fenced_mgr->num_fenced = 0;
818
819 list_inithead(&fenced_mgr->unfenced);
820 fenced_mgr->num_unfenced = 0;
821
822 (void) mtx_init(&fenced_mgr->mutex, mtx_plain);
823
824 return &fenced_mgr->base;
825 }