← Back to branch summary

~mmach/netext73/mesa-ryzen

« back to all changes in this revision

Viewing changes to src/gallium/drivers/zink/zink_screen.c

  • Committer: mmach
  • Date: 2023-11-02 21:31:35 UTC
  • Revision ID: netbit73@gmail.com-20231102213135-18d4tzh7tj0uz752
2023-11-02 22:11:57

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gallium/drivers/zink/zink_screen.c
37
37
#include "zink_state.h"
38
38
#include "nir_to_spirv/nir_to_spirv.h" // for SPIRV_VERSION
39
39
 
40
 
#include "os/os_process.h"
41
40
#include "util/u_debug.h"
42
41
#include "util/u_dl.h"
43
42
#include "util/os_file.h"
46
45
#include "util/u_string.h"
47
46
#include "util/perf/u_trace.h"
48
47
#include "util/u_transfer_helper.h"
 
48
#include "util/hex.h"
49
49
#include "util/xmlconfig.h"
50
50
 
51
51
#include "util/u_cpu_detect.h"
91
91
   { "norp", ZINK_DEBUG_NORP, "Disable renderpass tracking/optimizations" },
92
92
   { "map", ZINK_DEBUG_MAP, "Track amount of mapped VRAM" },
93
93
   { "flushsync", ZINK_DEBUG_FLUSHSYNC, "Force synchronous flushes/presents" },
 
94
   { "noshobj", ZINK_DEBUG_NOSHOBJ, "Disable EXT_shader_object" },
 
95
   { "optimal_keys", ZINK_DEBUG_OPTIMAL_KEYS, "Debug/use optimal_keys" },
 
96
   { "noopt", ZINK_DEBUG_NOOPT, "Disable async optimized pipeline compiles" },
 
97
   { "nobgc", ZINK_DEBUG_NOBGC, "Disable all async pipeline compiles" },
 
98
   { "dgc", ZINK_DEBUG_DGC, "Use DGC (driver testing only)" },
 
99
   { "mem", ZINK_DEBUG_MEM, "Debug memory allocations" },
94
100
   DEBUG_NAMED_VALUE_END
95
101
};
96
102
 
190
196
zink_set_max_shader_compiler_threads(struct pipe_screen *pscreen, unsigned max_threads)
191
197
{
192
198
   struct zink_screen *screen = zink_screen(pscreen);
193
 
   util_queue_adjust_num_threads(&screen->cache_get_thread, max_threads);
 
199
   util_queue_adjust_num_threads(&screen->cache_get_thread, max_threads, false);
194
200
}
195
201
 
196
202
static bool
279
285
    */
280
286
   _mesa_sha1_update(&ctx, &screen->driconf, sizeof(screen->driconf));
281
287
 
 
288
   /* EXT_shader_object causes different descriptor layouts for separate shaders */
 
289
   _mesa_sha1_update(&ctx, &screen->info.have_EXT_shader_object, sizeof(screen->info.have_EXT_shader_object));
 
290
 
282
291
   /* Finish the sha1 and format it as text. */
283
292
   unsigned char sha1[20];
284
293
   _mesa_sha1_final(&ctx, sha1);
285
294
 
286
295
   char cache_id[20 * 2 + 1];
287
 
   disk_cache_format_hex_id(cache_id, sha1, 20 * 2);
 
296
   mesa_bytes_to_hex(cache_id, sha1, 20);
288
297
 
289
298
   screen->disk_cache = disk_cache_create("zink", cache_id, 0);
290
299
 
313
322
   struct zink_program *pg = data;
314
323
   struct zink_screen *screen = gdata;
315
324
   size_t size = 0;
 
325
   u_rwlock_rdlock(&pg->pipeline_cache_lock);
316
326
   VkResult result = VKSCR(GetPipelineCacheData)(screen->dev, pg->pipeline_cache, &size, NULL);
