Blender V5.3
vk_device.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include <fmt/format.h>
10#include <fmt/ranges.h>
11#include <sstream>
12
13#include "CLG_log.h"
14
15#include "vk_backend.hh"
16#include "vk_context.hh"
17#include "vk_device.hh"
18#include "vk_state_manager.hh"
19#include "vk_storage_buffer.hh"
20#include "vk_texture.hh"
21#include "vk_vertex_buffer.hh"
22
24
25#include "GPU_capabilities.hh"
27
29
30namespace blender {
31
32static CLG_LogRef LOG = {"gpu.vulkan"};
33
34namespace gpu {
35
37{
39 "Device features\n"
40 " - [%c] fragment shader barycentric\n"
41 " - [%c] wide lines\n"
42 " - [%c] multi draw indirect\n"
43 " - [%c] shader clip distance\n"
44 "Device extensions\n"
45 " - [%c] dynamic rendering local read\n"
46 " - [%c] dynamic rendering unused attachments\n"
47 " - [%c] extended dynamic state\n"
48 " - [%c] external memory\n"
49 " - [%c] graphics pipeline library\n"
50 " - [%c] host image copy\n"
51 " - [%c] line rasterization\n"
52 " - [%c] maintenance4\n"
53 " - [%c] memory priority\n"
54 " - [%c] pageable device local memory\n"
55 " - [%c] provoking vertex\n"
56 " - [%c] shader stencil export\n"
57 " - [%c] shader output viewport index and layer\n"
58 " - [%c] spirv 1.4\n"
59 " - [%c] ray queries\n"
60 " - [%c] vertex input dynamic state\n"
61 " - [%c] vertex pipeline stores and atomics",
63 wide_lines ? 'X' : ' ',
64 multi_draw_indirect ? 'X' : ' ',
65 shader_clip_distance ? 'X' : ' ',
68 extended_dynamic_state ? 'X' : ' ',
69 external_memory ? 'X' : ' ',
70 graphics_pipeline_library ? 'X' : ' ',
71 host_image_copy ? 'X' : ' ',
72 line_rasterization ? 'X' : ' ',
73 maintenance4 ? 'X' : ' ',
74 memory_priority ? 'X' : ' ',
76 provoking_vertex ? 'X' : ' ',
77 GPU_stencil_export_support() ? 'X' : ' ',
79 spirv_1_4 ? 'X' : ' ',
80 GPU_ray_query_support() ? 'X' : ' ',
83}
84
86{
88 "Activated workarounds\n"
89 " - [%c] Not 16/32 bit aligned image formats\n"
90 " - [%c] Static viewport & scissor state\n"
91 " - [%c] No texture pool\n"
92 " - [%c] Missing sRGB clear conversions",
93 not_aligned_pixel_formats ? 'X' : ' ',
94 static_viewport_scissor ? 'X' : ' ',
97}
98
100{
101 samplers_.free();
102 samplers_.init();
103}
104
106{
107 if (!is_initialized()) {
108 return;
109 }
110
111 deinit_submission_thread();
112
114 samplers_.free();
115 GPU_SHADER_FREE_SAFE(vk_backbuffer_blit_sh_);
116
117 /* Destroy resources that reached a zero ref count but were never consumed by a submission,
118 * as no further submissions will drain them. */
119 {
123 }
125 orphaned_data.deinit(*this);
126 {
127 while (!thread_data_.is_empty()) {
128 VKThreadData *thread_data = thread_data_.pop_last();
129 delete thread_data;
130 }
131 thread_data_.clear();
132 }
134 pipelines.free_data(*this);
135 descriptor_set_layouts_.deinit();
136 vma_pools.deinit(*this);
137 mem_allocator_ = VK_NULL_HANDLE;
138
139 while (!render_graphs_.is_empty()) {
140 render_graph::VKRenderGraph *render_graph = render_graphs_.pop_last();
141 MEM_delete<render_graph::VKRenderGraph>(render_graph);
142 }
143
144 debugging_tools_.deinit(vk_instance_);
145
146 vk_instance_ = VK_NULL_HANDLE;
147 vk_physical_device_ = VK_NULL_HANDLE;
148 vk_device_ = VK_NULL_HANDLE;
149 vk_queue_family_ = 0;
150 vk_queue_ = VK_NULL_HANDLE;
151 vk_physical_device_properties_ = {};
152 glsl_vert_patch_.clear();
153 glsl_frag_patch_.clear();
154 glsl_geom_patch_.clear();
155 glsl_comp_patch_.clear();
156 is_initialized_ = false;
157}
158
159void VKDevice::init(GHOST_IContext *ghost_context)
160{
162 GHOST_VulkanHandles handles = {};
163 ghost_context->getVulkanHandles(handles);
164 vk_instance_ = handles.instance;
165 vk_physical_device_ = handles.physical_device;
166 vk_device_ = handles.device;
167 vk_queue_family_ = handles.graphic_queue_family;
168 vk_queue_ = handles.queue;
169 mem_allocator_ = handles.vma_allocator;
170 queue_mutex_ = static_cast<std::mutex *>(handles.queue_mutex);
171
172 volkLoadDeviceTable(&functions, vk_device_);
173
174 init_physical_device_extensions();
175 init_physical_device_properties();
176 init_physical_device_memory_properties();
177 init_physical_device_features();
180 init_debug_callbacks();
181 vma_pools.init(*this);
182 pipelines.init();
184
185 samplers_.init();
186 init_dummy_buffer();
187
188 debug::object_label(vk_handle(), "LogicalDevice");
189 debug::object_label(vk_queue_, "GenericQueue");
190
191 resources.use_dynamic_rendering_local_read = extensions_.dynamic_rendering_local_read;
192 orphaned_data.timeline_ = 0;
193
194 init_submission_thread();
195 is_initialized_ = true;
196}
197
198void VKDevice::init_debug_callbacks()
199{
200 debugging_tools_.init(vk_instance_);
201}
202
203void VKDevice::init_physical_device_properties()
204{
205 BLI_assert(vk_physical_device_ != VK_NULL_HANDLE);
206
207 VkPhysicalDeviceProperties2 vk_physical_device_properties = {};
208 vk_physical_device_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
209 vk_physical_device_driver_properties_.sType =
210 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;
211 vk_physical_device_id_properties_.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES;
212 vk_physical_device_properties.pNext = &vk_physical_device_driver_properties_;
213 vk_physical_device_driver_properties_.pNext = &vk_physical_device_id_properties_;
214
215 if (supports_extension(VK_KHR_MAINTENANCE_4_EXTENSION_NAME)) {
216 vk_physical_device_maintenance4_properties_.pNext = vk_physical_device_properties.pNext;
217 vk_physical_device_properties.pNext = &vk_physical_device_maintenance4_properties_;
218 }
219
220 if (supports_extension(VK_EXT_GRAPHICS_PIPELINE_LIBRARY_EXTENSION_NAME)) {
221 vk_physical_device_graphics_pipeline_library_properties_.pNext =
222 vk_physical_device_properties.pNext;
223 vk_physical_device_properties.pNext =
224 &vk_physical_device_graphics_pipeline_library_properties_;
225 }
226 if (supports_extension(VK_KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME)) {
227 vk_physical_device_acceleration_structure_properties_.pNext =
228 vk_physical_device_properties.pNext;
229 vk_physical_device_properties.pNext = &vk_physical_device_acceleration_structure_properties_;
230 }
231
232 vkGetPhysicalDeviceProperties2(vk_physical_device_, &vk_physical_device_properties);
233 vk_physical_device_properties_ = vk_physical_device_properties.properties;
234}
235
236void VKDevice::init_physical_device_memory_properties()
237{
238 BLI_assert(vk_physical_device_ != VK_NULL_HANDLE);
239 vkGetPhysicalDeviceMemoryProperties(vk_physical_device_, &vk_physical_device_memory_properties_);
240}
241
242void VKDevice::init_physical_device_features()
243{
244 BLI_assert(vk_physical_device_ != VK_NULL_HANDLE);
245
246 VkPhysicalDeviceFeatures2 features = {};
247 features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
248 vk_physical_device_vulkan_11_features_.sType =
249 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES;
250
251 features.pNext = &vk_physical_device_vulkan_11_features_;
252 vk_physical_device_vulkan_11_features_.pNext =
253 &vk_physical_device_acceleration_structure_features_;
254
255 vkGetPhysicalDeviceFeatures2(vk_physical_device_, &features);
256 vk_physical_device_features_ = features.features;
257}
258
259void VKDevice::init_physical_device_extensions()
260{
261 uint32_t count = 0;
262 vkEnumerateDeviceExtensionProperties(vk_physical_device_, nullptr, &count, nullptr);
263 device_extensions_ = Array<VkExtensionProperties>(count);
264 vkEnumerateDeviceExtensionProperties(
265 vk_physical_device_, nullptr, &count, device_extensions_.data());
266}
267
268bool VKDevice::supports_extension(const char *extension_name) const
269{
270 for (const VkExtensionProperties &vk_extension_properties : device_extensions_) {
271 if (STREQ(vk_extension_properties.extensionName, extension_name)) {
272 return true;
273 }
274 }
275 return false;
276}
277
278void VKDevice::init_dummy_buffer()
279{
281 VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
282 VMA_MEMORY_USAGE_AUTO_PREFER_HOST,
283 VMA_ALLOCATION_CREATE_HOST_ACCESS_SEQUENTIAL_WRITE_BIT,
284 1.0f,
285 false,
286 "DummyBuffer");
287 /* Default dummy buffer. Set the 4th element to 1 to fix missing orcos. */
288 float data[16] = {
289 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
290 dummy_buffer.update_immediately(static_cast<void *>(data));
291}
292
294{
295 const bool requires_460 = use_ray_query;
296 return requires_460 ? 460u : 450u;
297}
298
300 bool use_ray_query) const
301{
302 std::stringstream ss;
303
304 ss << "#version " << glsl_patch_version_get(use_ray_query) << "\n";
305 ss << "#define GPU_ARB_clip_control\n";
306 ss << "#define GPU_ARB_derivative_control\n";
307
308 ss << "#define gl_VertexID gl_VertexIndex\n";
309 /* usage of gpu_BaseInstance is deprecated to support more Android devices. Prefer to use
310 * gpu_InstanceIndex. */
311 ss << "#define gpu_BaseInstance (0)\n";
312 ss << "#define gpu_InstanceIndex (gl_InstanceIndex)\n";
313 ss << "#define gl_InstanceID (gpu_InstanceIndex)\n";
314
315 ss << "#extension GL_ARB_shader_viewport_layer_array: enable\n";
317 ss << "#extension GL_ARB_shader_stencil_export: enable\n";
318 ss << "#define GPU_ARB_shader_stencil_export 1\n";
319 }
320 if (extensions_.fragment_shader_barycentric) {
321 ss << "#extension GL_EXT_fragment_shader_barycentric : require\n";
322 ss << "#define gpu_BaryCoord gl_BaryCoordEXT\n";
323 ss << "#define gpu_BaryCoordNoPersp gl_BaryCoordNoPerspEXT\n";
324 }
325 if (use_ray_query) {
326 ss << "#extension GL_EXT_ray_query : enable\n";
327 ss << "#define GPU_EXT_RAY_QUERY\n";
328 }
329 if (!extensions_.provoking_vertex) {
330 ss << "#define GPU_PROVOKING_VERTEX_LAST\n";
331 }
332 ss << stage_define;
333
334 return shader::GeneratedSource{"gpu_shader_glsl_extension.glsl", {}, ss.str()};
335}
336
337std::string VKDevice::glsl_vertex_patch_get(bool use_ray_query) const
338{
340 extensions_define("#define GPU_VERTEX_SHADER\n", use_ray_query)};
341 return fmt::to_string(fmt::join(
342 gpu_shader_dependency_get_resolved_source("gpu_shader_compat_glsl.glsl", sources), ""));
343}
344
346{
347 shader::GeneratedSourceList sources{extensions_define("#define GPU_GEOMETRY_SHADER\n", false)};
348 return fmt::to_string(fmt::join(
349 gpu_shader_dependency_get_resolved_source("gpu_shader_compat_glsl.glsl", sources), ""));
350}
351
352std::string VKDevice::glsl_fragment_patch_get(bool use_ray_query) const
353{
355 extensions_define("#define GPU_FRAGMENT_SHADER\n", use_ray_query)};
356 return fmt::to_string(fmt::join(
357 gpu_shader_dependency_get_resolved_source("gpu_shader_compat_glsl.glsl", sources), ""));
358}
359
360std::string VKDevice::glsl_compute_patch_get(bool use_ray_query) const
361{
363 extensions_define("#define GPU_COMPUTE_SHADER\n", use_ray_query)};
364 return fmt::to_string(fmt::join(
365 gpu_shader_dependency_get_resolved_source("gpu_shader_compat_glsl.glsl", sources), ""));
366}
367
368/* -------------------------------------------------------------------- */
371
372constexpr int32_t PCI_ID_NVIDIA = 0x10de;
373constexpr int32_t PCI_ID_INTEL = 0x8086;
374constexpr int32_t PCI_ID_AMD = 0x1002;
375constexpr int32_t PCI_ID_ATI = 0x1022;
376constexpr int32_t PCI_ID_APPLE = 0x106b;
377
379{
380 switch (vk_physical_device_driver_properties_.driverID) {
381 case VK_DRIVER_ID_AMD_PROPRIETARY:
382 case VK_DRIVER_ID_AMD_OPEN_SOURCE:
383 case VK_DRIVER_ID_MESA_RADV:
384 return GPU_DEVICE_ATI;
385
386 case VK_DRIVER_ID_NVIDIA_PROPRIETARY:
387 case VK_DRIVER_ID_MESA_NVK:
388 return GPU_DEVICE_NVIDIA;
389
390 case VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS:
391 case VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA:
392 return GPU_DEVICE_INTEL;
393
394 case VK_DRIVER_ID_QUALCOMM_PROPRIETARY:
395 return GPU_DEVICE_QUALCOMM;
396
397 case VK_DRIVER_ID_MOLTENVK:
398 return GPU_DEVICE_APPLE;
399
400 case VK_DRIVER_ID_MESA_LLVMPIPE:
401 return GPU_DEVICE_SOFTWARE;
402
403 default:
404 return GPU_DEVICE_UNKNOWN;
405 }
406
407 return GPU_DEVICE_UNKNOWN;
408}
409
411{
412 switch (vk_physical_device_driver_properties_.driverID) {
413 case VK_DRIVER_ID_AMD_PROPRIETARY:
414 case VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS:
415 case VK_DRIVER_ID_NVIDIA_PROPRIETARY:
416 case VK_DRIVER_ID_QUALCOMM_PROPRIETARY:
417 /* NOTE: Marking AMDVLK as an official driver to make distinction between Mesa and AMD open
418 * source. AMDVLK is being replaced by Mesa in the official driver stack. */
419 case VK_DRIVER_ID_AMD_OPEN_SOURCE:
420 return GPU_DRIVER_OFFICIAL;
421
422 case VK_DRIVER_ID_MOLTENVK:
423 case VK_DRIVER_ID_MESA_RADV:
424 case VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA:
425 case VK_DRIVER_ID_MESA_NVK:
427
428 case VK_DRIVER_ID_MESA_LLVMPIPE:
429 return GPU_DRIVER_SOFTWARE;
430
431 default:
432 return GPU_DRIVER_ANY;
433 }
434
435 return GPU_DRIVER_ANY;
436}
437
438std::string VKDevice::vendor_name() const
439{
440 /* Below 0x10000 are the PCI vendor IDs (https://pcisig.com/membership/member-companies) */
441 if (vk_physical_device_properties_.vendorID < 0x10000) {
442 switch (vk_physical_device_properties_.vendorID) {
443 case PCI_ID_AMD:
444 case PCI_ID_ATI:
445 return "Advanced Micro Devices";
446 case PCI_ID_NVIDIA:
447 return "NVIDIA Corporation";
448 case PCI_ID_INTEL:
449 return "Intel Corporation";
450 case PCI_ID_APPLE:
451 return "Apple";
452 default:
453 return std::to_string(vk_physical_device_properties_.vendorID);
454 }
455 }
456 else {
457 /* above 0x10000 should be vkVendorIDs
458 * NOTE: When debug_messaging landed we can use something similar to
459 * vk::to_string(vk::VendorId(properties.vendorID));
460 */
461 return std::to_string(vk_physical_device_properties_.vendorID);
462 }
463}
464
465std::string VKDevice::driver_version() const
466{
467 return StringRefNull(vk_physical_device_driver_properties_.driverName) + " " +
468 StringRefNull(vk_physical_device_driver_properties_.driverInfo);
469}
470
472
473/* -------------------------------------------------------------------- */
476
481
483
484/* -------------------------------------------------------------------- */
487
489{
490 std::scoped_lock mutex(resources.mutex);
491 pthread_t current_thread_id = pthread_self();
492
493 for (VKThreadData *thread_data : thread_data_) {
494 if (pthread_equal(thread_data->thread_id, current_thread_id)) {
495 return *thread_data;
496 }
497 }
498
499 VKThreadData *thread_data = new VKThreadData(*this, current_thread_id);
500 thread_data_.append(thread_data);
501 return *thread_data;
502}
503
505{
506 contexts_.append(std::reference_wrapper(context));
507}
508
510{
511 if (context.render_graph_.has_value()) {
512 render_graph::VKRenderGraph &render_graph = context.render_graph();
513 context.render_graph_.reset();
514 BLI_assert_msg(render_graph.is_empty(),
515 "Unregistering a context that still has an unsubmitted render graph.");
516 render_graph.reset();
518 unused_render_graphs_, &render_graph, BLI_THREAD_QUEUE_WORK_PRIORITY_NORMAL);
519 }
520 {
521 std::scoped_lock lock(orphaned_data.mutex_get());
522 orphaned_data.move_data(context.discard_pool, timeline_value_ + 1);
523 }
524
525 contexts_.remove(contexts_.first_index_of(std::reference_wrapper(context)));
526}
528{
529 return contexts_;
530};
531
532void VKDevice::memory_statistics_get(int *r_total_mem_kb, int *r_free_mem_kb) const
533{
534 VmaBudget budgets[VK_MAX_MEMORY_HEAPS];
535 vmaGetHeapBudgets(mem_allocator_get(), budgets);
536 VkDeviceSize total_mem = 0;
537 VkDeviceSize used_mem = 0;
538
539 for (int memory_heap_index : IndexRange(vk_physical_device_memory_properties_.memoryHeapCount)) {
540 const VkMemoryHeap &memory_heap =
541 vk_physical_device_memory_properties_.memoryHeaps[memory_heap_index];
542 const VmaBudget &budget = budgets[memory_heap_index];
543
544 /* Skip host memory-heaps. */
545 if (!bool(memory_heap.flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT)) {
546 continue;
547 }
548
549 total_mem += memory_heap.size;
550 used_mem += budget.usage;
551 }
552
553 *r_total_mem_kb = int(total_mem / 1024);
554 *r_free_mem_kb = int((total_mem - used_mem) / 1024);
555}
556
558
559/* -------------------------------------------------------------------- */
562
564{
566 "VKDevice::debug_print can only be called from the main thread.");
567
569 std::ostream &os = std::cout;
570 os << "Pipelines\n";
571 os << " Graphics: " << pipelines.graphics_.size() << "\n";
572 os << " Compute: " << pipelines.compute_.size() << "\n";
573 os << " VertexInLib: " << pipelines.vertex_input_libs_.size() << "\n";
574 os << " ShaderLib: " << pipelines.shaders_libs_.size() << "\n";
575 os << " FragmentOutLib: " << pipelines.fragment_output_libs_.size() << "\n";
576 os << "Descriptor sets\n";
577 os << " VkDescriptorSetLayouts: " << descriptor_set_layouts_.size() << "\n";
578 for (const VKThreadData *thread_data : thread_data_) {
579 /* NOTE: Assumption that this is always called form the main thread. This could be solved by
580 * keeping track of the main thread inside the thread data. */
581 const bool is_main = pthread_equal(thread_data->thread_id, pthread_self());
582 os << "ThreadData" << (is_main ? " (main-thread)" : "") << ")\n";
583 os << " Rendering_depth: " << thread_data->rendering_depth << "\n";
584 }
585 os << "Discard pool\n";
586 os << orphaned_data << "\n";
587 os << "Discard pool (render)\n";
588 os << orphaned_data_render << "\n";
589 os << "\n";
590
591 for (const std::reference_wrapper<VKContext> &context : contexts_) {
592 os << " VKContext \n";
593 os << context.get().discard_pool << "\n";
594 }
595
596 int total_mem_kb;
597 int free_mem_kb;
598 memory_statistics_get(&total_mem_kb, &free_mem_kb);
599 os << "\nMemory: total=" << total_mem_kb << ", free=" << free_mem_kb << "\n";
600}
601
603
604} // namespace gpu
605} // namespace blender
#define UINT64_MAX
#define CLOG_DEBUG(clg_ref,...)
Definition CLG_log.h:191
#define GPU_SHADER_FREE_SAFE(shader)
volatile int lock
#define BLI_assert(a)
#define BLI_assert_msg(a, msg)
#define STREQ(a, b)
constexpr IndexRange()=default
constexpr StringRefNull()
static void capabilities_init(VKDevice &device)
static void platform_init(const VKDevice &device)
void update_immediately(const void *data) const
Definition vk_buffer.cc:144
bool create(size_t size, VkBufferUsageFlags buffer_usage, VmaMemoryUsage vma_memory_usage, VmaAllocationCreateFlags vma_allocation_flags, float priority, bool export_memory=false, const char *debug_name="VKBuffer", size_t alignment=0)
Definition vk_buffer.cc:29
void init(const VKDevice &vk_device)
VKPipelinePool pipelines
Definition vk_device.hh:274
render_graph::VKResourceStateTracker resources
Definition vk_device.hh:270
GPUDriverType driver_type() const
Definition vk_device.cc:410
VmaAllocator mem_allocator_get() const
Definition vk_device.hh:348
VkDevice vk_handle() const
Definition vk_device.hh:338
void debug_print() const
Definition vk_device.cc:563
VKMemoryPools vma_pools
Definition vk_device.hh:282
bool supports_extension(const char *extension_name) const
Definition vk_device.cc:268
void init(GHOST_IContext *ghost_context)
Definition vk_device.cc:159
std::string vendor_name() const
Definition vk_device.cc:438
std::string driver_version() const
Definition vk_device.cc:465
VKDiscardPool orphaned_data
Definition vk_device.hh:271
GPUDeviceType device_type() const
Definition vk_device.cc:378
VKThreadData & current_thread_data()
Definition vk_device.cc:488
VolkDeviceTable functions
Definition vk_device.hh:280
shader::GeneratedSource extensions_define(StringRefNull stage_define, bool use_ray_query) const
Definition vk_device.cc:299
uint32_t glsl_patch_version_get(bool use_ray_query) const
Definition vk_device.cc:293
void context_register(VKContext &context)
Definition vk_device.cc:504
bool is_initialized() const
Definition vk_device.hh:376
std::string glsl_compute_patch_get(bool use_ray_query) const
Definition vk_device.cc:360
void context_unregister(VKContext &context)
Definition vk_device.cc:509
std::string glsl_vertex_patch_get(bool use_ray_query) const
Definition vk_device.cc:337
void memory_statistics_get(int *r_total_mem_kb, int *r_free_mem_kb) const
Definition vk_device.cc:532
std::string glsl_geometry_patch_get() const
Definition vk_device.cc:345
std::string glsl_fragment_patch_get(bool use_ray_query) const
Definition vk_device.cc:352
Span< std::reference_wrapper< VKContext > > contexts_get() const
Definition vk_device.cc:527
VKDiscardPool orphaned_data_render
Definition vk_device.hh:273
void move_data(VKDiscardPool &src_pool, TimelineValue timeline)
void discard_resources(Span< render_graph::VKResourceStateTracker::DiscardableResource > discardable, TimelineValue timeline)
void deinit(VKDevice &device)
void free_data(const VKDevice &device)
VKThreadData(VKDevice &device, pthread_t thread_id)
Definition vk_device.cc:477
VKDescriptorPools descriptor_pools
Definition vk_device.hh:164
void init(VkInstance vk_instance)
Definition vk_debug.cc:162
void object_label(GLenum type, GLuint object, const char *name)
Definition gl_debug.cc:331
Vector< shader::GeneratedSource, 0 > GeneratedSourceList
Vector< StringRefNull > gpu_shader_dependency_get_resolved_source(const StringRefNull shader_source_name, const shader::GeneratedSourceList &generated_sources, const StringRefNull shader_name)
constexpr int32_t PCI_ID_NVIDIA
Definition vk_device.cc:372
constexpr int32_t PCI_ID_INTEL
Definition vk_device.cc:373
constexpr int32_t PCI_ID_ATI
Definition vk_device.cc:375
GPUCapabilities GCaps
constexpr int32_t PCI_ID_AMD
Definition vk_device.cc:374
constexpr int32_t PCI_ID_APPLE
Definition vk_device.cc:376
BMesh Iterators.
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
@ BLI_THREAD_QUEUE_WORK_PRIORITY_NORMAL
bool GPU_vertex_pipeline_stores_and_atomics_support()
@ GPU_DRIVER_OFFICIAL
@ GPU_DRIVER_SOFTWARE
@ GPU_DRIVER_OPENSOURCE
bool GPU_ray_query_support()
MatBase< float, 4, 4 > float4x4
unsigned int uint32_t
Definition BKE_text.h:81
BMesh const char void * data
int BLI_thread_is_main()
Definition threads.cc:184
signed int int32_t
Definition BKE_text.h:78
static CLG_LogRef LOG
Definition logging.cpp:12
bool GPU_stencil_export_support()
uint64_t BLI_thread_queue_push(ThreadQueue *queue, void *work, ThreadQueueWorkPriority priority)
Definition threads.cc:648
@ GPU_DEVICE_QUALCOMM
@ GPU_DEVICE_SOFTWARE
@ GPU_DEVICE_UNKNOWN
@ GPU_DEVICE_INTEL
@ GPU_DEVICE_NVIDIA
@ GPU_DEVICE_APPLE
void deinit(VKDevice &device)
void init(VKDevice &device)