1 #ifndef _VKTEXTERNALMEMORYUTIL_HPP 2 #define _VKTEXTERNALMEMORYUTIL_HPP 3 /*------------------------------------------------------------------------- 4 * Vulkan Conformance Tests 5 * ------------------------ 6 * 7 * Copyright (c) 2016 Google Inc. 8 * 9 * Licensed under the Apache License, Version 2.0 (the "License"); 10 * you may not use this file except in compliance with the License. 11 * You may obtain a copy of the License at 12 * 13 * http://www.apache.org/licenses/LICENSE-2.0 14 * 15 * Unless required by applicable law or agreed to in writing, software 16 * distributed under the License is distributed on an "AS IS" BASIS, 17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 18 * See the License for the specific language governing permissions and 19 * limitations under the License. 20 * 21 * \brief Vulkan external memory utilities 22 *//*--------------------------------------------------------------------*/ 23 24 #include "tcuDefs.hpp" 25 26 #include "vkPlatform.hpp" 27 #include "vkRefUtil.hpp" 28 29 #include "deMemory.h" 30 #include "deInt32.h" 31 32 namespace vkt 33 { 34 namespace ExternalMemoryUtil 35 { 36 37 class NativeHandle 38 { 39 public: 40 enum Win32HandleType 41 { 42 WIN32HANDLETYPE_NT = 0, 43 WIN32HANDLETYPE_KMT, 44 45 WIN32HANDLETYPE_LAST 46 }; 47 48 NativeHandle (void); 49 NativeHandle (const NativeHandle& other); 50 NativeHandle (int fd); 51 NativeHandle (Win32HandleType type, vk::pt::Win32Handle handle); 52 NativeHandle (vk::pt::AndroidHardwareBufferPtr buffer); 53 ~NativeHandle (void); 54 55 NativeHandle& operator= (int fd); 56 NativeHandle& operator= (vk::pt::AndroidHardwareBufferPtr buffer); 57 58 void setWin32Handle (Win32HandleType type, vk::pt::Win32Handle handle); 59 vk::pt::Win32Handle getWin32Handle (void) const; 60 void setHostPtr (void* hostPtr); 61 void* getHostPtr (void) const; 62 int getFd (void) const; 63 vk::pt::AndroidHardwareBufferPtr getAndroidHardwareBuffer (void) const; 64 void disown (void); 65 void reset (void); 66 67 private: 68 int m_fd; 69 Win32HandleType m_win32HandleType; 70 vk::pt::Win32Handle m_win32Handle; 71 vk::pt::AndroidHardwareBufferPtr m_androidHardwareBuffer; 72 void* m_hostPtr; 73 74 // Disabled 75 NativeHandle& operator= (const NativeHandle&); 76 }; 77 78 class AndroidHardwareBufferExternalApi 79 { 80 public: 81 82 /** 83 * getInstance obtains the object, that provides an interface to AHB system APIs . 84 * If the AHB system API is not supported or if it is not built as supported with the CTS, 85 * then this function would return a null object. 86 */ 87 static AndroidHardwareBufferExternalApi* getInstance(); 88 89 /* Is AndroidHardwareBuffer supported? */ 90 static bool supportsAhb(); 91 92 /* Are Cube maps supported on current api level? */ 93 static bool supportsCubeMap(); 94 95 /** 96 * Allocates a buffer that backs an AHardwareBuffer using the passed parameter as follows: 97 * width; - width in pixels 98 * height; - height in pixels 99 * layers; - number of images 100 * format; - One of AHARDWAREBUFFER_FORMAT_* 101 * usage; - Combination of AHARDWAREBUFFER_USAGE_* 102 * 103 * Returns a valid AndroidHardwareBufferPtr object on success, or an null AndroidHardwareBufferPtr if 104 * the allocation fails for any reason. 105 */ 106 virtual vk::pt::AndroidHardwareBufferPtr allocate(deUint32 width, deUint32 height, deUint32 layers, deUint32 format, deUint64 usage) = 0; 107 108 /** 109 * Acquire a reference on the given AHardwareBuffer object. This prevents the 110 * object from being deleted until the last reference is removed. 111 */ 112 virtual void acquire(vk::pt::AndroidHardwareBufferPtr buffer) = 0; 113 114 /** 115 * Remove a reference that was previously acquired with 116 * AHardwareBuffer_acquire(). 117 */ 118 virtual void release(vk::pt::AndroidHardwareBufferPtr buffer) = 0; 119 120 /** 121 * Return a description of the AHardwareBuffer in the passed in the following fields, if not NULL: 122 * width; - width in pixels 123 * height; - height in pixels 124 * layers; - number of images 125 * format; - One of AHARDWAREBUFFER_FORMAT_* 126 * usage; - Combination of AHARDWAREBUFFER_USAGE_* 127 * 128 */ 129 virtual void describe(const vk::pt::AndroidHardwareBufferPtr buffer, 130 deUint32* width, 131 deUint32* height, 132 deUint32* layers, 133 deUint32* format, 134 deUint64* usage, 135 deUint32* stride) = 0; 136 137 138 virtual deUint64 vkUsageToAhbUsage(vk::VkImageUsageFlagBits vkFlag) = 0; 139 virtual deUint64 vkCreateToAhbUsage(vk::VkImageCreateFlagBits vkFlag) = 0; 140 virtual deUint32 vkFormatToAhbFormat(vk::VkFormat vkFormat) = 0; 141 virtual deUint64 mustSupportAhbUsageFlags() = 0; 142 virtual bool ahbFormatIsBlob(deUint32 format) = 0; 143 144 virtual ~AndroidHardwareBufferExternalApi(); 145 146 protected: 147 // Protected Constructor 148 AndroidHardwareBufferExternalApi(); 149 150 private: 151 // Stop the compiler generating methods of copy the object 152 AndroidHardwareBufferExternalApi(AndroidHardwareBufferExternalApi const& copy); // Not Implemented 153 AndroidHardwareBufferExternalApi& operator=(AndroidHardwareBufferExternalApi const& copy); // Not Implemented 154 155 static bool loadAhbDynamicApis(deInt32 sdkVersion); 156 }; 157 158 const char* externalSemaphoreTypeToName (vk::VkExternalSemaphoreHandleTypeFlagBits type); 159 const char* externalFenceTypeToName (vk::VkExternalFenceHandleTypeFlagBits type); 160 const char* externalMemoryTypeToName (vk::VkExternalMemoryHandleTypeFlagBits type); 161 162 enum Permanence 163 { 164 PERMANENCE_PERMANENT = 0, 165 PERMANENCE_TEMPORARY 166 }; 167 168 enum Transference 169 { 170 TRANSFERENCE_COPY = 0, 171 TRANSFERENCE_REFERENCE 172 }; 173 174 struct ExternalHostMemory 175 { ExternalHostMemoryvkt::ExternalMemoryUtil::ExternalHostMemory176 ExternalHostMemory(vk::VkDeviceSize aSize, vk::VkDeviceSize aAlignment) 177 : size(deAlignSize(static_cast<size_t>(aSize), static_cast<size_t>(aAlignment))) 178 { 179 data = deAlignedMalloc(this->size, static_cast<size_t>(aAlignment)); 180 } 181 ~ExternalHostMemoryvkt::ExternalMemoryUtil::ExternalHostMemory182 ~ExternalHostMemory() 183 { 184 if (data != DE_NULL) 185 { 186 deAlignedFree(data); 187 } 188 } 189 190 size_t size; 191 void* data; 192 }; 193 194 bool isSupportedPermanence (vk::VkExternalSemaphoreHandleTypeFlagBits type, 195 Permanence permanence); 196 Transference getHandelTypeTransferences (vk::VkExternalSemaphoreHandleTypeFlagBits type); 197 198 bool isSupportedPermanence (vk::VkExternalFenceHandleTypeFlagBits type, 199 Permanence permanence); 200 Transference getHandelTypeTransferences (vk::VkExternalFenceHandleTypeFlagBits type); 201 202 int getMemoryFd (const vk::DeviceInterface& vkd, 203 vk::VkDevice device, 204 vk::VkDeviceMemory memory, 205 vk::VkExternalMemoryHandleTypeFlagBits externalType); 206 207 void getMemoryNative (const vk::DeviceInterface& vkd, 208 vk::VkDevice device, 209 vk::VkDeviceMemory memory, 210 vk::VkExternalMemoryHandleTypeFlagBits externalType, 211 NativeHandle& nativeHandle); 212 213 vk::Move<vk::VkSemaphore> createExportableSemaphore (const vk::DeviceInterface& vkd, 214 vk::VkDevice device, 215 vk::VkExternalSemaphoreHandleTypeFlagBits externalType); 216 217 vk::Move<vk::VkSemaphore> createExportableSemaphoreType (const vk::DeviceInterface& vkd, 218 vk::VkDevice device, 219 vk::VkSemaphoreType semaphoreType, 220 vk::VkExternalSemaphoreHandleTypeFlagBits externalType); 221 222 int getSemaphoreFd (const vk::DeviceInterface& vkd, 223 vk::VkDevice device, 224 vk::VkSemaphore semaphore, 225 vk::VkExternalSemaphoreHandleTypeFlagBits externalType); 226 227 void getSemaphoreNative (const vk::DeviceInterface& vkd, 228 vk::VkDevice device, 229 vk::VkSemaphore semaphore, 230 vk::VkExternalSemaphoreHandleTypeFlagBits externalType, 231 NativeHandle& nativeHandle); 232 233 void importSemaphore (const vk::DeviceInterface& vkd, 234 const vk::VkDevice device, 235 const vk::VkSemaphore semaphore, 236 vk::VkExternalSemaphoreHandleTypeFlagBits externalType, 237 NativeHandle& handle, 238 vk::VkSemaphoreImportFlags flags); 239 240 vk::Move<vk::VkSemaphore> createAndImportSemaphore (const vk::DeviceInterface& vkd, 241 const vk::VkDevice device, 242 vk::VkExternalSemaphoreHandleTypeFlagBits externalType, 243 NativeHandle& handle, 244 vk::VkSemaphoreImportFlags flags); 245 246 vk::Move<vk::VkFence> createExportableFence (const vk::DeviceInterface& vkd, 247 vk::VkDevice device, 248 vk::VkExternalFenceHandleTypeFlagBits externalType); 249 250 int getFenceFd (const vk::DeviceInterface& vkd, 251 vk::VkDevice device, 252 vk::VkFence fence, 253 vk::VkExternalFenceHandleTypeFlagBits externalType); 254 255 void getFenceNative (const vk::DeviceInterface& vkd, 256 vk::VkDevice device, 257 vk::VkFence fence, 258 vk::VkExternalFenceHandleTypeFlagBits externalType, 259 NativeHandle& nativeHandle, 260 bool expectFenceUnsignaled = true); 261 262 void importFence (const vk::DeviceInterface& vkd, 263 const vk::VkDevice device, 264 const vk::VkFence fence, 265 vk::VkExternalFenceHandleTypeFlagBits externalType, 266 NativeHandle& handle, 267 vk::VkFenceImportFlags flags); 268 269 vk::Move<vk::VkFence> createAndImportFence (const vk::DeviceInterface& vkd, 270 const vk::VkDevice device, 271 vk::VkExternalFenceHandleTypeFlagBits externalType, 272 NativeHandle& handle, 273 vk::VkFenceImportFlags flags); 274 275 deUint32 chooseMemoryType (deUint32 bits); 276 277 deUint32 chooseHostVisibleMemoryType (deUint32 bits, 278 const vk::VkPhysicalDeviceMemoryProperties properties); 279 280 vk::VkMemoryRequirements getImageMemoryRequirements (const vk::DeviceInterface& vkd, 281 vk::VkDevice device, 282 vk::VkImage image, 283 vk::VkExternalMemoryHandleTypeFlagBits externalType); 284 285 // If buffer is not null use dedicated allocation 286 vk::Move<vk::VkDeviceMemory> allocateExportableMemory (const vk::DeviceInterface& vkd, 287 vk::VkDevice device, 288 vk::VkDeviceSize allocationSize, 289 deUint32 memoryTypeIndex, 290 vk::VkExternalMemoryHandleTypeFlagBits externalType, 291 vk::VkBuffer buffer); 292 293 // If image is not null use dedicated allocation 294 vk::Move<vk::VkDeviceMemory> allocateExportableMemory (const vk::DeviceInterface& vkd, 295 vk::VkDevice device, 296 vk::VkDeviceSize allocationSize, 297 deUint32 memoryTypeIndex, 298 vk::VkExternalMemoryHandleTypeFlagBits externalType, 299 vk::VkImage image); 300 301 /* 302 // \note hostVisible argument is strict. Setting it to false will cause NotSupportedError to be thrown if non-host visible memory doesn't exist. 303 // If buffer is not null use dedicated allocation 304 vk::Move<vk::VkDeviceMemory> allocateExportableMemory (const vk::InstanceInterface& vki, 305 vk::VkPhysicalDevice physicalDevice, 306 const vk::DeviceInterface& vkd, 307 vk::VkDevice device, 308 const vk::VkMemoryRequirements& requirements, 309 vk::VkExternalMemoryHandleTypeFlagBits externalType, 310 bool hostVisible, 311 vk::VkBuffer buffer, 312 deUint32& exportedMemoryTypeIndex); 313 */ 314 315 vk::Move<vk::VkDeviceMemory> importMemory (const vk::DeviceInterface& vkd, 316 vk::VkDevice device, 317 const vk::VkMemoryRequirements& requirements, 318 vk::VkExternalMemoryHandleTypeFlagBits externalType, 319 deUint32 memoryTypeIndex, 320 NativeHandle& handle); 321 322 vk::Move<vk::VkDeviceMemory> importDedicatedMemory (const vk::DeviceInterface& vkd, 323 vk::VkDevice device, 324 vk::VkBuffer buffer, 325 const vk::VkMemoryRequirements& requirements, 326 vk::VkExternalMemoryHandleTypeFlagBits externalType, 327 deUint32 memoryTypeIndex, 328 NativeHandle& handle); 329 330 vk::Move<vk::VkDeviceMemory> importDedicatedMemory (const vk::DeviceInterface& vkd, 331 vk::VkDevice device, 332 vk::VkImage image, 333 const vk::VkMemoryRequirements& requirements, 334 vk::VkExternalMemoryHandleTypeFlagBits externalType, 335 deUint32 memoryTypeIndex, 336 NativeHandle& handle); 337 338 vk::Move<vk::VkBuffer> createExternalBuffer (const vk::DeviceInterface& vkd, 339 vk::VkDevice device, 340 deUint32 queueFamilyIndex, 341 vk::VkExternalMemoryHandleTypeFlagBits externalType, 342 vk::VkDeviceSize size, 343 vk::VkBufferCreateFlags createFlags, 344 vk::VkBufferUsageFlags usageFlags); 345 346 vk::Move<vk::VkImage> createExternalImage (const vk::DeviceInterface& vkd, 347 vk::VkDevice device, 348 deUint32 queueFamilyIndex, 349 vk::VkExternalMemoryHandleTypeFlagBits externalType, 350 vk::VkFormat format, 351 deUint32 width, 352 deUint32 height, 353 vk::VkImageTiling tiling, 354 vk::VkImageCreateFlags createFlags, 355 vk::VkImageUsageFlags usageFlags, 356 deUint32 mipLevels = 1u, 357 deUint32 arrayLayers = 1u); 358 359 vk::VkPhysicalDeviceExternalMemoryHostPropertiesEXT getPhysicalDeviceExternalMemoryHostProperties(const vk::InstanceInterface& vki, 360 vk::VkPhysicalDevice physicalDevice); 361 362 } // ExternalMemoryUtil 363 } // vkt 364 365 #endif // _VKTEXTERNALMEMORYUTIL_HPP 366