317
327
   if (result != VK_SUCCESS) {
 
328
      u_rwlock_rdunlock(&pg->pipeline_cache_lock);
318
329
      mesa_loge("ZINK: vkGetPipelineCacheData failed (%s)", vk_Result_to_str(result));
319
330
      return;
320
331
   }
321
 
   if (pg->pipeline_cache_size == size)
 
332
   if (pg->pipeline_cache_size == size) {
 
333
      u_rwlock_rdunlock(&pg->pipeline_cache_lock);
322
334
      return;
 
335
   }
323
336
   void *pipeline_data = malloc(size);
324
 
   if (!pipeline_data)
 
337
   if (!pipeline_data) {
 
338
      u_rwlock_rdunlock(&pg->pipeline_cache_lock);
325
339
      return;
 
340
   }
326
341
   result = VKSCR(GetPipelineCacheData)(screen->dev, pg->pipeline_cache, &size, pipeline_data);
 
342
   u_rwlock_rdunlock(&pg->pipeline_cache_lock);
327
343
   if (result == VK_SUCCESS) {
328
344
      pg->pipeline_cache_size = size;
329
345
 
343
359
 
344
360
   if (in_thread)
345
361
      cache_put_job(pg, screen, 0);
346
 
   else
 
362
   else if (util_queue_fence_is_signalled(&pg->cache_fence))
347
363
      util_queue_add_job(&screen->cache_put_thread, pg, &pg->cache_fence, cache_put_job, NULL, 0);
348
364
}
349
365
 
428
444
   case PIPE_COMPUTE_CAP_IMAGES_SUPPORTED:
429
445
      RET((uint32_t []) { 1 });
430
446
 
431
 
   case PIPE_COMPUTE_CAP_SUBGROUP_SIZE:
 
447
   case PIPE_COMPUTE_CAP_SUBGROUP_SIZES:
432
448
      RET((uint32_t []) { screen->info.props11.subgroupSize });
433
449
 
 
450
   case PIPE_COMPUTE_CAP_MAX_SUBGROUPS:
434
451
   case PIPE_COMPUTE_CAP_MAX_MEM_ALLOC_SIZE:
435
452
   case PIPE_COMPUTE_CAP_MAX_CLOCK_FREQUENCY:
436
453
   case PIPE_COMPUTE_CAP_MAX_COMPUTE_UNITS:
505
522
   case PIPE_CAP_EMULATE_NONFIXED_PRIMITIVE_RESTART:
506
523
      return 1;
507
524
   case PIPE_CAP_SUPPORTED_PRIM_MODES_WITH_RESTART: {
508
 
      uint32_t modes = BITFIELD_BIT(PIPE_PRIM_LINE_STRIP) |
509
 
                       BITFIELD_BIT(PIPE_PRIM_TRIANGLE_STRIP) |
510
 
                       BITFIELD_BIT(PIPE_PRIM_LINE_STRIP_ADJACENCY) |
511
 
                       BITFIELD_BIT(PIPE_PRIM_TRIANGLE_STRIP_ADJACENCY);
 
525
      uint32_t modes = BITFIELD_BIT(MESA_PRIM_LINE_STRIP) |
 
526
                       BITFIELD_BIT(MESA_PRIM_TRIANGLE_STRIP) |
 
527
                       BITFIELD_BIT(MESA_PRIM_LINE_STRIP_ADJACENCY) |
 
528
                       BITFIELD_BIT(MESA_PRIM_TRIANGLE_STRIP_ADJACENCY);
512
529
      if (screen->have_triangle_fans)
513
 
         modes |= BITFIELD_BIT(PIPE_PRIM_TRIANGLE_FAN);
 
530
         modes |= BITFIELD_BIT(MESA_PRIM_TRIANGLE_FAN);
514
531
      if (screen->info.have_EXT_primitive_topology_list_restart) {
515
 
         modes |= BITFIELD_BIT(PIPE_PRIM_POINTS) |
516
 
                  BITFIELD_BIT(PIPE_PRIM_LINES) |
517
 
                  BITFIELD_BIT(PIPE_PRIM_LINES_ADJACENCY) |
518
 
                  BITFIELD_BIT(PIPE_PRIM_TRIANGLES) |
519
 
                  BITFIELD_BIT(PIPE_PRIM_TRIANGLES_ADJACENCY);
 
532
         modes |= BITFIELD_BIT(MESA_PRIM_POINTS) |
 
533
                  BITFIELD_BIT(MESA_PRIM_LINES) |
 
534
                  BITFIELD_BIT(MESA_PRIM_LINES_ADJACENCY) |
 
535
                  BITFIELD_BIT(MESA_PRIM_TRIANGLES) |
 
536
                  BITFIELD_BIT(MESA_PRIM_TRIANGLES_ADJACENCY);
520
537
         if (screen->info.list_restart_feats.primitiveTopologyPatchListRestart)
521
 
            modes |= BITFIELD_BIT(PIPE_PRIM_PATCHES);
 
538
            modes |= BITFIELD_BIT(MESA_PRIM_PATCHES);
522
539
      }
523
540
      return modes;
524
541
   }
