vulkaninfo: Present Surfaces now wont show duplicates

If a machine has multiple surface types that work with the
same gpu and have the same properties, vulkainfo will now
list them in a short array instead of duplicating the entire
surfaces information. To do this required being able to compare
vulkan objects, necesitating the autogeneration of comparators
for vulkan structs. This patch also refactors some of the
device creation code to better reflect the actual data
dependencies of the various vulkan objects.

files modified
 - vulkaninfo/vulkaninfo.cpp
 - vulkaninfo/vulkaninfo.h
 - scripts/vulkaninfo_generator.py
 - vulkaninfo/generated/vulkaninfo.hpp

Change-Id: Ifda51eacc3883982a6e2f7f60439827eb355c204

4 files changed, 298 insertions, 168 deletions

diff --git a/scripts/vulkaninfo_generator.py b/scripts/vulkaninfo_generator.py
index 318ecd51..3846e345 100644
--- a/scripts/vulkaninfo_generator.py
+++ b/scripts/vulkaninfo_generator.py
@@ -92,6 +92,9 @@ flags_to_gen = ['VkSurfaceTransformFlagsKHR', 'VkCompositeAlphaFlagsKHR',
                 'VkDeviceGroupPresentModeFlagsKHR', 'VkFormatFeatureFlags', 'VkMemoryPropertyFlags', 'VkMemoryHeapFlags']
 flags_strings_to_gen = ['VkQueueFlags']
 
+struct_comparisons_to_gen = ['VkSurfaceFormatKHR', 'VkSurfaceFormat2KHR', 'VkSurfaceCapabilitiesKHR',
+                             'VkSurfaceCapabilities2KHR', 'VkSurfaceCapabilities2EXT']
+
 # iostream or custom outputter handles these types
 predefined_types = ['char', 'VkBool32', 'uint32_t', 'uint8_t', 'int32_t',
                     'float', 'uint64_t', 'size_t', 'VkDeviceSize', 'VkConformanceVersionKHR']
@@ -177,6 +180,7 @@ class VulkanInfoGenerator(OutputGenerator):
         self.flags = set()
         self.bitmasks = set()
         self.structures = set()
+        self.structs_to_comp = set()
         self.all_structures = set()
 
         self.types_to_gen = set()
@@ -216,6 +220,12 @@ class VulkanInfoGenerator(OutputGenerator):
             types_to_gen = types_to_gen.union(
                 GatherTypesToGen(self.extension_sets[key]))
 
+        structs_to_comp = set()
+        for s in struct_comparisons_to_gen:
+            structs_to_comp.add(s)
+        structs_to_comp = structs_to_comp.union(
+            GatherTypesToGen(self.structs_to_comp))
+
         self.enums = sorted(self.enums, key=operator.attrgetter('name'))
         self.flags = sorted(self.flags, key=operator.attrgetter('name'))
         self.bitmasks = sorted(self.bitmasks, key=operator.attrgetter('name'))
@@ -275,6 +285,14 @@ class VulkanInfoGenerator(OutputGenerator):
             out += PrintChainIterator(key,
                                       self.extension_sets[key], value.get('type'))
 
+        for s in self.all_structures:
+            if s.name in structs_to_comp:
+                out += PrintStructComparisonForwardDef(s)
+
+        for s in self.all_structures:
+            if s.name in structs_to_comp:
+                out += PrintStructComparison(s)
+
         gen.write(out, file=self.outFile)
 
         gen.OutputGenerator.endFile(self)
@@ -311,6 +329,10 @@ class VulkanInfoGenerator(OutputGenerator):
             self.structures.add(VulkanStructure(
                 name, typeinfo.elem, self.constants, self.extTypes))
 
+        if typeinfo.elem.get('category') == 'struct' and name in struct_comparisons_to_gen:
+            self.structs_to_comp.add(VulkanStructure(
+                name, typeinfo.elem, self.constants, self.extTypes))
+
         if typeinfo.elem.get('category') == 'struct':
             self.all_structures.add(VulkanStructure(
                 name, typeinfo.elem, self.constants, self.extTypes))
