1 /*
2 * Copyright © Microsoft Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
21 * IN THE SOFTWARE.
22 */
23
24 #include "d3d12_bufmgr.h"
25 #include "d3d12_context.h"
26 #include "d3d12_format.h"
27 #include "d3d12_screen.h"
28
29 #include "pipebuffer/pb_buffer.h"
30 #include "pipebuffer/pb_bufmgr.h"
31
32 #include "util/format/u_format.h"
33 #include "util/u_memory.h"
34
35 #include <dxguids/dxguids.h>
36
37 struct d3d12_bufmgr {
38 struct pb_manager base;
39
40 struct d3d12_screen *screen;
41 };
42
43 extern const struct pb_vtbl d3d12_buffer_vtbl;
44
45 static inline struct d3d12_bufmgr *
d3d12_bufmgr(struct pb_manager * mgr)46 d3d12_bufmgr(struct pb_manager *mgr)
47 {
48 assert(mgr);
49
50 return (struct d3d12_bufmgr *)mgr;
51 }
52
53 static void
describe_direct_bo(char * buf,struct d3d12_bo * ptr)54 describe_direct_bo(char *buf, struct d3d12_bo *ptr)
55 {
56 sprintf(buf, "d3d12_bo<direct,%p,0x%x>", ptr->res, (unsigned)ptr->estimated_size);
57 }
58
59 static void
describe_suballoc_bo(char * buf,struct d3d12_bo * ptr)60 describe_suballoc_bo(char *buf, struct d3d12_bo *ptr)
61 {
62 char res[128];
63 uint64_t offset;
64 d3d12_bo *base = d3d12_bo_get_base(ptr, &offset);
65 describe_direct_bo(res, base);
66 sprintf(buf, "d3d12_bo<suballoc<%s>,0x%x,0x%x>", res,
67 (unsigned)ptr->buffer->base.size, (unsigned)offset);
68 }
69
70 void
d3d12_debug_describe_bo(char * buf,struct d3d12_bo * ptr)71 d3d12_debug_describe_bo(char *buf, struct d3d12_bo *ptr)
72 {
73 if (ptr->buffer)
74 describe_suballoc_bo(buf, ptr);
75 else
76 describe_direct_bo(buf, ptr);
77 }
78
79 struct d3d12_bo *
d3d12_bo_wrap_res(struct d3d12_screen * screen,ID3D12Resource * res,enum d3d12_residency_status residency)80 d3d12_bo_wrap_res(struct d3d12_screen *screen, ID3D12Resource *res, enum d3d12_residency_status residency)
81 {
82 struct d3d12_bo *bo;
83
84 bo = MALLOC_STRUCT(d3d12_bo);
85 if (!bo)
86 return NULL;
87 memset(bo, 0, offsetof(d3d12_bo, local_context_states));
88
89 D3D12_RESOURCE_DESC desc = GetDesc(res);
90 unsigned array_size = desc.Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D ? 1 : desc.DepthOrArraySize;
91 unsigned total_subresources = desc.MipLevels * array_size * d3d12_non_opaque_plane_count(desc.Format);
92 bool supports_simultaneous_access = d3d12_resource_supports_simultaneous_access(&desc);
93
94 pipe_reference_init(&bo->reference, 1);
95 bo->screen = screen;
96 bo->res = res;
97 bo->unique_id = p_atomic_inc_return(&screen->resource_id_generator);
98 if (!supports_simultaneous_access)
99 d3d12_resource_state_init(&bo->global_state, total_subresources, false);
100
101 bo->residency_status = residency;
102 bo->last_used_timestamp = 0;
103 desc.Flags &= ~D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
104 bo->estimated_size = GetResourceAllocationInfo(screen->dev, 0, 1, &desc).SizeInBytes;
105 if (residency == d3d12_resident) {
106 mtx_lock(&screen->submit_mutex);
107 list_add(&bo->residency_list_entry, &screen->residency_list);
108 mtx_unlock(&screen->submit_mutex);
109 }
110
111 return bo;
112 }
113
114 struct d3d12_bo *
d3d12_bo_new(struct d3d12_screen * screen,uint64_t size,const pb_desc * pb_desc)115 d3d12_bo_new(struct d3d12_screen *screen, uint64_t size, const pb_desc *pb_desc)
116 {
117 ID3D12Device *dev = screen->dev;
118 ID3D12Resource *res;
119
120 D3D12_RESOURCE_DESC res_desc;
121 res_desc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
122 res_desc.Format = DXGI_FORMAT_UNKNOWN;
123 res_desc.Alignment = 0;
124 res_desc.Width = size;
125 res_desc.Height = 1;
126 res_desc.DepthOrArraySize = 1;
127 res_desc.MipLevels = 1;
128 res_desc.SampleDesc.Count = 1;
129 res_desc.SampleDesc.Quality = 0;
130 res_desc.Flags = (screen->max_feature_level >= D3D_FEATURE_LEVEL_11_0) ? D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS : D3D12_RESOURCE_FLAG_NONE;
131 res_desc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
132
133 D3D12_HEAP_TYPE heap_type = D3D12_HEAP_TYPE_DEFAULT;
134 if (pb_desc->usage & PB_USAGE_CPU_READ)
135 heap_type = D3D12_HEAP_TYPE_READBACK;
136 else if (pb_desc->usage & PB_USAGE_CPU_WRITE)
137 heap_type = D3D12_HEAP_TYPE_UPLOAD;
138
139 D3D12_HEAP_FLAGS heap_flags = screen->support_create_not_resident ?
140 D3D12_HEAP_FLAG_CREATE_NOT_RESIDENT : D3D12_HEAP_FLAG_NONE;
141 enum d3d12_residency_status init_residency = screen->support_create_not_resident ?
142 d3d12_evicted : d3d12_resident;
143
144 D3D12_HEAP_PROPERTIES heap_pris = GetCustomHeapProperties(dev, heap_type);
145 HRESULT hres = dev->CreateCommittedResource(&heap_pris,
146 heap_flags,
147 &res_desc,
148 D3D12_RESOURCE_STATE_COMMON,
149 NULL,
150 IID_PPV_ARGS(&res));
151
152 if (FAILED(hres))
153 return NULL;
154
155 return d3d12_bo_wrap_res(screen, res, init_residency);
156 }
157
158 struct d3d12_bo *
d3d12_bo_wrap_buffer(struct d3d12_screen * screen,struct pb_buffer * buf)159 d3d12_bo_wrap_buffer(struct d3d12_screen *screen, struct pb_buffer *buf)
160 {
161 struct d3d12_bo *bo;
162
163 bo = MALLOC_STRUCT(d3d12_bo);
164 if (!bo)
165 return NULL;
166 memset(bo, 0, offsetof(d3d12_bo, local_context_states));
167
168 pipe_reference_init(&bo->reference, 1);
169 bo->screen = screen;
170 bo->buffer = buf;
171 bo->unique_id = p_atomic_inc_return(&screen->resource_id_generator);
172 bo->residency_status = d3d12_evicted;
173
174 return bo;
175 }
176
177 void
d3d12_bo_unreference(struct d3d12_bo * bo)178 d3d12_bo_unreference(struct d3d12_bo *bo)
179 {
180 if (bo == NULL)
181 return;
182
183 assert(pipe_is_referenced(&bo->reference));
184
185 if (pipe_reference_described(&bo->reference, NULL,
186 (debug_reference_descriptor)
187 d3d12_debug_describe_bo)) {
188 if (bo->buffer)
189 pb_reference(&bo->buffer, NULL);
190
191 mtx_lock(&bo->screen->submit_mutex);
192
193 if (bo->residency_status == d3d12_resident)
194 list_del(&bo->residency_list_entry);
195
196 /* MSVC's offsetof fails when the name is ambiguous between struct and function */
197 typedef struct d3d12_context d3d12_context_type;
198 list_for_each_entry(d3d12_context_type, ctx, &bo->screen->context_list, context_list_entry)
199 if (ctx->id == D3D12_CONTEXT_NO_ID)
200 util_dynarray_append(&ctx->recently_destroyed_bos, uint64_t, bo->unique_id);
201
202 mtx_unlock(&bo->screen->submit_mutex);
203
204 d3d12_resource_state_cleanup(&bo->global_state);
205 if (bo->res)
206 bo->res->Release();
207
208 uint64_t mask = bo->local_context_state_mask;
209 while (mask) {
210 int ctxid = u_bit_scan64(&mask);
211 d3d12_destroy_context_state_table_entry(&bo->local_context_states[ctxid]);
212 }
213
214 FREE(bo);
215 }
216 }
217
218 void *
d3d12_bo_map(struct d3d12_bo * bo,D3D12_RANGE * range)219 d3d12_bo_map(struct d3d12_bo *bo, D3D12_RANGE *range)
220 {
221 struct d3d12_bo *base_bo;
222 D3D12_RANGE offset_range = {0, 0};
223 uint64_t offset;
224 void *ptr;
225
226 base_bo = d3d12_bo_get_base(bo, &offset);
227
228 if (!range || range->Begin >= range->End) {
229 offset_range.Begin = offset;
230 offset_range.End = offset + d3d12_bo_get_size(bo);
231 range = &offset_range;
232 } else {
233 offset_range.Begin = range->Begin + offset;
234 offset_range.End = range->End + offset;
235 range = &offset_range;
236 }
237
238 if (FAILED(base_bo->res->Map(0, range, &ptr)))
239 return NULL;
240
241 return (uint8_t *)ptr + (range ? range->Begin : 0);
242 }
243
244 void
d3d12_bo_unmap(struct d3d12_bo * bo,D3D12_RANGE * range)245 d3d12_bo_unmap(struct d3d12_bo *bo, D3D12_RANGE *range)
246 {
247 struct d3d12_bo *base_bo;
248 D3D12_RANGE offset_range = {0, 0};
249 uint64_t offset;
250
251 base_bo = d3d12_bo_get_base(bo, &offset);
252
253 if (!range || range->Begin >= range->End) {
254 offset_range.Begin = offset;
255 offset_range.End = offset + d3d12_bo_get_size(bo);
256 range = &offset_range;
257 } else {
258 offset_range.Begin = range->Begin + offset;
259 offset_range.End = range->End + offset;
260 range = &offset_range;
261 }
262
263 base_bo->res->Unmap(0, range);
264 }
265
266 static void
d3d12_buffer_destroy(void * winsys,struct pb_buffer * pbuf)267 d3d12_buffer_destroy(void *winsys, struct pb_buffer *pbuf)
268 {
269 struct d3d12_buffer *buf = d3d12_buffer(pbuf);
270
271 if (buf->map)
272 d3d12_bo_unmap(buf->bo, &buf->range);
273 d3d12_bo_unreference(buf->bo);
274 FREE(buf);
275 }
276
277 static void *
d3d12_buffer_map(struct pb_buffer * pbuf,enum pb_usage_flags flags,void * flush_ctx)278 d3d12_buffer_map(struct pb_buffer *pbuf,
279 enum pb_usage_flags flags,
280 void *flush_ctx)
281 {
282 return d3d12_buffer(pbuf)->map;
283 }
284
285 static void
d3d12_buffer_unmap(struct pb_buffer * pbuf)286 d3d12_buffer_unmap(struct pb_buffer *pbuf)
287 {
288 }
289
290 static void
d3d12_buffer_get_base_buffer(struct pb_buffer * buf,struct pb_buffer ** base_buf,pb_size * offset)291 d3d12_buffer_get_base_buffer(struct pb_buffer *buf,
292 struct pb_buffer **base_buf,
293 pb_size *offset)
294 {
295 *base_buf = buf;
296 *offset = 0;
297 }
298
299 static enum pipe_error
d3d12_buffer_validate(struct pb_buffer * pbuf,struct pb_validate * vl,enum pb_usage_flags flags)300 d3d12_buffer_validate(struct pb_buffer *pbuf,
301 struct pb_validate *vl,
302 enum pb_usage_flags flags )
303 {
304 /* Always pinned */
305 return PIPE_OK;
306 }
307
308 static void
d3d12_buffer_fence(struct pb_buffer * pbuf,struct pipe_fence_handle * fence)309 d3d12_buffer_fence(struct pb_buffer *pbuf,
310 struct pipe_fence_handle *fence )
311 {
312 }
313
314 const struct pb_vtbl d3d12_buffer_vtbl = {
315 d3d12_buffer_destroy,
316 d3d12_buffer_map,
317 d3d12_buffer_unmap,
318 d3d12_buffer_validate,
319 d3d12_buffer_fence,
320 d3d12_buffer_get_base_buffer
321 };
322
323 static struct pb_buffer *
d3d12_bufmgr_create_buffer(struct pb_manager * pmgr,pb_size size,const struct pb_desc * pb_desc)324 d3d12_bufmgr_create_buffer(struct pb_manager *pmgr,
325 pb_size size,
326 const struct pb_desc *pb_desc)
327 {
328 struct d3d12_bufmgr *mgr = d3d12_bufmgr(pmgr);
329 struct d3d12_buffer *buf;
330
331 buf = CALLOC_STRUCT(d3d12_buffer);
332 if (!buf)
333 return NULL;
334
335 pipe_reference_init(&buf->base.base.reference, 1);
336 buf->base.base.alignment_log2 = util_logbase2(pb_desc->alignment);
337 buf->base.base.usage = pb_desc->usage;
338 buf->base.vtbl = &d3d12_buffer_vtbl;
339 buf->base.base.size = size;
340 buf->range.Begin = 0;
341 buf->range.End = size;
342
343 buf->bo = d3d12_bo_new(mgr->screen, size, pb_desc);
344 if (!buf->bo) {
345 FREE(buf);
346 return NULL;
347 }
348
349 if (pb_desc->usage & PB_USAGE_CPU_READ_WRITE) {
350 buf->map = d3d12_bo_map(buf->bo, &buf->range);
351 if (!buf->map) {
352 d3d12_bo_unreference(buf->bo);
353 FREE(buf);
354 return NULL;
355 }
356 }
357
358 return &buf->base;
359 }
360
361 static void
d3d12_bufmgr_flush(struct pb_manager * mgr)362 d3d12_bufmgr_flush(struct pb_manager *mgr)
363 {
364 /* No-op */
365 }
366
367 static void
d3d12_bufmgr_destroy(struct pb_manager * _mgr)368 d3d12_bufmgr_destroy(struct pb_manager *_mgr)
369 {
370 struct d3d12_bufmgr *mgr = d3d12_bufmgr(_mgr);
371 FREE(mgr);
372 }
373
374 static bool
d3d12_bufmgr_is_buffer_busy(struct pb_manager * _mgr,struct pb_buffer * _buf)375 d3d12_bufmgr_is_buffer_busy(struct pb_manager *_mgr, struct pb_buffer *_buf)
376 {
377 /* We're only asked this on buffers that are known not busy */
378 return false;
379 }
380
381 struct pb_manager *
d3d12_bufmgr_create(struct d3d12_screen * screen)382 d3d12_bufmgr_create(struct d3d12_screen *screen)
383 {
384 struct d3d12_bufmgr *mgr;
385
386 mgr = CALLOC_STRUCT(d3d12_bufmgr);
387 if (!mgr)
388 return NULL;
389
390 mgr->base.destroy = d3d12_bufmgr_destroy;
391 mgr->base.create_buffer = d3d12_bufmgr_create_buffer;
392 mgr->base.flush = d3d12_bufmgr_flush;
393 mgr->base.is_buffer_busy = d3d12_bufmgr_is_buffer_busy;
394
395 mgr->screen = screen;
396
397 return &mgr->base;
398 }
399