525
542
   case PIPE_CAP_SUPPORTED_PRIM_MODES: {
526
 
      uint32_t modes = BITFIELD_MASK(PIPE_PRIM_MAX);
527
 
      modes &= ~BITFIELD_BIT(PIPE_PRIM_QUAD_STRIP);
528
 
      modes &= ~BITFIELD_BIT(PIPE_PRIM_POLYGON);
529
 
      modes &= ~BITFIELD_BIT(PIPE_PRIM_LINE_LOOP);
 
543
      uint32_t modes = BITFIELD_MASK(MESA_PRIM_COUNT);
 
544
      modes &= ~BITFIELD_BIT(MESA_PRIM_QUAD_STRIP);
 
545
      modes &= ~BITFIELD_BIT(MESA_PRIM_POLYGON);
 
546
      modes &= ~BITFIELD_BIT(MESA_PRIM_LINE_LOOP);
530
547
      if (!screen->have_triangle_fans)
531
 
         modes &= ~BITFIELD_BIT(PIPE_PRIM_TRIANGLE_FAN);
 
548
         modes &= ~BITFIELD_BIT(MESA_PRIM_TRIANGLE_FAN);
532
549
      return modes;
533
550
   }
534
551
 
543
560
      return screen->info.have_KHR_external_semaphore_fd || screen->info.have_KHR_external_semaphore_win32;
544
561
   case PIPE_CAP_NATIVE_FENCE_FD:
545
562
      return screen->instance_info.have_KHR_external_semaphore_capabilities && screen->info.have_KHR_external_semaphore_fd;
 
563
   case PIPE_CAP_RESOURCE_FROM_USER_MEMORY:
 
564
      return screen->info.have_EXT_external_memory_host;
546
565
 
547
566
   case PIPE_CAP_SURFACE_REINTERPRET_BLOCKS:
548
567
      return screen->info.have_vulkan11 || screen->info.have_KHR_maintenance2;
558
577
   case PIPE_CAP_DRAW_INDIRECT:
559
578
   case PIPE_CAP_TEXTURE_QUERY_LOD:
560
579
   case PIPE_CAP_GLSL_TESS_LEVELS_AS_INPUTS:
561
 
   case PIPE_CAP_CLEAR_TEXTURE:
562
580
   case PIPE_CAP_COPY_BETWEEN_COMPRESSED_AND_PLAIN_FORMATS:
563
581
   case PIPE_CAP_FORCE_PERSAMPLE_INTERP:
564
582
   case PIPE_CAP_FRAMEBUFFER_NO_ATTACHMENT:
579
597
   case PIPE_CAP_SEAMLESS_CUBE_MAP_PER_TEXTURE:
580
598
   case PIPE_CAP_LOAD_CONSTBUF:
581
599
   case PIPE_CAP_MULTISAMPLE_Z_RESOLVE:
582
 
   case PIPE_CAP_RGB_OVERRIDE_DST_ALPHA_BLEND:
