← Back to branch summary

~mmach/netext73/mesa-ryzen

« back to all changes in this revision

Viewing changes to src/virtio/vulkan/vn_device_memory.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/virtio/vulkan/vn_device_memory.c
29
29
{
30
30
   VkDevice dev_handle = vn_device_to_handle(dev);
31
31
   const VkAllocationCallbacks *alloc = &dev->base.base.alloc;
32
 
   const VkPhysicalDeviceMemoryProperties *mem_props =
33
 
      &dev->physical_device->memory_properties.memoryProperties;
34
 
   const VkMemoryPropertyFlags mem_flags =
35
 
      mem_props->memoryTypes[mem_type_index].propertyFlags;
36
32
   struct vn_device_memory *mem = NULL;
37
33
   VkDeviceMemory mem_handle = VK_NULL_HANDLE;
38
34
   VkResult result;
44
40
 
45
41
   vn_object_base_init(&mem->base, VK_OBJECT_TYPE_DEVICE_MEMORY, &dev->base);
46
42
   mem->size = size;
47
 
   mem->flags = mem_flags;
 
43
   mem->type = dev->physical_device->memory_properties.memoryProperties
 
44
                  .memoryTypes[mem_type_index];
48
45
 
49
46
   mem_handle = vn_device_memory_to_handle(mem);
50
47
   result = vn_call_vkAllocateMemory(
61
58
   }
62
59
 
63
60
   result = vn_renderer_bo_create_from_device_memory(
64
 
      dev->renderer, mem->size, mem->base.id, mem->flags, 0, &mem->base_bo);
 
61
      dev->renderer, mem->size, mem->base.id, mem->type.propertyFlags, 0,
 
62
      &mem->base_bo);
65
63
   if (result != VK_SUCCESS) {
66
64
      assert(!mem->base_bo);
67
65
      goto fail;
306
304
   VkResult result = VK_SUCCESS;
307
305
 
308
306
   result = vn_renderer_bo_create_from_device_memory(
309
 
      dev->renderer, mem->size, 0, mem->flags, external_handles,
 
307
      dev->renderer, mem->size, 0, mem->type.propertyFlags, external_handles,
310
308
      &mem->base_bo);
311
309
   if (result != VK_SUCCESS) {
312
310
      return result;
364
362
      return result;
365
363
 
366
364
   result = vn_renderer_bo_create_from_device_memory(
367
 
      dev->renderer, mem->size, mem->base.id, mem->flags, external_handles,
368
 
      &mem->base_bo);
 
365
      dev->renderer, mem->size, mem->base.id, mem->type.propertyFlags,
 
366
      external_handles, &mem->base_bo);
369
367
   if (result != VK_SUCCESS) {
370
368
      vn_async_vkFreeMemory(dev->instance, dev_handle, mem_handle, NULL);
371
369
      return result;
470
468
                                         external_handles);
471
469
}
472
470
 
 
471
static void
 
472
vn_device_memory_emit_report(struct vn_device *dev,
 
473
                             struct vn_device_memory *mem,
 
474
                             bool is_alloc,
 
475
                             VkResult result)
 
476
{
 
477
   if (likely(!dev->memory_reports))
 
478
      return;
 
479
 
 
480
   VkDeviceMemoryReportEventTypeEXT type;
 
481
   if (result != VK_SUCCESS) {
 
482
      type = VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT;
 
483
   } else if (is_alloc) {
 
484
      type = mem->is_import ? VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT
 
485
                            : VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT;
 
486
   } else {
 
487
      type = mem->is_import ? VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT
 
488
                            : VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT;
 
489
   }
 
490
   const uint64_t mem_obj_id =
 
491
      mem->is_external ? mem->base_bo->res_id : mem->base.id;
 
492
   vn_device_emit_device_memory_report(dev, type, mem_obj_id, mem->size,
 
493
                                       &mem->base, mem->type.heapIndex);
 
494
}
 
495
 
