Limit the apiVersion of the instance within the CTS framework

This CL allows older CTS tests to run on implementations that
support a newer instance version not supported by this version
of CTS.

The dEQP-VK.api.version_check.version test was modified to
fail if this version of CTS is run on an implementation
it does not support. This is to stop old CTS from passing
on newer implementations, where the newer CTS should have
been used.

Affects:

dEQP-VK.api.version_check.version
dEQP-VK.*

Components: Vulkan

VK-GL-CTS issue: 1979

Change-Id: I97cd17b0aae9b3cba7c2e000d21636ad37c1fd80

diff --git a/external/vulkancts/framework/vulkan/vkBasicTypes.inl b/external/vulkancts/framework/vulkan/vkBasicTypes.inl
index 04371cf..fc4422e 100644 (file)
--- a/external/vulkancts/framework/vulkan/vkBasicTypes.inl
+++ b/external/vulkancts/framework/vulkan/vkBasicTypes.inl
@@ -22,6 +22,7 @@
 #define VK_WHOLE_SIZE                                          (static_cast<vk::VkDeviceSize>  ((~0ULL)))
 #define VK_TRUE                                                                (static_cast<vk::VkBool32>              (1))
 #define VK_FALSE                                                       (static_cast<vk::VkBool32>              (0))
+#define VK_API_MAX_FRAMEWORK_VERSION           VK_API_VERSION_1_1
 
 VK_DEFINE_HANDLE                                       (VkInstance,                                    HANDLE_TYPE_INSTANCE);
 VK_DEFINE_HANDLE                                       (VkPhysicalDevice,                              HANDLE_TYPE_PHYSICAL_DEVICE);

diff --git a/external/vulkancts/modules/vulkan/api/vktApiVersionCheck.cpp b/external/vulkancts/modules/vulkan/api/vktApiVersionCheck.cpp
index 80a863e..d441f85 100644 (file)
--- a/external/vulkancts/modules/vulkan/api/vktApiVersionCheck.cpp
+++ b/external/vulkancts/modules/vulkan/api/vktApiVersionCheck.cpp
@@ -72,16 +72,25 @@ public:
        {}
        virtual tcu::TestStatus         iterate                                 (void)
        {
-               tcu::TestLog&                   log                             = m_context.getTestContext().getLog();
-               const vk::ApiVersion    instanceVersion = vk::unpackVersion(m_context.getAvailableInstanceVersion());
-               const vk::ApiVersion    deviceVersion   = vk::unpackVersion(m_context.getDeviceVersion());
-               const vk::ApiVersion    usedApiVersion  = vk::unpackVersion(m_context.getUsedApiVersion());
+               tcu::TestLog&                   log                                             = m_context.getTestContext().getLog();
+               const vk::ApiVersion    maxVulkanVersion                = vk::unpackVersion(m_context.getMaximumFrameworkVulkanVersion());
+               const vk::ApiVersion    instanceVersion                 = vk::unpackVersion(m_context.getAvailableInstanceVersion());
+               const ::std::string             instanceVersionString   = de::toString(instanceVersion.majorNum) + ::std::string(".") + de::toString(instanceVersion.minorNum) + ::std::string(".") + de::toString(instanceVersion.patchNum);
+               const vk::ApiVersion    deviceVersion                   = vk::unpackVersion(m_context.getDeviceVersion());
+               const ::std::string             deviceVersionString             = de::toString(deviceVersion.majorNum) + ::std::string(".") + de::toString(deviceVersion.minorNum) + ::std::string(".") + de::toString(deviceVersion.patchNum);
+               const vk::ApiVersion    usedApiVersion                  = vk::unpackVersion(m_context.getUsedApiVersion());
+               const ::std::string             usedApiVersionString    = de::toString(usedApiVersion.majorNum) + ::std::string(".") + de::toString(usedApiVersion.minorNum) + ::std::string(".") + de::toString(usedApiVersion.patchNum);
 
                log << tcu::TestLog::Message << "availableInstanceVersion: " << instanceVersion << tcu::TestLog::EndMessage;
                log << tcu::TestLog::Message << "deviceVersion: " << deviceVersion << tcu::TestLog::EndMessage;
                log << tcu::TestLog::Message << "usedApiVersion: " << usedApiVersion << tcu::TestLog::EndMessage;
-               const ::std::string             result                  = de::toString(usedApiVersion.majorNum) + ::std::string(".") + de::toString(usedApiVersion.minorNum) + ::std::string(".") + de::toString(usedApiVersion.patchNum);
-               return tcu::TestStatus::pass(result);
+
+               if (instanceVersion.majorNum > maxVulkanVersion.majorNum || instanceVersion.minorNum > maxVulkanVersion.minorNum)
+                       return tcu::TestStatus::fail(de::toString("This version of CTS does not support a Vulkan instance with version ") + instanceVersionString);
+               else if (deviceVersion.majorNum > maxVulkanVersion.majorNum || deviceVersion.minorNum > maxVulkanVersion.minorNum)
+                       return tcu::TestStatus::fail(de::toString("This version of CTS does not support Vulkan device version ") + deviceVersionString);
+               else
+                       return tcu::TestStatus::pass(usedApiVersionString);
        }
 };
 