583
600
   case PIPE_CAP_ALLOW_GLTHREAD_BUFFER_SUBDATA_OPT:
584
601
      return 1;
585
602
 
786
803
   case PIPE_CAP_QUERY_TIMESTAMP_BITS:
787
804
      return screen->timestamp_valid_bits;
788
805
 
 
806
   case PIPE_CAP_TIMER_RESOLUTION:
 
807
      return ceil(screen->info.props.limits.timestampPeriod);
 
808
 
789
809
   case PIPE_CAP_MIN_MAP_BUFFER_ALIGNMENT:
790
810
      return 1 << MIN_SLAB_ORDER;
791
811
 
849
869
   case PIPE_CAP_SAMPLER_REDUCTION_MINMAX_ARB:
850
870
      return screen->info.feats12.samplerFilterMinmax || screen->info.have_EXT_sampler_filter_minmax;
851
871
 
 
872
   case PIPE_CAP_OPENCL_INTEGER_FUNCTIONS:
 
873
   case PIPE_CAP_INTEGER_MULTIPLY_32X16:
 
874
      return screen->info.have_INTEL_shader_integer_functions2;
 
875
 
852
876
   case PIPE_CAP_FS_FINE_DERIVATIVE:
853
877
      return 1;
854
878
 
946
970
      return 1;
947
971
 
948
972
   case PIPE_CAP_FS_FACE_IS_INTEGER_SYSVAL:
 
973
   case PIPE_CAP_FS_POINT_IS_SYSVAL:
949
974
      return 1;
950
975
 
951
976
   case PIPE_CAP_VIEWPORT_TRANSFORM_LOWERED:
1191
1216
   case PIPE_SHADER_CAP_INT16:
1192
1217
      return screen->info.feats.features.shaderInt16;
1193
1218
 
1194
 
   case PIPE_SHADER_CAP_PREFERRED_IR:
1195
 
      return PIPE_SHADER_IR_NIR;
1196
 
 
1197
1219
   case PIPE_SHADER_CAP_TGSI_SQRT_SUPPORTED:
1198
1220
      return 0; /* not implemented */
1199
1221
 
1480
1502
   if (screen->bindless_layout)
1481
1503
      VKSCR(DestroyDescriptorSetLayout)(screen->dev, screen->bindless_layout, NULL);
1482
1504
 
 
1505
   if (zink_debug & ZINK_DEBUG_MEM)
 
1506
      simple_mtx_destroy(&screen->debug_mem_lock);
 
1507
 
1483
1508
   simple_mtx_destroy(&screen->queue_lock);
1484
1509
   VKSCR(DestroyDevice)(screen->dev, NULL);
1485
1510
   VKSCR(DestroyInstance)(screen->instance, NULL);
1511
1536
      assert(pdev_count > 0);
1512
1537
 
1513
1538
      pdevs = malloc(sizeof(*pdevs) * pdev_count);
 
1539
      if (!pdevs) {
 
1540
         mesa_loge("ZINK: failed to allocate pdevs!");
 
1541
         return;
 
1542
      }
1514
1543
      result = VKSCR(EnumeratePhysicalDevices)(screen->instance, &pdev_count, pdevs);
1515
1544
      assert(result == VK_SUCCESS);
1516
1545
      assert(pdev_count > 0);
1570
1599
   assert(num_queues > 0);
1571
1600
 
1572
1601
   VkQueueFamilyProperties *props = malloc(sizeof(*props) * num_queues);
 
1602
   if (!props) {
 
1603
      mesa_loge("ZINK: failed to allocate props!");
 
1604
      return;
 
1605
   }
 
1606
      
1573
1607
   VKSCR(GetPhysicalDeviceQueueFamilyProperties)(screen->pdev, &num_queues, props);
1574
1608
 
1575
1609
   bool found_gfx = false;
2391
2425
   default:
2392
2426
      break;
2393
2427
   }
 
2428
   /* TODO: maybe compile multiple variants for different set counts for compact mode? */
 
