Cherry-pick SPIR-V assembly test improvements
[platform/upstream/VK-GL-CTS.git] / external / vulkancts / modules / vulkan / spirv_assembly / vktSpvAsmUtils.cpp
1 /*-------------------------------------------------------------------------
2  * Vulkan Conformance Tests
3  * ------------------------
4  *
5  * Copyright (c) 2017 Google Inc.
6  *
7  * Licensed under the Apache License, Version 2.0 (the "License");
8  * you may not use this file except in compliance with the License.
9  * You may obtain a copy of the License at
10  *
11  *      http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing, software
14  * distributed under the License is distributed on an "AS IS" BASIS,
15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16  * See the License for the specific language governing permissions and
17  * limitations under the License.
18  *
19  *//*!
20  * \file
21  * \brief Utilities for Vulkan SPIR-V assembly tests
22  *//*--------------------------------------------------------------------*/
23
24 #include "vktSpvAsmUtils.hpp"
25
26 #include "deMemory.h"
27 #include "deSTLUtil.hpp"
28 #include "vkQueryUtil.hpp"
29 #include "vkRefUtil.hpp"
30
31 namespace vkt
32 {
33 namespace SpirVAssembly
34 {
35
36 using namespace vk;
37
38 namespace
39 {
40
41 VkPhysicalDeviceFeatures filterDefaultDeviceFeatures (const VkPhysicalDeviceFeatures& deviceFeatures)
42 {
43         VkPhysicalDeviceFeatures enabledDeviceFeatures = deviceFeatures;
44
45         // Disable robustness by default, as it has an impact on performance on some HW.
46         enabledDeviceFeatures.robustBufferAccess = false;
47
48         return enabledDeviceFeatures;
49 }
50
51 } // anonymous
52
53 bool is16BitStorageFeaturesSupported (const InstanceInterface& vki, VkPhysicalDevice device, const std::vector<std::string>& instanceExtensions, Extension16BitStorageFeatures toCheck)
54 {
55         VkPhysicalDevice16BitStorageFeaturesKHR extensionFeatures       =
56         {
57                 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR,   // sType
58                 DE_NULL,                                                                                                                // pNext
59                 false,                                                                                                                  // storageUniformBufferBlock16
60                 false,                                                                                                                  // storageUniform16
61                 false,                                                                                                                  // storagePushConstant16
62                 false,                                                                                                                  // storageInputOutput16
63         };
64         VkPhysicalDeviceFeatures2KHR                    features;
65
66         deMemset(&features, 0, sizeof(features));
67         features.sType  = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR;
68         features.pNext  = &extensionFeatures;
69
70         // Call the getter only if supported. Otherwise above "zero" defaults are used
71         if (de::contains(instanceExtensions.begin(), instanceExtensions.end(), "VK_KHR_get_physical_device_properties2"))
72         {
73                 vki.getPhysicalDeviceFeatures2KHR(device, &features);
74         }
75
76         if ((toCheck & EXT16BITSTORAGEFEATURES_UNIFORM_BUFFER_BLOCK) != 0 && extensionFeatures.storageUniformBufferBlock16 == VK_FALSE)
77                 return false;
78
79         if ((toCheck & EXT16BITSTORAGEFEATURES_UNIFORM) != 0 && extensionFeatures.storageUniform16 == VK_FALSE)
80                 return false;
81
82         if ((toCheck & EXT16BITSTORAGEFEATURES_PUSH_CONSTANT) != 0 && extensionFeatures.storagePushConstant16 == VK_FALSE)
83                 return false;
84
85         if ((toCheck & EXT16BITSTORAGEFEATURES_INPUT_OUTPUT) != 0 && extensionFeatures.storageInputOutput16 == VK_FALSE)
86                 return false;
87
88         return true;
89 }
90
91 Move<VkDevice> createDeviceWithExtensions (const InstanceInterface&                     vki,
92                                                                                    VkPhysicalDevice                                     physicalDevice,
93                                                                                    const deUint32                                       queueFamilyIndex,
94                                                                                    const std::vector<std::string>&      supportedExtensions,
95                                                                                    const std::vector<std::string>&      requiredExtensions)
96 {
97         std::vector<const char*>                extensions                      (requiredExtensions.size());
98
99         for (deUint32 extNdx = 0; extNdx < requiredExtensions.size(); ++extNdx)
100         {
101                 const std::string&      ext = requiredExtensions[extNdx];
102
103                 // Check that all required extensions are supported first.
104                 if (!de::contains(supportedExtensions.begin(), supportedExtensions.end(), ext))
105                 {
106                         TCU_THROW(NotSupportedError, (std::string("Device extension not supported: ") + ext).c_str());
107                 }
108
109                 extensions[extNdx] = ext.c_str();
110         }
111
112         const float                                             queuePriorities[]       = { 1.0f };
113         const VkDeviceQueueCreateInfo   queueInfos[]            =
114         {
115                 {
116                         VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
117                         DE_NULL,
118                         (VkDeviceQueueCreateFlags)0,
119                         queueFamilyIndex,
120                         DE_LENGTH_OF_ARRAY(queuePriorities),
121                         &queuePriorities[0]
122                 }
123         };
124         const VkPhysicalDeviceFeatures  features                        = filterDefaultDeviceFeatures(getPhysicalDeviceFeatures(vki, physicalDevice));
125         const VkDeviceCreateInfo                deviceParams            =
126         {
127                 VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
128                 DE_NULL,
129                 (VkDeviceCreateFlags)0,
130                 DE_LENGTH_OF_ARRAY(queueInfos),
131                 &queueInfos[0],
132                 0u,
133                 DE_NULL,
134                 (deUint32)extensions.size(),
135                 extensions.empty() ? DE_NULL : &extensions[0],
136                 &features
137         };
138
139         return vk::createDevice(vki, physicalDevice, &deviceParams);
140 }
141
142 Allocator* createAllocator (const InstanceInterface& instanceInterface, const VkPhysicalDevice physicalDevice, const DeviceInterface& deviceInterface, const VkDevice device)
143 {
144         const VkPhysicalDeviceMemoryProperties memoryProperties = getPhysicalDeviceMemoryProperties(instanceInterface, physicalDevice);
145
146         // \todo [2015-07-24 jarkko] support allocator selection/configuration from command line (or compile time)
147         return new SimpleAllocator(deviceInterface, device, memoryProperties);
148 }
149
150 } // SpirVAssembly
151 } // vkt