add config option to keep allocated memories mapped (#801)

Some workloads on some devices can get huge performance improvement by
keeping allocated memories mapped.

Author: rjodinchr

src/config.def

@@ -66,6 +66,8 @@ OPTION(uint32_t, enqueue_command_retry_sleep_us, UINT32_MAX) // UINT32_MAX meani
 
 OPTION(bool, supports_filter_linear, true)
 
+OPTION(bool, keep_memory_allocations_mapped, false)
+
 OPTION(std::string, device_extensions, "")
 OPTION(std::string, device_extensions_masked, "")
 

src/device.hpp

@@ -699,6 +699,10 @@ struct cvk_device : public _cl_device_id,
                0;
     }
 
+    bool keep_memory_allocations_mapped() const {
+        return m_clvk_properties->keep_memory_allocations_mapped();
+    }
+
 private:
     std::string version_desc() const {
         std::string ret = "CLVK on Vulkan v";

src/device_properties.hpp

@@ -71,6 +71,10 @@ struct cvk_device_properties {
         return no_disabled_formats;
     }
 
+    virtual bool keep_memory_allocations_mapped() const {
+        return config.keep_memory_allocations_mapped();
+    }
+
     virtual ~cvk_device_properties() {}
 };
 

src/memory.cpp

@@ -127,7 +127,8 @@ bool cvk_buffer::init() {
 
     // Allocate memory
     m_memory = std::make_shared<cvk_memory_allocation>(
-        vkdev, params.size, params.memory_type_index, params.memory_coherent);
+        vkdev, params.size, params.memory_type_index, params.memory_coherent,
+        device->keep_memory_allocations_mapped());
     res = m_memory->allocate(device->uses_physical_addressing());
 
     if (res != VK_SUCCESS) {
@@ -441,7 +442,8 @@ bool cvk_image::init_vulkan_image() {
 
     // Allocate memory
     m_memory = std::make_unique<cvk_memory_allocation>(
-        vkdev, params.size, params.memory_type_index, params.memory_coherent);
+        vkdev, params.size, params.memory_type_index, params.memory_coherent,
+        device->keep_memory_allocations_mapped());
 
     res = m_memory->allocate(device->uses_physical_addressing());
 

src/memory.hpp

@@ -25,11 +25,15 @@
 struct cvk_memory_allocation {
 
     cvk_memory_allocation(VkDevice dev, VkDeviceSize size, uint32_t type_index,
-                          bool coherent)
+                          bool coherent, bool keep_mapping)
         : m_device(dev), m_size(size), m_memory(VK_NULL_HANDLE),
-          m_memory_type_index(type_index), m_coherent(coherent) {}
+          m_memory_type_index(type_index), m_coherent(coherent),
+          m_keep_mapping(keep_mapping), m_map_ptr(nullptr) {}
 
     ~cvk_memory_allocation() {
+        if (m_keep_mapping && m_map_ptr != nullptr) {
+            vkUnmapMemory(m_device, m_memory);
+        }
         if (m_memory != VK_NULL_HANDLE) {
             vkFreeMemory(m_device, m_memory, nullptr);
         }
@@ -73,10 +77,19 @@ struct cvk_memory_allocation {
     }
 
     VkResult map(void** map_ptr) {
-        return vkMapMemory(m_device, m_memory, 0, m_size, 0, map_ptr);
+        VkResult result = VK_SUCCESS;
+        if (!m_keep_mapping || m_map_ptr == nullptr) {
+            result = vkMapMemory(m_device, m_memory, 0, m_size, 0, &m_map_ptr);
+        }
+        *map_ptr = m_map_ptr;
+        return result;
     }
 
-    void unmap() { vkUnmapMemory(m_device, m_memory); }
+    void unmap() {
+        if (!m_keep_mapping) {
+            vkUnmapMemory(m_device, m_memory);
+        }
+    }
 
     VkDeviceMemory vulkan_memory() { return m_memory; }
 
@@ -86,6 +99,8 @@ struct cvk_memory_allocation {
     VkDeviceMemory m_memory;
     uint32_t m_memory_type_index;
     bool m_coherent;
+    bool m_keep_mapping;
+    void* m_map_ptr;
 };
 
 using cvk_mem_callback_pointer_type = void(CL_CALLBACK*)(cl_mem mem,