"spirv-tools"),
GitRepo(
"https://github.com/KhronosGroup/glslang.git",
- "5184353326ae52d63a1d7c7fccd66269aab768f7",
+ "f2d8a5c53fda69a7e19defbda7964f380da54ad1",
"glslang"),
]
};
const Unique<VkCommandPool> cmdPool (createCommandPool(vk, vkDevice, &cmdPoolParams));
- // create a minimal amount of command buffers - is there any minimal amount in spec?
+ // \todo Determining the minimum number of command buffers should be a function of available system memory and driver capabilities.
+#if (DE_PTR_SIZE == 4)
+ const unsigned minCommandBuffer = 1024;
+#else
const unsigned minCommandBuffer = 10000;
+#endif
// Command buffer
const VkCommandBufferAllocateInfo cmdBufParams =
};
const Unique<VkCommandPool> cmdPool (createCommandPool(vk, vkDevice, &cmdPoolParams));
- // create a minimal amount of command buffers - is there any minimal amount in spec?
+ // \todo Determining the minimum number of command buffers should be a function of available system memory and driver capabilities.
+#if (DE_PTR_SIZE == 4)
+ const unsigned minCommandBuffer = 1024;
+#else
const unsigned minCommandBuffer = 10000;
+#endif
// Command buffer
const VkCommandBufferAllocateInfo cmdBufParams =
const ApiVersion apiVersion = unpackVersion(VK_API_VERSION);
const deUint32 invalidMajorVersion = (1 << 10) - 1;
const deUint32 invalidMinorVersion = (1 << 10) - 1;
- const deUint32 invalidPatchNum = (1 << 12) - 1;
vector<ApiVersion> invalidApiVersions;
invalidApiVersions.push_back(ApiVersion(invalidMajorVersion, apiVersion.minorNum, apiVersion.patchNum));
invalidApiVersions.push_back(ApiVersion(apiVersion.majorNum, invalidMinorVersion, apiVersion.patchNum));
- invalidApiVersions.push_back(ApiVersion(apiVersion.majorNum, apiVersion.minorNum, invalidPatchNum));
for (size_t apiVersionNdx = 0; apiVersionNdx < invalidApiVersions.size(); apiVersionNdx++)
{
static deUint32 getMaxConcurrent (Context&)
{
+ // \todo Scale this based on available system memory
+#if (DE_PTR_SIZE == 4)
+ return 1024;
+#else
return DEFAULT_MAX_CONCURRENT_OBJECTS;
+#endif
}
struct Parameters
}
else if (m_scale == BLIT_SCALE_20)
{
- tcu::TextureLevel source (TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8), m_srcImageWidth, m_srcImageHeight);
+ tcu::TextureLevel source (TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8), m_srcImageWidth, m_srcImageHeight);
+ const float xscale = ((float)m_srcImageWidth) / (float)m_imageWidth;
+ const float yscale = ((float)m_srcImageHeight) / (float)m_imageHeight;
for (deInt32 y = 0; y < m_srcImageHeight; y++)
for (deInt32 x = 0; x < m_srcImageWidth; x++)
for (deInt32 y = 0; y < m_imageHeight; y++)
for (deInt32 x = 0; x < m_imageWidth; x++)
- refAccess.setPixel(source.getAccess().getPixelUint(x / 2, y / 2), x, y);
+ refAccess.setPixel(source.getAccess().getPixelUint(int(x * xscale), int(y * yscale)), x, y);
}
else
DE_FATAL("Unsupported scale");
const VkDevice vkDevice = context.getDevice();
// Create buffer object, allocate storage, and generate input data
- const VkDeviceSize size = sizeof(tcu::Vec4) * 128u;
+ const VkDeviceSize size = sizeof(tcu::Vec4) * 128u * 128u;
m_inputBuf = createBufferAndBindMemory(size, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, &m_inputBufAlloc);
// Load vertices into buffer
tcu::Vec4* pVec = reinterpret_cast<tcu::Vec4*>(m_inputBufAlloc->getHostPtr());
- for (deUint32 ndx = 0u; ndx < 128u; ndx++)
+ for (deUint32 ndx = 0u; ndx < (128u * 128u); ndx++)
{
for (deUint32 component = 0u; component < 4u; component++)
{
m_outputBuf = createBufferAndBindMemory(size, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, &m_outputBufAlloc);
std::vector<VkDescriptorBufferInfo> descriptorInfos;
- descriptorInfos.push_back(makeDescriptorBufferInfo(*m_inputBuf, 0u, sizeof(tcu::Vec4) * 128u));
- descriptorInfos.push_back(makeDescriptorBufferInfo(*m_outputBuf, 0u, sizeof(tcu::Vec4) * 128u));
+ descriptorInfos.push_back(makeDescriptorBufferInfo(*m_inputBuf, 0u, size));
+ descriptorInfos.push_back(makeDescriptorBufferInfo(*m_outputBuf, 0u, size));
// Create descriptor set layout
DescriptorSetLayoutBuilder descLayoutBuilder;
checkSupported(descriptorType);
- for (size_t i = 0 ; i < m_inValues.size(); i++)
- m_uniformSetup->addData(new UniformData<deUint32>(bindingLocation++, descriptorType, m_inValues[i]));
+ m_uniformSetup->addData(new UniformArrayData<deUint32>(bindingLocation++, descriptorType, m_inValues));
if (m_indexExprType == INDEX_EXPR_TYPE_DYNAMIC_UNIFORM)
{
global << "const highp int indexBase = 1;\n";
global <<
- "layout(set = 0, binding = " << binding << ") " << interfaceName << " " << blockName << "\n"
+ "layout(set = 0, binding = " << binding++ << ") " << interfaceName << " " << blockName << "\n"
"{\n"
" highp uint value;\n"
"} " << instanceName << "[" << numInstances << "];\n";
- binding += numInstances;
-
if (m_indexExprType == INDEX_EXPR_TYPE_DYNAMIC_UNIFORM)
{
for (int readNdx = 0; readNdx < numReads; readNdx++)
}
}
-void ShaderExecutor::setupUniformData (const VkDevice& vkDevice,
- const DeviceInterface& vk,
- const VkQueue /*queue*/,
- const deUint32 queueFamilyIndex,
- Allocator& memAlloc,
- deUint32 bindingLocation,
- VkDescriptorType descriptorType,
- deUint32 size,
- const void* dataPtr)
+de::MovePtr<ShaderExecutor::BufferUniform> ShaderExecutor::createBufferUniform (const VkDevice& vkDevice,
+ const DeviceInterface& vk,
+ const VkQueue /*queue*/,
+ const deUint32 queueFamilyIndex,
+ Allocator& memAlloc,
+ deUint32 bindingLocation,
+ VkDescriptorType descriptorType,
+ deUint32 size,
+ const void* dataPtr)
{
DE_ASSERT(descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER || descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER);
uniformInfo->buffer = VkBufferSp(new Unique<VkBuffer>(buffer));
uniformInfo->alloc = AllocationSp(alloc.release());
+ return uniformInfo;
+}
+
+void ShaderExecutor::setupUniformData (const VkDevice& vkDevice,
+ const DeviceInterface& vk,
+ const VkQueue queue,
+ const deUint32 queueFamilyIndex,
+ Allocator& memAlloc,
+ deUint32 bindingLocation,
+ VkDescriptorType descriptorType,
+ deUint32 size,
+ const void* dataPtr)
+{
+ de::MovePtr<BufferUniform> uniform = createBufferUniform(vkDevice, vk, queue, queueFamilyIndex, memAlloc, bindingLocation, descriptorType, size, dataPtr);
+
m_descriptorSetLayoutBuilder.addSingleBinding(descriptorType, VK_SHADER_STAGE_ALL);
m_descriptorPoolBuilder.addType(descriptorType);
- m_uniformInfos.push_back(UniformInfoSp(new de::UniquePtr<UniformInfo>(uniformInfo)));
+ m_uniformInfos.push_back(UniformInfoSp(new de::UniquePtr<UniformInfo>(uniform)));
+}
+
+void ShaderExecutor::setupUniformArray (const VkDevice& vkDevice,
+ const DeviceInterface& vk,
+ const VkQueue queue,
+ const deUint32 queueFamilyIndex,
+ Allocator& memAlloc,
+ deUint32 bindingLocation,
+ VkDescriptorType descriptorType,
+ deUint32 arraySize,
+ deUint32 size,
+ const void* dataPtr)
+{
+ DE_ASSERT(arraySize > 0);
+
+ de::MovePtr<BufferArrayUniform> bufferArray (new BufferArrayUniform());
+
+ bufferArray->type = descriptorType;
+ bufferArray->location = bindingLocation;
+
+ for (deUint32 ndx = 0; ndx < arraySize; ++ndx)
+ {
+ const void* bufferData = ((deUint8*)dataPtr) + (ndx * size);
+ de::MovePtr<BufferUniform> uniform = createBufferUniform(vkDevice, vk, queue, queueFamilyIndex, memAlloc, bindingLocation, descriptorType, size, bufferData);
+
+ bufferArray->uniforms.push_back(BufferUniformSp(new de::UniquePtr<BufferUniform>(uniform)));
+ }
+
+ m_descriptorSetLayoutBuilder.addArrayBinding(descriptorType, arraySize, VK_SHADER_STAGE_ALL);
+ m_descriptorPoolBuilder.addType(descriptorType, arraySize);
+
+ m_uniformInfos.push_back(UniformInfoSp(new de::UniquePtr<UniformInfo>(bufferArray)));
}
void ShaderExecutor::setupSamplerData (const VkDevice& vkDevice,
for (; it != m_uniformInfos.end(); it++)
{
const UniformInfo* uniformInfo = it->get()->get();
- if (uniformInfo->isBufferUniform() && uniformInfo->location == bindingLocation)
+ if (uniformInfo->getType() == UniformInfo::UNIFORM_TYPE_BUFFER && uniformInfo->location == bindingLocation)
{
const BufferUniform* bufferUniform = static_cast<const BufferUniform*>(uniformInfo);
return bufferUniform->alloc->getHostPtr();
{
for (std::vector<UniformInfoSp>::const_iterator it = m_uniformInfos.begin(); it != m_uniformInfos.end(); ++it)
{
- const UniformInfo* uniformInfo = it->get()->get();
+ const UniformInfo* uniformInfo = it->get()->get();
+ UniformInfo::UniformType uniformType = uniformInfo->getType();
+
+ if (uniformType == UniformInfo::UNIFORM_TYPE_BUFFER_ARRAY)
+ {
+ const BufferArrayUniform* arrayInfo = static_cast<const BufferArrayUniform*>(uniformInfo);
+ std::vector<VkDescriptorBufferInfo> descriptors;
+
+ for (std::vector<BufferUniformSp>::const_iterator ait = arrayInfo->uniforms.begin(); ait != arrayInfo->uniforms.end(); ++ait)
+ {
+ descriptors.push_back(ait->get()->get()->descriptor);
+ }
- if (uniformInfo->isSamplerArray())
+ descriptorSetUpdateBuilder.writeArray(descriptorSet, DescriptorSetUpdateBuilder::Location::binding(uniformInfo->location), uniformInfo->type, (deUint32)descriptors.size(), &descriptors[0]);
+ }
+ else if (uniformType == UniformInfo::UNIFORM_TYPE_SAMPLER_ARRAY)
{
- const SamplerArrayUniform* arrayInfo = static_cast<const SamplerArrayUniform*>(uniformInfo);
- std::vector<VkDescriptorImageInfo> descriptors;
+ const SamplerArrayUniform* arrayInfo = static_cast<const SamplerArrayUniform*>(uniformInfo);
+ std::vector<VkDescriptorImageInfo> descriptors;
for (std::vector<SamplerUniformSp>::const_iterator ait = arrayInfo->uniforms.begin(); ait != arrayInfo->uniforms.end(); ++ait)
{
descriptorSetUpdateBuilder.writeArray(descriptorSet, DescriptorSetUpdateBuilder::Location::binding(uniformInfo->location), uniformInfo->type, (deUint32)descriptors.size(), &descriptors[0]);
}
- else if (uniformInfo->isBufferUniform())
+ else if (uniformType == UniformInfo::UNIFORM_TYPE_BUFFER)
{
- const BufferUniform* bufferUniform = static_cast<const BufferUniform*>(uniformInfo);
+ const BufferUniform* bufferUniform = static_cast<const BufferUniform*>(uniformInfo);
descriptorSetUpdateBuilder.writeSingle(descriptorSet, DescriptorSetUpdateBuilder::Location::binding(bufferUniform->location), bufferUniform->type, &bufferUniform->descriptor);
}
- else if (uniformInfo->isSamplerUniform())
+ else if (uniformType == UniformInfo::UNIFORM_TYPE_SAMPLER)
{
- const SamplerUniform* samplerUniform = static_cast<const SamplerUniform*>(uniformInfo);
+ const SamplerUniform* samplerUniform = static_cast<const SamplerUniform*>(uniformInfo);
descriptorSetUpdateBuilder.writeSingle(descriptorSet, DescriptorSetUpdateBuilder::Location::binding(samplerUniform->location), samplerUniform->type, &samplerUniform->descriptor);
}
}
deUint32 size,
const void* dataPtr);
+ void setupUniformArray (const VkDevice& vkDevice,
+ const DeviceInterface& vk,
+ const VkQueue queue,
+ const deUint32 queueFamilyIndex,
+ Allocator& memAlloc,
+ deUint32 bindingLocation,
+ VkDescriptorType descriptorType,
+ deUint32 arraySize,
+ deUint32 size,
+ const void* dataPtr);
+
void setupSamplerData (const VkDevice& vkDevice,
const DeviceInterface& vk,
const VkQueue queue,
class UniformInfo;
typedef de::SharedPtr<de::UniquePtr<UniformInfo> > UniformInfoSp;
-
+ class BufferUniform;
+ typedef de::SharedPtr<de::UniquePtr<BufferUniform> > BufferUniformSp;
class SamplerUniform;
typedef de::SharedPtr<de::UniquePtr<SamplerUniform> > SamplerUniformSp;
class UniformInfo
{
public:
+ enum UniformType
+ {
+ UNIFORM_TYPE_BUFFER = 0,
+ UNIFORM_TYPE_SAMPLER,
+ UNIFORM_TYPE_BUFFER_ARRAY,
+ UNIFORM_TYPE_SAMPLER_ARRAY,
+
+ UNIFORM_TYPE_LAST
+ };
+
UniformInfo (void) {}
virtual ~UniformInfo (void) {}
- virtual bool isSamplerArray (void) const { return false; }
- virtual bool isBufferUniform (void) const { return false; }
- virtual bool isSamplerUniform (void) const { return false; }
+ virtual UniformType getType (void) const = 0;
VkDescriptorType type;
deUint32 location;
public:
BufferUniform (void) {}
virtual ~BufferUniform (void) {}
- virtual bool isBufferUniform (void) const { return true; }
+ virtual UniformType getType (void) const { return UNIFORM_TYPE_BUFFER; }
VkBufferSp buffer;
AllocationSp alloc;
public:
SamplerUniform (void) {}
virtual ~SamplerUniform (void) {}
- virtual bool isSamplerUniform (void) const { return true; }
+ virtual UniformType getType (void) const { return UNIFORM_TYPE_SAMPLER; }
+
VkImageSp image;
VkImageViewSp imageView;
VkSamplerSp sampler;
VkDescriptorImageInfo descriptor;
};
+ class BufferArrayUniform : public UniformInfo
+ {
+ public:
+ BufferArrayUniform (void) {}
+ virtual ~BufferArrayUniform (void) {}
+ virtual UniformType getType (void) const { return UNIFORM_TYPE_BUFFER_ARRAY; }
+
+ std::vector<BufferUniformSp> uniforms;
+ };
+
class SamplerArrayUniform : public UniformInfo
{
public:
SamplerArrayUniform (void) {}
virtual ~SamplerArrayUniform (void) {}
- virtual bool isSamplerArray (void) const { return true; }
+ virtual UniformType getType (void) const { return UNIFORM_TYPE_SAMPLER_ARRAY; }
std::vector<SamplerUniformSp> uniforms;
};
VkImageViewType imageViewType,
const void* data);
+ de::MovePtr<BufferUniform> createBufferUniform (const VkDevice& vkDevice,
+ const DeviceInterface& vk,
+ const VkQueue queue,
+ const deUint32 queueFamilyIndex,
+ Allocator& memAlloc,
+ deUint32 bindingLocation,
+ VkDescriptorType descriptorType,
+ deUint32 size,
+ const void* dataPtr);
+
const ShaderSpec m_shaderSpec;
const glu::ShaderType m_shaderType;
executor.setupUniformData(vkDevice, vk, queue, queueFamilyIndex, memAlloc, m_bindingLocation, m_descriptorType, sizeof(T), &m_data);
}
+template<typename T>
+class UniformArrayData : public UniformDataBase
+{
+public:
+ UniformArrayData (deUint32 bindingLocation, VkDescriptorType descriptorType, const std::vector<T>& data);
+ virtual ~UniformArrayData (void);
+ virtual void setup (ShaderExecutor& executor, const VkDevice& vkDevice, const DeviceInterface& vk, const VkQueue queue, const deUint32 queueFamilyIndex, Allocator& memAlloc) const;
+
+private:
+ VkDescriptorType m_descriptorType;
+ std::vector<T> m_data;
+};
+
+template<typename T>
+UniformArrayData<T>::UniformArrayData (deUint32 bindingLocation, VkDescriptorType descriptorType, const std::vector<T>& data)
+ : UniformDataBase (bindingLocation)
+ , m_descriptorType (descriptorType)
+ , m_data (data)
+{
+}
+
+template<typename T>
+UniformArrayData<T>::~UniformArrayData (void)
+{
+}
+
+template<typename T>
+void UniformArrayData<T>::setup (ShaderExecutor& executor, const VkDevice& vkDevice, const DeviceInterface& vk, const VkQueue queue, const deUint32 queueFamilyIndex, Allocator& memAlloc) const
+{
+ DE_ASSERT(!m_data.empty());
+ executor.setupUniformArray(vkDevice, vk, queue, queueFamilyIndex, memAlloc, m_bindingLocation, m_descriptorType, (deUint32)m_data.size(), sizeof(T), &m_data[0]);
+}
+
class SamplerUniformData : public UniformDataBase
{
public: