Staging buffer transfers

Author: Pilzschaf

libs/SDL

@@ -128,16 +128,11 @@ void initApplication(SDL_Window* window) {
 		VKA(vkAllocateCommandBuffers(context->device, &allocateInfo, &commandBuffers[i]));
 	}
 
-	createBuffer(context, &vertexBuffer, sizeof(vertexData), VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
-	void* data;
-	VKA(vkMapMemory(context->device, vertexBuffer.memory, 0, sizeof(vertexData), 0, &data));
-	memcpy(data, vertexData, sizeof(vertexData));
-	VK(vkUnmapMemory(context->device, vertexBuffer.memory));
-
-	createBuffer(context, &indexBuffer, sizeof(indexData), VK_BUFFER_USAGE_INDEX_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
-	VKA(vkMapMemory(context->device, indexBuffer.memory, 0, sizeof(indexData), 0, &data));
-	memcpy(data, indexData, sizeof(indexData));
-	VK(vkUnmapMemory(context->device, indexBuffer.memory));
+	createBuffer(context, &vertexBuffer, sizeof(vertexData), VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
+	uploadDataToBuffer(context, &vertexBuffer, vertexData, sizeof(vertexData));
+	
+	createBuffer(context, &indexBuffer, sizeof(indexData), VK_BUFFER_USAGE_INDEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
+	uploadDataToBuffer(context, &indexBuffer, indexData, sizeof(indexData));
 }
 
 void recreateSwapchain() {

src/main.cpp

@@ -56,6 +56,7 @@ VkRenderPass createRenderPass(VulkanContext* context, VkFormat format);
 void destroyRenderpass(VulkanContext* context, VkRenderPass renderPass);
 
 void createBuffer(VulkanContext* context, VulkanBuffer* buffer, uint64_t size, VkBufferUsageFlags usage, VkMemoryPropertyFlags memoryProperties);
+void uploadDataToBuffer(VulkanContext* context, VulkanBuffer* buffer, void* data, size_t size);
 void destroyBuffer(VulkanContext* context, VulkanBuffer* buffer);
 
 VulkanPipeline createPipeline(VulkanContext* context, const char* vertexShaderFilename, const char* fragmentShaderFilename, VkRenderPass renderPass, uint32_t width, uint32_t height, VkVertexInputAttributeDescription* attributes, uint32_t numAttributes, VkVertexInputBindingDescription* binding);

src/vulkan_base/vulkan_base.h

@@ -116,6 +116,17 @@ bool createLogicalDevice(VulkanContext* context, uint32_t deviceExtensionCount,
 	context->graphicsQueue.familyIndex = graphicsQueueIndex;
 	VK(vkGetDeviceQueue(context->device, graphicsQueueIndex, 0, &context->graphicsQueue.queue));
 
+	VkPhysicalDeviceMemoryProperties deviceMemoryProperties;
+	VK(vkGetPhysicalDeviceMemoryProperties(context->physicalDevice, &deviceMemoryProperties));
+	LOG_INFO("Num device memory heaps: ", deviceMemoryProperties.memoryHeapCount);
+	for (uint32_t i = 0; i < deviceMemoryProperties.memoryHeapCount; ++i) {
+		const char* isDeviceLocal = "false";
+		if (deviceMemoryProperties.memoryHeaps[i].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) {
+			isDeviceLocal = "true";
+		}
+		LOG_INFO("Heap ", i, ": Size:", deviceMemoryProperties.memoryHeaps[i].size, "bytes Device local: ", isDeviceLocal);
+	}
+
 	return true;
 }
 

src/vulkan_base/vulkan_device.cpp

@@ -10,12 +10,13 @@ uint32_t findMemoryType(VulkanContext* context, uint32_t typeFilter, VkMemoryPro
 			// Check if required properties are satisfied
 			if ((deviceMemoryProperties.memoryTypes[i].propertyFlags & memoryProperties) == memoryProperties) {
 				// Return this memory type index
+				LOG_INFO("Using memory heap index ", deviceMemoryProperties.memoryTypes[i].heapIndex);
 				return i;
 			}
 		}
 	}
 
-	// No matching avaialble memroy type found
+	// No matching avaialble memory type found
 	assert(false);
 	return UINT32_MAX;
 }
@@ -41,6 +42,57 @@ void createBuffer(VulkanContext* context, VulkanBuffer* buffer, uint64_t size, V
 	VKA(vkBindBufferMemory(context->device, buffer->buffer, buffer->memory, 0));
 }
 
+void uploadDataToBuffer(VulkanContext* context, VulkanBuffer* buffer, void* data, size_t size) {
+#if 0
+	void* mapped;
+	VKA(vkMapMemory(context->device, buffer->memory, 0, size, 0, &mapped));
+	memcpy(mapped, data, size);
+	VK(vkUnmapMemory(context->device, buffer->memory));
+#else
+	// Upload with staging buffer
+	VulkanQueue* queue = &context->graphicsQueue;
+	VkCommandPool commandPool;
+	VkCommandBuffer commandBuffer;
+	VulkanBuffer stagingBuffer;
+	createBuffer(context, &stagingBuffer, size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
+	void* mapped;
+	VKA(vkMapMemory(context->device, stagingBuffer.memory, 0, size, 0, &mapped));
+	memcpy(mapped, data, size);
+	VK(vkUnmapMemory(context->device, stagingBuffer.memory));
+	{
+		VkCommandPoolCreateInfo createInfo = { VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO };
+		createInfo.flags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT;
+		createInfo.queueFamilyIndex = queue->familyIndex;
+		VKA(vkCreateCommandPool(context->device, &createInfo, 0, &commandPool));
+	}
+	{
+		VkCommandBufferAllocateInfo allocateInfo = { VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO };
+		allocateInfo.commandPool = commandPool;
+		allocateInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
+		allocateInfo.commandBufferCount = 1;
+		VKA(vkAllocateCommandBuffers(context->device, &allocateInfo, &commandBuffer));
+	}
+
+	VkCommandBufferBeginInfo beginInfo = { VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO };
+	beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
+	VKA(vkBeginCommandBuffer(commandBuffer, &beginInfo));
+
+	VkBufferCopy region = { 0, 0, size };
+	VK(vkCmdCopyBuffer(commandBuffer, stagingBuffer.buffer, buffer->buffer, 1, &region));
+
+	VKA(vkEndCommandBuffer(commandBuffer));
+
+	VkSubmitInfo submitInfo = { VK_STRUCTURE_TYPE_SUBMIT_INFO };
+	submitInfo.commandBufferCount = 1;
+	submitInfo.pCommandBuffers = &commandBuffer;
+	VKA(vkQueueSubmit(queue->queue, 1, &submitInfo, VK_NULL_HANDLE));
+	VKA(vkQueueWaitIdle(queue->queue));
+
+	VK(vkDestroyCommandPool(context->device, commandPool, 0));
+	destroyBuffer(context, &stagingBuffer);
+#endif
+}
+
 void destroyBuffer(VulkanContext* context, VulkanBuffer* buffer) {
 	VK(vkDestroyBuffer(context->device, buffer->buffer, 0));
 	// Assumes that the buffer owns its own memory block