{
VulkanFeatures features;
if (string(cap) == "uniform_buffer_block")
- features.ext16BitStorage = EXT16BITSTORAGEFEATURES_UNIFORM_BUFFER_BLOCK;
+ features.ext16BitStorage.storageBuffer16BitAccess = true;
else if (string(cap) == "uniform")
- features.ext16BitStorage = EXT16BITSTORAGEFEATURES_UNIFORM;
+ features.ext16BitStorage.uniformAndStorageBuffer16BitAccess = true;
else
DE_ASSERT(false && "not supported");
spec.outputs.push_back(Resource(BufferSp(new Float32Buffer(cTypes[tyIdx].useConstantIndex ? float32DataConstIdx : float32Data))));
spec.extensions.push_back("VK_KHR_16bit_storage");
- spec.requestedVulkanFeatures.ext16BitStorage = EXT16BITSTORAGEFEATURES_PUSH_CONSTANT;
+ spec.requestedVulkanFeatures.ext16BitStorage.storagePushConstant16 = true;
group->addChild(new SpvAsmComputeShaderCase(testCtx, testName.c_str(), testName.c_str(), spec));
}
else
spec.outputs.push_back(Resource(BufferSp(new Int32Buffer(uOutputs))));
spec.extensions.push_back("VK_KHR_16bit_storage");
- spec.requestedVulkanFeatures.ext16BitStorage = EXT16BITSTORAGEFEATURES_PUSH_CONSTANT;
+ spec.requestedVulkanFeatures.ext16BitStorage.storagePushConstant16 = true;
group->addChild(new SpvAsmComputeShaderCase(testCtx, testName, testName, spec));
}
};
VulkanFeatures requiredFeatures;
- requiredFeatures.ext16BitStorage = EXT16BITSTORAGEFEATURES_INPUT_OUTPUT;
+ requiredFeatures.ext16BitStorage.storageInputOutput16 = true;
for (deUint32 caseIdx = 0; caseIdx < DE_LENGTH_OF_ARRAY(cases); ++caseIdx)
for (deUint32 rndModeIdx = 0; rndModeIdx < DE_LENGTH_OF_ARRAY(rndModes); ++rndModeIdx)
};
VulkanFeatures requiredFeatures;
- requiredFeatures.ext16BitStorage = EXT16BITSTORAGEFEATURES_INPUT_OUTPUT;
+ requiredFeatures.ext16BitStorage.storageInputOutput16 = true;
for (deUint32 caseIdx = 0; caseIdx < DE_LENGTH_OF_ARRAY(cases); ++caseIdx)
{
vector<deFloat16> float16Data (getFloat16s(rnd, numDataPoints));
VulkanFeatures requiredFeatures;
- requiredFeatures.ext16BitStorage = EXT16BITSTORAGEFEATURES_INPUT_OUTPUT;
+ requiredFeatures.ext16BitStorage.storageInputOutput16 = true;
extensions.push_back("VK_KHR_16bit_storage");
fragments["capability"] = "OpCapability StorageInputOutput16\n";
getDefaultColors(defaultColors);
extensions.push_back("VK_KHR_16bit_storage");
- requiredFeatures.ext16BitStorage = EXT16BITSTORAGEFEATURES_INPUT_OUTPUT;
+ requiredFeatures.ext16BitStorage.storageInputOutput16 = true;
const struct
{
getDefaultColors(defaultColors);
extensions.push_back("VK_KHR_16bit_storage");
- requiredFeatures.ext16BitStorage = EXT16BITSTORAGEFEATURES_INPUT_OUTPUT;
+ requiredFeatures.ext16BitStorage.storageInputOutput16 = true;
requiredFeatures.coreFeatures.shaderInt16 = DE_TRUE;
const struct
VulkanFeatures requiredFeatures;
requiredFeatures.coreFeatures.shaderInt16 = DE_TRUE;
- requiredFeatures.ext16BitStorage = EXT16BITSTORAGEFEATURES_INPUT_OUTPUT;
+ requiredFeatures.ext16BitStorage.storageInputOutput16 = true;
for (deUint32 caseIdx = 0; caseIdx < DE_LENGTH_OF_ARRAY(cases); ++caseIdx)
{
VulkanFeatures requiredFeatures;
requiredFeatures.coreFeatures.shaderInt16 = DE_TRUE;
- requiredFeatures.ext16BitStorage = EXT16BITSTORAGEFEATURES_INPUT_OUTPUT;
+ requiredFeatures.ext16BitStorage.storageInputOutput16 = true;
for (deUint32 caseIdx = 0; caseIdx < DE_LENGTH_OF_ARRAY(cases); ++caseIdx)
{
vector<deInt16> inputs = getInt16s(rnd, numDataPoints);
VulkanFeatures requiredFeatures;
- requiredFeatures.ext16BitStorage = EXT16BITSTORAGEFEATURES_INPUT_OUTPUT;
+ requiredFeatures.ext16BitStorage.storageInputOutput16 = true;
extensions.push_back("VK_KHR_16bit_storage");
fragments["capability"] = "OpCapability StorageInputOutput16\n";
requiredFeatures.coreFeatures.vertexPipelineStoresAndAtomics = true;
requiredFeatures.coreFeatures.fragmentStoresAndAtomics = true;
- requiredFeatures.ext16BitStorage = EXT16BITSTORAGEFEATURES_PUSH_CONSTANT;
+ requiredFeatures.ext16BitStorage.storagePushConstant16 = true;
fragments["capability"] = "OpCapability StoragePushConstant16\n";
fragments["extension"] = "OpExtension \"SPV_KHR_16bit_storage\"";
requiredFeatures.coreFeatures.vertexPipelineStoresAndAtomics = true;
requiredFeatures.coreFeatures.fragmentStoresAndAtomics = true;
- requiredFeatures.ext16BitStorage = EXT16BITSTORAGEFEATURES_PUSH_CONSTANT;
+ requiredFeatures.ext16BitStorage.storagePushConstant16 = true;
fragments["capability"] = "OpCapability StoragePushConstant16\n";
fragments["extension"] = "OpExtension \"SPV_KHR_16bit_storage\"";
features.coreFeatures.vertexPipelineStoresAndAtomics = true;
features.coreFeatures.fragmentStoresAndAtomics = true;
- features.ext16BitStorage = EXT16BITSTORAGEFEATURES_UNIFORM_BUFFER_BLOCK;
+ features.ext16BitStorage.storageBuffer16BitAccess = true;
createTestsForAllStages(testName, defaultColors, defaultColors, fragments, resources, extensions, testGroup, features);
}
VulkanFeatures requiredFeatures;
requiredFeatures.coreFeatures.shaderFloat64 = DE_TRUE;
- requiredFeatures.ext16BitStorage = EXT16BITSTORAGEFEATURES_INPUT_OUTPUT;
+ requiredFeatures.ext16BitStorage.storageInputOutput16 = true;
for (deUint32 caseIdx = 0; caseIdx < DE_LENGTH_OF_ARRAY(cases); ++caseIdx)
{
extensions.push_back("VK_KHR_16bit_storage");
requiredFeatures.coreFeatures.shaderFloat64 = DE_TRUE;
- requiredFeatures.ext16BitStorage = EXT16BITSTORAGEFEATURES_PUSH_CONSTANT;
+ requiredFeatures.ext16BitStorage.storagePushConstant16 = true;
fragments["capability"] =
"OpCapability StoragePushConstant16\n"
VulkanFeatures requiredFeatures;
requiredFeatures.coreFeatures.shaderFloat64 = DE_TRUE;
- requiredFeatures.ext16BitStorage = EXT16BITSTORAGEFEATURES_INPUT_OUTPUT;
+ requiredFeatures.ext16BitStorage.storageInputOutput16 = true;
for (deUint32 caseIdx = 0; caseIdx < DE_LENGTH_OF_ARRAY(cases); ++caseIdx)
for (deUint32 rndModeIdx = 0; rndModeIdx < DE_LENGTH_OF_ARRAY(rndModes); ++rndModeIdx)
spec.extensions.push_back("VK_KHR_16bit_storage");
spec.requestedVulkanFeatures.coreFeatures.shaderFloat64 = VK_TRUE;
- spec.requestedVulkanFeatures.ext16BitStorage = EXT16BITSTORAGEFEATURES_PUSH_CONSTANT;
+ spec.requestedVulkanFeatures.ext16BitStorage.storagePushConstant16 = true;
group->addChild(new SpvAsmComputeShaderCase(testCtx, testName.c_str(), testName.c_str(), spec));
}
DE_ASSERT(DE_NULL == "Invalid shader stage specified");
}
- ExtensionFloatControlsFeatures fcFeatures;
+ vk::VkPhysicalDeviceFloatControlsProperties fcFeatures;
deMemset(&fcFeatures, 0, sizeof(fcFeatures));
fcFeatures.shaderSignedZeroInfNanPreserveFloat64 = VK_TRUE;
- if (m_params.requireNanPreserve && !isFloatControlsFeaturesSupported(context, fcFeatures))
+ const char *unused;
+ if (m_params.requireNanPreserve && !isFloatControlsFeaturesSupported(context, fcFeatures, &unused))
TCU_THROW(NotSupportedError, "NaN preservation not supported");
}
{
VulkanFeatures features;
if (string(cap) == "storage_buffer")
- features.ext8BitStorage = EXT8BITSTORAGEFEATURES_STORAGE_BUFFER;
+ features.ext8BitStorage.storageBuffer8BitAccess = true;
else if (string(cap) == "uniform")
- features.ext8BitStorage = EXT8BITSTORAGEFEATURES_UNIFORM_STORAGE_BUFFER;
+ features.ext8BitStorage.uniformAndStorageBuffer8BitAccess = true;
else if (string(cap) == "push_constant")
- features.ext8BitStorage = EXT8BITSTORAGEFEATURES_PUSH_CONSTANT;
+ features.ext8BitStorage.storagePushConstant8 = true;
else
DE_ASSERT(false && "not supported");
spec.outputs.push_back(BufferSp(new Int32Buffer(uOutputs)));
spec.extensions.push_back("VK_KHR_8bit_storage");
spec.extensions.push_back("VK_KHR_storage_buffer_storage_class");
- spec.requestedVulkanFeatures.ext8BitStorage = EXT8BITSTORAGEFEATURES_PUSH_CONSTANT;
+ spec.requestedVulkanFeatures.ext8BitStorage.storagePushConstant8 = true;
group->addChild(new SpvAsmComputeShaderCase(testCtx, testName, testName, spec));
}
spec.extensions.push_back("VK_KHR_8bit_storage");
spec.extensions.push_back("VK_KHR_storage_buffer_storage_class");
spec.requestedVulkanFeatures = get8BitStorageFeatures(CAPABILITIES[STORAGE_BUFFER_TEST].name);
- spec.requestedVulkanFeatures.ext16BitStorage = EXT16BITSTORAGEFEATURES_UNIFORM;
+ spec.requestedVulkanFeatures.ext16BitStorage.uniformAndStorageBuffer16BitAccess = true;
group->addChild(new SpvAsmComputeShaderCase(testCtx, testName.c_str(), testName.c_str(), spec));
}
spec.extensions.push_back("VK_KHR_16bit_storage");
spec.extensions.push_back("VK_KHR_storage_buffer_storage_class");
spec.requestedVulkanFeatures = get8BitStorageFeatures(CAPABILITIES[UNIFORM_AND_STORAGEBUFFER_TEST].name);
- spec.requestedVulkanFeatures.ext16BitStorage = EXT16BITSTORAGEFEATURES_UNIFORM;
+ spec.requestedVulkanFeatures.ext16BitStorage.uniformAndStorageBuffer16BitAccess = true;
if (cTypes[tyIdx].componentsCount == 4)
spec.verifyIO = checkUniformsArray<deInt8, deInt16, 4>;
spec.extensions.push_back("VK_KHR_8bit_storage");
spec.extensions.push_back("VK_KHR_16bit_storage");
spec.extensions.push_back("VK_KHR_storage_buffer_storage_class");
- spec.requestedVulkanFeatures.ext8BitStorage = EXT8BITSTORAGEFEATURES_PUSH_CONSTANT;
- spec.requestedVulkanFeatures.ext16BitStorage = EXT16BITSTORAGEFEATURES_UNIFORM;
+ spec.requestedVulkanFeatures.ext8BitStorage.storagePushConstant8 = true;
+ spec.requestedVulkanFeatures.ext16BitStorage.uniformAndStorageBuffer16BitAccess = true;
group->addChild(new SpvAsmComputeShaderCase(testCtx, testName, testName, spec));
}
spec.outputs.push_back(BufferSp(new Int8Buffer(int8DummyData)));
spec.extensions.push_back("VK_KHR_storage_buffer_storage_class");
spec.extensions.push_back("VK_KHR_8bit_storage");
- spec.requestedVulkanFeatures.ext8BitStorage = EXT8BITSTORAGEFEATURES_STORAGE_BUFFER;
+ spec.requestedVulkanFeatures.ext8BitStorage.storageBuffer8BitAccess = true;
group->addChild(new SpvAsmComputeShaderCase(testCtx, "stress_test", "Granularity stress test", spec));
}
requiredFeatures.coreFeatures.vertexPipelineStoresAndAtomics = true;
requiredFeatures.coreFeatures.fragmentStoresAndAtomics = true;
- requiredFeatures.ext8BitStorage = EXT8BITSTORAGEFEATURES_PUSH_CONSTANT;
+ requiredFeatures.ext8BitStorage.storagePushConstant8 = true;
fragments["capability"] = "OpCapability StoragePushConstant8\n";
fragments["extension"] = "OpExtension \"SPV_KHR_storage_buffer_storage_class\"\n"
fragments["decoration"] = categories[catIdx].decoration.specialize(specs);
features = get8BitStorageFeatures(CAPABILITIES[UNIFORM_AND_STORAGEBUFFER_TEST].name);
- features.ext16BitStorage = EXT16BITSTORAGEFEATURES_UNIFORM;
+ features.ext16BitStorage.uniformAndStorageBuffer16BitAccess = true;
features.coreFeatures.vertexPipelineStoresAndAtomics = true;
features.coreFeatures.fragmentStoresAndAtomics = true;
}
features = get8BitStorageFeatures(CAPABILITIES[UNIFORM_AND_STORAGEBUFFER_TEST].name);
- features.ext16BitStorage = EXT16BITSTORAGEFEATURES_UNIFORM;
+ features.ext16BitStorage.uniformAndStorageBuffer16BitAccess = true;
features.coreFeatures.vertexPipelineStoresAndAtomics = true;
features.coreFeatures.fragmentStoresAndAtomics = true;
requiredFeatures.coreFeatures.vertexPipelineStoresAndAtomics = true;
requiredFeatures.coreFeatures.fragmentStoresAndAtomics = true;
- requiredFeatures.ext8BitStorage = EXT8BITSTORAGEFEATURES_PUSH_CONSTANT;
- requiredFeatures.ext16BitStorage = EXT16BITSTORAGEFEATURES_UNIFORM;
+ requiredFeatures.ext8BitStorage.storagePushConstant8 = true;
+ requiredFeatures.ext16BitStorage.uniformAndStorageBuffer16BitAccess = true;
fragments["capability"] = "OpCapability StoragePushConstant8\n"
"OpCapability StorageUniform16\n";
// Core features
{
- const char* unsupportedFeature = DE_NULL;
- vk::VkPhysicalDeviceFeatures localRequiredCoreFeatures = m_shaderSpec.requestedVulkanFeatures.coreFeatures;
+ VulkanFeatures localRequired = m_shaderSpec.requestedVulkanFeatures;
// Skip check features not targeted to compute
- localRequiredCoreFeatures.fullDrawIndexUint32 = DE_FALSE;
- localRequiredCoreFeatures.independentBlend = DE_FALSE;
- localRequiredCoreFeatures.geometryShader = DE_FALSE;
- localRequiredCoreFeatures.tessellationShader = DE_FALSE;
- localRequiredCoreFeatures.sampleRateShading = DE_FALSE;
- localRequiredCoreFeatures.dualSrcBlend = DE_FALSE;
- localRequiredCoreFeatures.logicOp = DE_FALSE;
- localRequiredCoreFeatures.multiDrawIndirect = DE_FALSE;
- localRequiredCoreFeatures.drawIndirectFirstInstance = DE_FALSE;
- localRequiredCoreFeatures.depthClamp = DE_FALSE;
- localRequiredCoreFeatures.depthBiasClamp = DE_FALSE;
- localRequiredCoreFeatures.fillModeNonSolid = DE_FALSE;
- localRequiredCoreFeatures.depthBounds = DE_FALSE;
- localRequiredCoreFeatures.wideLines = DE_FALSE;
- localRequiredCoreFeatures.largePoints = DE_FALSE;
- localRequiredCoreFeatures.alphaToOne = DE_FALSE;
- localRequiredCoreFeatures.multiViewport = DE_FALSE;
- localRequiredCoreFeatures.occlusionQueryPrecise = DE_FALSE;
- localRequiredCoreFeatures.vertexPipelineStoresAndAtomics = DE_FALSE;
- localRequiredCoreFeatures.fragmentStoresAndAtomics = DE_FALSE;
- localRequiredCoreFeatures.shaderTessellationAndGeometryPointSize = DE_FALSE;
- localRequiredCoreFeatures.shaderClipDistance = DE_FALSE;
- localRequiredCoreFeatures.shaderCullDistance = DE_FALSE;
- localRequiredCoreFeatures.sparseBinding = DE_FALSE;
- localRequiredCoreFeatures.variableMultisampleRate = DE_FALSE;
-
- if (!isCoreFeaturesSupported(context, localRequiredCoreFeatures, &unsupportedFeature))
- TCU_THROW(NotSupportedError, std::string("At least following requested core feature is not supported: ") + unsupportedFeature);
+ // TODO: Is this really needed? Just don't have tests ask for features that they don't want.
+ localRequired.coreFeatures.fullDrawIndexUint32 = DE_FALSE;
+ localRequired.coreFeatures.independentBlend = DE_FALSE;
+ localRequired.coreFeatures.geometryShader = DE_FALSE;
+ localRequired.coreFeatures.tessellationShader = DE_FALSE;
+ localRequired.coreFeatures.sampleRateShading = DE_FALSE;
+ localRequired.coreFeatures.dualSrcBlend = DE_FALSE;
+ localRequired.coreFeatures.logicOp = DE_FALSE;
+ localRequired.coreFeatures.multiDrawIndirect = DE_FALSE;
+ localRequired.coreFeatures.drawIndirectFirstInstance = DE_FALSE;
+ localRequired.coreFeatures.depthClamp = DE_FALSE;
+ localRequired.coreFeatures.depthBiasClamp = DE_FALSE;
+ localRequired.coreFeatures.fillModeNonSolid = DE_FALSE;
+ localRequired.coreFeatures.depthBounds = DE_FALSE;
+ localRequired.coreFeatures.wideLines = DE_FALSE;
+ localRequired.coreFeatures.largePoints = DE_FALSE;
+ localRequired.coreFeatures.alphaToOne = DE_FALSE;
+ localRequired.coreFeatures.multiViewport = DE_FALSE;
+ localRequired.coreFeatures.occlusionQueryPrecise = DE_FALSE;
+ localRequired.coreFeatures.vertexPipelineStoresAndAtomics = DE_FALSE;
+ localRequired.coreFeatures.fragmentStoresAndAtomics = DE_FALSE;
+ localRequired.coreFeatures.shaderTessellationAndGeometryPointSize = DE_FALSE;
+ localRequired.coreFeatures.shaderClipDistance = DE_FALSE;
+ localRequired.coreFeatures.shaderCullDistance = DE_FALSE;
+ localRequired.coreFeatures.sparseBinding = DE_FALSE;
+ localRequired.coreFeatures.variableMultisampleRate = DE_FALSE;
+
+ const char* unsupportedFeature = DE_NULL;
+ if (!isVulkanFeaturesSupported(context, localRequired, &unsupportedFeature))
+ TCU_THROW(NotSupportedError, std::string("At least following requested feature is not supported: ") + unsupportedFeature);
}
// Extension features
- {
- // 8bit storage features
- if (!is8BitStorageFeaturesSupported(context, m_shaderSpec.requestedVulkanFeatures.ext8BitStorage))
- TCU_THROW(NotSupportedError, "Requested 8bit storage features not supported");
-
- // 16bit storage features
- if (!is16BitStorageFeaturesSupported(context, m_shaderSpec.requestedVulkanFeatures.ext16BitStorage))
- TCU_THROW(NotSupportedError, "Requested 16bit storage features not supported");
-
- // VariablePointers features
- if (!isVariablePointersFeaturesSupported(context, m_shaderSpec.requestedVulkanFeatures.extVariablePointers))
- TCU_THROW(NotSupportedError, "Requested Variable Pointer feature not supported");
-
- // Float16/Int8 shader features
- if (!isFloat16Int8FeaturesSupported(context, m_shaderSpec.requestedVulkanFeatures.extFloat16Int8))
- TCU_THROW(NotSupportedError, "Requested 16bit float or 8bit int feature not supported");
-
- // Vulkan Memory Model features
- if (!isVulkanMemoryModelFeaturesSupported(context, m_shaderSpec.requestedVulkanFeatures.extVulkanMemoryModel))
- TCU_THROW(NotSupportedError, "Requested Vulkan Memory Model feature not supported");
-
- // FloatControls features
- if (!isFloatControlsFeaturesSupported(context, m_shaderSpec.requestedVulkanFeatures.floatControlsProperties))
- TCU_THROW(NotSupportedError, "Requested Float Controls features not supported");
-
- if (m_shaderSpec.usesPhysStorageBuffer && !context.isBufferDeviceAddressSupported())
- TCU_THROW(NotSupportedError, "Request physical storage buffer feature not supported");
- }
+ if (m_shaderSpec.usesPhysStorageBuffer && !context.isBufferDeviceAddressSupported())
+ TCU_THROW(NotSupportedError, "Request physical storage buffer feature not supported");
}
void SpvAsmComputeShaderCase::initPrograms (SourceCollections& programCollection) const
spec.assembly = computeSource;
spec.numWorkGroups = tcu::IVec3(1, 1, 1);
spec.spirvVersion = SPIRV_VERSION_1_4;
- spec.requestedVulkanFeatures.extVariablePointers =
- EXTVARIABLEPOINTERSFEATURES_VARIABLE_POINTERS_STORAGEBUFFER;
+ spec.requestedVulkanFeatures.extVariablePointers.variablePointersStorageBuffer = true;
spec.inputs.push_back(Resource(BufferSp(new Int32Buffer(input))));
spec.outputs.push_back(Resource(BufferSp(new Int32Buffer(expectedOutput))));
spec.extensions.push_back("VK_KHR_spirv_1_4");
spec.assembly = shaderTemplate.specialize(specializationMap);
spec.numWorkGroups = tcu::IVec3(2, 1, 1);
spec.spirvVersion = SPIRV_VERSION_1_4;
- spec.requestedVulkanFeatures.extVariablePointers =
- EXTVARIABLEPOINTERSFEATURES_VARIABLE_POINTERS_STORAGEBUFFER;
+ spec.requestedVulkanFeatures.extVariablePointers.variablePointersStorageBuffer = true;
spec.inputs.push_back(Resource(BufferSp(new Int32Buffer(input))));
spec.outputs.push_back(
Resource(BufferSp(new Uint32Buffer(expectedOutput))));
if (m_fpWideness == 16)
{
context.requireDeviceFunctionality("VK_KHR_shader_float16_int8");
- if (!isFloat16Int8FeaturesSupported(context, EXTFLOAT16INT8FEATURES_FLOAT16))
+ const VkPhysicalDeviceShaderFloat16Int8Features& extensionFeatures = context.getShaderFloat16Int8Features();
+ if (!extensionFeatures.shaderFloat16)
TCU_THROW(NotSupportedError, "Floating point number of width 16 bit are not supported");
}
features.coreFeatures.shaderFloat64 = float64FeatureRequired;
// request proper float controls features
- ExtensionFloatControlsFeatures& floatControls = features.floatControlsProperties;
+ vk::VkPhysicalDeviceFloatControlsProperties& floatControls = features.floatControlsProperties;
// rounding mode should obey the destination type
bool rteRounding = (behaviorFlags & B_RTE_ROUNDING) != 0;
if (float16FeatureRequired && !testCase.fp16Without16BitStorage)
{
csSpec.extensions.push_back("VK_KHR_16bit_storage");
- csSpec.requestedVulkanFeatures.ext16BitStorage = EXT16BITSTORAGEFEATURES_UNIFORM_BUFFER_BLOCK;
+ csSpec.requestedVulkanFeatures.ext16BitStorage.storageBuffer16BitAccess = true;
needShaderFloat16 |= testOperation.floatUsage == FLOAT_ARITHMETIC;
}
needShaderFloat16 |= usesFP16Constants;
if (needShaderFloat16)
{
csSpec.extensions.push_back("VK_KHR_shader_float16_int8");
- csSpec.requestedVulkanFeatures.extFloat16Int8 = EXTFLOAT16INT8FEATURES_FLOAT16;
+ csSpec.requestedVulkanFeatures.extFloat16Int8.shaderFloat16 = true;
}
if (float64FeatureRequired)
csSpec.requestedVulkanFeatures.coreFeatures.shaderFloat64 = VK_TRUE;
ValueId fp32resultValue;
ValueId fp64resultValue;
- ExtensionFloatControlsFeatures& floatControls = csSpec.requestedVulkanFeatures.floatControlsProperties;
+ vk::VkPhysicalDeviceFloatControlsProperties& floatControls = csSpec.requestedVulkanFeatures.floatControlsProperties;
bool fp16Required = testCaseInfo.fp16Option != SO_UNUSED;
bool fp32Required = testCaseInfo.fp32Option != SO_UNUSED;
bool fp64Required = testCaseInfo.fp64Option != SO_UNUSED;
saveResult += fp16Data.snippets->multiStoreResultsFp16Snippet;
csSpec.extensions.push_back("VK_KHR_shader_float16_int8");
- csSpec.requestedVulkanFeatures.extFloat16Int8 = EXTFLOAT16INT8FEATURES_FLOAT16;
+ csSpec.requestedVulkanFeatures.extFloat16Int8.shaderFloat16 = true;
}
else
{
saveResult += fp16Data.snippets->multiStoreResultsSnippet;
csSpec.extensions.push_back("VK_KHR_16bit_storage");
- csSpec.requestedVulkanFeatures.ext16BitStorage = EXT16BITSTORAGEFEATURES_UNIFORM_BUFFER_BLOCK;
+ csSpec.requestedVulkanFeatures.ext16BitStorage.storageBuffer16BitAccess = true;
}
fp16Data.values->fillInputData(addArgs, inputData, inputOffset);
if (needsShaderFloat16)
{
extensions.push_back("VK_KHR_shader_float16_int8");
- vulkanFeatures.extFloat16Int8 = EXTFLOAT16INT8FEATURES_FLOAT16;
+ vulkanFeatures.extFloat16Int8.shaderFloat16 = true;
}
if (float16FeatureRequired && !testCase.fp16Without16BitStorage)
{
extensions.push_back("VK_KHR_16bit_storage");
- vulkanFeatures.ext16BitStorage = EXT16BITSTORAGEFEATURES_UNIFORM_BUFFER_BLOCK;
+ vulkanFeatures.ext16BitStorage.storageBuffer16BitAccess = true;
}
InstanceContext ctx(defaultColors,
}
}
- // Core features
{
+ VulkanFeatures localRequired = instance.requestedFeatures;
+
const VkShaderStageFlags vertexPipelineStoresAndAtomicsAffected = vk::VK_SHADER_STAGE_VERTEX_BIT
| vk::VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT
| vk::VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT
| vk::VK_SHADER_STAGE_GEOMETRY_BIT;
- const char* unsupportedFeature = DE_NULL;
- vk::VkPhysicalDeviceFeatures localRequiredCoreFeatures = instance.requestedFeatures.coreFeatures;
// reset fragment stores and atomics feature requirement
- if ((localRequiredCoreFeatures.fragmentStoresAndAtomics != DE_FALSE) &&
+ if ((localRequired.coreFeatures.fragmentStoresAndAtomics != DE_FALSE) &&
(instance.customizedStages & vk::VK_SHADER_STAGE_FRAGMENT_BIT) == 0)
{
- localRequiredCoreFeatures.fragmentStoresAndAtomics = DE_FALSE;
+ localRequired.coreFeatures.fragmentStoresAndAtomics = DE_FALSE;
}
// reset vertex pipeline stores and atomics feature requirement
- if (localRequiredCoreFeatures.vertexPipelineStoresAndAtomics != DE_FALSE &&
+ if (localRequired.coreFeatures.vertexPipelineStoresAndAtomics != DE_FALSE &&
(instance.customizedStages & vertexPipelineStoresAndAtomicsAffected) == 0)
{
- localRequiredCoreFeatures.vertexPipelineStoresAndAtomics = DE_FALSE;
- }
-
- if (!isCoreFeaturesSupported(context, localRequiredCoreFeatures, &unsupportedFeature))
- TCU_THROW(NotSupportedError, std::string("At least following requested core feature is not supported: ") + unsupportedFeature);
- }
-
- // Extension features
- {
- // 8bit storage features
- {
- if (!is8BitStorageFeaturesSupported(context, instance.requestedFeatures.ext8BitStorage))
- TCU_THROW(NotSupportedError, "Requested 8bit storage features not supported");
- }
-
- // 16bit storage features
- {
- if (!is16BitStorageFeaturesSupported(context, instance.requestedFeatures.ext16BitStorage))
- TCU_THROW(NotSupportedError, "Requested 16bit storage features not supported");
+ localRequired.coreFeatures.vertexPipelineStoresAndAtomics = DE_FALSE;
}
- // Variable Pointers features
- {
- if (!isVariablePointersFeaturesSupported(context, instance.requestedFeatures.extVariablePointers))
- TCU_THROW(NotSupportedError, "Requested Variable Pointer features not supported");
- }
-
- // Float16/Int8 shader features
- {
- if (!isFloat16Int8FeaturesSupported(context, instance.requestedFeatures.extFloat16Int8))
- TCU_THROW(NotSupportedError, "Requested 16bit float or 8bit int feature not supported");
- }
- }
-
- // FloatControls features
- {
- if (!isFloatControlsFeaturesSupported(context, instance.requestedFeatures.floatControlsProperties))
- TCU_THROW(NotSupportedError, "Requested Float Controls features not supported");
+ const char* unsupportedFeature = DE_NULL;
+ if (!isVulkanFeaturesSupported(context, localRequired, &unsupportedFeature))
+ TCU_THROW(NotSupportedError, std::string("At least following requested feature not supported: ") + unsupportedFeature);
}
// Check Interface Input/Output formats are supported
specs["extensions"] = "OpExtension \"SPV_KHR_variable_pointers\"\n "
"OpExtension \"SPV_KHR_storage_buffer_storage_class\"";
element = 1;
- vulkanFeatures.extVariablePointers = EXTVARIABLEPOINTERSFEATURES_VARIABLE_POINTERS_STORAGEBUFFER;
+ vulkanFeatures.extVariablePointers.variablePointersStorageBuffer = true;
spec.extensions.push_back("VK_KHR_variable_pointers");
break;
}
fragments["capability"] += "OpCapability VariablePointersStorageBuffer";
fragments["extension"] = "OpExtension \"SPV_KHR_variable_pointers\"\nOpExtension \"SPV_KHR_storage_buffer_storage_class\"";
extensions.push_back ("VK_KHR_variable_pointers");
- vulkanFeatures.extVariablePointers = EXTVARIABLEPOINTERSFEATURES_VARIABLE_POINTERS_STORAGEBUFFER;
+ vulkanFeatures.extVariablePointers.variablePointersStorageBuffer = true;
element = 1;
break;
}
" OpReturn\n"
" OpFunctionEnd\n";
- vulkanFeatures.extVariablePointers = EXTVARIABLEPOINTERSFEATURES_VARIABLE_POINTERS_STORAGEBUFFER;
+ vulkanFeatures.extVariablePointers.variablePointersStorageBuffer = true;
spec.extensions.push_back("VK_KHR_variable_pointers");
inputData.reserve(numInputFloats);
if (volatileAtomic)
{
spec.extensions.push_back("VK_KHR_vulkan_memory_model");
- spec.requestedVulkanFeatures.extVulkanMemoryModel = EXTVULKANMEMORYMODELFEATURES_ENABLE;
+ spec.requestedVulkanFeatures.extVulkanMemoryModel.vulkanMemoryModel = true;
// volatile, queuefamily scope
specializations["SEMANTICS"] = "%volbit";
// Special SPIR-V code when using 16-bit floats.
if (cases[caseNdx].caseFlags & FLAG_F16)
{
- spec.requestedVulkanFeatures.extFloat16Int8 |= EXTFLOAT16INT8FEATURES_FLOAT16;
+ spec.requestedVulkanFeatures.extFloat16Int8.shaderFloat16 = true;
specializations["CAPABILITIES"] += "OpCapability Float16\n"; // Adds 16-bit float capability
specializations["OPTYPE_DEFINITIONS"] += "%f16 = OpTypeFloat 16\n"; // Adds 16-bit float type
if (cases[caseNdx].caseFlags & FLAG_CONVERT)
// Special SPIR-V code when using 8-bit integers.
if (cases[caseNdx].caseFlags & FLAG_I8)
{
- spec.requestedVulkanFeatures.extFloat16Int8 |= EXTFLOAT16INT8FEATURES_INT8;
+ spec.requestedVulkanFeatures.extFloat16Int8.shaderInt8 = true;
specializations["CAPABILITIES"] += "OpCapability Int8\n"; // Adds 8-bit integer capability
specializations["OPTYPE_DEFINITIONS"] += "%i8 = OpTypeInt 8 1\n"; // Adds 8-bit integer type
if (cases[caseNdx].caseFlags & FLAG_CONVERT)
specFloat16.inputs.push_back(BufferSp(new Uint32Buffer(inputUints)));
specFloat16.outputs.push_back(BufferSp(new Uint32Buffer(outputUints)));
specFloat16.numWorkGroups = IVec3(numElements, 1, 1);
- specFloat16.requestedVulkanFeatures.extFloat16Int8 = EXTFLOAT16INT8FEATURES_FLOAT16;
+ specFloat16.requestedVulkanFeatures.extFloat16Int8.shaderFloat16 = true;
specMat4.assembly =
string(getComputeAsmShaderPreamble()) +
spec.extensions.push_back("VK_KHR_shader_float16_int8");
- spec.requestedVulkanFeatures.extFloat16Int8 = EXTFLOAT16INT8FEATURES_FLOAT16;
+ spec.requestedVulkanFeatures.extFloat16Int8.shaderFloat16 = true;
group->addChild(new SpvAsmComputeShaderCase(testCtx, cases[caseNdx].name, cases[caseNdx].name, spec));
}
// Special SPIR-V code when using 16-bit floats.
if (cases[caseNdx].caseFlags & FLAG_F16)
{
- requiredFeatures.extFloat16Int8 |= EXTFLOAT16INT8FEATURES_FLOAT16;
+ requiredFeatures.extFloat16Int8.shaderFloat16 = true;
fragments["capability"] += "OpCapability Float16\n"; // Adds 16-bit float capability
specializations["OPTYPE_DEFINITIONS"] += "%f16 = OpTypeFloat 16\n"; // Adds 16-bit float type
if (cases[caseNdx].caseFlags & FLAG_CONVERT)
// Special SPIR-V code when using 8-bit integers.
if (cases[caseNdx].caseFlags & FLAG_I8)
{
- requiredFeatures.extFloat16Int8 |= EXTFLOAT16INT8FEATURES_INT8;
+ requiredFeatures.extFloat16Int8.shaderInt8 = true;
fragments["capability"] += "OpCapability Int8\n"; // Adds 8-bit integer capability
specializations["OPTYPE_DEFINITIONS"] += "%i8 = OpTypeInt 8 1\n"; // Adds 8-bit integer type
if (cases[caseNdx].caseFlags & FLAG_CONVERT)
extensions4.push_back("VK_KHR_shader_float16_int8");
- vulkanFeatures4.extFloat16Int8 = EXTFLOAT16INT8FEATURES_FLOAT16;
+ vulkanFeatures4.extFloat16Int8.shaderFloat16 = true;
outputColors4[0] = RGBA(127, 127, 127, 255);
outputColors4[1] = RGBA(127, 0, 0, 255);
if ((usesInt16(from, to) || usesFloat16(from, to)) && useStorageExt)
{
extensions.push_back("VK_KHR_16bit_storage");
- vulkanFeatures.ext16BitStorage |= EXT16BITSTORAGEFEATURES_UNIFORM_BUFFER_BLOCK;
+ vulkanFeatures.ext16BitStorage.storageBuffer16BitAccess = true;
}
if (usesFloat16(from, to) || usesInt8(from, to))
if (usesFloat16(from, to))
{
- vulkanFeatures.extFloat16Int8 |= EXTFLOAT16INT8FEATURES_FLOAT16;
+ vulkanFeatures.extFloat16Int8.shaderFloat16 = true;
}
if (usesInt8(from, to))
{
- vulkanFeatures.extFloat16Int8 |= EXTFLOAT16INT8FEATURES_INT8;
+ vulkanFeatures.extFloat16Int8.shaderInt8 = true;
extensions.push_back("VK_KHR_8bit_storage");
- vulkanFeatures.ext8BitStorage |= EXT8BITSTORAGEFEATURES_STORAGE_BUFFER;
+ vulkanFeatures.ext8BitStorage.storageBuffer8BitAccess = true;
}
}
}
outputColors[3] = RGBA(127, 127, 255, 255);
extensions.push_back("VK_KHR_shader_float16_int8");
- features.extFloat16Int8 = EXTFLOAT16INT8FEATURES_FLOAT16;
+ features.extFloat16Int8.shaderFloat16 = true;
for (size_t testNdx = 0; testNdx < sizeof(tests) / sizeof(NameConstantsCode); ++testNdx)
{
features.floatControlsProperties.shaderSignedZeroInfNanPreserveFloat16 = DE_TRUE;
}
- features.extFloat16Int8 = EXTFLOAT16INT8FEATURES_FLOAT16;
+ features.extFloat16Int8.shaderFloat16 = true;
finalizeTestsCreation(specResource, fragments, testCtx, *testGroup.get(), testName, features, extensions, IVec3(1, 1, 1));
}
features.floatControlsProperties.shaderSignedZeroInfNanPreserveFloat16 = DE_TRUE;
}
- features.extFloat16Int8 = EXTFLOAT16INT8FEATURES_FLOAT16;
+ features.extFloat16Int8.shaderFloat16 = true;
finalizeTestsCreation(specResource, fragments, testCtx, *testGroup.get(), testName, features, extensions, IVec3(1, 1, 1), true);
}
extensions.push_back("VK_KHR_shader_float16_int8");
- features.extFloat16Int8 = EXTFLOAT16INT8FEATURES_FLOAT16;
+ features.extFloat16Int8.shaderFloat16 = true;
finalizeTestsCreation(specResource, fragments, testCtx, *testGroup.get(), testName, features, extensions, IVec3(1, 1, 1));
}
extensions.push_back("VK_KHR_shader_float16_int8");
- features.extFloat16Int8 = EXTFLOAT16INT8FEATURES_FLOAT16;
+ features.extFloat16Int8.shaderFloat16 = true;
finalizeTestsCreation(specResource, fragments, testCtx, *testGroup.get(), testName, features, extensions, IVec3(1, 1, 1));
}
extensions.push_back("VK_KHR_shader_float16_int8");
- features.extFloat16Int8 = EXTFLOAT16INT8FEATURES_FLOAT16;
+ features.extFloat16Int8.shaderFloat16 = true;
finalizeTestsCreation(specResource, fragments, testCtx, *testGroup.get(), testName, features, extensions, IVec3(1, 1, 1));
}
extensions.push_back("VK_KHR_shader_float16_int8");
- features.extFloat16Int8 = EXTFLOAT16INT8FEATURES_FLOAT16;
+ features.extFloat16Int8.shaderFloat16 = true;
finalizeTestsCreation(specResource, fragments, testCtx, *testGroup.get(), testName, features, extensions, IVec3(1, 1, 1));
}
extensions.push_back("VK_KHR_shader_float16_int8");
- features.extFloat16Int8 = EXTFLOAT16INT8FEATURES_FLOAT16;
+ features.extFloat16Int8.shaderFloat16 = true;
finalizeTestsCreation(specResource, fragments, testCtx, *testGroup.get(), testName, features, extensions, IVec3(1, 1, 1));
}
extensions.push_back("VK_KHR_shader_float16_int8");
- features.extFloat16Int8 = EXTFLOAT16INT8FEATURES_FLOAT16;
+ features.extFloat16Int8.shaderFloat16 = true;
finalizeTestsCreation(specResource, fragments, testCtx, *testGroup.get(), testName, features, extensions, IVec3(1, 1, 1));
}
extensions.push_back("VK_KHR_shader_float16_int8");
- features.extFloat16Int8 = EXTFLOAT16INT8FEATURES_FLOAT16;
+ features.extFloat16Int8.shaderFloat16 = true;
finalizeTestsCreation(specResource, fragments, testCtx, testGroup, testName, features, extensions, IVec3(1, 1, 1));
}
spec.outputs.push_back(BufferSp(new Float32Buffer(outputData)));
spec.numWorkGroups = IVec3(numElements, 1, 1);
if (hasFloat16)
- spec.requestedVulkanFeatures.extFloat16Int8 |= EXTFLOAT16INT8FEATURES_FLOAT16;
+ spec.requestedVulkanFeatures.extFloat16Int8.shaderFloat16 = true;
if (hasInt8)
- spec.requestedVulkanFeatures.extFloat16Int8 |= EXTFLOAT16INT8FEATURES_INT8;
+ spec.requestedVulkanFeatures.extFloat16Int8.shaderInt8 = true;
spec.extensions.push_back("VK_KHR_shader_float16_int8");
string testName = "b" + de::toString(cases[caseNdx][0]) + "b" + de::toString(cases[caseNdx][1]) + "b" + de::toString(cases[caseNdx][2]) + "b" + de::toString(cases[caseNdx][3]);
DE_ASSERT(!packingInfo.packed || elementSize == 8);
if ((!packingInfo.packed && elementSize == 8) || outSize == 8)
{
- spec.requestedVulkanFeatures.extFloat16Int8 |= EXTFLOAT16INT8FEATURES_INT8;
- spec.requestedVulkanFeatures.ext8BitStorage = EXT8BITSTORAGEFEATURES_STORAGE_BUFFER;
+ spec.requestedVulkanFeatures.extFloat16Int8.shaderInt8 = true;
+ spec.requestedVulkanFeatures.ext8BitStorage.storageBuffer8BitAccess = true;
spec.extensions.push_back("VK_KHR_8bit_storage");
}
if (elementSize == 16 || outSize == 16)
{
- spec.requestedVulkanFeatures.coreFeatures.shaderInt16 = VK_TRUE;
- spec.requestedVulkanFeatures.ext16BitStorage = EXT16BITSTORAGEFEATURES_UNIFORM_BUFFER_BLOCK;
+ spec.requestedVulkanFeatures.coreFeatures.shaderInt16 = true;
+ spec.requestedVulkanFeatures.ext16BitStorage.storageBuffer16BitAccess = true;
spec.extensions.push_back("VK_KHR_16bit_storage");
}
}
for (deUint32 numIdx = 0; numIdx < numFloats / 2; ++numIdx)
expectedOutput.push_back(2.0f);
- requiredFeatures.extVariablePointers = EXTVARIABLEPOINTERSFEATURES_VARIABLE_POINTERS_STORAGEBUFFER;
+ requiredFeatures.extVariablePointers.variablePointersStorageBuffer = true;
spec.outputs.push_back(BufferSp(new Float32Buffer(expectedOutput)));
for (deUint32 numIdx = 0; numIdx < numFloats / 2; ++numIdx)
expectedOutput.push_back(2.0f);
- requiredFeatures.extVariablePointers = EXTVARIABLEPOINTERSFEATURES_VARIABLE_POINTERS_STORAGEBUFFER;
+ requiredFeatures.extVariablePointers.variablePointersStorageBuffer = true;
spec.outputs.push_back(BufferSp(new Float32Buffer(expectedOutput)));
spec.extensions.push_back("VK_KHR_variable_pointers");
}
spec.outputs.push_back(BufferSp(new Float32Buffer(expectedOutput)));
- requiredFeatures.extVariablePointers = EXTVARIABLEPOINTERSFEATURES_VARIABLE_POINTERS;
+ requiredFeatures.extVariablePointers.variablePointers = true;
spec.extensions.push_back("VK_KHR_variable_pointers");
spec.assembly = shaderSource;
extensions.push_back("VK_KHR_variable_pointers");
requiredFeatures.coreFeatures.vertexPipelineStoresAndAtomics = true;
requiredFeatures.coreFeatures.fragmentStoresAndAtomics = true;
- requiredFeatures.extVariablePointers = EXTVARIABLEPOINTERSFEATURES_VARIABLE_POINTERS_STORAGEBUFFER;
+ requiredFeatures.extVariablePointers.variablePointersStorageBuffer = true;
resources.outputs.push_back(Resource(BufferSp(new Float32Buffer(expectedOutput)), vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER));
createTestsForAllStages("buffer_memory", defaultColors, defaultColors, fragments, resources, extensions, group, requiredFeatures);
extensions.push_back("VK_KHR_variable_pointers");
requiredFeatures.coreFeatures.fragmentStoresAndAtomics = true;
- requiredFeatures.extVariablePointers = EXTVARIABLEPOINTERSFEATURES_VARIABLE_POINTERS_STORAGEBUFFER;
+ requiredFeatures.extVariablePointers.variablePointersStorageBuffer = true;
requiredFeatures.coreFeatures.vertexPipelineStoresAndAtomics = DE_TRUE;
resources.outputs.push_back(Resource(BufferSp(new Float32Buffer(expectedOutput)), vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER));
if (uses8bit)
{
- requiredFeatures.extFloat16Int8 |= EXTFLOAT16INT8FEATURES_INT8;
+ requiredFeatures.extFloat16Int8.shaderInt8 = true;
}
if (m_inputType == TYPE_I8 || m_inputType == TYPE_U8)
{
- requiredFeatures.ext8BitStorage |= EXT8BITSTORAGEFEATURES_UNIFORM_STORAGE_BUFFER;
+ requiredFeatures.ext8BitStorage.storageBuffer8BitAccess = true;
spirvExtensions += "OpExtension \"SPV_KHR_8bit_storage\"\n";
}
if (m_inputType == TYPE_I16 || m_inputType == TYPE_U16)
{
- requiredFeatures.ext16BitStorage |= EXT16BITSTORAGEFEATURES_UNIFORM_BUFFER_BLOCK;
+ requiredFeatures.ext16BitStorage.storageBuffer16BitAccess = true;
spirvExtensions += "OpExtension \"SPV_KHR_16bit_storage\"\n";
}
if (uses8bit)
{
- requiredFeatures.extFloat16Int8 |= EXTFLOAT16INT8FEATURES_INT8;
+ requiredFeatures.extFloat16Int8.shaderInt8 = true;
}
if (m_inputType == TYPE_I8 || m_inputType == TYPE_U8)
{
- requiredFeatures.ext8BitStorage |= EXT8BITSTORAGEFEATURES_UNIFORM_STORAGE_BUFFER;
+ requiredFeatures.ext8BitStorage.storageBuffer8BitAccess = true;
spirvExtensions += "OpExtension \"SPV_KHR_8bit_storage\"\n";
}
if (m_inputType == TYPE_I16 || m_inputType == TYPE_U16)
{
- requiredFeatures.ext16BitStorage |= EXT16BITSTORAGEFEATURES_UNIFORM_BUFFER_BLOCK;
+ requiredFeatures.ext16BitStorage.storageBuffer16BitAccess = true;
spirvExtensions += "OpExtension \"SPV_KHR_16bit_storage\"\n";
}
return "Set " + de::toString(set) + " and Binding " + de::toString(binding);
}
-bool is8BitStorageFeaturesSupported (const Context& context, Extension8BitStorageFeatures toCheck)
-{
- VkPhysicalDevice8BitStorageFeaturesKHR extensionFeatures = context.get8BitStorageFeatures();
-
- if ((toCheck & EXT8BITSTORAGEFEATURES_STORAGE_BUFFER) != 0 && extensionFeatures.storageBuffer8BitAccess == VK_FALSE)
- return false;
-
- if ((toCheck & EXT8BITSTORAGEFEATURES_UNIFORM_STORAGE_BUFFER) != 0 && extensionFeatures.uniformAndStorageBuffer8BitAccess == VK_FALSE)
- return false;
-
- if ((toCheck & EXT8BITSTORAGEFEATURES_PUSH_CONSTANT) != 0 && extensionFeatures.storagePushConstant8 == VK_FALSE)
- return false;
-
- return true;
-}
-
#define IS_CORE_FEATURE_AVAILABLE(CHECKED, AVAILABLE, FEATURE) \
if ((CHECKED.FEATURE != DE_FALSE) && (AVAILABLE.FEATURE == DE_FALSE)) { *missingFeature = #FEATURE; return false; }
return true;
}
-bool is16BitStorageFeaturesSupported (const Context& context, Extension16BitStorageFeatures toCheck)
+#define IS_AVAIL(EXT_NAME, FEATURE) \
+ if (toCheck.FEATURE && !extensionFeatures.FEATURE) { *missingFeature = EXT_NAME #FEATURE; return false; }
+
+bool isFloat16Int8FeaturesSupported(const Context& context, const vk::VkPhysicalDeviceShaderFloat16Int8Features& toCheck, const char **missingFeature)
{
- const VkPhysicalDevice16BitStorageFeatures& extensionFeatures = context.get16BitStorageFeatures();
+ const VkPhysicalDeviceShaderFloat16Int8Features& extensionFeatures = context.getShaderFloat16Int8Features();
- if ((toCheck & EXT16BITSTORAGEFEATURES_UNIFORM_BUFFER_BLOCK) != 0 && extensionFeatures.storageBuffer16BitAccess == VK_FALSE)
- return false;
+ IS_AVAIL("ShaderFloat16Int8.", shaderFloat16);
+ IS_AVAIL("ShaderFloat16Int8.", shaderInt8);
- if ((toCheck & EXT16BITSTORAGEFEATURES_UNIFORM) != 0 && extensionFeatures.uniformAndStorageBuffer16BitAccess == VK_FALSE)
- return false;
+ return true;
+}
- if ((toCheck & EXT16BITSTORAGEFEATURES_PUSH_CONSTANT) != 0 && extensionFeatures.storagePushConstant16 == VK_FALSE)
- return false;
+bool is8BitStorageFeaturesSupported(const Context& context, const vk::VkPhysicalDevice8BitStorageFeatures& toCheck, const char **missingFeature)
+{
+ const VkPhysicalDevice8BitStorageFeaturesKHR& extensionFeatures = context.get8BitStorageFeatures();
- if ((toCheck & EXT16BITSTORAGEFEATURES_INPUT_OUTPUT) != 0 && extensionFeatures.storageInputOutput16 == VK_FALSE)
- return false;
+ IS_AVAIL("8BitStorage.", storageBuffer8BitAccess);
+ IS_AVAIL("8BitStorage.", uniformAndStorageBuffer8BitAccess);
+ IS_AVAIL("8BitStorage.", storagePushConstant8);
return true;
}
-bool isVariablePointersFeaturesSupported (const Context& context, ExtensionVariablePointersFeatures toCheck)
+bool is16BitStorageFeaturesSupported(const Context& context, const vk::VkPhysicalDevice16BitStorageFeatures& toCheck, const char **missingFeature)
{
- const VkPhysicalDeviceVariablePointersFeatures& extensionFeatures = context.getVariablePointersFeatures();
+ const VkPhysicalDevice16BitStorageFeatures& extensionFeatures = context.get16BitStorageFeatures();
- if ((toCheck & EXTVARIABLEPOINTERSFEATURES_VARIABLE_POINTERS_STORAGEBUFFER) != 0 && extensionFeatures.variablePointersStorageBuffer == VK_FALSE)
- return false;
-
- if ((toCheck & EXTVARIABLEPOINTERSFEATURES_VARIABLE_POINTERS) != 0 && extensionFeatures.variablePointers == VK_FALSE)
- return false;
+ IS_AVAIL("16BitStorage.", storageBuffer16BitAccess);
+ IS_AVAIL("16BitStorage.", uniformAndStorageBuffer16BitAccess);
+ IS_AVAIL("16BitStorage.", storagePushConstant16);
+ IS_AVAIL("16BitStorage.", storageInputOutput16);
return true;
}
-bool isFloat16Int8FeaturesSupported (const Context& context, ExtensionFloat16Int8Features toCheck)
+bool isVariablePointersFeaturesSupported(const Context& context, const vk::VkPhysicalDeviceVariablePointersFeatures& toCheck, const char **missingFeature)
{
- const VkPhysicalDeviceShaderFloat16Int8Features& extensionFeatures = context.getShaderFloat16Int8Features();
-
- if ((toCheck & EXTFLOAT16INT8FEATURES_FLOAT16) != 0 && extensionFeatures.shaderFloat16 == VK_FALSE)
- return false;
+ const VkPhysicalDeviceVariablePointersFeatures& extensionFeatures = context.getVariablePointersFeatures();
- if ((toCheck & EXTFLOAT16INT8FEATURES_INT8) != 0 && extensionFeatures.shaderInt8 == VK_FALSE)
- return false;
+ IS_AVAIL("VariablePointers.", variablePointersStorageBuffer);
+ IS_AVAIL("VariablePointers.", variablePointers);
return true;
}
-bool isVulkanMemoryModelFeaturesSupported (const Context& context, ExtensionVulkanMemoryModelFeatures toCheck)
+bool isVulkanMemoryModelFeaturesSupported(const Context& context, const vk::VkPhysicalDeviceVulkanMemoryModelFeatures& toCheck, const char **missingFeature)
{
const VkPhysicalDeviceVulkanMemoryModelFeaturesKHR& extensionFeatures = context.getVulkanMemoryModelFeatures();
- if ((toCheck & EXTVULKANMEMORYMODELFEATURES_ENABLE) != 0 && extensionFeatures.vulkanMemoryModel == VK_FALSE)
- return false;
-
- if ((toCheck & EXTVULKANMEMORYMODELFEATURES_DEVICESCOPE) != 0 && extensionFeatures.vulkanMemoryModelDeviceScope == VK_FALSE)
- return false;
-
- if ((toCheck & EXTVULKANMEMORYMODELFEATURES_AVAILABILITYVISIBILITYCHAINS) != 0 && extensionFeatures.vulkanMemoryModelAvailabilityVisibilityChains == VK_FALSE)
- return false;
+ IS_AVAIL("VulkanMemoryModel.", vulkanMemoryModel);
+ IS_AVAIL("VulkanMemoryModel.", vulkanMemoryModelDeviceScope);
+ IS_AVAIL("VulkanMemoryModel.", vulkanMemoryModelAvailabilityVisibilityChains);
return true;
}
-bool isFloatControlsFeaturesSupported (const Context& context, const ExtensionFloatControlsFeatures& toCheck)
+#undef IS_AVAIL
+
+bool isFloatControlsFeaturesSupported (const Context& context, const vk::VkPhysicalDeviceFloatControlsProperties& toCheck, const char **missingFeature)
{
// if all flags are set to false then no float control features are actualy requested by the test
if ((toCheck.shaderSignedZeroInfNanPreserveFloat16 ||
toCheck.shaderRoundingModeRTZFloat64) == false)
return true;
+ *missingFeature = "Float controls properties";
+
// return false when float control features are requested and proper extension is not supported
if (!context.isDeviceFunctionalitySupported("VK_KHR_shader_float_controls"))
return false;
// perform query to get supported float control properties
- ExtensionFloatControlsFeatures refControls;
+ vk::VkPhysicalDeviceFloatControlsProperties refControls;
{
refControls.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR;
refControls.pNext = DE_NULL;
return !requiredFeaturesNotSupported;
}
+bool isVulkanFeaturesSupported(const Context& context, const VulkanFeatures& requested, const char **missingFeature)
+{
+ if (!isCoreFeaturesSupported(context, requested.coreFeatures, missingFeature))
+ return false;
+
+ if (!is8BitStorageFeaturesSupported(context, requested.ext8BitStorage, missingFeature))
+ return false;
+
+ if (!is16BitStorageFeaturesSupported(context, requested.ext16BitStorage, missingFeature))
+ return false;
+
+ if (!isVariablePointersFeaturesSupported(context, requested.extVariablePointers, missingFeature))
+ return false;
+
+ if (!isFloat16Int8FeaturesSupported(context, requested.extFloat16Int8, missingFeature))
+ return false;
+
+ if (!isVulkanMemoryModelFeaturesSupported(context, requested.extVulkanMemoryModel, missingFeature))
+ return false;
+
+ if (!isFloatControlsFeaturesSupported(context, requested.floatControlsProperties, missingFeature))
+ return false;
+
+ return true;
+}
+
deUint32 getMinRequiredVulkanVersion (const SpirvVersion version)
{
switch(version)
std::vector<size_t> sizesBuffer;
};
-enum Extension8BitStorageFeatureBits
-{
- EXT8BITSTORAGEFEATURES_STORAGE_BUFFER = (1u << 1),
- EXT8BITSTORAGEFEATURES_UNIFORM_STORAGE_BUFFER = (1u << 2),
- EXT8BITSTORAGEFEATURES_PUSH_CONSTANT = (1u << 3),
-};
-typedef deUint32 Extension8BitStorageFeatures;
-
-enum Extension16BitStorageFeatureBits
-{
- EXT16BITSTORAGEFEATURES_UNIFORM_BUFFER_BLOCK = (1u << 1),
- EXT16BITSTORAGEFEATURES_UNIFORM = (1u << 2),
- EXT16BITSTORAGEFEATURES_PUSH_CONSTANT = (1u << 3),
- EXT16BITSTORAGEFEATURES_INPUT_OUTPUT = (1u << 4),
-};
-typedef deUint32 Extension16BitStorageFeatures;
-
-enum ExtensionVariablePointersFeaturesBits
-{
- EXTVARIABLEPOINTERSFEATURES_VARIABLE_POINTERS_STORAGEBUFFER = (1u << 1),
- EXTVARIABLEPOINTERSFEATURES_VARIABLE_POINTERS = (1u << 2),
-};
-typedef deUint32 ExtensionVariablePointersFeatures;
-
-enum ExtensionFloat16Int8FeaturesBits
-{
- EXTFLOAT16INT8FEATURES_FLOAT16 = (1u << 1),
- EXTFLOAT16INT8FEATURES_INT8 = (1u << 2),
-};
-typedef deUint32 ExtensionFloat16Int8Features;
-typedef vk::VkPhysicalDeviceFloatControlsProperties ExtensionFloatControlsFeatures;
-
-enum ExtensionVulkanMemoryModelFeaturesBits
-{
- EXTVULKANMEMORYMODELFEATURES_ENABLE = (1u << 1),
- EXTVULKANMEMORYMODELFEATURES_DEVICESCOPE = (1u << 2),
- EXTVULKANMEMORYMODELFEATURES_AVAILABILITYVISIBILITYCHAINS = (1u << 3),
-};
-typedef deUint32 ExtensionVulkanMemoryModelFeatures;
-
struct VulkanFeatures
{
- vk::VkPhysicalDeviceFeatures coreFeatures;
- ExtensionFloat16Int8Features extFloat16Int8;
- Extension8BitStorageFeatures ext8BitStorage;
- Extension16BitStorageFeatures ext16BitStorage;
- ExtensionVariablePointersFeatures extVariablePointers;
- ExtensionVulkanMemoryModelFeatures extVulkanMemoryModel;
- ExtensionFloatControlsFeatures floatControlsProperties;
- vk::VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR extIntegerDotProduct;
+ vk::VkPhysicalDeviceFeatures coreFeatures;
+ vk::VkPhysicalDeviceShaderFloat16Int8Features extFloat16Int8;
+ vk::VkPhysicalDevice8BitStorageFeatures ext8BitStorage;
+ vk::VkPhysicalDevice16BitStorageFeatures ext16BitStorage;
+ vk::VkPhysicalDeviceVariablePointersFeatures extVariablePointers;
+ vk::VkPhysicalDeviceVulkanMemoryModelFeatures extVulkanMemoryModel;
+ vk::VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR extIntegerDotProduct;
+ vk::VkPhysicalDeviceFloatControlsProperties floatControlsProperties;
VulkanFeatures (void)
- : extFloat16Int8 (0)
- , ext8BitStorage (0)
- , ext16BitStorage (0)
- , extVariablePointers (0)
- , extVulkanMemoryModel (0)
{
- deMemset(&coreFeatures, 0, sizeof(coreFeatures));
- deMemset(&floatControlsProperties, 0, sizeof(ExtensionFloatControlsFeatures));
+ deMemset(&coreFeatures, 0, sizeof(coreFeatures));
+ deMemset(&extFloat16Int8, 0, sizeof(vk::VkPhysicalDeviceShaderFloat16Int8Features));
+ deMemset(&ext8BitStorage, 0, sizeof(vk::VkPhysicalDevice8BitStorageFeatures));
+ deMemset(&ext16BitStorage, 0, sizeof(vk::VkPhysicalDevice16BitStorageFeatures));
+ deMemset(&extVariablePointers, 0, sizeof(vk::VkPhysicalDeviceVariablePointersFeatures));
+ deMemset(&extVulkanMemoryModel, 0, sizeof(vk::VkPhysicalDeviceVulkanMemoryModelFeatures));
+ deMemset(&floatControlsProperties, 0, sizeof(vk::VkPhysicalDeviceFloatControlsProperties));
floatControlsProperties.denormBehaviorIndependence = vk::VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR;
floatControlsProperties.roundingModeIndependence = vk::VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR;
}
};
+// Returns true if the whole VulkanFeatures is supported. If not, missingFeature will contain one feature that was missing.
+bool isVulkanFeaturesSupported(const Context& context, const VulkanFeatures& toCheck, const char** missingFeature);
+
struct VariableLocation
{
deUint32 set;
std::string toDescription() const;
};
-// Returns true if the given 8bit storage extension features in `toCheck` are all supported.
-bool is8BitStorageFeaturesSupported (const Context& context,
- Extension8BitStorageFeatures toCheck);
-
-// Returns true if the given 16bit storage extension features in `toCheck` are all supported.
-bool isCoreFeaturesSupported (const Context& context,
- const vk::VkPhysicalDeviceFeatures& toCheck,
- const char** missingFeature);
-
-// Returns true if the given 16bit storage extension features in `toCheck` are all supported.
-bool is16BitStorageFeaturesSupported (const Context& context,
- Extension16BitStorageFeatures toCheck);
-
-// Returns true if the given variable pointers extension features in `toCheck` are all supported.
-bool isVariablePointersFeaturesSupported (const Context& context,
- ExtensionVariablePointersFeatures toCheck);
-
-// Returns true if the given 16bit float/8bit int extension features in `toCheck` are all supported.
-bool isFloat16Int8FeaturesSupported (const Context& context,
- ExtensionFloat16Int8Features toCheck);
-
-// Returns true if the given Vulkan Memory Model extension features in `toCheck` are all supported.
-bool isVulkanMemoryModelFeaturesSupported (const Context& context,
- ExtensionVulkanMemoryModelFeatures toCheck);
-
// Returns true if the given float controls features in `toCheck` are all supported.
-bool isFloatControlsFeaturesSupported (const Context& context,
- const ExtensionFloatControlsFeatures& toCheck);
+bool isFloatControlsFeaturesSupported( const Context& context,
+ const vk::VkPhysicalDeviceFloatControlsProperties& toCheck,
+ const char** missingFeature);
deUint32 getMinRequiredVulkanVersion (const vk::SpirvVersion version);
" OpStore %" + type + "_global_1 %" + type + "_1\n"
" %outputData = OpLoad %" + type + " %outputDataPtr\n";
- spec.requestedVulkanFeatures.extVariablePointers = EXTVARIABLEPOINTERSFEATURES_VARIABLE_POINTERS;
+ spec.requestedVulkanFeatures.extVariablePointers.variablePointers = true;
spec.extensions.push_back("VK_KHR_variable_pointers");
break;
}
const string muxInput2 = isSingleInputBuffer ? " %inloc_a_2i_plus_1 " : " %inloc_b_i ";
// Set the proper extension features required for the test
- if (physPtrs)
- {
- requiredFeatures.extVariablePointers = 0;
- }
- else
+ if (!physPtrs)
{
if (isSingleInputBuffer)
- requiredFeatures.extVariablePointers = EXTVARIABLEPOINTERSFEATURES_VARIABLE_POINTERS_STORAGEBUFFER;
+ requiredFeatures.extVariablePointers.variablePointersStorageBuffer = true;
else
- requiredFeatures.extVariablePointers = EXTVARIABLEPOINTERSFEATURES_VARIABLE_POINTERS;
+ requiredFeatures.extVariablePointers.variablePointers = true;
}
{ // Variable Pointer Reads (using OpSelect)
for (int isSingleInputBuffer = 0 ; isSingleInputBuffer < 2; ++isSingleInputBuffer)
{
// Set the proper extension features required for the test
- if (physPtrs)
- {
- requiredFeatures.extVariablePointers = 0;
- }
- else
+ if (!physPtrs)
{
if (isSingleInputBuffer)
- requiredFeatures.extVariablePointers = EXTVARIABLEPOINTERSFEATURES_VARIABLE_POINTERS_STORAGEBUFFER;
+ requiredFeatures.extVariablePointers.variablePointersStorageBuffer = true;
else
- requiredFeatures.extVariablePointers = EXTVARIABLEPOINTERSFEATURES_VARIABLE_POINTERS;
+ requiredFeatures.extVariablePointers.variablePointers = true;
}
for (int selectInputA = 0; selectInputA < 2; ++selectInputA)
VulkanFeatures requiredFeatures;
// Requires the variable pointers feature.
- requiredFeatures.extVariablePointers = EXTVARIABLEPOINTERSFEATURES_VARIABLE_POINTERS;
+ requiredFeatures.extVariablePointers.variablePointers = true;
const string decorations (
// Decorations
// Set the proper extension features required for the test
if (isSingleInputBuffer)
- requiredFeatures.extVariablePointers = EXTVARIABLEPOINTERSFEATURES_VARIABLE_POINTERS_STORAGEBUFFER;
+ requiredFeatures.extVariablePointers.variablePointersStorageBuffer = true;
else
- requiredFeatures.extVariablePointers = EXTVARIABLEPOINTERSFEATURES_VARIABLE_POINTERS;
+ requiredFeatures.extVariablePointers.variablePointers = true;
// All of the following tests write their results into an output SSBO, therefore they require the following features.
requiredFeatures.coreFeatures.vertexPipelineStoresAndAtomics = DE_TRUE;
getDefaultColors(defaultColors);
// Set the proper extension features required for the tests.
- requiredFeatures.extVariablePointers = EXTVARIABLEPOINTERSFEATURES_VARIABLE_POINTERS;
+ requiredFeatures.extVariablePointers.variablePointers = true;
// Set the required extension.
extensions.push_back("VK_KHR_variable_pointers");
// Set the proper extension features required for the tests.
// The following tests use variable pointers confined withing a single buffer.
- requiredFeatures.extVariablePointers = EXTVARIABLEPOINTERSFEATURES_VARIABLE_POINTERS_STORAGEBUFFER;
+ requiredFeatures.extVariablePointers.variablePointersStorageBuffer = true;
// Set the required extension.
extensions.push_back("VK_KHR_variable_pointers");
extensions.push_back("VK_KHR_variable_pointers");
// Requires the variable pointers feature.
- requiredFeatures.extVariablePointers = EXTVARIABLEPOINTERSFEATURES_VARIABLE_POINTERS;
+ requiredFeatures.extVariablePointers.variablePointers = true;
fragments["capability"] = "OpCapability VariablePointers \n";
fragments["extension"] = "OpExtension \"SPV_KHR_variable_pointers\" \n"
shaderSpec["extensions"] = "OpExtension \"SPV_KHR_16bit_storage\"\n";
shaderSpec["capabilities"] = "OpCapability StorageUniformBufferBlock16\nOpCapability Float16\n";
- features.ext16BitStorage = EXT16BITSTORAGEFEATURES_UNIFORM_BUFFER_BLOCK;
- features.extFloat16Int8 = EXTFLOAT16INT8FEATURES_FLOAT16;
+ features.ext16BitStorage.storageBuffer16BitAccess = true;
+ features.extFloat16Int8.shaderFloat16 = true;
vector<deFloat16> inputData = getFloat16s(rnd, numElements);
vector<deFloat16> outputData;
shaderSpec["extensions"] = "OpExtension \"SPV_KHR_16bit_storage\"\n";
shaderSpec["capabilities"] = "OpCapability Int16\n";
- features.coreFeatures.shaderInt16 = VK_TRUE;
- features.ext16BitStorage = EXT16BITSTORAGEFEATURES_UNIFORM_BUFFER_BLOCK;
+ features.coreFeatures.shaderInt16 = true;
+ features.ext16BitStorage.storageBuffer16BitAccess = true;
vector<deInt16> inputData = getInt16s(rnd, numElements);
vector<deInt16> outputData;
shaderSpec["capabilities"] = "OpCapability UniformAndStorageBuffer8BitAccess\nOpCapability Int8\n";
shaderSpec["extensions"] = "OpExtension \"SPV_KHR_8bit_storage\"\n";
- features.ext8BitStorage = EXT8BITSTORAGEFEATURES_UNIFORM_STORAGE_BUFFER;
- features.extFloat16Int8 = EXTFLOAT16INT8FEATURES_INT8;
+ features.ext8BitStorage.storageBuffer8BitAccess = true;
+ features.extFloat16Int8.shaderInt8 = true;
vector<deInt8> inputData = getInt8s(rnd, numElements);
vector<deInt8> outputData;
shaderSpec["capabilities"] = "OpCapability Int16\n";
shaderSpec["extensions"] = "OpExtension \"SPV_KHR_16bit_storage\"\n";
- features.coreFeatures.shaderInt16 = VK_TRUE;
- features.ext16BitStorage = EXT16BITSTORAGEFEATURES_UNIFORM_BUFFER_BLOCK;
+ features.coreFeatures.shaderInt16 = true;
+ features.ext16BitStorage.storageBuffer16BitAccess = true;
vector<deUint16> inputData;
vector<deUint16> outputData;
shaderSpec["capabilities"] = "OpCapability UniformAndStorageBuffer8BitAccess\nOpCapability Int8\n";
shaderSpec["extensions"] = "OpExtension \"SPV_KHR_8bit_storage\"\n";
- features.ext8BitStorage = EXT8BITSTORAGEFEATURES_UNIFORM_STORAGE_BUFFER;
- features.extFloat16Int8 = EXTFLOAT16INT8FEATURES_INT8;
+ features.ext8BitStorage.storageBuffer8BitAccess = true;
+ features.extFloat16Int8.shaderInt8 = true;
vector<deUint8> inputData;
vector<deUint8> outputData;
projects / platform / upstream / VK-GL-CTS.git / commitdiff