blob: 46486bb65a8e3f0c8f590a3235e36b30845aeddc [file] [log] [blame]
// Copyright 2018 The SwiftShader Authors. All Rights Reserved.
//
// 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.
#include "VkPhysicalDevice.hpp"
#include "VkConfig.h"
#include <memory.h>
namespace vk
{
PhysicalDevice::PhysicalDevice(const void*, void* mem)
{
}
const VkPhysicalDeviceFeatures& PhysicalDevice::getFeatures() const
{
static const VkPhysicalDeviceFeatures features
{
true, // robustBufferAccess
false, // fullDrawIndexUint32
false, // imageCubeArray
false, // independentBlend
false, // geometryShader
false, // tessellationShader
false, // sampleRateShading
false, // dualSrcBlend
false, // logicOp
false, // multiDrawIndirect
false, // drawIndirectFirstInstance
false, // depthClamp
false, // depthBiasClamp
false, // fillModeNonSolid
false, // depthBounds
false, // wideLines
false, // largePoints
false, // alphaToOne
false, // multiViewport
false, // samplerAnisotropy
false, // textureCompressionETC2
false, // textureCompressionASTC_LDR
false, // textureCompressionBC
false, // occlusionQueryPrecise
false, // pipelineStatisticsQuery
false, // vertexPipelineStoresAndAtomics
false, // fragmentStoresAndAtomics
false, // shaderTessellationAndGeometryPointSize
false, // shaderImageGatherExtended
false, // shaderStorageImageExtendedFormats
false, // shaderStorageImageMultisample
false, // shaderStorageImageReadWithoutFormat
false, // shaderStorageImageWriteWithoutFormat
false, // shaderUniformBufferArrayDynamicIndexing
false, // shaderSampledImageArrayDynamicIndexing
false, // shaderStorageBufferArrayDynamicIndexing
false, // shaderStorageImageArrayDynamicIndexing
false, // shaderClipDistance
false, // shaderCullDistance
false, // shaderFloat64
false, // shaderInt64
false, // shaderInt16
false, // shaderResourceResidency
false, // shaderResourceMinLod
false, // sparseBinding
false, // sparseResidencyBuffer
false, // sparseResidencyImage2D
false, // sparseResidencyImage3D
false, // sparseResidency2Samples
false, // sparseResidency4Samples
false, // sparseResidency8Samples
false, // sparseResidency16Samples
false, // sparseResidencyAliased
false, // variableMultisampleRate
false, // inheritedQueries
};
return features;
}
void PhysicalDevice::getFeatures(VkPhysicalDeviceSamplerYcbcrConversionFeatures* features) const
{
features->samplerYcbcrConversion = VK_FALSE;
}
void PhysicalDevice::getFeatures(VkPhysicalDevice16BitStorageFeatures* features) const
{
features->storageBuffer16BitAccess = VK_FALSE;
features->storageInputOutput16 = VK_FALSE;
features->storagePushConstant16 = VK_FALSE;
features->uniformAndStorageBuffer16BitAccess = VK_FALSE;
}
void PhysicalDevice::getFeatures(VkPhysicalDeviceVariablePointerFeatures* features) const
{
features->variablePointersStorageBuffer = VK_FALSE;
features->variablePointers = VK_FALSE;
}
void PhysicalDevice::getFeatures(VkPhysicalDevice8BitStorageFeaturesKHR* features) const
{
features->storageBuffer8BitAccess = VK_FALSE;
features->uniformAndStorageBuffer8BitAccess = VK_FALSE;
features->storagePushConstant8 = VK_FALSE;
}
void PhysicalDevice::getFeatures(VkPhysicalDeviceMultiviewFeatures* features) const
{
features->multiview = VK_FALSE;
features->multiviewGeometryShader = VK_FALSE;
features->multiviewTessellationShader = VK_FALSE;
}
void PhysicalDevice::getFeatures(VkPhysicalDeviceProtectedMemoryFeatures* features) const
{
features->protectedMemory = VK_FALSE;
}
VkSampleCountFlags PhysicalDevice::getSampleCounts() const
{
return VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT;
}
const VkPhysicalDeviceLimits& PhysicalDevice::getLimits() const
{
VkSampleCountFlags sampleCounts = getSampleCounts();
static const VkPhysicalDeviceLimits limits =
{
(1 << vk::MAX_IMAGE_LEVELS_1D), // maxImageDimension1D
(1 << vk::MAX_IMAGE_LEVELS_2D), // maxImageDimension2D
(1 << vk::MAX_IMAGE_LEVELS_3D), // maxImageDimension3D
(1 << vk::MAX_IMAGE_LEVELS_CUBE), // maxImageDimensionCube
(1 << vk::MAX_IMAGE_ARRAY_LAYERS), // maxImageArrayLayers
65536, // maxTexelBufferElements
16384, // maxUniformBufferRange
(1ul << 27), // maxStorageBufferRange
128, // maxPushConstantsSize
4096, // maxMemoryAllocationCount
4000, // maxSamplerAllocationCount
131072, // bufferImageGranularity
0, // sparseAddressSpaceSize (unsupported)
4, // maxBoundDescriptorSets
16, // maxPerStageDescriptorSamplers
12, // maxPerStageDescriptorUniformBuffers
4, // maxPerStageDescriptorStorageBuffers
16, // maxPerStageDescriptorSampledImages
4, // maxPerStageDescriptorStorageImages
4, // maxPerStageDescriptorInputAttachments
128, // maxPerStageResources
96, // maxDescriptorSetSamplers
72, // maxDescriptorSetUniformBuffers
8, // maxDescriptorSetUniformBuffersDynamic
24, // maxDescriptorSetStorageBuffers
4, // maxDescriptorSetStorageBuffersDynamic
96, // maxDescriptorSetSampledImages
24, // maxDescriptorSetStorageImages
4, // maxDescriptorSetInputAttachments
16, // maxVertexInputAttributes
vk::MAX_VERTEX_INPUT_BINDINGS, // maxVertexInputBindings
2047, // maxVertexInputAttributeOffset
2048, // maxVertexInputBindingStride
64, // maxVertexOutputComponents
0, // maxTessellationGenerationLevel (unsupported)
0, // maxTessellationPatchSize (unsupported)
0, // maxTessellationControlPerVertexInputComponents (unsupported)
0, // maxTessellationControlPerVertexOutputComponents (unsupported)
0, // maxTessellationControlPerPatchOutputComponents (unsupported)
0, // maxTessellationControlTotalOutputComponents (unsupported)
0, // maxTessellationEvaluationInputComponents (unsupported)
0, // maxTessellationEvaluationOutputComponents (unsupported)
0, // maxGeometryShaderInvocations (unsupported)
0, // maxGeometryInputComponents (unsupported)
0, // maxGeometryOutputComponents (unsupported)
0, // maxGeometryOutputVertices (unsupported)
0, // maxGeometryTotalOutputComponents (unsupported)
64, // maxFragmentInputComponents
4, // maxFragmentOutputAttachments
1, // maxFragmentDualSrcAttachments
4, // maxFragmentCombinedOutputResources
16384, // maxComputeSharedMemorySize
{ 65535, 65535, 65535 }, // maxComputeWorkGroupCount[3]
128, // maxComputeWorkGroupInvocations
{ 128, 128, 64, }, // maxComputeWorkGroupSize[3]
4, // subPixelPrecisionBits
4, // subTexelPrecisionBits
4, // mipmapPrecisionBits
UINT32_MAX, // maxDrawIndexedIndexValue
UINT32_MAX, // maxDrawIndirectCount
2, // maxSamplerLodBias
16, // maxSamplerAnisotropy
16, // maxViewports
{ 4096, 4096 }, // maxViewportDimensions[2]
{ -8192, 8191 }, // viewportBoundsRange[2]
0, // viewportSubPixelBits
64, // minMemoryMapAlignment
256, // minTexelBufferOffsetAlignment
256, // minUniformBufferOffsetAlignment
256, // minStorageBufferOffsetAlignment
-8, // minTexelOffset
7, // maxTexelOffset
-8, // minTexelGatherOffset
7, // maxTexelGatherOffset
-0.5, // minInterpolationOffset
0.5, // maxInterpolationOffset
4, // subPixelInterpolationOffsetBits
4096, // maxFramebufferWidth
4096, // maxFramebufferHeight
256, // maxFramebufferLayers
sampleCounts, // framebufferColorSampleCounts
sampleCounts, // framebufferDepthSampleCounts
sampleCounts, // framebufferStencilSampleCounts
sampleCounts, // framebufferNoAttachmentsSampleCounts
4, // maxColorAttachments
sampleCounts, // sampledImageColorSampleCounts
VK_SAMPLE_COUNT_1_BIT, // sampledImageIntegerSampleCounts
sampleCounts, // sampledImageDepthSampleCounts
sampleCounts, // sampledImageStencilSampleCounts
VK_SAMPLE_COUNT_1_BIT, // storageImageSampleCounts (unsupported)
1, // maxSampleMaskWords
false, // timestampComputeAndGraphics
60, // timestampPeriod
8, // maxClipDistances
8, // maxCullDistances
8, // maxCombinedClipAndCullDistances
2, // discreteQueuePriorities
{ 1.0, 64.0 }, // pointSizeRange[2]
{ 1.0, 1.0 }, // lineWidthRange[2] (unsupported)
0.0, // pointSizeGranularity (unsupported)
0.0, // lineWidthGranularity (unsupported)
false, // strictLines
true, // standardSampleLocations
64, // optimalBufferCopyOffsetAlignment
64, // optimalBufferCopyRowPitchAlignment
256, // nonCoherentAtomSize
};
return limits;
}
const VkPhysicalDeviceProperties& PhysicalDevice::getProperties() const
{
static const VkPhysicalDeviceProperties properties
{
API_VERSION,
DRIVER_VERSION,
VENDOR_ID,
DEVICE_ID,
VK_PHYSICAL_DEVICE_TYPE_CPU, // deviceType
SWIFTSHADER_DEVICE_NAME, // deviceName
SWIFTSHADER_UUID, // pipelineCacheUUID
getLimits(), // limits
{ 0 } // sparseProperties
};
return properties;
}
void PhysicalDevice::getProperties(VkPhysicalDeviceIDProperties* properties) const
{
memset(properties->deviceUUID, 0, VK_UUID_SIZE);
memset(properties->driverUUID, 0, VK_UUID_SIZE);
memset(properties->deviceLUID, 0, VK_LUID_SIZE);
memcpy(properties->deviceUUID, SWIFTSHADER_UUID, VK_UUID_SIZE);
*((uint64_t*)properties->driverUUID) = DRIVER_VERSION;
properties->deviceNodeMask = 0;
properties->deviceLUIDValid = VK_FALSE;
}
void PhysicalDevice::getProperties(VkPhysicalDeviceMaintenance3Properties* properties) const
{
properties->maxMemoryAllocationSize = 1 << 31;
properties->maxPerSetDescriptors = 1024;
}
void PhysicalDevice::getProperties(VkPhysicalDeviceMultiviewProperties* properties) const
{
properties->maxMultiviewViewCount = 0;
properties->maxMultiviewInstanceIndex = 0;
}
void PhysicalDevice::getProperties(VkPhysicalDevicePointClippingProperties* properties) const
{
properties->pointClippingBehavior = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES;
}
void PhysicalDevice::getProperties(VkPhysicalDeviceProtectedMemoryProperties* properties) const
{
properties->protectedNoFault = VK_FALSE;
}
void PhysicalDevice::getProperties(VkPhysicalDeviceSubgroupProperties* properties) const
{
properties->subgroupSize = 1;
properties->supportedStages = VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_COMPUTE_BIT;
properties->supportedOperations = VK_SUBGROUP_FEATURE_BASIC_BIT;
properties->quadOperationsInAllStages = VK_FALSE;
}
bool PhysicalDevice::hasFeatures(const VkPhysicalDeviceFeatures& requestedFeatures) const
{
const VkPhysicalDeviceFeatures& supportedFeatures = getFeatures();
const VkBool32* supportedFeature = reinterpret_cast<const VkBool32*>(&supportedFeatures);
const VkBool32* requestedFeature = reinterpret_cast<const VkBool32*>(&requestedFeatures);
constexpr auto featureCount = sizeof(VkPhysicalDeviceFeatures) / sizeof(VkBool32);
for(unsigned int i = 0; i < featureCount; i++)
{
if((requestedFeature[i] == VK_TRUE) && (supportedFeature[i] != VK_TRUE))
{
return false;
}
}
return true;
}
void PhysicalDevice::getFormatProperties(VkFormat format, VkFormatProperties* pFormatProperties) const
{
pFormatProperties->linearTilingFeatures = 0; // Unsupported format
pFormatProperties->optimalTilingFeatures = 0; // Unsupported format
pFormatProperties->bufferFeatures = 0; // Unsupported format
}
void PhysicalDevice::getImageFormatProperties(VkFormat format, VkImageType type, VkImageTiling tiling,
VkImageUsageFlags usage, VkImageCreateFlags flags,
VkImageFormatProperties* pImageFormatProperties) const
{
pImageFormatProperties->maxArrayLayers = 1 << vk::MAX_IMAGE_ARRAY_LAYERS;
switch(type)
{
case VK_IMAGE_TYPE_1D:
pImageFormatProperties->maxMipLevels = vk::MAX_IMAGE_LEVELS_1D;
pImageFormatProperties->maxExtent.width = 1 << vk::MAX_IMAGE_LEVELS_1D;
pImageFormatProperties->maxExtent.height = 1;
pImageFormatProperties->maxExtent.depth = 1;
break;
case VK_IMAGE_TYPE_2D:
if(flags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT)
{
pImageFormatProperties->maxMipLevels = vk::MAX_IMAGE_LEVELS_CUBE;
pImageFormatProperties->maxExtent.width = 1 << vk::MAX_IMAGE_LEVELS_CUBE;
pImageFormatProperties->maxExtent.height = 1 << vk::MAX_IMAGE_LEVELS_CUBE;
pImageFormatProperties->maxExtent.depth = 1;
}
else
{
pImageFormatProperties->maxMipLevels = vk::MAX_IMAGE_LEVELS_2D;
pImageFormatProperties->maxExtent.width = 1 << vk::MAX_IMAGE_LEVELS_2D;
pImageFormatProperties->maxExtent.height = 1 << vk::MAX_IMAGE_LEVELS_2D;
pImageFormatProperties->maxExtent.depth = 1;
}
break;
case VK_IMAGE_TYPE_3D:
pImageFormatProperties->maxMipLevels = vk::MAX_IMAGE_LEVELS_3D;
pImageFormatProperties->maxExtent.width = 1 << vk::MAX_IMAGE_LEVELS_3D;
pImageFormatProperties->maxExtent.height = 1 << vk::MAX_IMAGE_LEVELS_3D;
pImageFormatProperties->maxExtent.depth = 1 << vk::MAX_IMAGE_LEVELS_3D;
break;
default:
UNREACHABLE(type);
break;
}
pImageFormatProperties->maxResourceSize = 1 << 31; // Minimum value for maxResourceSize
pImageFormatProperties->sampleCounts = getSampleCounts();
}
uint32_t PhysicalDevice::getQueueFamilyPropertyCount() const
{
return 1;
}
void PhysicalDevice::getQueueFamilyProperties(uint32_t pQueueFamilyPropertyCount,
VkQueueFamilyProperties* pQueueFamilyProperties) const
{
for(uint32_t i = 0; i < pQueueFamilyPropertyCount; i++)
{
pQueueFamilyProperties[i].minImageTransferGranularity.width = 1;
pQueueFamilyProperties[i].minImageTransferGranularity.height = 1;
pQueueFamilyProperties[i].minImageTransferGranularity.depth = 1;
pQueueFamilyProperties[i].queueCount = 1;
pQueueFamilyProperties[i].queueFlags = VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT;
pQueueFamilyProperties[i].timestampValidBits = 0; // No support for time stamps
}
}
const VkPhysicalDeviceMemoryProperties& PhysicalDevice::getMemoryProperties() const
{
static const VkPhysicalDeviceMemoryProperties properties
{
1, // memoryTypeCount
{
// vk::MEMORY_TYPE_GENERIC_BIT
{
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT |
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT |
VK_MEMORY_PROPERTY_HOST_CACHED_BIT, // propertyFlags
0 // heapIndex
},
},
1, // memoryHeapCount
{
{
1ull << 31, // size, FIXME(sugoi): This should be configurable based on available RAM
VK_MEMORY_HEAP_DEVICE_LOCAL_BIT // flags
},
}
};
return properties;
}
} // namespace vk