d3d12: introduce d3d12 gallium driver

This driver will allow running OpenGL and OpenCL on top of Gallium
for any hardware supporting Microsoft's Direct3D 12 on Windows 10.

This is the combination of a lot of commits from our development branch,
containing code from several authors.
Co-authored-by: Bill Kristiansen <billkris@microsoft.com>
Co-authored-by: Gert Wollny <gert.wollny@collabora.com>
Co-authored-by: Jesse Natalie <jenatali@microsoft.com>
Co-authored-by: Louis-Francis Ratté-Boulianne <lfrb@collabora.com>
Reviewed-By: Mike Blumenkrantz <michael.blumenkrantz@gmail.com>
Acked-by: Jason Ekstrand <jason@jlekstrand.net>
Part-of: <mesa/mesa!7477>

meson.build

@@ -235,6 +235,7 @@ with_gallium_virgl = gallium_drivers.contains('virgl')
 with_gallium_swr = gallium_drivers.contains('swr')
 with_gallium_lima = gallium_drivers.contains('lima')
 with_gallium_zink = gallium_drivers.contains('zink')
+with_gallium_d3d12 = gallium_drivers.contains('d3d12')
 
 with_gallium = gallium_drivers.length() != 0
 

meson_options.txt

@@ -68,7 +68,7 @@ option(
   choices : [
     'auto', 'kmsro', 'radeonsi', 'r300', 'r600', 'nouveau', 'freedreno',
     'swrast', 'v3d', 'vc4', 'etnaviv', 'tegra', 'i915', 'svga', 'virgl',
-    'swr', 'panfrost', 'iris', 'lima', 'zink'
+    'swr', 'panfrost', 'iris', 'lima', 'zink', 'd3d12'
   ],
   description : 'List of gallium drivers to build. If this is set to auto all drivers applicable to the target OS/architecture will be built'
 )

src/gallium/drivers/d3d12/d3d12_batch.cpp

