1 /*
2 * Copyright © 2022 Google LLC
3 * SPDX-License-Identifier: MIT
4 */
5
6 /**
7 * Suballocator for space within BOs.
8 *
9 * BOs are allocated at PAGE_SIZE (typically 4k) granularity, so small
10 * allocations are a waste to have in their own BO. Moreover, on DRM we track a
11 * list of all BOs currently allocated and submit the whole list for validation
12 * (busy tracking and implicit sync) on every submit, and that validation is a
13 * non-trivial cost. So, being able to pack multiple allocations into a BO can
14 * be a significant performance win.
15 *
16 * The allocator tracks a current BO it is linearly allocating from, and up to
17 * one extra BO returned to the pool when all of its previous suballocations
18 * have been freed. This means that fragmentation can be an issue for
19 * default_size > PAGE_SIZE and small allocations. Also, excessive BO
20 * reallocation may happen for workloads where default size < working set size.
21 */
22
23 #include "tu_suballoc.h"
24
25 /* Initializes a BO sub-allocator using refcounts on BOs.
26 */
27 void
tu_bo_suballocator_init(struct tu_suballocator * suballoc,struct tu_device * dev,uint32_t default_size,uint32_t flags)28 tu_bo_suballocator_init(struct tu_suballocator *suballoc,
29 struct tu_device *dev,
30 uint32_t default_size, uint32_t flags)
31 {
32 suballoc->dev = dev;
33 suballoc->default_size = default_size;
34 suballoc->flags = flags;
35 suballoc->bo = NULL;
36 suballoc->cached_bo = NULL;
37 }
38
39 void
tu_bo_suballocator_finish(struct tu_suballocator * suballoc)40 tu_bo_suballocator_finish(struct tu_suballocator *suballoc)
41 {
42 if (suballoc->bo)
43 tu_bo_finish(suballoc->dev, suballoc->bo);
44 if (suballoc->cached_bo)
45 tu_bo_finish(suballoc->dev, suballoc->cached_bo);
46 }
47
48 VkResult
tu_suballoc_bo_alloc(struct tu_suballoc_bo * suballoc_bo,struct tu_suballocator * suballoc,uint32_t size,uint32_t align)49 tu_suballoc_bo_alloc(struct tu_suballoc_bo *suballoc_bo,
50 struct tu_suballocator *suballoc,
51 uint32_t size, uint32_t align)
52 {
53 struct tu_bo *bo = suballoc->bo;
54 if (bo) {
55 uint32_t offset = ALIGN(suballoc->next_offset, align);
56 if (offset + size <= bo->size) {
57 suballoc_bo->bo = tu_bo_get_ref(bo);
58 suballoc_bo->iova = bo->iova + offset;
59 suballoc_bo->size = size;
60
61 suballoc->next_offset = offset + size;
62 return VK_SUCCESS;
63 } else {
64 tu_bo_finish(suballoc->dev, bo);
65 suballoc->bo = NULL;
66 }
67 }
68
69 uint32_t alloc_size = MAX2(size, suballoc->default_size);
70
71 /* Reuse a recycled suballoc BO if we have one and it's big enough, otherwise free it. */
72 if (suballoc->cached_bo) {
73 if (alloc_size <= suballoc->cached_bo->size)
74 suballoc->bo = suballoc->cached_bo;
75 else
76 tu_bo_finish(suballoc->dev, suballoc->cached_bo);
77 suballoc->cached_bo = NULL;
78 }
79
80 /* Allocate the new BO if we didn't have one cached. */
81 if (!suballoc->bo) {
82 VkResult result = tu_bo_init_new(suballoc->dev, &suballoc->bo,
83 alloc_size,
84 suballoc->flags);
85 if (result != VK_SUCCESS)
86 return result;
87 }
88
89 VkResult result = tu_bo_map(suballoc->dev, suballoc->bo);
90 if (result != VK_SUCCESS) {
91 tu_bo_finish(suballoc->dev, suballoc->bo);
92 return VK_ERROR_OUT_OF_HOST_MEMORY;
93 }
94
95 suballoc_bo->bo = tu_bo_get_ref(suballoc->bo);
96 suballoc_bo->iova = suballoc_bo->bo->iova;
97 suballoc_bo->size = size;
98 suballoc->next_offset = size;
99
100 return VK_SUCCESS;
101 }
102
103 void
tu_suballoc_bo_free(struct tu_suballocator * suballoc,struct tu_suballoc_bo * bo)104 tu_suballoc_bo_free(struct tu_suballocator *suballoc, struct tu_suballoc_bo *bo)
105 {
106 if (!bo->bo)
107 return;
108
109 /* If we we held the last reference to this BO, so just move it to the
110 * suballocator for the next time we need to allocate.
111 */
112 if (p_atomic_read(&bo->bo->refcnt) == 1 && !suballoc->cached_bo) {
113 suballoc->cached_bo = bo->bo;
114 return;
115 }
116
117 /* Otherwise, drop the refcount on it normally. */
118 tu_bo_finish(suballoc->dev, bo->bo);
119 }
120
121 void *
tu_suballoc_bo_map(struct tu_suballoc_bo * bo)122 tu_suballoc_bo_map(struct tu_suballoc_bo *bo)
123 {
124 return bo->bo->map + (bo->iova - bo->bo->iova);
125 }
126