diff --git a/external/vulkancts/modules/vulkan/vktTestCase.cpp b/external/vulkancts/modules/vulkan/vktTestCase.cpp
index 5338c15..a62283a 100644 (file)
--- a/external/vulkancts/modules/vulkan/vktTestCase.cpp
+++ b/external/vulkancts/modules/vulkan/vktTestCase.cpp
@@ -313,7 +313,9 @@ public:
 
        VkInstance                                                                                                              getInstance                                                             (void) const { return *m_instance;                                                                              }
        const InstanceInterface&                                                                                getInstanceInterface                                    (void) const { return m_instanceInterface;                                                              }
+       deUint32                                                                                                                getMaximumFrameworkVulkanVersion                (void) const { return m_maximumFrameworkVulkanVersion;                                  }
        deUint32                                                                                                                getAvailableInstanceVersion                             (void) const { return m_availableInstanceVersion;                                               }
+       deUint32                                                                                                                getUsedInstanceVersion                                  (void) const { return m_usedInstanceVersion;                                                    }
        const vector<string>&                                                                                   getInstanceExtensions                                   (void) const { return m_instanceExtensions;                                                             }
 
        VkPhysicalDevice                                                                                                getPhysicalDevice                                               (void) const { return m_physicalDevice;                                                                 }
@@ -337,7 +339,9 @@ public:
 
 private:
 
+       const deUint32                                          m_maximumFrameworkVulkanVersion;
        const deUint32                                          m_availableInstanceVersion;
+       const deUint32                                          m_usedInstanceVersion;
 
        const std::pair<deUint32, deUint32> m_deviceVersions;
        const deUint32                                          m_usedApiVersion;
@@ -367,24 +371,26 @@ static deUint32 sanitizeApiVersion(deUint32 v)
 }
 
 DefaultDevice::DefaultDevice (const PlatformInterface& vkPlatform, const tcu::CommandLine& cmdLine)
