diff options
Diffstat (limited to 'test_conformance/vulkan/vulkan_interop_common/vulkan_list_map.cpp')
| -rw-r--r-- | test_conformance/vulkan/vulkan_interop_common/vulkan_list_map.cpp | 424 |
1 files changed, 424 insertions, 0 deletions
diff --git a/test_conformance/vulkan/vulkan_interop_common/vulkan_list_map.cpp b/test_conformance/vulkan/vulkan_interop_common/vulkan_list_map.cpp new file mode 100644 index 00000000..bdae5d22 --- /dev/null +++ b/test_conformance/vulkan/vulkan_interop_common/vulkan_list_map.cpp @@ -0,0 +1,424 @@ +// +// Copyright (c) 2022 The Khronos Group Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +#ifdef _WIN32 +#define NOMINMAX +#endif +#include "vulkan_list_map.hpp" +#include "vulkan_utility.hpp" +#include "vulkan_wrapper.hpp" + +///////////////////////////////////////////// +// VulkanPhysicalDeviceList implementation // +///////////////////////////////////////////// + +VulkanPhysicalDeviceList::VulkanPhysicalDeviceList( + const VulkanPhysicalDeviceList &physicalDeviceList) +{} + +VulkanPhysicalDeviceList::VulkanPhysicalDeviceList() {} + +VulkanPhysicalDeviceList::~VulkanPhysicalDeviceList() {} + +///////////////////////////////////////// +// VulkanMemoryHeapList implementation // +///////////////////////////////////////// + +VulkanMemoryHeapList::VulkanMemoryHeapList( + const VulkanMemoryHeapList &memoryHeapList) +{} + +VulkanMemoryHeapList::VulkanMemoryHeapList() {} + +VulkanMemoryHeapList::~VulkanMemoryHeapList() {} + +///////////////////////////////////////// +// VulkanMemoryTypeList implementation // +///////////////////////////////////////// + +VulkanMemoryTypeList::VulkanMemoryTypeList( + const VulkanMemoryTypeList &memoryTypeList) +{} + +VulkanMemoryTypeList::VulkanMemoryTypeList() {} + +VulkanMemoryTypeList::~VulkanMemoryTypeList() {} + +////////////////////////////////////////// +// VulkanQueueFamilyList implementation // +////////////////////////////////////////// + +VulkanQueueFamilyList::VulkanQueueFamilyList( + const VulkanQueueFamilyList &queueFamilyList) +{} + +VulkanQueueFamilyList::VulkanQueueFamilyList() {} + +VulkanQueueFamilyList::~VulkanQueueFamilyList() {} + +///////////////////////////////////////////////////// +// VulkanQueueFamilyToQueueCountMap implementation // +///////////////////////////////////////////////////// + +VulkanQueueFamilyToQueueCountMap::VulkanQueueFamilyToQueueCountMap( + const VulkanQueueFamilyToQueueCountMap &queueFamilyToQueueCountMap) +{} + +VulkanQueueFamilyToQueueCountMap::VulkanQueueFamilyToQueueCountMap( + uint32_t numQueuesPerFamily) +{ + uint32_t maxQueueFamilyCount = 0; + const VulkanPhysicalDeviceList &physicalDeviceList = + getVulkanInstance().getPhysicalDeviceList(); + for (size_t pdIdx = 0; pdIdx < physicalDeviceList.size(); pdIdx++) + { + maxQueueFamilyCount = std::max( + maxQueueFamilyCount, + (uint32_t)physicalDeviceList[pdIdx].getQueueFamilyList().size()); + } + + for (uint32_t qfIdx = 0; qfIdx < maxQueueFamilyCount; qfIdx++) + { + insert(qfIdx, numQueuesPerFamily); + } +} + +VulkanQueueFamilyToQueueCountMap::~VulkanQueueFamilyToQueueCountMap() {} + +//////////////////////////////////////////////////// +// VulkanQueueFamilyToQueueListMap implementation // +//////////////////////////////////////////////////// + +VulkanQueueFamilyToQueueListMap::VulkanQueueFamilyToQueueListMap( + const VulkanQueueFamilyToQueueListMap &queueFamilyToQueueMap) +{} + +VulkanQueueFamilyToQueueListMap::VulkanQueueFamilyToQueueListMap() {} + +VulkanQueueFamilyToQueueListMap::~VulkanQueueFamilyToQueueListMap() {} + +void VulkanQueueFamilyToQueueListMap::insert(uint32_t key, + VulkanQueueList &queueList) +{ + m_map.insert(std::pair<uint32_t, std::reference_wrapper<VulkanQueueList>>( + key, std::reference_wrapper<VulkanQueueList>(queueList))); +} + +VulkanQueueList &VulkanQueueFamilyToQueueListMap::operator[](uint32_t key) +{ + return m_map.at(key).get(); +} + +//////////////////////////////////// +// VulkanQueueList implementation // +//////////////////////////////////// + +VulkanQueueList::VulkanQueueList(const VulkanQueueList &queueList) {} + +VulkanQueueList::VulkanQueueList() {} + +VulkanQueueList::~VulkanQueueList() {} + +///////////////////////////////////////////////////////// +// VulkanDescriptorSetLayoutBindingList implementation // +///////////////////////////////////////////////////////// + +VulkanDescriptorSetLayoutBindingList::VulkanDescriptorSetLayoutBindingList( + const VulkanDescriptorSetLayoutBindingList &descriptorSetLayoutBindingList) +{} + +VulkanDescriptorSetLayoutBindingList::VulkanDescriptorSetLayoutBindingList() {} + +VulkanDescriptorSetLayoutBindingList::VulkanDescriptorSetLayoutBindingList( + size_t numDescriptorSetLayoutBindings, VulkanDescriptorType descriptorType, + uint32_t descriptorCount, VulkanShaderStage shaderStage) +{ + for (size_t idx = 0; idx < numDescriptorSetLayoutBindings; idx++) + { + VulkanDescriptorSetLayoutBinding *descriptorSetLayoutBinding = + new VulkanDescriptorSetLayoutBinding((uint32_t)idx, descriptorType, + descriptorCount, shaderStage); + add(*descriptorSetLayoutBinding); + } +} + +VulkanDescriptorSetLayoutBindingList::VulkanDescriptorSetLayoutBindingList( + VulkanDescriptorType descriptorType0, uint32_t descriptorCount0, + VulkanDescriptorType descriptorType1, uint32_t descriptorCount1, + VulkanShaderStage shaderStage) +{ + for (uint32_t idx = 0; idx < descriptorCount0; idx++) + { + VulkanDescriptorSetLayoutBinding *descriptorSetLayoutBinding0 = + new VulkanDescriptorSetLayoutBinding(idx, descriptorType0, 1, + shaderStage); + add(*descriptorSetLayoutBinding0); + } + for (uint32_t idx = 0; idx < descriptorCount1; idx++) + { + VulkanDescriptorSetLayoutBinding *descriptorSetLayoutBinding1 = + new VulkanDescriptorSetLayoutBinding( + descriptorCount0 + idx, descriptorType1, 1, shaderStage); + add(*descriptorSetLayoutBinding1); + } +} + +VulkanDescriptorSetLayoutBindingList::~VulkanDescriptorSetLayoutBindingList() +{ + for (size_t idx = 0; idx < m_wrapperList.size(); idx++) + { + VulkanDescriptorSetLayoutBinding &descriptorSetLayoutBinding = + m_wrapperList[idx]; + delete &descriptorSetLayoutBinding; + } +} + +////////////////////////////////////////////////// +// VulkanDescriptorSetLayoutList implementation // +////////////////////////////////////////////////// + +VulkanDescriptorSetLayoutList::VulkanDescriptorSetLayoutList( + const VulkanDescriptorSetLayoutList &descriptorSetLayoutList) +{} + +VulkanDescriptorSetLayoutList::VulkanDescriptorSetLayoutList() {} + +VulkanDescriptorSetLayoutList::~VulkanDescriptorSetLayoutList() {} + +//////////////////////////////////////////// +// VulkanCommandBufferList implementation // +//////////////////////////////////////////// + +VulkanCommandBufferList::VulkanCommandBufferList( + const VulkanCommandBufferList &commandBufferList) +{} + +VulkanCommandBufferList::VulkanCommandBufferList() {} + +VulkanCommandBufferList::VulkanCommandBufferList( + size_t numCommandBuffers, const VulkanDevice &device, + const VulkanCommandPool &commandPool) +{ + for (size_t idx = 0; idx < numCommandBuffers; idx++) + { + VulkanCommandBuffer *commandBuffer = + new VulkanCommandBuffer(device, commandPool); + add(*commandBuffer); + } +} + +VulkanCommandBufferList::~VulkanCommandBufferList() +{ + for (size_t idx = 0; idx < m_wrapperList.size(); idx++) + { + VulkanCommandBuffer &commandBuffer = m_wrapperList[idx]; + delete &commandBuffer; + } +} + +///////////////////////////////////// +// VulkanBufferList implementation // +///////////////////////////////////// + +VulkanBufferList::VulkanBufferList(const VulkanBufferList &bufferList) {} + +VulkanBufferList::VulkanBufferList( + size_t numBuffers, const VulkanDevice &device, uint64_t size, + VulkanExternalMemoryHandleType externalMemoryHandleType, + VulkanBufferUsage bufferUsage, VulkanSharingMode sharingMode, + const VulkanQueueFamilyList &queueFamilyList) +{ + for (size_t bIdx = 0; bIdx < numBuffers; bIdx++) + { + VulkanBuffer *buffer = + new VulkanBuffer(device, size, externalMemoryHandleType, + bufferUsage, sharingMode, queueFamilyList); + add(*buffer); + } +} + +VulkanBufferList::~VulkanBufferList() +{ + for (size_t bIdx = 0; bIdx < m_wrapperList.size(); bIdx++) + { + VulkanBuffer &buffer = m_wrapperList[bIdx]; + delete &buffer; + } +} + +////////////////////////////////////// +// VulkanImage2DList implementation // +////////////////////////////////////// + +VulkanImage2DList::VulkanImage2DList(const VulkanImage2DList &image2DList) {} + +VulkanImage2DList::VulkanImage2DList( + size_t numImages, std::vector<VulkanDeviceMemory *> &deviceMemory, + uint64_t baseOffset, uint64_t interImageOffset, const VulkanDevice &device, + VulkanFormat format, uint32_t width, uint32_t height, uint32_t mipLevels, + VulkanExternalMemoryHandleType externalMemoryHandleType, + VulkanImageCreateFlag imageCreateFlag, VulkanImageUsage imageUsage, + VulkanSharingMode sharingMode) +{ + for (size_t i2DIdx = 0; i2DIdx < numImages; i2DIdx++) + { + VulkanImage2D *image2D = new VulkanImage2D( + device, format, width, height, mipLevels, externalMemoryHandleType, + imageCreateFlag, imageUsage, sharingMode); + add(*image2D); + deviceMemory[i2DIdx]->bindImage( + *image2D, baseOffset + (i2DIdx * interImageOffset)); + } +} + +VulkanImage2DList::VulkanImage2DList( + size_t numImages, const VulkanDevice &device, VulkanFormat format, + uint32_t width, uint32_t height, uint32_t mipLevels, + VulkanExternalMemoryHandleType externalMemoryHandleType, + VulkanImageCreateFlag imageCreateFlag, VulkanImageUsage imageUsage, + VulkanSharingMode sharingMode) +{ + for (size_t bIdx = 0; bIdx < numImages; bIdx++) + { + VulkanImage2D *image2D = new VulkanImage2D( + device, format, width, height, mipLevels, externalMemoryHandleType, + imageCreateFlag, imageUsage, sharingMode); + add(*image2D); + } +} + +VulkanImage2DList::~VulkanImage2DList() +{ + for (size_t i2DIdx = 0; i2DIdx < m_wrapperList.size(); i2DIdx++) + { + VulkanImage2D &image2D = m_wrapperList[i2DIdx]; + delete &image2D; + } +} + +//////////////////////////////////////// +// VulkanImageViewList implementation // +//////////////////////////////////////// + +VulkanImageViewList::VulkanImageViewList(const VulkanImageViewList &image2DList) +{} + +VulkanImageViewList::VulkanImageViewList(const VulkanDevice &device, + const VulkanImage2DList &image2DList, + bool createImageViewPerMipLevel) +{ + for (size_t i2DIdx = 0; i2DIdx < image2DList.size(); i2DIdx++) + { + if (createImageViewPerMipLevel) + { + for (uint32_t mipLevel = 0; + mipLevel < image2DList[i2DIdx].getNumMipLevels(); mipLevel++) + { + VulkanImageView *image2DView = + new VulkanImageView(device, image2DList[i2DIdx], + VULKAN_IMAGE_VIEW_TYPE_2D, mipLevel, 1); + add(*image2DView); + } + } + else + { + VulkanImageView *image2DView = new VulkanImageView( + device, image2DList[i2DIdx], VULKAN_IMAGE_VIEW_TYPE_2D); + add(*image2DView); + } + } +} + +VulkanImageViewList::~VulkanImageViewList() +{ + for (size_t ivIdx = 0; ivIdx < m_wrapperList.size(); ivIdx++) + { + VulkanImageView &imageView = m_wrapperList[ivIdx]; + delete &imageView; + } +} + +/////////////////////////////////////////// +// VulkanDeviceMemoryList implementation // +/////////////////////////////////////////// + +VulkanDeviceMemoryList::VulkanDeviceMemoryList( + const VulkanDeviceMemoryList &deviceMemoryList) +{} + +VulkanDeviceMemoryList::VulkanDeviceMemoryList( + size_t numImages, const VulkanImage2DList &image2DList, + const VulkanDevice &device, const VulkanMemoryType &memoryType, + VulkanExternalMemoryHandleType externalMemoryHandleType) +{ + for (size_t i2DIdx = 0; i2DIdx < image2DList.size(); i2DIdx++) + { + VulkanDeviceMemory *deviceMemory = new VulkanDeviceMemory( + device, image2DList[i2DIdx], memoryType, externalMemoryHandleType); + add(*deviceMemory); + deviceMemory->bindImage(image2DList[i2DIdx]); + } +} + +VulkanDeviceMemoryList::~VulkanDeviceMemoryList() +{ + for (size_t dmIdx = 0; dmIdx < m_wrapperList.size(); dmIdx++) + { + VulkanDeviceMemory &deviceMemory = m_wrapperList[dmIdx]; + delete &deviceMemory; + } +} + +//////////////////////////////////////// +// VulkanSemaphoreList implementation // +//////////////////////////////////////// + +VulkanSemaphoreList::VulkanSemaphoreList( + const VulkanSemaphoreList &semaphoreList) +{} + +VulkanSemaphoreList::VulkanSemaphoreList() {} + +VulkanSemaphoreList::VulkanSemaphoreList( + size_t numSemaphores, const VulkanDevice &device, + VulkanExternalSemaphoreHandleType externalSemaphoreHandleType, + const std::wstring namePrefix) +{ + std::wstring name = L""; + for (size_t idx = 0; idx < numSemaphores; idx++) + { + if (namePrefix.size()) + { + const size_t maxNameSize = 256; + wchar_t tempName[maxNameSize]; + swprintf(tempName, maxNameSize, L"%s%d", namePrefix.c_str(), + (int)idx); + name = tempName; + } + VulkanSemaphore *semaphore = + new VulkanSemaphore(device, externalSemaphoreHandleType, name); + add(*semaphore); + } +} + +VulkanSemaphoreList::~VulkanSemaphoreList() +{ + for (size_t idx = 0; idx < m_wrapperList.size(); idx++) + { + VulkanSemaphore &Semaphore = m_wrapperList[idx]; + delete &Semaphore; + } +} |