pipelineBuilder
.setShader (vk, device, VK_SHADER_STAGE_GEOMETRY_BIT, context.getBinaryCollection().get(shaderPrefix + "geom"), DE_NULL);
- m_pipeline = pipelineBuilder.build(vk, device, *m_pipelineLayout, *m_renderPass);
+ m_pipeline = pipelineBuilder.build(vk, device, *m_pipelineLayout, *m_renderPass, context.getPipelineCacheData());
}
void recordCommands (OperationContext& context, const VkCommandBuffer cmdBuffer, const VkDescriptorSet descriptorSet)
const Unique<VkShaderModule> shaderModule(createShaderModule(vk, device, context.getBinaryCollection().get(shaderPrefix + "comp"), (VkShaderModuleCreateFlags)0));
m_pipelineLayout = makePipelineLayout(vk, device, descriptorSetLayout);
- m_pipeline = makeComputePipeline(vk, device, *m_pipelineLayout, *shaderModule, DE_NULL);
+ m_pipeline = makeComputePipeline(vk, device, *m_pipelineLayout, *shaderModule, DE_NULL, context.getPipelineCacheData());
}
void recordCommands (OperationContext& context, const VkCommandBuffer cmdBuffer, const VkDescriptorSet descriptorSet)
.setShader (vk, device, VK_SHADER_STAGE_VERTEX_BIT, context.getBinaryCollection().get("draw_vert"), DE_NULL)
.setShader (vk, device, VK_SHADER_STAGE_FRAGMENT_BIT, context.getBinaryCollection().get("draw_frag"), DE_NULL);
- m_pipeline = pipelineBuilder.build(vk, device, *m_pipelineLayout, *m_renderPass);
+ m_pipeline = pipelineBuilder.build(vk, device, *m_pipelineLayout, *m_renderPass, context.getPipelineCacheData());
// Set expected draw values
.setShader (vk, device, VK_SHADER_STAGE_VERTEX_BIT, context.getBinaryCollection().get(shaderPrefix + "vert"), DE_NULL)
.setShader (vk, device, VK_SHADER_STAGE_FRAGMENT_BIT, context.getBinaryCollection().get(shaderPrefix + "frag"), DE_NULL);
- m_pipeline = pipelineBuilder.build(vk, device, *m_pipelineLayout, *m_renderPass);
+ m_pipeline = pipelineBuilder.build(vk, device, *m_pipelineLayout, *m_renderPass, context.getPipelineCacheData());
}
void recordCommands (OperationContext& context, const VkCommandBuffer cmdBuffer, const VkDescriptorSet descriptorSet)
const Unique<VkShaderModule> shaderModule(createShaderModule(vk, device, context.getBinaryCollection().get(shaderPrefix + "comp"), (VkShaderModuleCreateFlags)0));
m_pipelineLayout = makePipelineLayout(vk, device, descriptorSetLayout);
- m_pipeline = makeComputePipeline(vk, device, *m_pipelineLayout, *shaderModule, DE_NULL);
+ m_pipeline = makeComputePipeline(vk, device, *m_pipelineLayout, *shaderModule, DE_NULL, context.getPipelineCacheData());
}
void recordCommands (OperationContext& context, const VkCommandBuffer cmdBuffer, const VkDescriptorSet descriptorSet)
.setVertexInputSingleAttribute (VK_FORMAT_R32G32B32A32_UINT, tcu::getPixelSize(mapVkFormat(VK_FORMAT_R32G32B32A32_UINT)))
.setShader (vk, device, VK_SHADER_STAGE_VERTEX_BIT, context.getBinaryCollection().get("input_vert"), DE_NULL)
.setShader (vk, device, VK_SHADER_STAGE_FRAGMENT_BIT, context.getBinaryCollection().get("input_frag"), DE_NULL)
- .build (vk, device, *m_pipelineLayout, *m_renderPass);
+ .build (vk, device, *m_pipelineLayout, *m_renderPass, context.getPipelineCacheData());
}
void recordCommands (const VkCommandBuffer cmdBuffer)
} // anonymous ns
-OperationContext::OperationContext (Context& context)
+OperationContext::OperationContext (Context& context, PipelineCacheData& pipelineCacheData)
: m_vki (context.getInstanceInterface())
, m_vk (context.getDeviceInterface())
, m_physicalDevice (context.getPhysicalDevice())
, m_device (context.getDevice())
, m_allocator (context.getDefaultAllocator())
, m_progCollection (context.getBinaryCollection())
+ , m_pipelineCacheData (pipelineCacheData)
{
}
-OperationContext::OperationContext (Context& context, const DeviceInterface& vk, const VkDevice device, vk::Allocator& allocator)
+OperationContext::OperationContext (Context& context, PipelineCacheData& pipelineCacheData, const DeviceInterface& vk, const VkDevice device, vk::Allocator& allocator)
: m_vki (context.getInstanceInterface())
, m_vk (vk)
, m_physicalDevice (context.getPhysicalDevice())
, m_device (device)
, m_allocator (allocator)
, m_progCollection (context.getBinaryCollection())
+ , m_pipelineCacheData (pipelineCacheData)
{
}
vk::VkDevice getDevice (void) const { return m_device; }
vk::Allocator& getAllocator (void) const { return m_allocator; }
vk::ProgramCollection<vk::ProgramBinary>& getBinaryCollection (void) const { return m_progCollection; }
+ PipelineCacheData& getPipelineCacheData (void) const { return m_pipelineCacheData; }
- OperationContext (Context& context);
- OperationContext (Context& context, const vk::DeviceInterface& vk, const vk::VkDevice device, vk::Allocator& allocator);
+ OperationContext (Context& context, PipelineCacheData& pipelineCacheData);
+ OperationContext (Context& context, PipelineCacheData& pipelineCacheData, const vk::DeviceInterface& vk, const vk::VkDevice device, vk::Allocator& allocator);
private:
const vk::InstanceInterface& m_vki;
const vk::VkDevice m_device;
vk::Allocator& m_allocator;
vk::ProgramCollection<vk::ProgramBinary>& m_progCollection;
+ PipelineCacheData& m_pipelineCacheData;
OperationContext (const OperationContext&); // "deleted"
OperationContext& operator= (const OperationContext&);
class BaseTestInstance : public TestInstance
{
public:
- BaseTestInstance (Context& context, const ResourceDescription& resourceDesc, const OperationSupport& writeOp, const OperationSupport& readOp)
+ BaseTestInstance (Context& context, const ResourceDescription& resourceDesc, const OperationSupport& writeOp, const OperationSupport& readOp, PipelineCacheData& pipelineCacheData)
: TestInstance (context)
, m_queues (createQueues(context, writeOp.getQueueFlags(), readOp.getQueueFlags()))
- , m_opContext (new OperationContext(context, m_context.getDeviceInterface(), (*(*m_queues).m_logicalDevice), (*(*m_queues).m_allocator)))
+ , m_opContext (new OperationContext(context, pipelineCacheData, m_context.getDeviceInterface(), (*(*m_queues).m_logicalDevice), (*(*m_queues).m_allocator)))
, m_resource (new Resource(*m_opContext, resourceDesc, writeOp.getResourceUsageFlags() | readOp.getResourceUsageFlags()))
, m_writeOp (writeOp.build(*m_opContext, *m_resource))
, m_readOp (readOp.build(*m_opContext, *m_resource))
class SemaphoreTestInstance : public BaseTestInstance
{
public:
- SemaphoreTestInstance (Context& context, const ResourceDescription& resourceDesc, const OperationSupport& writeOp, const OperationSupport& readOp, const vk::VkSharingMode sharingMode)
- : BaseTestInstance (context, resourceDesc, writeOp, readOp)
+ SemaphoreTestInstance (Context& context, const ResourceDescription& resourceDesc, const OperationSupport& writeOp, const OperationSupport& readOp, PipelineCacheData& pipelineCacheData, const vk::VkSharingMode sharingMode)
+ : BaseTestInstance (context, resourceDesc, writeOp, readOp, pipelineCacheData)
, m_sharingMode (sharingMode)
{
}
class FenceTestInstance : public BaseTestInstance
{
public:
- FenceTestInstance (Context& context, const ResourceDescription& resourceDesc, const OperationSupport& writeOp, const OperationSupport& readOp, const vk::VkSharingMode sharingMode)
- : BaseTestInstance (context, resourceDesc, writeOp, readOp)
+ FenceTestInstance (Context& context, const ResourceDescription& resourceDesc, const OperationSupport& writeOp, const OperationSupport& readOp, PipelineCacheData& pipelineCacheData, const vk::VkSharingMode sharingMode)
+ : BaseTestInstance (context, resourceDesc, writeOp, readOp, pipelineCacheData)
, m_sharingMode (sharingMode)
{
}
const ResourceDescription resourceDesc,
const OperationName writeOp,
const OperationName readOp,
- const vk::VkSharingMode sharingMode)
+ const vk::VkSharingMode sharingMode,
+ PipelineCacheData& pipelineCacheData)
: TestCase (testCtx, name, description)
, m_resourceDesc (resourceDesc)
, m_writeOp (makeOperationSupport(writeOp, resourceDesc))
, m_readOp (makeOperationSupport(readOp, resourceDesc))
, m_syncPrimitive (syncPrimitive)
, m_sharingMode (sharingMode)
+ , m_pipelineCacheData (pipelineCacheData)
{
}
switch (m_syncPrimitive)
{
case SYNC_PRIMITIVE_FENCE:
- return new FenceTestInstance(context, m_resourceDesc, *m_writeOp, *m_readOp, m_sharingMode);
+ return new FenceTestInstance(context, m_resourceDesc, *m_writeOp, *m_readOp, m_pipelineCacheData, m_sharingMode);
case SYNC_PRIMITIVE_SEMAPHORE:
- return new SemaphoreTestInstance(context, m_resourceDesc, *m_writeOp, *m_readOp, m_sharingMode);
+ return new SemaphoreTestInstance(context, m_resourceDesc, *m_writeOp, *m_readOp, m_pipelineCacheData, m_sharingMode);
default :
DE_ASSERT(0);
return DE_NULL;
const de::UniquePtr<OperationSupport> m_readOp;
const SyncPrimitive m_syncPrimitive;
const vk::VkSharingMode m_sharingMode;
+ PipelineCacheData& m_pipelineCacheData;
};
-void createTests (tcu::TestCaseGroup* group)
+void createTests (tcu::TestCaseGroup* group, PipelineCacheData* pipelineCacheData)
{
tcu::TestContext& testCtx = group->getTestContext();
if (isResourceSupported(writeOp, resource) && isResourceSupported(readOp, resource))
{
- opGroup->addChild(new SyncTestCase(testCtx, name, "", groups[groupNdx].syncPrimitive, resource, writeOp, readOp, sharingMode));
+ opGroup->addChild(new SyncTestCase(testCtx, name, "", groups[groupNdx].syncPrimitive, resource, writeOp, readOp, sharingMode, *pipelineCacheData));
empty = false;
}
}
} // anonymous
-tcu::TestCaseGroup* createSynchronizedOperationMultiQueueTests (tcu::TestContext& testCtx)
+tcu::TestCaseGroup* createSynchronizedOperationMultiQueueTests (tcu::TestContext& testCtx, PipelineCacheData& pipelineCacheData)
{
- return createTestGroup(testCtx, "multi_queue", "Synchronization of a memory-modifying operation", createTests);
+ return createTestGroup(testCtx, "multi_queue", "Synchronization of a memory-modifying operation", createTests, &pipelineCacheData);
}
} // synchronization
namespace synchronization
{
-tcu::TestCaseGroup* createSynchronizedOperationMultiQueueTests (tcu::TestContext& testCtx);
+class PipelineCacheData;
+
+tcu::TestCaseGroup* createSynchronizedOperationMultiQueueTests (tcu::TestContext& testCtx, PipelineCacheData& pipelineCacheData);
} // synchronization
} // vkt
class BaseTestInstance : public TestInstance
{
public:
- BaseTestInstance (Context& context, const ResourceDescription& resourceDesc, const OperationSupport& writeOp, const OperationSupport& readOp)
+ BaseTestInstance (Context& context, const ResourceDescription& resourceDesc, const OperationSupport& writeOp, const OperationSupport& readOp, PipelineCacheData& pipelineCacheData)
: TestInstance (context)
- , m_opContext (context)
+ , m_opContext (context, pipelineCacheData)
, m_resource (new Resource(m_opContext, resourceDesc, writeOp.getResourceUsageFlags() | readOp.getResourceUsageFlags()))
, m_writeOp (writeOp.build(m_opContext, *m_resource))
, m_readOp (readOp.build(m_opContext, *m_resource))
class EventTestInstance : public BaseTestInstance
{
public:
- EventTestInstance (Context& context, const ResourceDescription& resourceDesc, const OperationSupport& writeOp, const OperationSupport& readOp)
- : BaseTestInstance (context, resourceDesc, writeOp, readOp)
+ EventTestInstance (Context& context, const ResourceDescription& resourceDesc, const OperationSupport& writeOp, const OperationSupport& readOp, PipelineCacheData& pipelineCacheData)
+ : BaseTestInstance (context, resourceDesc, writeOp, readOp, pipelineCacheData)
{
}
class BarrierTestInstance : public BaseTestInstance
{
public:
- BarrierTestInstance (Context& context, const ResourceDescription& resourceDesc, const OperationSupport& writeOp, const OperationSupport& readOp)
- : BaseTestInstance (context, resourceDesc, writeOp, readOp)
+ BarrierTestInstance (Context& context, const ResourceDescription& resourceDesc, const OperationSupport& writeOp, const OperationSupport& readOp, PipelineCacheData& pipelineCacheData)
+ : BaseTestInstance (context, resourceDesc, writeOp, readOp, pipelineCacheData)
{
}
class SemaphoreTestInstance : public BaseTestInstance
{
public:
- SemaphoreTestInstance (Context& context, const ResourceDescription& resourceDesc, const OperationSupport& writeOp, const OperationSupport& readOp)
- : BaseTestInstance (context, resourceDesc, writeOp, readOp)
+ SemaphoreTestInstance (Context& context, const ResourceDescription& resourceDesc, const OperationSupport& writeOp, const OperationSupport& readOp, PipelineCacheData& pipelineCacheData)
+ : BaseTestInstance (context, resourceDesc, writeOp, readOp, pipelineCacheData)
{
}
class FenceTestInstance : public BaseTestInstance
{
public:
- FenceTestInstance (Context& context, const ResourceDescription& resourceDesc, const OperationSupport& writeOp, const OperationSupport& readOp)
- : BaseTestInstance (context, resourceDesc, writeOp, readOp)
+ FenceTestInstance (Context& context, const ResourceDescription& resourceDesc, const OperationSupport& writeOp, const OperationSupport& readOp, PipelineCacheData& pipelineCacheData)
+ : BaseTestInstance (context, resourceDesc, writeOp, readOp, pipelineCacheData)
{
}
{
public:
SyncTestCase (tcu::TestContext& testCtx,
- const std::string& name,
- const std::string& description,
- const SyncPrimitive syncPrimitive,
- const ResourceDescription resourceDesc,
- const OperationName writeOp,
- const OperationName readOp)
+ const std::string& name,
+ const std::string& description,
+ const SyncPrimitive syncPrimitive,
+ const ResourceDescription resourceDesc,
+ const OperationName writeOp,
+ const OperationName readOp,
+ PipelineCacheData& pipelineCacheData)
: TestCase (testCtx, name, description)
, m_resourceDesc (resourceDesc)
, m_writeOp (makeOperationSupport(writeOp, resourceDesc))
, m_readOp (makeOperationSupport(readOp, resourceDesc))
, m_syncPrimitive (syncPrimitive)
+ , m_pipelineCacheData (pipelineCacheData)
{
}
switch (m_syncPrimitive)
{
case SYNC_PRIMITIVE_FENCE:
- return new FenceTestInstance(context, m_resourceDesc, *m_writeOp, *m_readOp);
+ return new FenceTestInstance(context, m_resourceDesc, *m_writeOp, *m_readOp, m_pipelineCacheData);
case SYNC_PRIMITIVE_SEMAPHORE:
- return new SemaphoreTestInstance(context, m_resourceDesc, *m_writeOp, *m_readOp);
+ return new SemaphoreTestInstance(context, m_resourceDesc, *m_writeOp, *m_readOp, m_pipelineCacheData);
case SYNC_PRIMITIVE_BARRIER:
- return new BarrierTestInstance(context, m_resourceDesc, *m_writeOp, *m_readOp);
+ return new BarrierTestInstance(context, m_resourceDesc, *m_writeOp, *m_readOp, m_pipelineCacheData);
case SYNC_PRIMITIVE_EVENT:
- return new EventTestInstance(context, m_resourceDesc, *m_writeOp, *m_readOp);
+ return new EventTestInstance(context, m_resourceDesc, *m_writeOp, *m_readOp, m_pipelineCacheData);
}
DE_ASSERT(0);
const de::UniquePtr<OperationSupport> m_writeOp;
const de::UniquePtr<OperationSupport> m_readOp;
const SyncPrimitive m_syncPrimitive;
+ PipelineCacheData& m_pipelineCacheData;
};
-void createTests (tcu::TestCaseGroup* group)
+void createTests (tcu::TestCaseGroup* group, PipelineCacheData* pipelineCacheData)
{
tcu::TestContext& testCtx = group->getTestContext();
if (isResourceSupported(writeOp, resource) && isResourceSupported(readOp, resource))
{
- opGroup->addChild(new SyncTestCase(testCtx, name, "", groups[groupNdx].syncPrimitive, resource, writeOp, readOp));
+ opGroup->addChild(new SyncTestCase(testCtx, name, "", groups[groupNdx].syncPrimitive, resource, writeOp, readOp, *pipelineCacheData));
empty = false;
}
}
} // anonymous
-tcu::TestCaseGroup* createSynchronizedOperationSingleQueueTests (tcu::TestContext& testCtx)
+tcu::TestCaseGroup* createSynchronizedOperationSingleQueueTests (tcu::TestContext& testCtx, PipelineCacheData& pipelineCacheData)
{
- return createTestGroup(testCtx, "single_queue", "Synchronization of a memory-modifying operation", createTests);
+ return createTestGroup(testCtx, "single_queue", "Synchronization of a memory-modifying operation", createTests, &pipelineCacheData);
}
} // synchronization
namespace synchronization
{
-tcu::TestCaseGroup* createSynchronizedOperationSingleQueueTests (tcu::TestContext& testCtx);
+class PipelineCacheData;
+
+tcu::TestCaseGroup* createSynchronizedOperationSingleQueueTests (tcu::TestContext& testCtx, PipelineCacheData& pipelineCacheData);
} // synchronization
} // vkt
* \brief Synchronization tests
*//*--------------------------------------------------------------------*/
-#include "vktTestGroupUtil.hpp"
#include "vktSynchronizationTests.hpp"
+#include "vktTestGroupUtil.hpp"
#include "vktSynchronizationSmokeTests.hpp"
#include "vktSynchronizationBasicFenceTests.hpp"
#include "vktSynchronizationBasicSemaphoreTests.hpp"
#include "vktSynchronizationOperationSingleQueueTests.hpp"
#include "vktSynchronizationOperationMultiQueueTests.hpp"
#include "vktSynchronizationInternallySynchronizedObjectsTests.hpp"
+#include "vktSynchronizationUtil.hpp"
#include "deUniquePtr.hpp"
group->addChild(createBasicEventTests (group->getTestContext()));
}
-void createOperationTests (tcu::TestCaseGroup* group)
+class OperationTests : public tcu::TestCaseGroup
{
- group->addChild(createSynchronizedOperationSingleQueueTests(group->getTestContext()));
- group->addChild(createSynchronizedOperationMultiQueueTests (group->getTestContext()));
-}
+public:
+ OperationTests (tcu::TestContext& testCtx)
+ : tcu::TestCaseGroup(testCtx, "op", "Synchronization of a memory-modifying operation")
+ {
+ }
+
+ void init (void)
+ {
+ addChild(createSynchronizedOperationSingleQueueTests(m_testCtx, m_pipelineCacheData));
+ addChild(createSynchronizedOperationMultiQueueTests (m_testCtx, m_pipelineCacheData));
+ }
+
+private:
+ // synchronization.op tests share pipeline cache data to speed up test
+ // execution.
+ PipelineCacheData m_pipelineCacheData;
+};
void createChildren (tcu::TestCaseGroup* group)
{
group->addChild(createSmokeTests(testCtx));
group->addChild(createTestGroup (testCtx, "basic", "Basic synchronization tests", createBasicTests));
- group->addChild(createTestGroup (testCtx, "op", "Synchronization of a memory-modifying operation", createOperationTests));
+ group->addChild(new OperationTests(testCtx));
group->addChild(createInternallySynchronizedObjects(testCtx));
}
const VkDevice device,
const VkPipelineLayout pipelineLayout,
const VkShaderModule shaderModule,
- const VkSpecializationInfo* specInfo)
+ const VkSpecializationInfo* specInfo,
+ PipelineCacheData& pipelineCacheData)
{
const VkPipelineShaderStageCreateInfo shaderStageInfo =
{
DE_NULL, // VkPipeline basePipelineHandle;
0, // deInt32 basePipelineIndex;
};
- return createComputePipeline(vk, device, DE_NULL , &pipelineInfo);
+
+ {
+ const vk::Unique<vk::VkPipelineCache> pipelineCache (pipelineCacheData.createPipelineCache(vk, device));
+ vk::Move<vk::VkPipeline> pipeline (createComputePipeline(vk, device, *pipelineCache, &pipelineInfo));
+
+ // Refresh data from cache
+ pipelineCacheData.setFromPipelineCache(vk, device, *pipelineCache);
+
+ return pipeline;
+ }
}
VkImageCreateInfo makeImageCreateInfo (const VkImageType imageType, const VkExtent3D& extent, const VkFormat format, const VkImageUsageFlags usage)
Move<VkPipeline> GraphicsPipelineBuilder::build (const DeviceInterface& vk,
const VkDevice device,
const VkPipelineLayout pipelineLayout,
- const VkRenderPass renderPass)
+ const VkRenderPass renderPass,
+ PipelineCacheData& pipelineCacheData)
{
const VkPipelineVertexInputStateCreateInfo vertexInputStateInfo =
{
0, // deInt32 basePipelineIndex;
};
- return createGraphicsPipeline(vk, device, DE_NULL, &graphicsPipelineInfo);
+ {
+ const vk::Unique<vk::VkPipelineCache> pipelineCache (pipelineCacheData.createPipelineCache(vk, device));
+ vk::Move<vk::VkPipeline> pipeline (createGraphicsPipeline(vk, device, *pipelineCache, &graphicsPipelineInfo));
+
+ // Refresh data from cache
+ pipelineCacheData.setFromPipelineCache(vk, device, *pipelineCache);
+
+ return pipeline;
+ }
}
void requireFeatures (const InstanceInterface& vki, const VkPhysicalDevice physDevice, const FeatureFlags flags)
}
}
+PipelineCacheData::PipelineCacheData (void)
+{
+}
+
+PipelineCacheData::~PipelineCacheData (void)
+{
+}
+
+vk::Move<VkPipelineCache> PipelineCacheData::createPipelineCache (const vk::DeviceInterface& vk, const vk::VkDevice device) const
+{
+ const de::ScopedLock dataLock (m_lock);
+ const struct vk::VkPipelineCacheCreateInfo params =
+ {
+ vk::VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO,
+ DE_NULL,
+ (vk::VkPipelineCacheCreateFlags)0,
+ (deUintptr)m_data.size(),
+ (m_data.empty() ? DE_NULL : &m_data[0])
+ };
+
+ return vk::createPipelineCache(vk, device, ¶ms);
+}
+
+void PipelineCacheData::setFromPipelineCache (const vk::DeviceInterface& vk, const vk::VkDevice device, const vk::VkPipelineCache pipelineCache)
+{
+ const de::ScopedLock dataLock (m_lock);
+ deUintptr dataSize = 0;
+
+ VK_CHECK(vk.getPipelineCacheData(device, pipelineCache, &dataSize, DE_NULL));
+
+ m_data.resize(dataSize);
+
+ if (dataSize > 0)
+ VK_CHECK(vk.getPipelineCacheData(device, pipelineCache, &dataSize, &m_data[0]));
+}
+
} // synchronization
} // vkt
#include "vkRefUtil.hpp"
#include "vkPrograms.hpp"
#include "tcuVector.hpp"
+#include "deMutex.hpp"
namespace vkt
{
Image& operator= (const Image&);
};
+class PipelineCacheData
+{
+public:
+ PipelineCacheData (void);
+ ~PipelineCacheData (void);
+
+ vk::Move<vk::VkPipelineCache> createPipelineCache (const vk::DeviceInterface& vk, const vk::VkDevice device) const;
+ void setFromPipelineCache (const vk::DeviceInterface& vk, const vk::VkDevice device, const vk::VkPipelineCache pipelineCache);
+
+private:
+ mutable de::Mutex m_lock;
+ std::vector<deUint8> m_data;
+};
+
class GraphicsPipelineBuilder
{
public:
//! Basic vertex input configuration (uses biding 0, location 0, etc.)
GraphicsPipelineBuilder& setVertexInputSingleAttribute (const vk::VkFormat vertexFormat, const deUint32 stride);
- vk::Move<vk::VkPipeline> build (const vk::DeviceInterface& vk, const vk::VkDevice device, const vk::VkPipelineLayout pipelineLayout, const vk::VkRenderPass renderPass);
+ vk::Move<vk::VkPipeline> build (const vk::DeviceInterface& vk, const vk::VkDevice device, const vk::VkPipelineLayout pipelineLayout, const vk::VkRenderPass renderPass, PipelineCacheData& pipelineCacheData);
private:
tcu::IVec2 m_renderSize;
vk::Move<vk::VkDescriptorSet> makeDescriptorSet (const vk::DeviceInterface& vk, const vk::VkDevice device, const vk::VkDescriptorPool descriptorPool, const vk::VkDescriptorSetLayout setLayout);
vk::Move<vk::VkPipelineLayout> makePipelineLayout (const vk::DeviceInterface& vk, const vk::VkDevice device, const vk::VkDescriptorSetLayout descriptorSetLayout);
vk::Move<vk::VkPipelineLayout> makePipelineLayoutWithoutDescriptors (const vk::DeviceInterface& vk, const vk::VkDevice device);
-vk::Move<vk::VkPipeline> makeComputePipeline (const vk::DeviceInterface& vk, const vk::VkDevice device, const vk::VkPipelineLayout pipelineLayout, const vk::VkShaderModule shaderModule, const vk::VkSpecializationInfo* specInfo);
+vk::Move<vk::VkPipeline> makeComputePipeline (const vk::DeviceInterface& vk, const vk::VkDevice device, const vk::VkPipelineLayout pipelineLayout, const vk::VkShaderModule shaderModule, const vk::VkSpecializationInfo* specInfo, PipelineCacheData& pipelineCacheData);
vk::Move<vk::VkRenderPass> makeRenderPass (const vk::DeviceInterface& vk, const vk::VkDevice device, const vk::VkFormat colorFormat);
vk::Move<vk::VkRenderPass> makeRenderPassWithoutAttachments (const vk::DeviceInterface& vk, const vk::VkDevice device);
vk::Move<vk::VkFramebuffer> makeFramebuffer (const vk::DeviceInterface& vk, const vk::VkDevice device, const vk::VkRenderPass renderPass, const vk::VkImageView colorAttachment, const deUint32 width, const deUint32 height, const deUint32 layers);
projects / platform / upstream / VK-GL-CTS.git / commitdiff