+/*
+ * Copyright © Microsoft Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#include "d3d12_batch.h"
+#include "d3d12_context.h"
+#include "d3d12_fence.h"
+#include "d3d12_query.h"
+#include "d3d12_resource.h"
+#include "d3d12_screen.h"
+#include "d3d12_surface.h"
+
+#include "util/hash_table.h"
+#include "util/set.h"
+#include "util/u_inlines.h"
+
+bool
+d3d12_init_batch(struct d3d12_context *ctx, struct d3d12_batch *batch)
+{
+   struct d3d12_screen *screen = d3d12_screen(ctx->base.screen);
+
+   batch->bos = _mesa_set_create(NULL, _mesa_hash_pointer,
+                                 _mesa_key_pointer_equal);
+   batch->sampler_views = _mesa_set_create(NULL, _mesa_hash_pointer,
+                                           _mesa_key_pointer_equal);
+   batch->surfaces = _mesa_set_create(NULL, _mesa_hash_pointer,
+                                      _mesa_key_pointer_equal);
+   batch->objects = _mesa_set_create(NULL,
+                                     _mesa_hash_pointer,
+                                     _mesa_key_pointer_equal);
+
+   if (!batch->bos || !batch->sampler_views || !batch->surfaces || !batch->objects)
+      return false;
+
+   util_dynarray_init(&batch->zombie_samplers, NULL);
+
+   if (FAILED(screen->dev->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT,
+                                                  __uuidof(batch->cmdalloc),
+                                                  (void **)&batch->cmdalloc)))
+      return false;
+
+
+   batch->sampler_heap =
+      d3d12_descriptor_heap_new(screen->dev,
+                                D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER,
+                                D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE,
+                                128);
+
+   batch->view_heap =
+      d3d12_descriptor_heap_new(screen->dev,
+                                D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV,
+                                D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE,
+                                1024);
+
+   if (!batch->sampler_heap && !batch->view_heap)
+      return false;
+
+   return true;
+}
+
+static void
+delete_bo(set_entry *entry)
+{
+   struct d3d12_bo *bo = (struct d3d12_bo *)entry->key;
+   d3d12_bo_unreference(bo);
+}
+
+static void
+delete_sampler_view(set_entry *entry)
+{
+   struct pipe_sampler_view *pres = (struct pipe_sampler_view *)entry->key;
+   pipe_sampler_view_reference(&pres, NULL);
+}
+
+static void
+delete_surface(set_entry *entry)
+{
+   struct pipe_surface *surf = (struct pipe_surface *)entry->key;
+   pipe_surface_reference(&surf, NULL);
+}
+
+static void
+delete_object(set_entry *entry)
+{
+   ID3D12Object *object = (ID3D12Object *)entry->key;
+   object->Release();
+}
+
+bool
+d3d12_reset_batch(struct d3d12_context *ctx, struct d3d12_batch *batch, uint64_t timeout_ns)
+{
+   struct d3d12_screen *screen = d3d12_screen(ctx->base.screen);
+
+   // batch hasn't been submitted before
+   if (!batch->fence && !batch->has_errors)
+      return true;
+
+   if (batch->fence) {
+      if (!d3d12_fence_finish(batch->fence, timeout_ns))
+         return false;
+      d3d12_fence_reference(&batch->fence, NULL);
+   }
+
+   _mesa_set_clear(batch->bos, delete_bo);
+   _mesa_set_clear(batch->sampler_views, delete_sampler_view);
+   _mesa_set_clear(batch->surfaces, delete_surface);
+   _mesa_set_clear(batch->objects, delete_object);
+
+   util_dynarray_foreach(&batch->zombie_samplers, d3d12_descriptor_handle, handle)
+      d3d12_descriptor_handle_free(handle);
+   util_dynarray_clear(&batch->zombie_samplers);
+
+   d3d12_descriptor_heap_clear(batch->view_heap);
+   d3d12_descriptor_heap_clear(batch->sampler_heap);
+
+   if (FAILED(batch->cmdalloc->Reset())) {
+      debug_printf("D3D12: resetting ID3D12CommandAllocator failed\n");
+      return false;
+   }
+   batch->has_errors = false;
+   return true;
+}
+
+void
+d3d12_destroy_batch(struct d3d12_context *ctx, struct d3d12_batch *batch)
+{
+   d3d12_reset_batch(ctx, batch, PIPE_TIMEOUT_INFINITE);
+   batch->cmdalloc->Release();
+   d3d12_descriptor_heap_free(batch->sampler_heap);
+   d3d12_descriptor_heap_free(batch->view_heap);
+   _mesa_set_destroy(batch->bos, NULL);
+   _mesa_set_destroy(batch->sampler_views, NULL);
+   _mesa_set_destroy(batch->surfaces, NULL);
+   _mesa_set_destroy(batch->objects, NULL);
+   util_dynarray_fini(&batch->zombie_samplers);
+}
+
+void
+d3d12_start_batch(struct d3d12_context *ctx, struct d3d12_batch *batch)
+{
+   struct d3d12_screen *screen = d3d12_screen(ctx->base.screen);
+   ID3D12DescriptorHeap* heaps[2] = { d3d12_descriptor_heap_get(batch->view_heap),
+                                      d3d12_descriptor_heap_get(batch->sampler_heap) };
+
+   d3d12_reset_batch(ctx, batch, PIPE_TIMEOUT_INFINITE);
+
+   /* Create or reset global command list */
+   if (ctx->cmdlist) {
+      if (FAILED(ctx->cmdlist->Reset(batch->cmdalloc, NULL))) {
+         debug_printf("D3D12: resetting ID3D12GraphicsCommandList failed\n");
+         batch->has_errors = true;
+         return;
+      }
+   } else {
+      if (FAILED(screen->dev->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT,
+                                                batch->cmdalloc, NULL,
+                                                __uuidof(ctx->cmdlist),
+                                                (void **)&ctx->cmdlist))) {
+         debug_printf("D3D12: creating ID3D12GraphicsCommandList failed\n");
+         batch->has_errors = true;
+         return;
+      }
+   }
+
+   ctx->cmdlist->SetDescriptorHeaps(2, heaps);
+   ctx->cmdlist_dirty = ~0;
+   for (int i = 0; i < D3D12_GFX_SHADER_STAGES; ++i)
+      ctx->shader_dirty[i] = ~0;
+
+   if (!ctx->queries_disabled)
+      d3d12_resume_queries(ctx);
+}
+
+void
+d3d12_end_batch(struct d3d12_context *ctx, struct d3d12_batch *batch)
+{
+   struct d3d12_screen *screen = d3d12_screen(ctx->base.screen);
+
+   if (!ctx->queries_disabled)
+      d3d12_suspend_queries(ctx);
+
+   if (FAILED(ctx->cmdlist->Close())) {
+      debug_printf("D3D12: closing ID3D12GraphicsCommandList failed\n");
+      batch->has_errors = true;
+      return;
+   }
+
+   ID3D12CommandList* cmdlists[] = { ctx->cmdlist };
+   screen->cmdqueue->ExecuteCommandLists(1, cmdlists);
+   batch->fence = d3d12_create_fence(screen, ctx);
+}
+
+bool
+d3d12_batch_has_references(struct d3d12_batch *batch,
+                           struct d3d12_bo *bo)
+{
+   return (_mesa_set_search(batch->bos, bo) != NULL);
+}
+
+void
+d3d12_batch_reference_resource(struct d3d12_batch *batch,
+                               struct d3d12_resource *res)
+{
+   if (!d3d12_batch_has_references(batch, res->bo)) {
+      _mesa_set_add(batch->bos, res->bo);
+      d3d12_bo_reference(res->bo);
+   }
+}
+
+void
+d3d12_batch_reference_sampler_view(struct d3d12_batch *batch,
+                                   struct d3d12_sampler_view *sv)
+{
+   struct set_entry *entry = _mesa_set_search(batch->sampler_views, sv);
+   if (!entry) {
+      entry = _mesa_set_add(batch->sampler_views, sv);
+      pipe_reference(NULL, &sv->base.reference);
+   }
+}
+
+void
+d3d12_batch_reference_surface_texture(struct d3d12_batch *batch,
+                                      struct d3d12_surface *surf)
+{
+   d3d12_batch_reference_resource(batch, d3d12_resource(surf->base.texture));
+}
+
+void
+d3d12_batch_reference_object(struct d3d12_batch *batch,
+                             ID3D12Object *object)
+{
+   struct set_entry *entry = _mesa_set_search(batch->objects, object);
+   if (!entry) {
+      entry = _mesa_set_add(batch->objects, object);
+      object->AddRef();
+   }
+}

src/gallium/drivers/d3d12/d3d12_batch.h

+/*
+ * Copyright © Microsoft Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#ifndef D3D12_BATCH_H
+#define D3D12_BATCH_H
+
+#include "util/u_dynarray.h"
+#include <stdint.h>
+
+#define D3D12_IGNORE_SDK_LAYERS
+#include <d3d12.h>
+
+struct d3d12_bo;
+struct d3d12_descriptor_heap;
+struct d3d12_fence;
+
+struct d3d12_batch {
+   struct d3d12_fence *fence;
+
+   struct set *bos;
+   struct set *sampler_views;
+   struct set *surfaces;
+   struct set *objects;
+
+   struct util_dynarray zombie_samplers;
+
+   ID3D12CommandAllocator *cmdalloc;
+   struct d3d12_descriptor_heap *sampler_heap;
+   struct d3d12_descriptor_heap *view_heap;
+   bool has_errors;
+};
+
+bool
+d3d12_init_batch(struct d3d12_context *ctx, struct d3d12_batch *batch);
+
+void
+d3d12_destroy_batch(struct d3d12_context *ctx, struct d3d12_batch *batch);
+
+void
+d3d12_start_batch(struct d3d12_context *ctx, struct d3d12_batch *batch);
+
+void
+d3d12_end_batch(struct d3d12_context *ctx, struct d3d12_batch *batch);
+
+bool
+d3d12_reset_batch(struct d3d12_context *ctx, struct d3d12_batch *batch, uint64_t timeout_ns);
+
+bool
+d3d12_batch_has_references(struct d3d12_batch *batch,
+                           struct d3d12_bo *bo);
+
+void
+d3d12_batch_reference_resource(struct d3d12_batch *batch,
+                               struct d3d12_resource *res);
+
+void
+d3d12_batch_reference_sampler_view(struct d3d12_batch *batch,
+                                   struct d3d12_sampler_view *sv);
+
+void
+d3d12_batch_reference_surface_texture(struct d3d12_batch *batch,
+                              struct d3d12_surface *surf);
+
+void
+d3d12_batch_reference_object(struct d3d12_batch *batch,
+                             ID3D12Object *object);
+
+#endif

src/gallium/drivers/d3d12/d3d12_blit.h

+/*
+ * Copyright © Microsoft Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#ifndef D3D12_BLIT_H
+#define D3D12_BLIT_H
+
+struct d3d12_context;
+struct d3d12_resource;
+struct pipe_box;
+
+void
+d3d12_context_blit_init(struct pipe_context *ctx);
+
+void
+d3d12_direct_copy(struct d3d12_context *ctx,
+                  struct d3d12_resource *dst,
+                  unsigned dst_level,
+                  const struct pipe_box *pdst_box,
+                  struct d3d12_resource *src,
+                  unsigned src_level,
+                  const struct pipe_box *psrc_box, unsigned mask);
+
+#endif // D3D12_BLIT_H

src/gallium/drivers/d3d12/d3d12_bufmgr.cpp

+/*
+ * Copyright © Microsoft Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#include "d3d12_bufmgr.h"
+#include "d3d12_format.h"
+#include "d3d12_screen.h"
+
+#include "D3D12ResourceState.h"
+
+#include "pipebuffer/pb_buffer.h"
+#include "pipebuffer/pb_bufmgr.h"
+
+#include "util/format/u_format.h"
+#include "util/u_memory.h"
+
+#include <d3d12.h>
+
+struct d3d12_bufmgr {
+   struct pb_manager base;
+
+   ID3D12Device *dev;
+};
+
+extern const struct pb_vtbl d3d12_buffer_vtbl;
+
+static inline struct d3d12_bufmgr *
+d3d12_bufmgr(struct pb_manager *mgr)
+{
+   assert(mgr);
+
+   return (struct d3d12_bufmgr *)mgr;
+}
+
+static struct TransitionableResourceState *
+create_trans_state(ID3D12Resource *res, enum pipe_format format)
+{
+   D3D12_RESOURCE_DESC desc = res->GetDesc();
+
+   // Calculate the total number of subresources
+   unsigned arraySize = desc.Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D ?
+                        1 : desc.DepthOrArraySize;
+   unsigned total_subresources = desc.MipLevels *
+                                 arraySize *
+                                 d3d12_non_opaque_plane_count(desc.Format);
+   total_subresources *= util_format_has_stencil(util_format_description(format)) ?
+                         2 : 1;
+
+   return new TransitionableResourceState(res,
+                                          total_subresources,
+                                          SupportsSimultaneousAccess(desc));
+}
+
+struct d3d12_bo *
+d3d12_bo_wrap_res(ID3D12Resource *res, enum pipe_format format)
+{
+   struct d3d12_bo *bo;
+
+   bo = CALLOC_STRUCT(d3d12_bo);
+   if (!bo)
+      return NULL;
+
+   bo->refcount = 1;
+   bo->res = res;
+   bo->trans_state = create_trans_state(res, format);
+
+   return bo;
+}
+
+struct d3d12_bo *
+d3d12_bo_new(ID3D12Device *dev, uint64_t size, uint64_t alignment)
+{
+   ID3D12Resource *res;
+
+   D3D12_RESOURCE_DESC res_desc;
+   res_desc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
+   res_desc.Format = DXGI_FORMAT_UNKNOWN;
+   res_desc.Alignment = alignment;
+   res_desc.Width = size;
+   res_desc.Height = 1;
+   res_desc.DepthOrArraySize = 1;
+   res_desc.MipLevels = 1;
+   res_desc.SampleDesc.Count = 1;
+   res_desc.SampleDesc.Quality = 0;
+   res_desc.Flags = D3D12_RESOURCE_FLAG_NONE;
+   res_desc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
+
+   D3D12_HEAP_PROPERTIES heap_pris = dev->GetCustomHeapProperties(0, D3D12_HEAP_TYPE_UPLOAD);
+   HRESULT hres = dev->CreateCommittedResource(&heap_pris,
+                                               D3D12_HEAP_FLAG_NONE,
+                                               &res_desc,
+                                               D3D12_RESOURCE_STATE_COMMON,
+                                               NULL,
+                                               __uuidof(ID3D12Resource),
+                                               (void **)&res);
+
+   if (FAILED(hres))
+      return NULL;
+
+   return d3d12_bo_wrap_res(res, PIPE_FORMAT_NONE);
+}
+
+struct d3d12_bo *
+d3d12_bo_wrap_buffer(struct pb_buffer *buf)
+{
+   struct d3d12_bo *bo;
+
+   bo = CALLOC_STRUCT(d3d12_bo);
+   if (!bo)
+      return NULL;
+
+   bo->refcount = 1;
+   bo->buffer = buf;
+   bo->trans_state = NULL; /* State from base BO will be used */
+
+   return bo;
+}
+
+void
+d3d12_bo_unreference(struct d3d12_bo *bo)
+{
+   if (bo == NULL)
+      return;
+
+   assert(p_atomic_read(&bo->refcount) > 0);
+
+   if (p_atomic_dec_zero(&bo->refcount)) {
+      if (bo->buffer) {
+         pb_reference(&bo->buffer, NULL);
+      } else {
+         delete bo->trans_state;
+         bo->res->Release();
+      }
+      FREE(bo);
+   }
+}
+
+void *
+d3d12_bo_map(struct d3d12_bo *bo, D3D12_RANGE *range)
+{
+   struct d3d12_bo *base_bo;
+   D3D12_RANGE offset_range = {0, 0};
+   uint64_t offset;
+   void *ptr;
+
+   base_bo = d3d12_bo_get_base(bo, &offset);
+
+   if (!range || offset == 0) {
+      /* Nothing to do */
+   } else if (range->Begin >= range->End) {
+      offset_range.Begin = offset;
+      offset_range.End = offset + d3d12_bo_get_size(bo);
+      range = &offset_range;
+   } else {
+      offset_range.Begin = range->Begin + offset;
+      offset_range.End = range->End + offset;
+      range = &offset_range;
+   }
+
+   if (FAILED(base_bo->res->Map(0, range, &ptr)))
+      return NULL;
+
+   return (uint8_t *)ptr + (range ? range->Begin : 0);
+}
+
+void
+d3d12_bo_unmap(struct d3d12_bo *bo, D3D12_RANGE *range)
+{
+   struct d3d12_bo *base_bo;
+   D3D12_RANGE offset_range = {0, 0};
+   uint64_t offset;
+
+   base_bo = d3d12_bo_get_base(bo, &offset);
+
+   if (!range || bo == base_bo</