mantle: added quirk to allocate memory specifically for descriptor buffers

Author: Cherser-s

src/mantle/mantle_descriptor_set.c

@@ -28,7 +28,10 @@ GR_RESULT GR_STDCALL grCreateDescriptorSet(
     }
 
     VkBuffer vkBuffer = VK_NULL_HANDLE;
+    VkDeviceMemory bufferMemory = VK_NULL_HANDLE;
     VkDeviceSize bufferSize = 0;
+    VkDeviceAddress bufferAddress = 0ull;
+    void* descriptorBufferPtr = NULL;
     VkDescriptorPool descriptorPool = VK_NULL_HANDLE;
     VkDescriptorSet descriptorSet = VK_NULL_HANDLE;
 
@@ -59,7 +62,69 @@ GR_RESULT GR_STDCALL grCreateDescriptorSet(
         vkRes = VKD.vkCreateBuffer(grDevice->device, &bufferCreateInfo, NULL, &vkBuffer);
         if (vkRes != VK_SUCCESS) {
             LOGE("vkCreateBuffer failed (%d)\n", vkRes);
-            return getGrResult(vkRes);
+            goto bail;
+        }
+        if (quirkHas(QUIRK_DESCRIPTOR_SET_USE_DEDICATED_ALLOCATION)) {
+            VkMemoryRequirements memReqs;
+            VKD.vkGetBufferMemoryRequirements(grDevice->device, vkBuffer, &memReqs);
+
+            const VkMemoryAllocateFlagsInfo flagsInfo = {
+                .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO,
+                .pNext = NULL,
+                .flags = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT,
+                .deviceMask = 0,
+            };
+            VkMemoryAllocateInfo allocateInfo = {
+                .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
+                .pNext = &flagsInfo,
+                .allocationSize = memReqs.size,
+                .memoryTypeIndex = 0xFFFF,
+            };
+            // exclude host non-visible memory types
+            for (unsigned i = 0; i < grDevice->memoryProperties.memoryTypeCount; ++i) {
+                if (!(memReqs.memoryTypeBits & (1 << i))) {
+                    continue;
+                }
+                if (!(grDevice->memoryProperties.memoryTypes[i].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)) {
+                    continue;
+                }
+
+                allocateInfo.memoryTypeIndex = i;
+                vkRes = VKD.vkAllocateMemory(grDevice->device, &allocateInfo, NULL, &bufferMemory);
+                if (vkRes == VK_SUCCESS) {
+                    break;
+                }
+            }
+
+            if (vkRes != VK_SUCCESS) {
+                LOGE("failed to allocate memory for descriptor buffer (%d)\n", vkRes);
+                goto bail;
+            } else if (bufferMemory == VK_NULL_HANDLE) {
+                LOGE("failed to select memory memory for descriptor buffer\n");
+                goto bail;
+            }
+
+            vkRes = VKD.vkBindBufferMemory(grDevice->device, vkBuffer, bufferMemory, 0);
+            if (vkRes != VK_SUCCESS) {
+                LOGE("Buffer binding failed (%d)\n", vkRes);
+                goto bail;
+            }
+            VkBufferDeviceAddressInfo vkBufferAddressInfo = {
+                .sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO,
+                .pNext = NULL,
+                .buffer = vkBuffer,
+            };
+
+            bufferAddress = VKD.vkGetBufferDeviceAddress(grDevice->device, &vkBufferAddressInfo);
+
+            vkRes = VKD.vkMapMemory(grDevice->device, bufferMemory,
+                                    0, VK_WHOLE_SIZE, 0, &descriptorBufferPtr);
+            if (vkRes != VK_SUCCESS) {
+                LOGE("vkMapMemory failed (%d)\n", vkRes);
+                goto bail;
+            }
+
+            memset(descriptorBufferPtr, 0, bufferSize);
         }
     } else {
         const VkDescriptorType descriptorTypes[] = {
@@ -132,11 +197,12 @@ GR_RESULT GR_STDCALL grCreateDescriptorSet(
         .slots = calloc(pCreateInfo->slots, sizeof(DescriptorSetSlot)),
         .descriptorPool = descriptorPool,
         .descriptorSet = descriptorSet,
-        .descriptorBufferPtr = NULL,
+        .descriptorBufferPtr = descriptorBufferPtr,
         .descriptorBuffer = vkBuffer,
+        .descriptorBufferMemory = bufferMemory,
         .descriptorBufferSize = bufferSize,
         .descriptorBufferMemoryOffset = 0ull,
-        .descriptorBufferAddress = 0ull,
+        .descriptorBufferAddress = bufferAddress,
     };
 
     *pDescriptorSet = (GR_DESCRIPTOR_SET)grDescriptorSet;
@@ -145,6 +211,7 @@ GR_RESULT GR_STDCALL grCreateDescriptorSet(
 bail:
     VKD.vkDestroyDescriptorPool(grDevice->device, descriptorPool, NULL);
     VKD.vkDestroyBuffer(grDevice->device, vkBuffer, NULL);
+    VKD.vkFreeMemory(grDevice->device, bufferMemory, NULL);
     return getGrResult(vkRes);
 }
 

src/mantle/mantle_object.h

@@ -241,6 +241,7 @@ typedef struct _GrDescriptorSet {
     VkDescriptorSet descriptorSet;
     void* descriptorBufferPtr;
     VkBuffer descriptorBuffer;
+    VkDeviceMemory descriptorBufferMemory;
     VkDeviceSize descriptorBufferSize;
     VkDeviceSize descriptorBufferMemoryOffset;
     VkDeviceAddress descriptorBufferAddress;

src/mantle/mantle_object_man.c

@@ -43,6 +43,7 @@ GR_RESULT GR_STDCALL grDestroyObject(
         grClearDescriptorSetSlots(grDescriptorSet, 0, grDescriptorSet->slotCount);
         free(grDescriptorSet->slots);
         VKD.vkDestroyBuffer(grDevice->device, grDescriptorSet->descriptorBuffer, NULL);
+        VKD.vkFreeMemory(grDevice->device, grDescriptorSet->descriptorBufferMemory, NULL);
         VKD.vkDestroyDescriptorPool(grDevice->device, grDescriptorSet->descriptorPool, NULL);
     }   break;
     case GR_OBJ_TYPE_EVENT: {
@@ -182,7 +183,7 @@ GR_RESULT GR_STDCALL grGetObjectInfo(
         case GR_OBJ_TYPE_DESCRIPTOR_SET: {
             GrDescriptorSet* grDescriptorSet = (GrDescriptorSet*)grBaseObject;
             GrDevice* grDevice = GET_OBJ_DEVICE(grBaseObject);
-            if (grDevice->descriptorBufferSupported) {
+            if (grDevice->descriptorBufferSupported && !quirkHas(QUIRK_DESCRIPTOR_SET_USE_DEDICATED_ALLOCATION)) {
                 VKD.vkGetBufferMemoryRequirements(grDevice->device, grDescriptorSet->descriptorBuffer, &memReqs);
 
                 // exclude host non-visible memory types
@@ -327,7 +328,7 @@ GR_RESULT GR_STDCALL grBindObjectMemory(
             GrDescriptorSet* grDescriptorSet = (GrDescriptorSet*)grObject;
             GrDevice* grDevice = GET_OBJ_DEVICE(grObject);
 
-            if (grDevice->descriptorBufferSupported) {
+            if (grDevice->descriptorBufferSupported && !quirkHas(QUIRK_DESCRIPTOR_SET_USE_DEDICATED_ALLOCATION)) {
                 vkRes = VKD.vkBindBufferMemory(grDevice->device, grDescriptorSet->descriptorBuffer, grGpuMemory->deviceMemory, offset);
                 if (vkRes == VK_SUCCESS) {
                     VkBufferDeviceAddressInfo vkBufferAddressInfo = {

src/mantle/quirk.c

@@ -12,7 +12,8 @@ void quirkInit(
                   QUIRK_COMPRESSED_IMAGE_COPY_IN_TEXELS |
                   QUIRK_INVALID_CMD_BUFFER_RESET |
                   QUIRK_CUBEMAP_LAYER_DIV_6 |
-                  QUIRK_SILENCE_TRANSFER_ONLY_LINEAR_IMAGE_WARNINGS;
+                  QUIRK_SILENCE_TRANSFER_ONLY_LINEAR_IMAGE_WARNINGS |
+                  QUIRK_DESCRIPTOR_SET_USE_DEDICATED_ALLOCATION;
     } else if (!strcmp(appInfo->pEngineName, "CivTech")) {
         mQuirks = QUIRK_NON_ZERO_MEM_REQ |
                   QUIRK_READ_ONLY_IMAGE_STATE_MISMATCH |

src/mantle/quirk.h

@@ -28,6 +28,9 @@ typedef enum {
     // RADV doesn't support linear transfer-only images used by Star Swarm, but it has no effect
     // on rendering. Silence it.
     QUIRK_SILENCE_TRANSFER_ONLY_LINEAR_IMAGE_WARNINGS = 1 << 7,
+
+    // Star Swarm uses completely incompatible memory types for descriptor buffers
+    QUIRK_DESCRIPTOR_SET_USE_DEDICATED_ALLOCATION = 1 << 8,
 } QUIRK_FLAGS;
 
 void quirkInit(