2429
   if (screen->info.props.limits.maxBoundDescriptorSets < ZINK_DESCRIPTOR_ALL_TYPES ||
 
2430
       zink_debug & (ZINK_DEBUG_COMPACT | ZINK_DEBUG_NOSHOBJ))
 
2431
      screen->info.have_EXT_shader_object = false;
2394
2432
   /* EDS2 is only used with EDS1 */
2395
2433
   if (!screen->info.have_EXT_extended_dynamic_state)
2396
2434
      screen->info.have_EXT_extended_dynamic_state2 = false;
2508
2546
   default:
2509
2547
      break;
2510
2548
   }
 
2549
   /* use same mechanics if dynamic state is supported */
 
2550
   screen->driver_workarounds.always_feedback_loop |= screen->info.have_EXT_attachment_feedback_loop_dynamic_state;
 
2551
   screen->driver_workarounds.always_feedback_loop_zs |= screen->info.have_EXT_attachment_feedback_loop_dynamic_state;
 
2552
 
2511
2553
   /* these drivers cannot handle OOB gl_Layer values, and therefore need clamping in shader.
2512
2554
    * TODO: Vulkan extension that details whether vulkan driver can handle OOB layer values
2513
2555
    */
2575
2617
   default:
2576
2618
      break;
2577
2619
   }
 
2620
 
 
2621
   /* these drivers have no difference between unoptimized and optimized shader compilation */
 
2622
   switch (screen->info.driver_props.driverID) {
 
2623
   case VK_DRIVER_ID_MESA_LLVMPIPE:
 
2624
      screen->driver_workarounds.disable_optimized_compile = true;
 
2625
      break;
 
2626
   default:
 
2627
      if (zink_debug & ZINK_DEBUG_NOOPT)
 
2628
         screen->driver_workarounds.disable_optimized_compile = true;
 
2629
      break;
 
2630
   }
 
2631
}
 
2632
 
 
2633
static void
 
2634
init_optimal_keys(struct zink_screen *screen)
 