@@ -328,13 +350,19 @@ class VulkanInfoGenerator(OutputGenerator):
 
 
 def GatherTypesToGen(structures):
-    types_to_gen = set()
-    for s in structures:
-        types_to_gen.add(s.name)
-        for m in s.members:
-            if m.typeID not in predefined_types and m.name not in ['sType', 'pNext']:
-                types_to_gen.add(m.typeID)
-    return types_to_gen
+    types = set()
+    added_stuff = True  # repeat until no new types are added
+    while added_stuff == True:
+        added_stuff = False
+        for s in structures:
+            size = len(types)
+            types.add(s.name)
+            if len(types) != size:
+                added_stuff = True
+            for m in s.members:
+                if m.typeID not in predefined_types and m.name not in ['sType', 'pNext']:
+                    types.add(m.typeID)
+    return types
 
 
 def GetExtension(name, generator):
@@ -608,6 +636,31 @@ def PrintChainIterator(listName, structures, checkExtLoc):
     return out
 
 
+def PrintStructComparisonForwardDef(structure):
+    out = ''
+    out += "bool operator==(const " + structure.name + \
+        " & a, const " + structure.name + " b);\n"
+    return out
+
+
+def PrintStructComparison(structure):
+    out = ''
+    out += "bool operator==(const " + structure.name + \
+        " & a, const " + structure.name + " b) {\n"
+    out += "    return "
+    is_first = True
+    for m in structure.members:
+        if m.name not in ['sType', 'pNext']:
+            if not is_first:
+                out += "\n        && "
+            else:
+                is_first = False
+            out += "a." + m.name + " == b." + m.name
+    out += ";\n"
+    out += "}\n"
+    return out
+
+
 def isPow2(num):
     return num != 0 and ((num & (num - 1)) == 0)
 
diff --git a/vulkaninfo/generated/vulkaninfo.hpp b/vulkaninfo/generated/vulkaninfo.hpp
index 261a05dd..12060fb3 100644
--- a/vulkaninfo/generated/vulkaninfo.hpp
+++ b/vulkaninfo/generated/vulkaninfo.hpp
@@ -2120,4 +2120,49 @@ void chain_iterator_format_properties2(Printer &p, AppGpu &gpu, void * place) {
         place = structure->pNext;
     }
 }
+bool operator==(const VkExtent2D & a, const VkExtent2D b);
+bool operator==(const VkSurfaceCapabilities2EXT & a, const VkSurfaceCapabilities2EXT b);
+bool operator==(const VkSurfaceCapabilities2KHR & a, const VkSurfaceCapabilities2KHR b);
+bool operator==(const VkSurfaceCapabilitiesKHR & a, const VkSurfaceCapabilitiesKHR b);
+bool operator==(const VkSurfaceFormat2KHR & a, const VkSurfaceFormat2KHR b);
+bool operator==(const VkSurfaceFormatKHR & a, const VkSurfaceFormatKHR b);
+bool operator==(const VkExtent2D & a, const VkExtent2D b) {
+    return a.width == b.width
+        && a.height == b.height;
+}
+bool operator==(const VkSurfaceCapabilities2EXT & a, const VkSurfaceCapabilities2EXT b) {
+    return a.minImageCount == b.minImageCount
+        && a.maxImageCount == b.maxImageCount
+        && a.currentExtent == b.currentExtent
+        && a.minImageExtent == b.minImageExtent
+        && a.maxImageExtent == b.maxImageExtent
+        && a.maxImageArrayLayers == b.maxImageArrayLayers
+        && a.supportedTransforms == b.supportedTransforms
+        && a.currentTransform == b.currentTransform
+        && a.supportedCompositeAlpha == b.supportedCompositeAlpha
+        && a.supportedUsageFlags == b.supportedUsageFlags
+        && a.supportedSurfaceCounters == b.supportedSurfaceCounters;
+}
+bool operator==(const VkSurfaceCapabilities2KHR & a, const VkSurfaceCapabilities2KHR b) {
+    return a.surfaceCapabilities == b.surfaceCapabilities;
+}
+bool operator==(const VkSurfaceCapabilitiesKHR & a, const VkSurfaceCapabilitiesKHR b) {
+    return a.minImageCount == b.minImageCount
+        && a.maxImageCount == b.maxImageCount
+        && a.currentExtent == b.currentExtent
+        && a.minImageExtent == b.minImageExtent
+        && a.maxImageExtent == b.maxImageExtent
+        && a.maxImageArrayLayers == b.maxImageArrayLayers
+        && a.supportedTransforms == b.supportedTransforms
+        && a.currentTransform == b.currentTransform
+        && a.supportedCompositeAlpha == b.supportedCompositeAlpha
+        && a.supportedUsageFlags == b.supportedUsageFlags;
+}
+bool operator==(const VkSurfaceFormat2KHR & a, const VkSurfaceFormat2KHR b) {
+    return a.surfaceFormat == b.surfaceFormat;
+}
+bool operator==(const VkSurfaceFormatKHR & a, const VkSurfaceFormatKHR b) {
+    return a.format == b.format
+        && a.colorSpace == b.colorSpace;
+}
 