473
496
VkResult
474
497
vn_AllocateMemory(VkDevice device,
475
498
                  const VkMemoryAllocateInfo *pAllocateInfo,
481
504
   const VkAllocationCallbacks *alloc =
482
505
      pAllocator ? pAllocator : &dev->base.base.alloc;
483
506
 
484
 
   const VkPhysicalDeviceMemoryProperties *mem_props =
485
 
      &dev->physical_device->memory_properties.memoryProperties;
486
 
   const VkMemoryPropertyFlags mem_flags =
487
 
      mem_props->memoryTypes[pAllocateInfo->memoryTypeIndex].propertyFlags;
488
 
 
489
507
   const VkExportMemoryAllocateInfo *export_info = NULL;
490
508
   const VkImportAndroidHardwareBufferInfoANDROID *import_ahb_info = NULL;
491
509
   const VkImportMemoryFdInfoKHR *import_fd_info = NULL;
492
510
   bool export_ahb = false;
493
 
 
494
511
   vk_foreach_struct_const(pnext, pAllocateInfo->pNext) {
495
512
      switch (pnext->sType) {
496
513
      case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
520
537
 
521
538
   vn_object_base_init(&mem->base, VK_OBJECT_TYPE_DEVICE_MEMORY, &dev->base);
522
539
   mem->size = pAllocateInfo->allocationSize;
523
 
   mem->flags = mem_flags;
 
540
   mem->type = dev->physical_device->memory_properties.memoryProperties
 
541
                  .memoryTypes[pAllocateInfo->memoryTypeIndex];
 
542
   mem->is_import = import_ahb_info || import_fd_info;
 
543
   mem->is_external = mem->is_import || export_info;
524
544
 
525
545
   VkDeviceMemory mem_handle = vn_device_memory_to_handle(mem);
526
546
   VkResult result;
536
556
      result = vn_device_memory_alloc(dev, mem, pAllocateInfo,
537
557
                                      export_info->handleTypes);
538
558
   } else if (vn_device_memory_should_suballocate(dev, pAllocateInfo,
539
 
                                                  mem_flags)) {
 
559
                                                  mem->type.propertyFlags)) {
540
560
      result = vn_device_memory_pool_suballocate(
541
561
         dev, mem, pAllocateInfo->memoryTypeIndex);
542
562
   } else {
543
563
      result = vn_device_memory_alloc(dev, mem, pAllocateInfo, 0);
544
564
   }
 
565
 
 
566
   vn_device_memory_emit_report(dev, mem, /* is_alloc */ true, result);
 
567
 
545
568
   if (result != VK_SUCCESS) {
546
569
      vn_object_base_fini(&mem->base);
547
570
      vk_free(alloc, mem);
567
590
   if (!mem)
568
591
      return;
569
592
 
 
593
   vn_device_memory_emit_report(dev, mem, /* is_alloc */ false, VK_SUCCESS);
 
594
 
570
595
   if (mem->base_memory) {
571
596
      vn_device_memory_pool_unref(dev, mem->base_memory);
572
597
   } else {
614
639
   void *ptr = NULL;
615
640
   VkResult result;
616
641
 
617
 
   assert(mem->flags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
 
642
   assert(mem->type.propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
618
643
 
619
644
   /* We don't want to blindly create a bo for each HOST_VISIBLE memory as
620
645
    * that has a cost. By deferring bo creation until now, we can avoid the
630
655
    */
631
656
   if (need_bo) {
632
657
      result = vn_renderer_bo_create_from_device_memory(
633
 
         dev->renderer, mem->size, mem->base.id, mem->flags, 0,
 
658
         dev->renderer, mem->size, mem->base.id, mem->type.propertyFlags, 0,
634
659
         &mem->base_bo);
635
660
      if (result != VK_SUCCESS)
636
661
         return vn_error(dev->instance, result);
762
787
 
763
788
   vn_instance_roundtrip(dev->instance);
764
789
 
765
 
   VkMemoryResourceAllocationSizeProperties100000MESA alloc_size_props = {
 
790
   VkMemoryResourceAllocationSizePropertiesMESA alloc_size_props = {
766
791
      .sType =
767
 
         VK_STRUCTURE_TYPE_MEMORY_RESOURCE_ALLOCATION_SIZE_PROPERTIES_100000_MESA,
 
792
         VK_STRUCTURE_TYPE_MEMORY_RESOURCE_ALLOCATION_SIZE_PROPERTIES_MESA,
768
793
   };
769
794
   VkMemoryResourcePropertiesMESA props = {
770
795
      .sType = VK_STRUCTURE_TYPE_MEMORY_RESOURCE_PROPERTIES_MESA,