2635
{
 
2636
   screen->optimal_keys = !screen->need_decompose_attrs &&
 
2637
                          screen->info.have_EXT_non_seamless_cube_map &&
 
2638
                          screen->info.have_EXT_provoking_vertex &&
 
2639
                          !screen->driconf.inline_uniforms &&
 
2640
                          !screen->driver_workarounds.no_linestipple &&
 
2641
                          !screen->driver_workarounds.no_linesmooth &&
 
2642
                          !screen->driver_workarounds.no_hw_gl_point &&
 
2643
                          !screen->driver_workarounds.lower_robustImageAccess2 &&
 
2644
                          !screen->driconf.emulate_point_smooth &&
 
2645
                          !screen->driver_workarounds.needs_zs_shader_swizzle;
 
2646
   if (!screen->optimal_keys && zink_debug & ZINK_DEBUG_OPTIMAL_KEYS) {
 
2647
      fprintf(stderr, "The following criteria are preventing optimal_keys enablement:");
 
2648
      if (screen->need_decompose_attrs)
 
2649
         fprintf(stderr, "missing vertex attribute formats\n");
 
2650
      if (screen->driconf.inline_uniforms)
 
2651
         fprintf(stderr, "uniform inlining must be disabled (set ZINK_INLINE_UNIFORMS=0 in your env)\n");
 
2652
      CHECK_OR_PRINT(have_EXT_line_rasterization);
 
2653
      CHECK_OR_PRINT(line_rast_feats.stippledBresenhamLines);
 
2654
      CHECK_OR_PRINT(feats.features.geometryShader);
 
2655
      CHECK_OR_PRINT(feats.features.sampleRateShading);
 
2656
      CHECK_OR_PRINT(have_EXT_non_seamless_cube_map);
 
2657
      CHECK_OR_PRINT(have_EXT_provoking_vertex);
 
2658
      if (screen->driver_workarounds.no_linesmooth)
 
2659
         fprintf(stderr, "driver does not support smooth lines\n");
 
2660
      if (screen->driver_workarounds.no_hw_gl_point)
 
2661
         fprintf(stderr, "driver does not support hardware GL_POINT\n");
 
2662
      CHECK_OR_PRINT(rb2_feats.robustImageAccess2);
 
2663
      CHECK_OR_PRINT(feats.features.robustBufferAccess);
 
2664
      CHECK_OR_PRINT(rb_image_feats.robustImageAccess);
 
2665
      if (screen->driconf.emulate_point_smooth)
 
2666
         fprintf(stderr, "smooth point emulation is enabled\n");
 
2667
      if (screen->driver_workarounds.needs_zs_shader_swizzle)
 
2668
         fprintf(stderr, "Z/S shader swizzle workaround is enabled\n");
 
2669
      mesa_logw("zink: force-enabling optimal_keys despite missing features. Good luck!");
 
2670
      screen->optimal_keys = true;
 
2671
   }
 
2672
   if (!screen->optimal_keys)
 
2673
      screen->info.have_EXT_graphics_pipeline_library = false;
 
2674
 
 
2675
   if (!screen->optimal_keys ||
 
2676
      /* EXT_shader_object needs either dynamic feedback loop or per-app enablement */
 
2677
       (!screen->driconf.zink_shader_object_enable && !screen->info.have_EXT_attachment_feedback_loop_dynamic_state))
 
2678
      screen->info.have_EXT_shader_object = false;
 
2679
   if (screen->info.have_EXT_shader_object)
 
2680
      screen->have_full_ds3 = true;
 
2681
   if (zink_debug & ZINK_DEBUG_DGC) {
 
2682
      if (!screen->optimal_keys) {
 
2683
         mesa_loge("zink: can't DGC without optimal_keys!");
 
2684
         zink_debug &= ~ZINK_DEBUG_DGC;
 
2685
      } else {
 
2686
         screen->info.have_EXT_multi_draw = false;
 
2687
         screen->info.have_EXT_shader_object = false;
 
2688
         screen->info.have_EXT_graphics_pipeline_library = false;
 
2689
         screen->info.have_EXT_vertex_input_dynamic_state = false;
 
2690
      }
 
2691
   }
2578
2692
}
2579
2693
 
2580
2694
static struct disk_cache *
2687
2801
   }
2688
2802
 
2689
2803
   struct zink_screen *screen = rzalloc(NULL, struct zink_screen);
2690
 
   if (!screen)
 
2804
   if (!screen) {
 
2805
      mesa_loge("ZINK: failed to allocate screen");
2691
2806
      return NULL;
 
2807
   }
2692
2808
 
2693
2809
   zink_debug = debug_get_option_zink_debug();
2694
 
   zink_descriptor_mode = debug_get_option_zink_descriptor_mode();
 
2810
   if (zink_descriptor_mode == ZINK_DESCRIPTOR_MODE_AUTO)
 
2811
      zink_descriptor_mode = debug_get_option_zink_descriptor_mode();
2695
2812
 
2696
2813
   screen->threaded = util_get_cpu_caps()->nr_cpus > 1 && debug_get_bool_option("GALLIUM_THREAD", util_get_cpu_caps()->nr_cpus > 1);
2697
2814
   if (zink_debug & ZINK_DEBUG_FLUSHSYNC)
2704
2821
   u_trace_state_init();
2705
2822
 
2706
2823
   screen->loader_lib = util_dl_open(VK_LIBNAME);
2707
 
   if (!screen->loader_lib)
 
2824
   if (!screen->loader_lib) {
 
2825
      mesa_loge("ZINK: failed to load "VK_LIBNAME);
2708
2826
      goto fail;
 
2827
   }
2709
2828
 
2710
2829
   screen->vk_GetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)util_dl_get_proc_address(screen->loader_lib, "vkGetInstanceProcAddr");
2711
2830
   screen->vk_GetDeviceProcAddr = (PFN_vkGetDeviceProcAddr)util_dl_get_proc_address(screen->loader_lib, "vkGetDeviceProcAddr");