-       : m_availableInstanceVersion    (getTargetInstanceVersion(vkPlatform))
-       , m_deviceVersions                              (determineDeviceVersions(vkPlatform, m_availableInstanceVersion, cmdLine))
-       , m_usedApiVersion                              (sanitizeApiVersion(deMinu32(m_availableInstanceVersion, m_deviceVersions.first)))
-
-       , m_instanceExtensions                  (addCoreInstanceExtensions(filterExtensions(enumerateInstanceExtensionProperties(vkPlatform, DE_NULL)), m_usedApiVersion))
-       , m_instance                                    (createInstance(vkPlatform, m_usedApiVersion, m_instanceExtensions, cmdLine))
-
-       , m_instanceInterface                   (vkPlatform, *m_instance)
-       , m_physicalDevice                              (chooseDevice(m_instanceInterface, *m_instance, cmdLine))
-       , m_deviceVersion                               (getPhysicalDeviceProperties(m_instanceInterface, m_physicalDevice).apiVersion)
-
-       , m_deviceExtensions                    (addCoreDeviceExtensions(filterExtensions(enumerateDeviceExtensionProperties(m_instanceInterface, m_physicalDevice, DE_NULL)), m_usedApiVersion))
-       , m_deviceFeatures                              (m_instanceInterface, m_usedApiVersion, m_physicalDevice, m_instanceExtensions, m_deviceExtensions)
-       , m_universalQueueFamilyIndex   (findQueueFamilyIndexWithCaps(m_instanceInterface, m_physicalDevice, VK_QUEUE_GRAPHICS_BIT|VK_QUEUE_COMPUTE_BIT))
-       , m_sparseQueueFamilyIndex              (m_deviceFeatures.getCoreFeatures2().features.sparseBinding ? findQueueFamilyIndexWithCaps(m_instanceInterface, m_physicalDevice, VK_QUEUE_SPARSE_BINDING_BIT) : 0)
-       , m_deviceProperties                    (getPhysicalDeviceProperties(m_instanceInterface, m_physicalDevice))
-       , m_device                                              (createDefaultDevice(vkPlatform, *m_instance, m_instanceInterface, m_physicalDevice, m_usedApiVersion, m_universalQueueFamilyIndex, m_sparseQueueFamilyIndex, m_deviceFeatures.getCoreFeatures2(), m_deviceExtensions, cmdLine))
-       , m_deviceInterface                             (vkPlatform, *m_instance, *m_device)
+       : m_maximumFrameworkVulkanVersion       (VK_API_MAX_FRAMEWORK_VERSION)
+       , m_availableInstanceVersion            (getTargetInstanceVersion(vkPlatform))
+       , m_usedInstanceVersion                         (sanitizeApiVersion(deMinu32(m_availableInstanceVersion, m_maximumFrameworkVulkanVersion)))
+       , m_deviceVersions                                      (determineDeviceVersions(vkPlatform, m_usedInstanceVersion, cmdLine))
+       , m_usedApiVersion                                      (sanitizeApiVersion(deMinu32(m_usedInstanceVersion, m_deviceVersions.first)))
+
+       , m_instanceExtensions                          (addCoreInstanceExtensions(filterExtensions(enumerateInstanceExtensionProperties(vkPlatform, DE_NULL)), m_usedApiVersion))
+       , m_instance                                            (createInstance(vkPlatform, m_usedApiVersion, m_instanceExtensions, cmdLine))
+
+       , m_instanceInterface                           (vkPlatform, *m_instance)
+       , m_physicalDevice                                      (chooseDevice(m_instanceInterface, *m_instance, cmdLine))
+       , m_deviceVersion                                       (getPhysicalDeviceProperties(m_instanceInterface, m_physicalDevice).apiVersion)
+
+       , m_deviceExtensions                            (addCoreDeviceExtensions(filterExtensions(enumerateDeviceExtensionProperties(m_instanceInterface, m_physicalDevice, DE_NULL)), m_usedApiVersion))
+       , m_deviceFeatures                                      (m_instanceInterface, m_usedApiVersion, m_physicalDevice, m_instanceExtensions, m_deviceExtensions)
+       , m_universalQueueFamilyIndex           (findQueueFamilyIndexWithCaps(m_instanceInterface, m_physicalDevice, VK_QUEUE_GRAPHICS_BIT|VK_QUEUE_COMPUTE_BIT))
+       , m_sparseQueueFamilyIndex                      (m_deviceFeatures.getCoreFeatures2().features.sparseBinding ? findQueueFamilyIndexWithCaps(m_instanceInterface, m_physicalDevice, VK_QUEUE_SPARSE_BINDING_BIT) : 0)
+       , m_deviceProperties                            (getPhysicalDeviceProperties(m_instanceInterface, m_physicalDevice))
+       , m_device                                                      (createDefaultDevice(vkPlatform, *m_instance, m_instanceInterface, m_physicalDevice, m_usedApiVersion, m_universalQueueFamilyIndex, m_sparseQueueFamilyIndex, m_deviceFeatures.getCoreFeatures2(), m_deviceExtensions, cmdLine))
+       , m_deviceInterface                                     (vkPlatform, *m_instance, *m_device)
 {
        DE_ASSERT(m_deviceVersions.first == m_deviceVersion);
 }
