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 <wrl/client.h>
25 using Microsoft::WRL::ComPtr;
26
27 #include "d3d12_root_signature.h"
28 #include "d3d12_compiler.h"
29 #include "d3d12_screen.h"
30
31 #include "util/u_memory.h"
32
33 #include <dxguids/dxguids.h>
34
35 struct d3d12_root_signature {
36 struct d3d12_root_signature_key key;
37 ID3D12RootSignature *sig;
38 };
39
40 static D3D12_SHADER_VISIBILITY
get_shader_visibility(enum pipe_shader_type stage)41 get_shader_visibility(enum pipe_shader_type stage)
42 {
43 switch (stage) {
44 case PIPE_SHADER_VERTEX:
45 return D3D12_SHADER_VISIBILITY_VERTEX;
46 case PIPE_SHADER_FRAGMENT:
47 return D3D12_SHADER_VISIBILITY_PIXEL;
48 case PIPE_SHADER_GEOMETRY:
49 return D3D12_SHADER_VISIBILITY_GEOMETRY;
50 case PIPE_SHADER_TESS_CTRL:
51 return D3D12_SHADER_VISIBILITY_HULL;
52 case PIPE_SHADER_TESS_EVAL:
53 return D3D12_SHADER_VISIBILITY_DOMAIN;
54 case PIPE_SHADER_COMPUTE:
55 return D3D12_SHADER_VISIBILITY_ALL;
56 default:
57 unreachable("unknown shader stage");
58 }
59 }
60
61 static inline void
init_constant_root_param(D3D12_ROOT_PARAMETER1 * param,unsigned reg,unsigned size,D3D12_SHADER_VISIBILITY visibility)62 init_constant_root_param(D3D12_ROOT_PARAMETER1 *param,
63 unsigned reg,
64 unsigned size,
65 D3D12_SHADER_VISIBILITY visibility)
66 {
67 param->ParameterType = D3D12_ROOT_PARAMETER_TYPE_32BIT_CONSTANTS;
68 param->ShaderVisibility = visibility;
69 param->Constants.RegisterSpace = 0;
70 param->Constants.ShaderRegister = reg;
71 param->Constants.Num32BitValues = size;
72 }
73
74 static inline void
init_range(D3D12_DESCRIPTOR_RANGE1 * range,D3D12_DESCRIPTOR_RANGE_TYPE type,uint32_t num_descs,uint32_t base_shader_register,uint32_t register_space,uint32_t offset_from_start)75 init_range(D3D12_DESCRIPTOR_RANGE1 *range,
76 D3D12_DESCRIPTOR_RANGE_TYPE type,
77 uint32_t num_descs,
78 uint32_t base_shader_register,
79 uint32_t register_space,
80 uint32_t offset_from_start)
81 {
82 range->RangeType = type;
83 range->NumDescriptors = num_descs;
84 range->BaseShaderRegister = base_shader_register;
85 range->RegisterSpace = register_space;
86 #ifdef _GAMING_XBOX
87 range->Flags = D3D12_DESCRIPTOR_RANGE_FLAG_NONE;
88 #else
89 if (type == D3D12_DESCRIPTOR_RANGE_TYPE_SAMPLER ||
90 type == D3D12_DESCRIPTOR_RANGE_TYPE_UAV)
91 range->Flags = D3D12_DESCRIPTOR_RANGE_FLAG_NONE;
92 else
93 range->Flags = D3D12_DESCRIPTOR_RANGE_FLAG_DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS;
94 #endif
95 range->OffsetInDescriptorsFromTableStart = offset_from_start;
96 }
97
98 static inline void
init_range_root_param(D3D12_ROOT_PARAMETER1 * param,D3D12_DESCRIPTOR_RANGE1 * range,D3D12_DESCRIPTOR_RANGE_TYPE type,uint32_t num_descs,D3D12_SHADER_VISIBILITY visibility,uint32_t base_shader_register,uint32_t register_space)99 init_range_root_param(D3D12_ROOT_PARAMETER1 *param,
100 D3D12_DESCRIPTOR_RANGE1 *range,
101 D3D12_DESCRIPTOR_RANGE_TYPE type,
102 uint32_t num_descs,
103 D3D12_SHADER_VISIBILITY visibility,
104 uint32_t base_shader_register,
105 uint32_t register_space)
106 {
107 init_range(range, type, num_descs, base_shader_register, register_space, D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND);
108 param->ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE;
109 param->DescriptorTable.NumDescriptorRanges = 1;
110 param->DescriptorTable.pDescriptorRanges = range;
111 param->ShaderVisibility = visibility;
112 }
113
114 static ID3D12RootSignature *
create_root_signature(struct d3d12_context * ctx,struct d3d12_root_signature_key * key)115 create_root_signature(struct d3d12_context *ctx, struct d3d12_root_signature_key *key)
116 {
117 struct d3d12_screen *screen = d3d12_screen(ctx->base.screen);
118 D3D12_ROOT_PARAMETER1 root_params[D3D12_GFX_SHADER_STAGES * D3D12_NUM_BINDING_TYPES];
119 D3D12_DESCRIPTOR_RANGE1 desc_ranges[D3D12_GFX_SHADER_STAGES * (D3D12_NUM_BINDING_TYPES + 1)];
120 unsigned num_params = 0;
121 unsigned num_ranges = 0;
122
123 unsigned count = key->compute ? 1 : D3D12_GFX_SHADER_STAGES;
124 for (unsigned i = 0; i < count; ++i) {
125 unsigned stage = key->compute ? PIPE_SHADER_COMPUTE : i;
126 D3D12_SHADER_VISIBILITY visibility = get_shader_visibility((enum pipe_shader_type)stage);
127
128 if (key->stages[i].end_cb_bindings - key->stages[i].begin_cb_bindings > 0) {
129 init_range_root_param(&root_params[num_params++],
130 &desc_ranges[num_ranges++],
131 D3D12_DESCRIPTOR_RANGE_TYPE_CBV,
132 key->stages[i].end_cb_bindings - key->stages[i].begin_cb_bindings,
133 visibility,
134 key->stages[i].begin_cb_bindings,
135 0);
136 }
137
138 if (key->stages[i].end_srv_binding > 0) {
139 init_range_root_param(&root_params[num_params++],
140 &desc_ranges[num_ranges++],
141 D3D12_DESCRIPTOR_RANGE_TYPE_SRV,
142 key->stages[i].end_srv_binding - key->stages[i].begin_srv_binding,
143 visibility,
144 key->stages[i].begin_srv_binding,
145 0);
146
147 init_range_root_param(&root_params[num_params++],
148 &desc_ranges[num_ranges++],
149 D3D12_DESCRIPTOR_RANGE_TYPE_SAMPLER,
150 key->stages[i].end_srv_binding - key->stages[i].begin_srv_binding,
151 visibility,
152 key->stages[i].begin_srv_binding,
153 0);
154 }
155
156 if (key->stages[i].num_ssbos > 0) {
157 init_range_root_param(&root_params[num_params],
158 &desc_ranges[num_ranges++],
159 D3D12_DESCRIPTOR_RANGE_TYPE_UAV,
160 key->stages[i].num_ssbos,
161 visibility,
162 0,
163 0);
164
165 /* To work around a WARP bug, bind these descriptors a second time in descriptor
166 * space 2. Space 0 will be used for static indexing, while space 2 will be used
167 * for dynamic indexing. Space 0 will be individual SSBOs in the DXIL shader, while
168 * space 2 will be a single array.
169 */
170 root_params[num_params++].DescriptorTable.NumDescriptorRanges++;
171 init_range(&desc_ranges[num_ranges++],
172 D3D12_DESCRIPTOR_RANGE_TYPE_UAV,
173 key->stages[i].num_ssbos,
174 0,
175 2,
176 0);
177 }
178
179 if (key->stages[i].num_images > 0) {
180 init_range_root_param(&root_params[num_params++],
181 &desc_ranges[num_ranges++],
182 D3D12_DESCRIPTOR_RANGE_TYPE_UAV,
183 key->stages[i].num_images,
184 visibility,
185 0,
186 1);
187 }
188
189 if (key->stages[i].state_vars_size > 0) {
190 init_constant_root_param(&root_params[num_params++],
191 key->stages[i].end_cb_bindings,
192 key->stages[i].state_vars_size,
193 visibility);
194 }
195 assert(num_params < PIPE_SHADER_TYPES * D3D12_NUM_BINDING_TYPES);
196 assert(num_ranges < PIPE_SHADER_TYPES * (D3D12_NUM_BINDING_TYPES + 1));
197 }
198
199 D3D12_VERSIONED_ROOT_SIGNATURE_DESC root_sig_desc;
200 root_sig_desc.Version = D3D_ROOT_SIGNATURE_VERSION_1_1;
201 root_sig_desc.Desc_1_1.NumParameters = num_params;
202 root_sig_desc.Desc_1_1.pParameters = (num_params > 0) ? root_params : NULL;
203 root_sig_desc.Desc_1_1.NumStaticSamplers = 0;
204 root_sig_desc.Desc_1_1.pStaticSamplers = NULL;
205 root_sig_desc.Desc_1_1.Flags = D3D12_ROOT_SIGNATURE_FLAG_NONE;
206
207 /* TODO Only enable this flag when needed (optimization) */
208 if (!key->compute)
209 root_sig_desc.Desc_1_1.Flags |= D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT;
210
211 if (key->has_stream_output)
212 root_sig_desc.Desc_1_1.Flags |= D3D12_ROOT_SIGNATURE_FLAG_ALLOW_STREAM_OUTPUT;
213
214 ComPtr<ID3DBlob> sig, error;
215 #ifndef _GAMING_XBOX
216 if (ctx->dev_config) {
217 if (FAILED(ctx->dev_config->SerializeVersionedRootSignature(&root_sig_desc,
218 &sig, &error))) {
219 debug_printf("D3D12SerializeRootSignature failed: %s\n", (char *)error->GetBufferPointer());
220 return NULL;
221 }
222 } else
223 #endif
224 {
225 if (FAILED(ctx->D3D12SerializeVersionedRootSignature(&root_sig_desc,
226 &sig, &error))) {
227 debug_printf("D3D12SerializeRootSignature failed: %s\n", (char *)error->GetBufferPointer());
228 return NULL;
229 }
230 }
231
232 ID3D12RootSignature *ret;
233 if (FAILED(screen->dev->CreateRootSignature(0,
234 sig->GetBufferPointer(),
235 sig->GetBufferSize(),
236 IID_PPV_ARGS(&ret)))) {
237 debug_printf("CreateRootSignature failed\n");
238 return NULL;
239 }
240 return ret;
241 }
242
243 static void
fill_key(struct d3d12_context * ctx,struct d3d12_root_signature_key * key,bool compute)244 fill_key(struct d3d12_context *ctx, struct d3d12_root_signature_key *key, bool compute)
245 {
246 memset(key, 0, sizeof(struct d3d12_root_signature_key));
247
248 key->compute = compute;
249 unsigned count = compute ? 1 : D3D12_GFX_SHADER_STAGES;
250 for (unsigned i = 0; i < count; ++i) {
251 struct d3d12_shader *shader = compute ?
252 ctx->compute_pipeline_state.stage :
253 ctx->gfx_pipeline_state.stages[i];
254
255 if (shader) {
256 key->stages[i].begin_cb_bindings = shader->begin_ubo_binding;
257 key->stages[i].end_cb_bindings = shader->end_ubo_binding;
258 key->stages[i].end_srv_binding = shader->end_srv_binding;
259 key->stages[i].begin_srv_binding = shader->begin_srv_binding;
260 key->stages[i].state_vars_size = shader->state_vars_size;
261 key->stages[i].num_ssbos = shader->nir->info.num_ssbos;
262 key->stages[i].num_images = shader->nir->info.num_images;
263
264 if (!compute && ctx->gfx_stages[i]->so_info.num_outputs > 0)
265 key->has_stream_output = true;
266 }
267 }
268 }
269
270 ID3D12RootSignature *
d3d12_get_root_signature(struct d3d12_context * ctx,bool compute)271 d3d12_get_root_signature(struct d3d12_context *ctx, bool compute)
272 {
273 struct d3d12_root_signature_key key;
274
275 fill_key(ctx, &key, compute);
276 struct hash_entry *entry = _mesa_hash_table_search(ctx->root_signature_cache, &key);
277 if (!entry) {
278 struct d3d12_root_signature *data =
279 (struct d3d12_root_signature *)MALLOC(sizeof(struct d3d12_root_signature));
280 if (!data)
281 return NULL;
282
283 data->key = key;
284 data->sig = create_root_signature(ctx, &key);
285 if (!data->sig) {
286 FREE(data);
287 return NULL;
288 }
289
290 entry = _mesa_hash_table_insert(ctx->root_signature_cache, &data->key, data);
291 assert(entry);
292 }
293
294 return ((struct d3d12_root_signature *)entry->data)->sig;
295 }
296
297 static uint32_t
hash_root_signature_key(const void * key)298 hash_root_signature_key(const void *key)
299 {
300 return _mesa_hash_data(key, sizeof(struct d3d12_root_signature_key));
301 }
302
303 static bool
equals_root_signature_key(const void * a,const void * b)304 equals_root_signature_key(const void *a, const void *b)
305 {
306 return memcmp(a, b, sizeof(struct d3d12_root_signature_key)) == 0;
307 }
308
309 void
d3d12_root_signature_cache_init(struct d3d12_context * ctx)310 d3d12_root_signature_cache_init(struct d3d12_context *ctx)
311 {
312 ctx->root_signature_cache = _mesa_hash_table_create(NULL,
313 hash_root_signature_key,
314 equals_root_signature_key);
315 }
316
317 static void
delete_entry(struct hash_entry * entry)318 delete_entry(struct hash_entry *entry)
319 {
320 struct d3d12_root_signature *data = (struct d3d12_root_signature *)entry->data;
321 data->sig->Release();
322 FREE(data);
323 }
324
325 void
d3d12_root_signature_cache_destroy(struct d3d12_context * ctx)326 d3d12_root_signature_cache_destroy(struct d3d12_context *ctx)
327 {
328 _mesa_hash_table_destroy(ctx->root_signature_cache, delete_entry);
329 }
330