2712
2831
   if (!screen->vk_GetInstanceProcAddr ||
2713
 
       !screen->vk_GetDeviceProcAddr)
 
2832
       !screen->vk_GetDeviceProcAddr) {
 
2833
      mesa_loge("ZINK: failed to get proc address");
2714
2834
      goto fail;
 
2835
   }
2715
2836
 
2716
2837
   screen->instance_info.loader_version = zink_get_loader_version(screen);
2717
2838
   if (config) {
2721
2842
      screen->driconf.glsl_correct_derivatives_after_discard = driQueryOptionb(config->options, "glsl_correct_derivatives_after_discard");
2722
2843
      //screen->driconf.inline_uniforms = driQueryOptionb(config->options, "radeonsi_inline_uniforms");
2723
2844
      screen->driconf.emulate_point_smooth = driQueryOptionb(config->options, "zink_emulate_point_smooth");
 
2845
      screen->driconf.zink_shader_object_enable = driQueryOptionb(config->options, "zink_shader_object_enable");
2724
2846
      screen->instance_info.disable_xcb_surface = driQueryOptionb(config->options, "disable_xcb_surface");
2725
2847
   }
2726
2848
 
2749
2871
      debug_printf("ZINK: failed to setup debug utils\n");
2750
2872
 
2751
2873
   choose_pdev(screen);
2752
 
   if (screen->pdev == VK_NULL_HANDLE)
 
2874
   if (screen->pdev == VK_NULL_HANDLE) {
 
2875
      mesa_loge("ZINK: failed to choose pdev");
2753
2876
      goto fail;
 
2877
   }
2754
2878
   screen->is_cpu = screen->info.props.deviceType == VK_PHYSICAL_DEVICE_TYPE_CPU;
2755
2879
 
2756
2880
   update_queue_props(screen);
2778
2902
      mesa_loge("zink: KHR_timeline_semaphore is required");
2779
2903
      goto fail;
2780
2904
   }
 
2905
   if (zink_debug & ZINK_DEBUG_DGC) {
 
2906
      if (!screen->info.have_NV_device_generated_commands) {
 
2907
         mesa_loge("zink: can't use DGC without NV_device_generated_commands");
 
2908
         goto fail;
 
2909
      }
 
2910
   }
 
2911
 
 
2912
   if (zink_debug & ZINK_DEBUG_MEM) {
 
2913
      simple_mtx_init(&screen->debug_mem_lock, mtx_plain);
 
2914
      screen->debug_mem_sizes = _mesa_hash_table_create(screen, _mesa_hash_string, _mesa_key_string_equal);
 
2915
   }
2781
2916
 
2782
2917
   init_driver_workarounds(screen);
2783
2918
 
2887
3022
 
2888
3023
   if (!zink_screen_resource_init(&screen->base))
2889
3024
      goto fail;
2890
 
   zink_bo_init(screen);
 
3025
   if (!zink_bo_init(screen)) {
 
3026
      mesa_loge("ZINK: failed to initialize suballocator");
 
3027
      goto fail;
 
3028
   }
2891
3029
   zink_screen_fence_init(&screen->base);
2892
3030
 
2893
3031
   zink_screen_init_compiler(screen);
2894
 
   if (!disk_cache_init(screen))
 
3032
   if (!disk_cache_init(screen)) {
 
3033
      mesa_loge("ZINK: failed to initialize disk cache");
2895
3034
      goto fail;
 
3035
   }
2896
3036
   if (!util_queue_init(&screen->cache_get_thread, "zcfq", 8, 4,
2897
3037
                        UTIL_QUEUE_INIT_RESIZE_IF_FULL | UTIL_QUEUE_INIT_SCALE_THREADS, screen))
2898
3038
      goto fail;
2900
3040
 
2901
3041
   slab_create_parent(&screen->transfer_pool, sizeof(struct zink_transfer), 16);
2902
3042
 
2903
 
   screen->driconf.inline_uniforms = debug_get_bool_option("ZINK_INLINE_UNIFORMS", screen->is_cpu);
 