diff --git a/vulkaninfo/vulkaninfo.cpp b/vulkaninfo/vulkaninfo.cpp
index fbfda81a..75a653d8 100644
--- a/vulkaninfo/vulkaninfo.cpp
+++ b/vulkaninfo/vulkaninfo.cpp
@@ -53,7 +53,7 @@ void DumpExtensions(Printer &p, std::string layer_name, std::vector<VkExtensionP
     p.ArrayEnd();
 }
 
-void DumpLayers(Printer &p, std::vector<LayerExtensionList> layers, std::vector<AppGpu *> gpus) {
+void DumpLayers(Printer &p, std::vector<LayerExtensionList> layers, const std::vector<std::unique_ptr<AppGpu>> &gpus) {
     std::sort(layers.begin(), layers.end(), [](LayerExtensionList &left, LayerExtensionList &right) -> int {
         const char *a = left.layer_properties.layerName;
         const char *b = right.layer_properties.layerName;
@@ -146,7 +146,7 @@ void DumpSurfaceCapabilities(Printer &p, AppInstance &inst, AppGpu &gpu, AppSurf
     chain_iterator_surface_capabilities2(p, inst, gpu, surface.surface_capabilities2_khr.pNext);
 }
 
-void DumpSurface(Printer &p, AppInstance &inst, AppGpu &gpu, AppSurface &surface) {
+void DumpSurface(Printer &p, AppInstance &inst, AppGpu &gpu, AppSurface &surface, std::vector<std::string> surface_types) {
     std::string header;
     if (p.Type() == OutputType::text)
         header = std::string("GPU id : ") + std::to_string(gpu.id) + " (" + gpu.props.deviceName + ")";
@@ -154,7 +154,15 @@ void DumpSurface(Printer &p, AppInstance &inst, AppGpu &gpu, AppSurface &surface
         header = std::string("GPU id : <span class='val'>") + std::to_string(gpu.id) + "</span> (" + gpu.props.deviceName + ")";
     p.ObjectStart(header);
 
-    p.SetAsType().PrintKeyValue("Surface type", surface.surface_extension.name);
+    if (surface_types.size() == 0) {
+        p.SetAsType().PrintKeyValue("Surface type", surface.surface_extension.name);
+    } else {
+        p.ArrayStart("Surface types", surface_types.size());
+        for (auto &name : surface_types) {
+            p.PrintElement(name);
+        }
+        p.ArrayEnd();
+    }
 
     DumpSurfaceFormats(p, inst, surface);
 
@@ -166,14 +174,43 @@ void DumpSurface(Printer &p, AppInstance &inst, AppGpu &gpu, AppSurface &surface
     p.AddNewline();
 }
 
-void DumpPresentableSurfaces(Printer &p, AppInstance &inst, std::vector<AppGpu *> &gpus, std::vector<AppSurface *> &surfaces) {
+struct SurfaceTypeGroup {
+    AppSurface *surface;
+    std::vector<std::string> surface_types;
+    AppGpu *gpu;
+};
+
+bool operator==(AppSurface const &a, AppSurface const &b) {
+    return a.surf_present_modes == b.surf_present_modes && a.surf_formats == b.surf_formats && a.surf_formats2 == b.surf_formats2 &&
+           a.surface_capabilities == b.surface_capabilities && a.surface_capabilities2_khr == b.surface_capabilities2_khr &&
+           a.surface_capabilities2_ext == b.surface_capabilities2_ext;
+}
+
+void DumpPresentableSurfaces(Printer &p, AppInstance &inst, const std::vector<std::unique_ptr<AppGpu>> &gpus,
+                             const std::vector<std::unique_ptr<AppSurface>> &surfaces) {
     p.SetHeader().ObjectStart("Presentable Surfaces");
     p.IndentDecrease();
+    std::vector<SurfaceTypeGroup> surface_list;
+
     for (auto &surface : surfaces) {
         for (auto &gpu : gpus) {
-            DumpSurface(p, inst, *gpu, *surface);
+            auto exists = surface_list.end();
+            for (auto it = surface_list.begin(); it != surface_list.end(); it++) {
+                // use custom comparator to check if the surface has the same values
+                if (it->gpu == gpu.get() && *it->surface == *surface.get()) {
+                    exists = it;
+                }
+            }
+            if (exists != surface_list.end()) {
+                exists->surface_types.push_back(surface.get()->surface_extension.name);
+            } else {
+                surface_list.push_back({surface.get(), {surface.get()->surface_extension.name}, gpu.get()});
+            }
         }
     }
+    for (auto &group : surface_list) {
+        DumpSurface(p, inst, *group.gpu, *group.surface, group.surface_types);
+    }
     p.IndentIncrease();
     p.ObjectEnd();
     p.AddNewline();
@@ -671,34 +708,31 @@ int main(int argc, char **argv) {
 
     auto pNext_chains = get_chain_infos();
 
-    auto gpu_holder = FindGpus(instance, pNext_chains);
+    auto phys_devices = instance.FindPhysicalDevices();
 
-    std::vector<AppGpu *> gpus;
-    for (auto &gpu : gpu_holder) {
-        gpus.push_back(gpu.get());
-    }
-
-    if (selected_gpu >= gpus.size()) {
-        selected_gpu = 0;
-    }
-
-    std::vector<std::unique_ptr<AppSurface>> surfaces_holder;
+    std::vector<std::unique_ptr<AppSurface>> surfaces;
 #if defined(VK_USE_PLATFORM_XCB_KHR) || defined(VK_USE_PLATFORM_XLIB_KHR) || defined(VK_USE_PLATFORM_WIN32_KHR) || \
     defined(VK_USE_PLATFORM_MACOS_MVK) || defined(VK_USE_PLATFORM_WAYLAND_KHR)
     for (auto &surface_extension : instance.surface_extensions) {
         surface_extension.create_window(instance);
         surface_extension.surface = surface_extension.create_surface(instance);
-        for (auto &gpu : gpus) {
-            surfaces_holder.push_back(
-                std::unique_ptr<AppSurface>(new AppSurface(instance, gpu, surface_extension, pNext_chains.surface_capabilities2)));
+        for (auto &phys_device : phys_devices) {
+            surfaces.push_back(std::unique_ptr<AppSurface>(
+                new AppSurface(instance, phys_device, surface_extension, pNext_chains.surface_capabilities2)));
         }
     }
+#endif
 
-    std::vector<AppSurface *> surfaces;
-    for (auto &surface : surfaces_holder) {
-        surfaces.push_back(surface.get());
+    std::vector<std::unique_ptr<AppGpu>> gpus;
+
+    uint32_t gpu_counter = 0;
+    for (auto &phys_device : phys_devices) {
+        gpus.push_back(std::unique_ptr<AppGpu>(new AppGpu(instance, gpu_counter++, phys_device, pNext_chains)));
+    }
+
+    if (selected_gpu >= gpus.size()) {
+        selected_gpu = 0;
     }
-#endif
 
     std::vector<std::unique_ptr<Printer>> printers;
 
@@ -738,7 +772,7 @@ int main(int argc, char **argv) {
         for (auto &gpu : gpus) {
             if ((p->Type() == OutputType::json && gpu->id == selected_gpu) || p->Type() == OutputType::text ||
                 p->Type() == OutputType::html) {
-                DumpGpu(*p.get(), *gpu, show_formats, pNext_chains);
+                DumpGpu(*p.get(), *gpu.get(), show_formats, pNext_chains);
             }
         }
         if (p->Type() != OutputType::json) {
diff --git a/vulkaninfo/vulkaninfo.h b/vulkaninfo/vulkaninfo.h
index ea8ddd54..3a10370a 100644
--- a/vulkaninfo/vulkaninfo.h
+++ b/vulkaninfo/vulkaninfo.h
@@ -146,6 +146,33 @@ struct pNextChainBuildingBlockInfo {
     uint32_t mem_size;
 };
 
+void buildpNextChain(VkStructureHeader *first, const std::vector<pNextChainBuildingBlockInfo> &chain_info) {
+    VkStructureHeader *place = first;
+
+    for (uint32_t i = 0; i < chain_info.size(); i++) {
+        place->pNext = static_cast<VkStructureHeader *>(malloc(chain_info[i].mem_size));
+        if (!place->pNext) {
+            ERR_EXIT(VK_ERROR_OUT_OF_HOST_MEMORY);
+        }
+        std::memset(place->pNext, 0, chain_info[i].mem_size);
+        place = place->pNext;
+        place->sType = chain_info[i].sType;
+    }
+
+    place->pNext = nullptr;
+}
+
+void freepNextChain(VkStructureHeader *first) {
+    VkStructureHeader *place = first;
+    VkStructureHeader *next = nullptr;
+
+    while (place) {
+        next = place->pNext;
+        free(place);
+        place = next;
+    }
+}
+
 struct LayerExtensionList {
     VkLayerProperties layer_properties;
     std::vector<VkExtensionProperties> extension_properties;
@@ -353,6 +380,26 @@ struct AppInstance {
         if (err) ERR_EXIT(err);
         return ext_props;
     }
+
+    std::vector<VkPhysicalDevice> FindPhysicalDevices() {
+        std::vector<VkPhysicalDevice> phys_devices;
+
+        VkResult err;
+        uint32_t gpu_count = 0;
+
+        /* repeat get until VK_INCOMPLETE goes away */
+        do {
+            err = vkEnumeratePhysicalDevices(instance, &gpu_count, nullptr);
+            if (err) ERR_EXIT(err);
+
+            phys_devices.resize(gpu_count);
+            err = vkEnumeratePhysicalDevices(instance, &gpu_count, phys_devices.data());
+            if (err) ERR_EXIT(err);
+            phys_devices.resize(gpu_count);
+        } while (err == VK_INCOMPLETE);
+
+        return phys_devices;
+    }
 };
 
 // --------- Platform Specific Presentation Calls --------- //
@@ -725,6 +772,94 @@ void SetupWindowExtensions(AppInstance &inst) {
 #endif
 }
 
+// ---------- Surfaces -------------- //
+
+class AppSurface {
+   public:
+    AppInstance &inst;
+    SurfaceExtension surface_extension;
+
+    std::vector<VkPresentModeKHR> surf_present_modes;
+
+    std::vector<VkSurfaceFormatKHR> surf_formats;
+    std::vector<VkSurfaceFormat2KHR> surf_formats2;
+
+    VkSurfaceCapabilitiesKHR surface_capabilities;
+    VkSurfaceCapabilities2KHR surface_capabilities2_khr;
+    VkSurfaceCapabilities2EXT surface_capabilities2_ext;
+
+    AppSurface(AppInstance &inst, VkPhysicalDevice phys_device, SurfaceExtension surface_extension,
+               std::vector<pNextChainBuildingBlockInfo> &sur_extension_pNextChain)
+        : inst(inst), surface_extension(surface_extension) {
+        uint32_t present_mode_count = 0;
+        VkResult err =
+            inst.vkGetPhysicalDeviceSurfacePresentModesKHR(phys_device, surface_extension.surface, &present_mode_count, nullptr);
+        if (err) ERR_EXIT(err);
+
+        surf_present_modes.resize(present_mode_count);
+        err = inst.vkGetPhysicalDeviceSurfacePresentModesKHR(phys_device, surface_extension.surface, &present_mode_count,
+                                                             surf_present_modes.data());
+        if (err) ERR_EXIT(err);
+
+        const VkPhysicalDeviceSurfaceInfo2KHR surface_info2 = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR, nullptr,
+                                                               surface_extension.surface};
+
+        uint32_t format_count = 0;
+        if (inst.CheckExtensionEnabled(VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME)) {
+            VkResult err = inst.vkGetPhysicalDeviceSurfaceFormats2KHR(phys_device, &surface_info2, &format_count, nullptr);
+            if (err) ERR_EXIT(err);
+            surf_formats2.resize(format_count);
+            for (uint32_t i = 0; i < format_count; ++i) {
+                surf_formats2[i].sType = VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR;
+                surf_formats2[i].pNext = nullptr;
+            }
+            err = inst.vkGetPhysicalDeviceSurfaceFormats2KHR(phys_device, &surface_info2, &format_count, surf_formats2.data());
+            if (err) ERR_EXIT(err);
+        } else {
+            VkResult err =
+                inst.vkGetPhysicalDeviceSurfaceFormatsKHR(phys_device, surface_extension.surface, &format_count, nullptr);
+            if (err) ERR_EXIT(err);
+            surf_formats.resize(format_count);
+            err = inst.vkGetPhysicalDeviceSurfaceFormatsKHR(phys_device, surface_extension.surface, &format_count,
+                                                            surf_formats.data());
+            if (err) ERR_EXIT(err);
+        }
+
+        if (inst.CheckExtensionEnabled(VK_KHR_SURFACE_EXTENSION_NAME)) {
+            VkResult err =
+                inst.vkGetPhysicalDeviceSurfaceCapabilitiesKHR(phys_device, surface_extension.surface, &surface_capabilities);
+            if (err) ERR_EXIT(err);
+        }
+
+        if (inst.CheckExtensionEnabled(VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME)) {
+            surface_capabilities2_khr.sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR;
+            buildpNextChain((VkStructureHeader *)&surface_capabilities2_khr, sur_extension_pNextChain);
+
+            VkPhysicalDeviceSurfaceInfo2KHR surface_info;
+            surface_info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR;
+            surface_info.pNext = nullptr;
+            surface_info.surface = surface_extension.surface;
+
+            VkResult err = inst.vkGetPhysicalDeviceSurfaceCapabilities2KHR(phys_device, &surface_info, &surface_capabilities2_khr);
+            if (err) ERR_EXIT(err);
+        }
+
+        if (inst.CheckExtensionEnabled(VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME)) {
+            surface_capabilities2_ext.sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT;
+            surface_capabilities2_ext.pNext = nullptr;
+            VkResult err =
+                inst.vkGetPhysicalDeviceSurfaceCapabilities2EXT(phys_device, surface_extension.surface, &surface_capabilities2_ext);
+            if (err) ERR_EXIT(err);
+        }
+    }
+
+    ~AppSurface() {
+        if (inst.CheckExtensionEnabled(VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME)) {
+            freepNextChain(static_cast<VkStructureHeader *>(surface_capabilities2_khr.pNext));
+        }
+    }
+};
+
 // -------------------- Device Groups ------------------------//
 
 std::vector<VkPhysicalDeviceGroupProperties> GetGroups(AppInstance &inst) {
@@ -798,33 +933,6 @@ std::pair<bool, VkDeviceGroupPresentCapabilitiesKHR> GetGroupCapabilities(AppIns
 
 // -------------------- Device Setup ------------------- //
 
-void buildpNextChain(VkStructureHeader *first, const std::vector<pNextChainBuildingBlockInfo> &chain_info) {
-    VkStructureHeader *place = first;
-
-    for (uint32_t i = 0; i < chain_info.size(); i++) {
-        place->pNext = static_cast<VkStructureHeader *>(malloc(chain_info[i].mem_size));
-        if (!place->pNext) {
-            ERR_EXIT(VK_ERROR_OUT_OF_HOST_MEMORY);
-        }
-        std::memset(place->pNext, 0, chain_info[i].mem_size);
-        place = place->pNext;
-        place->sType = chain_info[i].sType;
-    }
-
-    place->pNext = nullptr;
-}
-
-void freepNextChain(VkStructureHeader *first) {
-    VkStructureHeader *place = first;
-    VkStructureHeader *next = nullptr;
-
-    while (place) {
-        next = place->pNext;
-        free(place);
-        place = next;
-    }
-}
-
 struct MemImageSupport {
     bool regular_supported, sparse_supported, transient_supported;
     VkFormat format;
@@ -1164,26 +1272,6 @@ struct AppGpu {
         }
     }
 };
-
-std::vector<std::unique_ptr<AppGpu>> FindGpus(AppInstance &instance, pNextChainInfos chainInfos) {
-    uint32_t gpu_count;
-    VkResult err = vkEnumeratePhysicalDevices(instance.instance, &gpu_count, nullptr);
-    if (err) ERR_EXIT(err);
-
-    std::vector<VkPhysicalDevice> phys_devices(gpu_count);
-
-    err = vkEnumeratePhysicalDevices(instance.instance, &gpu_count, phys_devices.data());
-    if (err) ERR_EXIT(err);
-
-    std::vector<std::unique_ptr<AppGpu>> gpus;
-
-    uint32_t i = 0;
-    for (auto &phys_device : phys_devices) {
-        gpus.push_back(std::unique_ptr<AppGpu>(new AppGpu(instance, i++, phys_device, chainInfos)));
-    }
-    return gpus;
-}
-
 struct AppQueueFamilyProperties {
     VkQueueFamilyProperties props;
     uint32_t queue_index;
@@ -1212,96 +1300,6 @@ struct AppQueueFamilyProperties {
     }
 };
 
-// ---------- Surfaces -------------- //
-
-class AppSurface {
-   public:
-    AppInstance &inst;
-    SurfaceExtension surface_extension;
-
-    uint32_t present_mode_count = 0;
-    std::vector<VkPresentModeKHR> surf_present_modes;
-
-    uint32_t format_count = 0;
-    std::vector<VkSurfaceFormatKHR> surf_formats;
-    std::vector<VkSurfaceFormat2KHR> surf_formats2;
-
-    VkSurfaceCapabilitiesKHR surface_capabilities;
-    VkSurfaceCapabilities2KHR surface_capabilities2_khr;
-    VkSurfaceCapabilities2EXT surface_capabilities2_ext;
-
-    AppSurface(AppInstance &inst, AppGpu *gpu, SurfaceExtension surface_extension,
-               std::vector<pNextChainBuildingBlockInfo> &sur_extension_pNextChain)
-        : inst(inst), surface_extension(surface_extension) {
-        uint32_t present_mode_count = 0;
-        VkResult err = inst.vkGetPhysicalDeviceSurfacePresentModesKHR(gpu->phys_device, surface_extension.surface,
-                                                                      &present_mode_count, nullptr);
-        if (err) ERR_EXIT(err);
-
-        surf_present_modes.resize(present_mode_count);
-        err = inst.vkGetPhysicalDeviceSurfacePresentModesKHR(gpu->phys_device, surface_extension.surface, &present_mode_count,
-                                                             surf_present_modes.data());
-        if (err) ERR_EXIT(err);
-
-        const VkPhysicalDeviceSurfaceInfo2KHR surface_info2 = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR, nullptr,
-                                                               surface_extension.surface};
-
-        if (inst.CheckExtensionEnabled(VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME)) {
-            VkResult err = inst.vkGetPhysicalDeviceSurfaceFormats2KHR(gpu->phys_device, &surface_info2, &format_count, nullptr);
-            if (err) ERR_EXIT(err);
-            surf_formats2.resize(format_count);
-            for (uint32_t i = 0; i < format_count; ++i) {
-                surf_formats2[i].sType = VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR;
-                surf_formats2[i].pNext = nullptr;
-            }
-            err = inst.vkGetPhysicalDeviceSurfaceFormats2KHR(gpu->phys_device, &surface_info2, &format_count, surf_formats2.data());
-            if (err) ERR_EXIT(err);
-        } else {
-            VkResult err =
-                inst.vkGetPhysicalDeviceSurfaceFormatsKHR(gpu->phys_device, surface_extension.surface, &format_count, nullptr);
-            if (err) ERR_EXIT(err);
-            surf_formats.resize(format_count);
-            err = inst.vkGetPhysicalDeviceSurfaceFormatsKHR(gpu->phys_device, surface_extension.surface, &format_count,
-                                                            surf_formats.data());
-            if (err) ERR_EXIT(err);
-        }
-
-        if (inst.CheckExtensionEnabled(VK_KHR_SURFACE_EXTENSION_NAME)) {
-            VkResult err =
-                inst.vkGetPhysicalDeviceSurfaceCapabilitiesKHR(gpu->phys_device, surface_extension.surface, &surface_capabilities);
-            if (err) ERR_EXIT(err);
-        }
-
-        if (inst.CheckExtensionEnabled(VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME)) {
-            surface_capabilities2_khr.sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR;
-            buildpNextChain((VkStructureHeader *)&surface_capabilities2_khr, sur_extension_pNextChain);
-
-            VkPhysicalDeviceSurfaceInfo2KHR surface_info;
-            surface_info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR;
-            surface_info.pNext = nullptr;
-            surface_info.surface = surface_extension.surface;
-
-            VkResult err =
-                inst.vkGetPhysicalDeviceSurfaceCapabilities2KHR(gpu->phys_device, &surface_info, &surface_capabilities2_khr);
-            if (err) ERR_EXIT(err);
-        }
-
-        if (inst.CheckExtensionEnabled(VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME)) {
-            surface_capabilities2_ext.sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT;
-            surface_capabilities2_ext.pNext = nullptr;
-            VkResult err = inst.vkGetPhysicalDeviceSurfaceCapabilities2EXT(gpu->phys_device, surface_extension.surface,
-                                                                           &surface_capabilities2_ext);
-            if (err) ERR_EXIT(err);
-        }
-    }
-
-    ~AppSurface() {
-        if (inst.CheckExtensionEnabled(VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME)) {
-            freepNextChain(static_cast<VkStructureHeader *>(surface_capabilities2_khr.pNext));
-        }
-    }
-};
-
 // --------- Format Properties ----------//
 
 struct PropFlags {