@@ -437,33 +443,34 @@ Context::~Context (void)
 {
 }
 
-deUint32                                                               Context::getAvailableInstanceVersion    (void) const { return m_device->getAvailableInstanceVersion();  }
-const vector<string>&                                  Context::getInstanceExtensions                  (void) const { return m_device->getInstanceExtensions();                }
-vk::VkInstance                                                 Context::getInstance                                    (void) const { return m_device->getInstance();                                  }
-const vk::InstanceInterface&                   Context::getInstanceInterface                   (void) const { return m_device->getInstanceInterface();                 }
-vk::VkPhysicalDevice                                   Context::getPhysicalDevice                              (void) const { return m_device->getPhysicalDevice();                    }
-deUint32                                                               Context::getDeviceVersion                               (void) const { return m_device->getDeviceVersion();                             }
-const vk::VkPhysicalDeviceFeatures&            Context::getDeviceFeatures                              (void) const { return m_device->getDeviceFeatures();                    }
-const vk::VkPhysicalDeviceFeatures2&   Context::getDeviceFeatures2                             (void) const { return m_device->getDeviceFeatures2();                   }
+deUint32                                                               Context::getMaximumFrameworkVulkanVersion       (void) const { return m_device->getMaximumFrameworkVulkanVersion();             }
+deUint32                                                               Context::getAvailableInstanceVersion            (void) const { return m_device->getAvailableInstanceVersion();                  }
+const vector<string>&                                  Context::getInstanceExtensions                          (void) const { return m_device->getInstanceExtensions();                                }
+vk::VkInstance                                                 Context::getInstance                                            (void) const { return m_device->getInstance();                                                  }
+const vk::InstanceInterface&                   Context::getInstanceInterface                           (void) const { return m_device->getInstanceInterface();                                 }
+vk::VkPhysicalDevice                                   Context::getPhysicalDevice                                      (void) const { return m_device->getPhysicalDevice();                                    }
+deUint32                                                               Context::getDeviceVersion                                       (void) const { return m_device->getDeviceVersion();                                             }
+const vk::VkPhysicalDeviceFeatures&            Context::getDeviceFeatures                                      (void) const { return m_device->getDeviceFeatures();                                    }
+const vk::VkPhysicalDeviceFeatures2&   Context::getDeviceFeatures2                                     (void) const { return m_device->getDeviceFeatures2();                                   }
 
 #include "vkDeviceFeaturesForContextDefs.inl"
 