3043
   screen->driconf.inline_uniforms = debug_get_bool_option("ZINK_INLINE_UNIFORMS", screen->is_cpu) && !(zink_debug & ZINK_DEBUG_DGC);
2904
3044
 
2905
3045
   screen->total_video_mem = get_video_mem(screen);
2906
3046
   screen->clamp_video_mem = screen->total_video_mem * 0.8;
2907
 
   if (!os_get_total_physical_memory(&screen->total_mem))
 
3047
   if (!os_get_total_physical_memory(&screen->total_mem)) {
 
3048
      mesa_loge("ZINK: failed to get total physical memory");
2908
3049
      goto fail;
 
3050
   }
2909
3051
 
2910
3052
   if (!zink_screen_init_semaphore(screen)) {
2911
3053
      mesa_loge("zink: failed to create timeline semaphore");
2926
3068
      /* not found: use compatible heap */
2927
3069
      if (screen->heap_map[i][0] == UINT8_MAX) {
2928
3070
         /* only cached mem has a failure case for now */
2929
 
         assert(i == ZINK_HEAP_HOST_VISIBLE_CACHED || i == ZINK_HEAP_DEVICE_LOCAL_LAZY ||
 
3071
         assert(i == ZINK_HEAP_HOST_VISIBLE_COHERENT_CACHED || i == ZINK_HEAP_DEVICE_LOCAL_LAZY ||
2930
3072
                i == ZINK_HEAP_DEVICE_LOCAL_VISIBLE);
2931
 
         if (i == ZINK_HEAP_HOST_VISIBLE_CACHED) {
 
3073
         if (i == ZINK_HEAP_HOST_VISIBLE_COHERENT_CACHED) {
2932
3074
            memcpy(screen->heap_map[i], screen->heap_map[ZINK_HEAP_HOST_VISIBLE_COHERENT], screen->heap_count[ZINK_HEAP_HOST_VISIBLE_COHERENT]);
2933
3075
            screen->heap_count[i] = screen->heap_count[ZINK_HEAP_HOST_VISIBLE_COHERENT];
2934
3076
         } else {
3047
3189
 
3048
3190
   zink_init_screen_pipeline_libs(screen);
3049
3191
 
3050
 
   if (!init_layouts(screen))
 
3192
   if (!init_layouts(screen)) {
 
3193
      mesa_loge("ZINK: failed to initialize layouts");
3051
3194
      goto fail;
 
3195
   }
3052
3196
 
3053
 
   if (!zink_descriptor_layouts_init(screen))
 
3197
   if (!zink_descriptor_layouts_init(screen)) {
 
3198
      mesa_loge("ZINK: failed to initialize descriptor layouts");
3054
3199
      goto fail;
 
3200
   }
3055
3201
 
3056
3202
   simple_mtx_init(&screen->copy_context_lock, mtx_plain);
3057
3203
 
3058
 
   screen->optimal_keys = !screen->need_decompose_attrs &&
3059
 
                          screen->info.have_EXT_non_seamless_cube_map &&
3060
 
                          screen->info.have_EXT_provoking_vertex &&
3061
 
                          !screen->driconf.inline_uniforms &&
3062
 
                          !screen->driver_workarounds.no_linestipple &&
3063
 
                          !screen->driver_workarounds.no_linesmooth &&
3064
 
                          !screen->driver_workarounds.no_hw_gl_point &&
3065
 
                          !screen->driver_workarounds.lower_robustImageAccess2 &&
3066
 
                          !screen->driconf.emulate_point_smooth &&
3067
 
                          !screen->driver_workarounds.needs_zs_shader_swizzle;
3068
 
   if (!screen->optimal_keys)
3069
 
      screen->info.have_EXT_graphics_pipeline_library = false;
 
3204
   init_optimal_keys(screen);
3070
3205
 
3071
3206
   screen->screen_id = p_atomic_inc_return(&num_screens);
3072
3207
   zink_tracing = screen->instance_info.have_EXT_debug_utils &&