-const vk::VkPhysicalDeviceProperties&  Context::getDeviceProperties                    (void) const { return m_device->getDeviceProperties();                  }
-const vector<string>&                                  Context::getDeviceExtensions                    (void) const { return m_device->getDeviceExtensions();                  }
-vk::VkDevice                                                   Context::getDevice                                              (void) const { return m_device->getDevice();                                    }
-const vk::DeviceInterface&                             Context::getDeviceInterface                             (void) const { return m_device->getDeviceInterface();                   }
-deUint32                                                               Context::getUniversalQueueFamilyIndex   (void) const { return m_device->getUniversalQueueFamilyIndex(); }
-vk::VkQueue                                                            Context::getUniversalQueue                              (void) const { return m_device->getUniversalQueue();                    }
-deUint32                                                               Context::getSparseQueueFamilyIndex              (void) const { return m_device->getSparseQueueFamilyIndex();    }
-vk::VkQueue                                                            Context::getSparseQueue                                 (void) const { return m_device->getSparseQueue();                               }
-vk::Allocator&                                                 Context::getDefaultAllocator                    (void) const { return *m_allocator;                                                             }
-deUint32                                                               Context::getUsedApiVersion                              (void) const { return m_device->getUsedApiVersion();                    }
-bool                                                                   Context::contextSupports                                (const deUint32 majorNum, const deUint32 minorNum, const deUint32 patchNum) const
-                                                                                                                                                                                       { return m_device->getUsedApiVersion() >= VK_MAKE_VERSION(majorNum, minorNum, patchNum); }
-bool                                                                   Context::contextSupports                                (const ApiVersion version) const
-                                                                                                                                                                                       { return m_device->getUsedApiVersion() >= pack(version); }
-bool                                                                   Context::contextSupports                                (const deUint32 requiredApiVersionBits) const
-                                                                                                                                                                                       { return m_device->getUsedApiVersion() >= requiredApiVersionBits; }
+const vk::VkPhysicalDeviceProperties&  Context::getDeviceProperties                            (void) const { return m_device->getDeviceProperties();                                  }
+const vector<string>&                                  Context::getDeviceExtensions                            (void) const { return m_device->getDeviceExtensions();                                  }
+vk::VkDevice                                                   Context::getDevice                                                      (void) const { return m_device->getDevice();                                                    }
+const vk::DeviceInterface&                             Context::getDeviceInterface                                     (void) const { return m_device->getDeviceInterface();                                   }
+deUint32                                                               Context::getUniversalQueueFamilyIndex           (void) const { return m_device->getUniversalQueueFamilyIndex();                 }
+vk::VkQueue                                                            Context::getUniversalQueue                                      (void) const { return m_device->getUniversalQueue();                                    }
+deUint32                                                               Context::getSparseQueueFamilyIndex                      (void) const { return m_device->getSparseQueueFamilyIndex();                    }
+vk::VkQueue                                                            Context::getSparseQueue                                         (void) const { return m_device->getSparseQueue();                                               }
+vk::Allocator&                                                 Context::getDefaultAllocator                            (void) const { return *m_allocator;                                                                             }
+deUint32                                                               Context::getUsedApiVersion                                      (void) const { return m_device->getUsedApiVersion();                                    }
+bool                                                                   Context::contextSupports                                        (const deUint32 majorNum, const deUint32 minorNum, const deUint32 patchNum) const
+                                                                                                                                                                                               { return m_device->getUsedApiVersion() >= VK_MAKE_VERSION(majorNum, minorNum, patchNum); }
+bool                                                                   Context::contextSupports                                        (const ApiVersion version) const
+                                                                                                                                                                                               { return m_device->getUsedApiVersion() >= pack(version); }
+bool                                                                   Context::contextSupports                                        (const deUint32 requiredApiVersionBits) const
+                                                                                                                                                                                               { return m_device->getUsedApiVersion() >= requiredApiVersionBits; }
 
 bool Context::requireDeviceExtension (const std::string& required)
 {

diff --git a/external/vulkancts/modules/vulkan/vktTestCase.hpp b/external/vulkancts/modules/vulkan/vktTestCase.hpp
index de0f153..cf6a0e4 100644 (file)
--- a/external/vulkancts/modules/vulkan/vktTestCase.hpp
+++ b/external/vulkancts/modules/vulkan/vktTestCase.hpp
@@ -57,45 +57,46 @@ class DefaultDevice;
 class Context
 {
 public:
-                                                                                               Context                                                 (tcu::TestContext&                              testCtx,
-                                                                                                                                                                const vk::PlatformInterface&   platformInterface,
-                                                                                                                                                                vk::BinaryCollection&                  progCollection);
-                                                                                               ~Context                                                (void);
+                                                                                               Context                                                         (tcu::TestContext&                              testCtx,
+                                                                                                                                                                        const vk::PlatformInterface&   platformInterface,
+                                                                                                                                                                        vk::BinaryCollection&                  progCollection);
+                                                                                               ~Context                                                        (void);
 
-       tcu::TestContext&                                                       getTestContext                                  (void) const { return m_testCtx;                        }
-       const vk::PlatformInterface&                            getPlatformInterface                    (void) const { return m_platformInterface;      }
-       vk::BinaryCollection&                                           getBinaryCollection                             (void) const { return m_progCollection;         }
+       tcu::TestContext&                                                       getTestContext                                          (void) const { return m_testCtx;                        }
+       const vk::PlatformInterface&                            getPlatformInterface                            (void) const { return m_platformInterface;      }
+       vk::BinaryCollection&                                           getBinaryCollection                                     (void) const { return m_progCollection;         }
 
        // Default instance & device, selected with --deqp-vk-device-id=N
-       deUint32                                                                        getAvailableInstanceVersion             (void) const;
-       const std::vector<std::string>&                         getInstanceExtensions                   (void) const;
-       vk::VkInstance                                                          getInstance                                             (void) const;
-       const vk::InstanceInterface&                            getInstanceInterface                    (void) const;
-       vk::VkPhysicalDevice                                            getPhysicalDevice                               (void) const;
-       deUint32                                                                        getDeviceVersion                                (void) const;
-       const vk::VkPhysicalDeviceFeatures&                     getDeviceFeatures                               (void) const;
-       const vk::VkPhysicalDeviceFeatures2&            getDeviceFeatures2                              (void) const;
+       deUint32                                                                        getMaximumFrameworkVulkanVersion        (void) const;
+       deUint32                                                                        getAvailableInstanceVersion                     (void) const;
+       const std::vector<std::string>&                         getInstanceExtensions                           (void) const;
+       vk::VkInstance                                                          getInstance                                                     (void) const;
+       const vk::InstanceInterface&                            getInstanceInterface                            (void) const;
+       vk::VkPhysicalDevice                                            getPhysicalDevice                                       (void) const;
+       deUint32                                                                        getDeviceVersion                                        (void) const;
+       const vk::VkPhysicalDeviceFeatures&                     getDeviceFeatures                                       (void) const;
+       const vk::VkPhysicalDeviceFeatures2&            getDeviceFeatures2                                      (void) const;
 
 #include "vkDeviceFeaturesForContextDecl.inl"
 
-       const vk::VkPhysicalDeviceProperties&           getDeviceProperties                             (void) const;
-       const std::vector<std::string>&                         getDeviceExtensions                             (void) const;
-       vk::VkDevice                                                            getDevice                                               (void) const;
-       const vk::DeviceInterface&                                      getDeviceInterface                              (void) const;
-       deUint32                                                                        getUniversalQueueFamilyIndex    (void) const;
-       vk::VkQueue                                                                     getUniversalQueue                               (void) const;
-       deUint32                                                                        getUsedApiVersion                               (void) const;
-       deUint32                                                                        getSparseQueueFamilyIndex               (void) const;
-       vk::VkQueue                                                                     getSparseQueue                                  (void) const;
-       vk::Allocator&                                                          getDefaultAllocator                             (void) const;
-       bool                                                                            contextSupports                                 (const deUint32 majorNum, const deUint32 minorNum, const deUint32 patchNum) const;
-       bool                                                                            contextSupports                                 (const vk::ApiVersion version) const;
-       bool                                                                            contextSupports                                 (const deUint32 requiredApiVersionBits) const;
-       bool                                                                            requireDeviceExtension                  (const std::string& required);
-       bool                                                                            requireInstanceExtension                (const std::string& required);
-       bool                                                                            requireDeviceCoreFeature                (const DeviceCoreFeature requiredDeviceCoreFeature);
-
-       void*                                                                           getInstanceProcAddr                             ();
+       const vk::VkPhysicalDeviceProperties&           getDeviceProperties                                     (void) const;
+       const std::vector<std::string>&                         getDeviceExtensions                                     (void) const;
+       vk::VkDevice                                                            getDevice                                                       (void) const;
+       const vk::DeviceInterface&                                      getDeviceInterface                                      (void) const;
+       deUint32                                                                        getUniversalQueueFamilyIndex            (void) const;
+       vk::VkQueue                                                                     getUniversalQueue                                       (void) const;
+       deUint32                                                                        getUsedApiVersion                                       (void) const;
+       deUint32                                                                        getSparseQueueFamilyIndex                       (void) const;
+       vk::VkQueue                                                                     getSparseQueue                                          (void) const;
+       vk::Allocator&                                                          getDefaultAllocator                                     (void) const;
+       bool                                                                            contextSupports                                         (const deUint32 majorNum, const deUint32 minorNum, const deUint32 patchNum) const;
+       bool                                                                            contextSupports                                         (const vk::ApiVersion version) const;
+       bool                                                                            contextSupports                                         (const deUint32 requiredApiVersionBits) const;
+       bool                                                                            requireDeviceExtension                          (const std::string& required);
+       bool                                                                            requireInstanceExtension                        (const std::string& required);
+       bool                                                                            requireDeviceCoreFeature                        (const DeviceCoreFeature requiredDeviceCoreFeature);
+
+       void*                                                                           getInstanceProcAddr                                     ();
 
 protected:
        tcu::TestContext&                                                       m_testCtx;
@@ -106,8 +107,8 @@ protected:
        const de::UniquePtr<vk::Allocator>                      m_allocator;
 
 private:
-                                                                                               Context                                                 (const Context&); // Not allowed
-       Context&                                                                        operator=                                               (const Context&); // Not allowed
+                                                                                               Context                                                         (const Context&); // Not allowed
+       Context&                                                                        operator=                                                       (const Context&); // Not allowed
 };
 
 class TestInstance;

diff --git a/external/vulkancts/scripts/gen_framework.py b/external/vulkancts/scripts/gen_framework.py
index 637e5f1..c1bc006 100644 (file)
--- a/external/vulkancts/scripts/gen_framework.py
+++ b/external/vulkancts/scripts/gen_framework.py
@@ -846,12 +846,27 @@ def genDefinitionsAliasSrc (definitions):
                        raise Exception("Value of %s (%s) is different than core definition value %s (%s)." % (definition.name, definition.value, definitions[definition].name, definitions[definition].value))
                yield line
 
+def genMaxFrameworkVersion (definitions):
+       maxApiVersionMajor = 1
+       maxApiVersionMinor = 0
+       for definition in definitions:
+               match = re.match("VK_API_VERSION_(\d+)_(\d+)", definition.name)
+               if match:
+                       apiVersionMajor = int(match.group(1))
+                       apiVersionMinor = int(match.group(2))
+                       if apiVersionMajor > maxApiVersionMajor:
+                               maxApiVersionMajor = apiVersionMajor
+                               maxApiVersionMinor = apiVersionMinor
+                       elif apiVersionMajor == maxApiVersionMajor and apiVersionMinor > maxApiVersionMinor:
+                               maxApiVersionMinor = apiVersionMinor
+       yield "#define VK_API_MAX_FRAMEWORK_VERSION\tVK_API_VERSION_%d_%d" % (maxApiVersionMajor, maxApiVersionMinor)
+
 def writeBasicTypes (api, filename):
 
        def gen ():
                definitionsCore, definitionDuplicates = splitUniqueAndDuplicatedEntries(api.definitions)
 
-               for line in indentLines(chain(genDefinitionsSrc(definitionsCore), genDefinitionsAliasSrc(definitionDuplicates))):
+               for line in indentLines(chain(genDefinitionsSrc(definitionsCore), genMaxFrameworkVersion(definitionsCore), genDefinitionsAliasSrc(definitionDuplicates))):
                        yield line
                yield ""