external/vulkancts/framework/vulkan/vkBinaryRegistry.cpp \
external/vulkancts/framework/vulkan/vkBufferWithMemory.cpp \
external/vulkancts/framework/vulkan/vkBuilderUtil.cpp \
+ external/vulkancts/framework/vulkan/vkCmdUtil.cpp \
external/vulkancts/framework/vulkan/vkDebugReportUtil.cpp \
external/vulkancts/framework/vulkan/vkDefs.cpp \
external/vulkancts/framework/vulkan/vkDeviceUtil.cpp \
vkApiVersion.hpp
vkBuilderUtil.cpp
vkBuilderUtil.hpp
+ vkCmdUtil.cpp
+ vkCmdUtil.hpp
vkDefs.cpp
vkDefs.hpp
vkRef.cpp
--- /dev/null
+/*-------------------------------------------------------------------------
+ * Vulkan CTS Framework
+ * --------------------
+ *
+ * Copyright (c) 2018 Google 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.
+ *
+ *//*!
+ * \file
+ * \brief Utilities for commonly used command tasks
+ *//*--------------------------------------------------------------------*/
+
+#include "vkCmdUtil.hpp"
+#include "vkDefs.hpp"
+#include "vkRefUtil.hpp"
+
+namespace vk
+{
+
+void submitCommandsAndWait (const DeviceInterface& vk,
+ const VkDevice device,
+ const VkQueue queue,
+ const VkCommandBuffer commandBuffer,
+ const bool useDeviceGroups,
+ const deUint32 deviceMask)
+{
+ const Unique<VkFence> fence (createFence(vk, device));
+
+ VkDeviceGroupSubmitInfo deviceGroupSubmitInfo =
+ {
+ VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR, // VkStructureType sType;
+ DE_NULL, // const void* pNext;
+ 0u, // uint32_t waitSemaphoreCount;
+ DE_NULL, // const uint32_t* pWaitSemaphoreDeviceIndices;
+ 1u, // uint32_t commandBufferCount;
+ &deviceMask, // const uint32_t* pCommandBufferDeviceMasks;
+ 0u, // uint32_t signalSemaphoreCount;
+ DE_NULL, // const uint32_t* pSignalSemaphoreDeviceIndices;
+ };
+
+ const VkSubmitInfo submitInfo =
+ {
+ VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
+ useDeviceGroups ? &deviceGroupSubmitInfo : DE_NULL, // const void* pNext;
+ 0u, // deUint32 waitSemaphoreCount;
+ DE_NULL, // const VkSemaphore* pWaitSemaphores;
+ (const VkPipelineStageFlags*)DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask;
+ 1u, // deUint32 commandBufferCount;
+ &commandBuffer, // const VkCommandBuffer* pCommandBuffers;
+ 0u, // deUint32 signalSemaphoreCount;
+ DE_NULL, // const VkSemaphore* pSignalSemaphores;
+ };
+
+ VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
+ VK_CHECK(vk.waitForFences(device, 1u, &fence.get(), DE_TRUE, ~0ull));
+}
+
+} // vk
--- /dev/null
+#ifndef _VKCMDUTIL_HPP
+#define _VKCMDUTIL_HPP
+/*-------------------------------------------------------------------------
+ * Vulkan CTS Framework
+ * --------------------
+ *
+ * Copyright (c) 2018 Google 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.
+ *
+ *//*!
+ * \file
+ * \brief Utilities for commonly used command tasks
+ *//*--------------------------------------------------------------------*/
+
+#include "vkDefs.hpp"
+#include "tcuVector.hpp"
+
+namespace vk
+{
+
+void submitCommandsAndWait (const DeviceInterface& vk,
+ const VkDevice device,
+ const VkQueue queue,
+ const VkCommandBuffer commandBuffer,
+ const bool useDeviceGroups = false,
+ const deUint32 deviceMask = 1u);
+
+} // vk
+
+#endif // _VKCMDUTIL_HPP
#include "vkQueryUtil.hpp"
#include "vkRef.hpp"
#include "vkRefUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "vkTypeUtil.hpp"
#include "tcuImageCompare.hpp"
#include "tcuTexture.hpp"
Move<VkBuffer> m_resultBuffer;
de::MovePtr<Allocation> m_resultBufferAlloc;
-
- Move<VkFence> m_fence;
};
static void generateBuffer (std::vector<deUint32>& uniformData,
VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
}
-
- // Create fence
- m_fence = createFence(vk, vkDevice);
}
tcu::TestStatus BufferViewTestInstance::checkResult (deInt8 factor)
const DeviceInterface& vk = m_context.getDeviceInterface();
const VkDevice vkDevice = m_context.getDevice();
const VkQueue queue = m_context.getUniversalQueue();
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO,
- DE_NULL,
- 0u,
- (const VkSemaphore*)DE_NULL,
- (const VkPipelineStageFlags*)DE_NULL,
- 1u,
- &m_cmdBuffer.get(),
- 0u,
- (const VkSemaphore*)DE_NULL,
- };
- VK_CHECK(vk.resetFences(vkDevice, 1, &m_fence.get()));
- VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *m_fence));
- VK_CHECK(vk.waitForFences(vkDevice, 1, &m_fence.get(), true, ~(0ull) /* infinity */));
+ submitCommandsAndWait(vk, vkDevice, queue, m_cmdBuffer.get());
tcu::TestStatus testStatus = checkResult(1);
if (testStatus.getCode() != QP_TEST_RESULT_PASS)
deMemcpy(m_uniformBufferAlloc->getHostPtr(), uniformData.data(), (size_t)uniformSize);
flushMappedMemoryRange(vk, vkDevice, m_uniformBufferAlloc->getMemory(), m_uniformBufferAlloc->getOffset(), uniformSize);
- VK_CHECK(vk.resetFences(vkDevice, 1, &m_fence.get()));
- VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *m_fence));
- VK_CHECK(vk.waitForFences(vkDevice, 1, &m_fence.get(), true, ~(0ull) /* infinity */));
+ submitCommandsAndWait(vk, vkDevice, queue, m_cmdBuffer.get());
return checkResult(factor);
}
#include "vkQueryUtil.hpp"
#include "vkMemUtil.hpp"
#include "vkDeviceUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuTextureUtil.hpp"
#include "vkImageUtil.hpp"
#include "vkPrograms.hpp"
void CommandBufferRenderPassTestEnvironment::submitPrimaryCommandBuffer(void)
{
- const Unique<VkFence> fence (createFence(m_vkd, m_device));
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask;
- 1u, // deUint32 commandBufferCount;
- m_primaryCommandBuffers, // const VkCommandBuffer* pCommandBuffers;
- 0u, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
-
- VK_CHECK(m_vkd.queueSubmit(m_queue, 1, &submitInfo, *fence));
-
- VK_CHECK(m_vkd.waitForFences(m_device, 1, &fence.get(), VK_TRUE, ~0ull));
-
+ submitCommandsAndWait(m_vkd, m_device, m_queue, *m_primaryCommandBuffers);
}
de::MovePtr<tcu::TextureLevel> CommandBufferRenderPassTestEnvironment::readColorAttachment ()
}
VK_CHECK(vk.endCommandBuffer(commandBuffer));
- {
- const Unique<VkFence> fence (createFence(vk, device));
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // sType
- DE_NULL, // pNext
- 0u, // waitSemaphoreCount
- DE_NULL, // pWaitSemaphores
- (const VkPipelineStageFlags*)DE_NULL, // pWaitDstStageMask
- 1u, // commandBufferCount
- &commandBuffer, // pCommandBuffers
- 0u, // signalSemaphoreCount
- DE_NULL // pSignalSemaphores
- };
+ submitCommandsAndWait(vk, device, queue, commandBuffer);
- // Submit the command buffer to the queue
- VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
- // wait for end of execution of queue
- VK_CHECK(vk.waitForFences(device, 1u, &fence.get(), 0u, INFINITE_TIMEOUT));
- }
// check if buffer has been executed
const VkResult result = vk.getEventStatus(device, *event);
return result == VK_EVENT_SET;
}
VK_CHECK(vk.endCommandBuffer(*primCmdBuf));
- // create fence to wait for execution of queue
- const Unique<VkFence> fence (createFence(vk, vkDevice));
-
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // sType
- DE_NULL, // pNext
- 0u, // waitSemaphoreCount
- DE_NULL, // pWaitSemaphores
- (const VkPipelineStageFlags*)DE_NULL, // pWaitDstStageMask
- 1, // commandBufferCount
- &primCmdBuf.get(), // pCommandBuffers
- 0u, // signalSemaphoreCount
- DE_NULL, // pSignalSemaphores
- };
-
- // Submit the command buffer to the queue
- VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
-
- // wait for end of execution of queue
- VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
+ submitCommandsAndWait(vk, vkDevice, queue, primCmdBuf.get());
// check if buffer has been executed
VkResult result = vk.getEventStatus(vkDevice,*event);
}
VK_CHECK(vk.endCommandBuffer(*primCmdBuf));
- // create fence to wait for execution of queue
- const Unique<VkFence> fence (createFence(vk, vkDevice));
-
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // sType
- DE_NULL, // pNext
- 0u, // waitSemaphoreCount
- DE_NULL, // pWaitSemaphores
- (const VkPipelineStageFlags*)DE_NULL, // pWaitDstStageMask
- 1, // commandBufferCount
- &primCmdBuf.get(), // pCommandBuffers
- 0u, // signalSemaphoreCount
- DE_NULL, // pSignalSemaphores
- };
-
- // Submit the command buffer to the queue
- VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
-
- // wait for end of execution of queue
- VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
+ submitCommandsAndWait(vk, vkDevice, queue, primCmdBuf.get());
// check if the buffer was executed correctly - all events had their status
// changed
}
VK_CHECK(vk.endCommandBuffer(*cmdBuf));
- // We'll use a fence to wait for the execution of the queue
- const Unique<VkFence> fence (createFence(vk, vkDevice));
-
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // sType
- DE_NULL, // pNext
- 0u, // waitSemaphoreCount
- DE_NULL, // pWaitSemaphores
- (const VkPipelineStageFlags*)DE_NULL, // pWaitDstStageMask
- 1u, // commandBufferCount
- &cmdBuf.get(), // pCommandBuffers
- 0u, // signalSemaphoreCount
- DE_NULL, // pSignalSemaphores
- };
-
- // Submitting the command buffer that sets the event to the queue
- VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, fence.get()));
-
- // Waiting for the queue to finish executing
- VK_CHECK(vk.waitForFences(vkDevice, 1u, &fence.get(), 0u, INFINITE_TIMEOUT));
- // Reset the fence so that we can reuse it
- VK_CHECK(vk.resetFences(vkDevice, 1u, &fence.get()));
+ submitCommandsAndWait(vk, vkDevice, queue, cmdBuf.get());
// Check if the buffer was executed
if (vk.getEventStatus(vkDevice, *event) != VK_EVENT_SET)
// Submit the command buffer after resetting. It should have no commands
// recorded, so the event should remain unsignaled.
- VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, fence.get()));
- // Waiting for the queue to finish executing
- VK_CHECK(vk.waitForFences(vkDevice, 1u, &fence.get(), 0u, INFINITE_TIMEOUT));
+ submitCommandsAndWait(vk, vkDevice, queue, cmdBuf.get());
// Check if the event remained unset.
if(vk.getEventStatus(vkDevice, *event) == VK_EVENT_RESET)
}
VK_CHECK(vk.endCommandBuffer(*primCmdBuf));
- // create fence to wait for execution of queue
- const Unique<VkFence> fence (createFence(vk, vkDevice));
-
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // sType
- DE_NULL, // pNext
- 0u, // waitSemaphoreCount
- DE_NULL, // pWaitSemaphores
- (const VkPipelineStageFlags*)DE_NULL, // pWaitDstStageMask
- 1, // commandBufferCount
- &primCmdBuf.get(), // pCommandBuffers
- 0u, // signalSemaphoreCount
- DE_NULL, // pSignalSemaphores
- };
-
- // Submit the command buffer to the queue
- VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
-
- // wait for end of execution of queue
- VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
+ submitCommandsAndWait(vk, vkDevice, queue, primCmdBuf.get());
return tcu::TestStatus::pass("hugeTest succeeded");
}
}
VK_CHECK(vk.endCommandBuffer(*primCmdBuf));
- // create fence to wait for execution of queue
- const Unique<VkFence> fence (createFence(vk, vkDevice));
-
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // sType
- DE_NULL, // pNext
- 0u, // waitSemaphoreCount
- DE_NULL, // pWaitSemaphores
- (const VkPipelineStageFlags*)DE_NULL, // pWaitDstStageMask
- 1, // commandBufferCount
- &primCmdBuf.get(), // pCommandBuffers
- 0u, // signalSemaphoreCount
- DE_NULL, // pSignalSemaphores
- };
-
- // Submit the command buffer to the queue
- VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
-
- // wait for end of execution of queue
- VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
+ submitCommandsAndWait(vk, vkDevice, queue, primCmdBuf.get());
return tcu::TestStatus::pass("hugeTest succeeded");
}
}
VK_CHECK(vk.endCommandBuffer(*primCmdBuf));
- // create fence to wait for execution of queue
- const Unique<VkFence> fence (createFence(vk, vkDevice));
+ submitCommandsAndWait(vk, vkDevice, queue, primCmdBuf.get());
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // sType
- DE_NULL, // pNext
- 0u, // waitSemaphoreCount
- DE_NULL, // pWaitSemaphores
- (const VkPipelineStageFlags*)DE_NULL, // pWaitDstStageMask
- 1, // commandBufferCount
- &primCmdBuf.get(), // pCommandBuffers
- 0u, // signalSemaphoreCount
- DE_NULL, // pSignalSemaphores
- };
-
- // submit primary buffer
- VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
-
- // wait for end of execution of queue
- VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
- VK_CHECK(vk.resetFences(vkDevice, 1u, &fence.get()));
// check if buffer has been executed
VkResult result = vk.getEventStatus(vkDevice,*event);
if (result != VK_EVENT_SET)
// reset event
VK_CHECK(vk.resetEvent(vkDevice, *event));
- VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
-
- // wait for end of execution of queue
- VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
+ submitCommandsAndWait(vk, vkDevice, queue, primCmdBuf.get());
// check if buffer has been executed
result = vk.getEventStatus(vkDevice,*event);
}
VK_CHECK(vk.endCommandBuffer(*primCmdBuf1));
- // create fence to wait for execution of queue
- const Unique<VkFence> fence (createFence(vk, vkDevice));
-
- const VkSubmitInfo submitInfo1 =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // sType
- DE_NULL, // pNext
- 0u, // waitSemaphoreCount
- DE_NULL, // pWaitSemaphores
- (const VkPipelineStageFlags*)DE_NULL, // pWaitDstStageMask
- 1, // commandBufferCount
- &primCmdBuf1.get(), // pCommandBuffers
- 0u, // signalSemaphoreCount
- DE_NULL, // pSignalSemaphores
- };
-
- VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo1, *fence));
-
- // wait for end of execution of queue
- VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
- VK_CHECK(vk.resetFences(vkDevice, 1u, &fence.get()));
+ submitCommandsAndWait(vk, vkDevice, queue, primCmdBuf1.get());
// check if secondary buffer has been executed
VkResult result = vk.getEventStatus(vkDevice,*event);
// end recording
VK_CHECK(vk.endCommandBuffer(*primCmdBuf2));
- // submit second primary buffer, the secondary should be executed too
- const VkSubmitInfo submitInfo2 =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // sType
- DE_NULL, // pNext
- 0u, // waitSemaphoreCount
- DE_NULL, // pWaitSemaphores
- (const VkPipelineStageFlags*)DE_NULL, // pWaitDstStageMask
- 1, // commandBufferCount
- &primCmdBuf2.get(), // pCommandBuffers
- 0u, // signalSemaphoreCount
- DE_NULL, // pSignalSemaphores
- };
- VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo2, *fence));
-
- // wait for end of execution of queue
- VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
+ submitCommandsAndWait(vk, vkDevice, queue, primCmdBuf2.get());
// check if secondary buffer has been executed
result = vk.getEventStatus(vkDevice,*event);
}
VK_CHECK(vk.endCommandBuffer(*primCmdBuf));
- // create fence to wait for execution of queue
- const Unique<VkFence> fence (createFence(vk, vkDevice));
-
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // sType
- DE_NULL, // pNext
- 0u, // waitSemaphoreCount
- DE_NULL, // pWaitSemaphores
- (const VkPipelineStageFlags*)DE_NULL, // pWaitDstStageMask
- 1, // commandBufferCount
- &primCmdBuf.get(), // pCommandBuffers
- 0u, // signalSemaphoreCount
- DE_NULL, // pSignalSemaphores
- };
-
- // submit primary buffer
- VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
-
- // wait for end of execution of queue
- VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
- VK_CHECK(vk.resetFences(vkDevice, 1u, &fence.get()));
+ submitCommandsAndWait(vk, vkDevice, queue, primCmdBuf.get());
// check if buffer has been executed
VkResult result = vk.getEventStatus(vkDevice,*event);
}
VK_CHECK(vk.endCommandBuffer(*primCmdBuf));
- // reset event
- VK_CHECK(vk.resetEvent(vkDevice, *event));
-
- VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
-
- // wait for end of execution of queue
- VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
+ submitCommandsAndWait(vk, vkDevice, queue, primCmdBuf.get());
// check if buffer has been executed
result = vk.getEventStatus(vkDevice,*event);
}
VK_CHECK(vk.endCommandBuffer(*primCmdBuf1));
- // create fence to wait for execution of queue
- const Unique<VkFence> fence (createFence(vk, vkDevice));
-
- const VkSubmitInfo submitInfo1 =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // sType
- DE_NULL, // pNext
- 0u, // waitSemaphoreCount
- DE_NULL, // pWaitSemaphores
- (const VkPipelineStageFlags*)DE_NULL, // pWaitDstStageMask
- 1, // commandBufferCount
- &primCmdBuf1.get(), // pCommandBuffers
- 0u, // signalSemaphoreCount
- DE_NULL, // pSignalSemaphores
- };
-
- VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo1, *fence));
-
- // wait for end of execution of queue
- VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
- VK_CHECK(vk.resetFences(vkDevice, 1u, &fence.get()));
+ submitCommandsAndWait(vk, vkDevice, queue, primCmdBuf1.get());
// check if secondary buffer has been executed
VkResult result = vk.getEventStatus(vkDevice,*event);
// end recording
VK_CHECK(vk.endCommandBuffer(*primCmdBuf2));
- // submit second primary buffer, the secondary should be executed too
- const VkSubmitInfo submitInfo2 =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // sType
- DE_NULL, // pNext
- 0u, // waitSemaphoreCount
- DE_NULL, // pWaitSemaphores
- (const VkPipelineStageFlags*)DE_NULL, // pWaitDstStageMask
- 1, // commandBufferCount
- &primCmdBuf2.get(), // pCommandBuffers
- 0u, // signalSemaphoreCount
- DE_NULL, // pSignalSemaphores
- };
- VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo2, *fence));
-
- // wait for end of execution of queue
- VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
+ submitCommandsAndWait(vk, vkDevice, queue, primCmdBuf2.get());
// check if secondary buffer has been executed
result = vk.getEventStatus(vkDevice,*event);
}
VK_CHECK(vk.endCommandBuffer(*primCmdBuf));
- // create fence to wait for execution of queue
- const Unique<VkFence> fence(createFence(vk, vkDevice));
-
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // sType
- DE_NULL, // pNext
- 0u, // waitSemaphoreCount
- DE_NULL, // pWaitSemaphores
- (const VkPipelineStageFlags*)DE_NULL, // pWaitDstStageMask
- 1, // commandBufferCount
- &primCmdBuf.get(), // pCommandBuffers
- 0u, // signalSemaphoreCount
- DE_NULL, // pSignalSemaphores
- };
-
- // submit primary buffer, the secondary should be executed too
- VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
-
- // wait for end of execution of queue
- VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
+ submitCommandsAndWait(vk, vkDevice, queue, primCmdBuf.get());
deUint32 resultCount;
result.readResultContentsTo(&resultCount);
}
VK_CHECK(vk.endCommandBuffer(*primCmdBuf));
- // create fence to wait for execution of queue
- const Unique<VkFence> fence (createFence(vk, vkDevice));
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // sType
- DE_NULL, // pNext
- 0u, // waitSemaphoreCount
- DE_NULL, // pWaitSemaphores
- (const VkPipelineStageFlags*)DE_NULL, // pWaitDstStageMask
- 1u, // commandBufferCount
- &primCmdBuf.get(), // pCommandBuffers
- 0u, // signalSemaphoreCount
- DE_NULL, // pSignalSemaphores
- };
-
- // submit primary buffer, the secondary should be executed too
- VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, fence.get()));
-
- // wait for end of execution of queue
- VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), 0u, INFINITE_TIMEOUT));
+ submitCommandsAndWait(vk, vkDevice, queue, primCmdBuf.get());
// check if secondary buffer has been executed
VkResult result = vk.getEventStatus(vkDevice, *event);
(const VkCommandBufferInheritanceInfo*)DE_NULL,
};
- const Unique<VkFence> cmdCompleteFence (createFence(vk, device));
const Unique<VkCommandBuffer> cmd (allocateCommandBuffer(vk, device, &cmdBufCreateInfo));
VK_CHECK(vk.beginCommandBuffer(*cmd, &cmdBufBeginInfo));
// run
// submit second primary buffer, the secondary should be executed too
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // sType
- DE_NULL, // pNext
- 0u, // waitSemaphoreCount
- DE_NULL, // pWaitSemaphores
- (const VkPipelineStageFlags*)DE_NULL, // pWaitDstStageMask
- 1, // commandBufferCount
- &cmd.get(), // pCommandBuffers
- 0u, // signalSemaphoreCount
- DE_NULL, // pSignalSemaphores
- };
- VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *cmdCompleteFence));
-
- VK_CHECK(vk.waitForFences(device, 1u, &cmdCompleteFence.get(), 0u, INFINITE_TIMEOUT)); // \note: timeout is failure
- VK_CHECK(vk.resetFences(device, 1u, &cmdCompleteFence.get()));
+ submitCommandsAndWait(vk, device, queue, cmd.get());
// submit and wait end
result.readResultContentsTo(&results);
#include "vktTestCaseUtil.hpp"
#include "vktTestGroupUtil.hpp"
#include "vkTypeUtil.hpp"
+#include "vkCmdUtil.hpp"
#include <set>
de::MovePtr<tcu::TextureLevel> readImage (vk::VkImage image,
const ImageParms& imageParms,
const deUint32 mipLevel = 0u);
- void submitCommandsAndWait (const DeviceInterface& vk,
- const VkDevice device,
- const VkQueue queue,
- const VkCommandBuffer& cmdBuffer);
private:
void uploadImageAspect (const tcu::ConstPixelBufferAccess& src,
tcu::copy(dst, tcu::ConstPixelBufferAccess(dst.getFormat(), dst.getSize(), bufferAlloc->getHostPtr()));
}
-void CopiesAndBlittingTestInstance::submitCommandsAndWait (const DeviceInterface& vk, const VkDevice device, const VkQueue queue, const VkCommandBuffer& cmdBuffer)
-{
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const VkPipelineStageFlags*)DE_NULL,
- 1u, // deUint32 commandBufferCount;
- &cmdBuffer, // const VkCommandBuffer* pCommandBuffers;
- 0u, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
-
- VK_CHECK(vk.resetFences(device, 1, &m_fence.get()));
- VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *m_fence));
- VK_CHECK(vk.waitForFences(device, 1, &m_fence.get(), true, ~(0ull) /* infinity */));
-}
-
de::MovePtr<tcu::TextureLevel> CopiesAndBlittingTestInstance::readImage (vk::VkImage image,
const ImageParms& parms,
const deUint32 mipLevel)
#include "deUniquePtr.hpp"
#include "vkImageUtil.hpp"
#include "vkMemUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "vktTestCase.hpp"
#include "vktTestCaseUtil.hpp"
#include "vkQueryUtil.hpp"
Move<VkCommandPool> m_cmdPool;
Move<VkCommandBuffer> m_cmdBuffer;
- Move<VkFence> m_fence;
de::MovePtr<tcu::TextureLevel> m_destinationTextureLevel;
de::MovePtr<tcu::TextureLevel> m_expectedTextureLevel;
// Create command buffer
m_cmdBuffer = allocateCommandBuffer(vk, vkDevice, *m_cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
- // Create fence
- m_fence = createFence(vk, vkDevice);
-
testParams.bufferAllocator->createTestBuffer(m_params.dstSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT, context, memAlloc, m_destination, MemoryRequirement::HostVisible, m_destinationBufferAlloc);
}
vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &dstBufferBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const VkPipelineStageFlags*)DE_NULL,
- 1u, // deUint32 commandBufferCount;
- &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0u, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
-
- VK_CHECK(vk.resetFences(vkDevice, 1, &m_fence.get()));
- VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *m_fence));
- VK_CHECK(vk.waitForFences(vkDevice, 1, &m_fence.get(), true, ~(0ull) /* infinity */));
+ submitCommandsAndWait(vk, vkDevice, queue, m_cmdBuffer.get());
// Read buffer data
de::MovePtr<tcu::TextureLevel> resultLevel (new tcu::TextureLevel(m_destinationTextureLevel->getAccess().getFormat(), dstLevelWidth, 1));
vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &dstBufferBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const VkPipelineStageFlags*)DE_NULL,
- 1u, // deUint32 commandBufferCount;
- &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0u, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
-
- VK_CHECK(vk.resetFences(vkDevice, 1, &m_fence.get()));
- VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *m_fence));
- VK_CHECK(vk.waitForFences(vkDevice, 1, &m_fence.get(), true, ~(0ull) /* infinity */));
+ submitCommandsAndWait(vk, vkDevice, queue, m_cmdBuffer.get());
// Read buffer data
de::MovePtr<tcu::TextureLevel> resultLevel (new tcu::TextureLevel(m_destinationTextureLevel->getAccess().getFormat(), dstLevelWidth, 1));
#include "vkImageUtil.hpp"
#include "vkMemUtil.hpp"
#include "vkPrograms.hpp"
+#include "vkCmdUtil.hpp"
#include "vktTestCase.hpp"
#include "vkTypeUtil.cpp"
deUint32 getMemoryTypeIndex (VkMemoryPropertyFlags propertyFlag, VkPhysicalDeviceMemoryProperties pMemoryProperties);
Move<VkCommandPool> createCommandPool () const;
Move<VkCommandBuffer> allocatePrimaryCommandBuffer (VkCommandPool commandPool) const;
- void submitCommandsAndWait (const DeviceInterface& vkd,
- const VkDevice device,
- const VkQueue queue,
- const VkCommandBuffer& cmdBuffer);
bool isDeviceMemoryCommitmentOk (const VkMemoryRequirements memoryRequirements);
private:
return tcu::TestStatus::pass("Pass");
}
-void MemoryCommitmentTestInstance::submitCommandsAndWait (const DeviceInterface& vkd, const VkDevice device, const VkQueue queue, const VkCommandBuffer& cmdBuffer)
-{
- Move<VkFence> fence = createFence(vkd, device);
-
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const VkPipelineStageFlags*)DE_NULL,
- 1u, // deUint32 commandBufferCount;
- &cmdBuffer, // const VkCommandBuffer* pCommandBuffers;
- 0u, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
-
- VK_CHECK(vkd.queueSubmit(queue, 1, &submitInfo, *fence));
- VK_CHECK(vkd.waitForFences(device, 1, &fence.get(), true, ~(0ull) /* infinity */));
-}
-
deUint32 MemoryCommitmentTestInstance::getMemoryTypeIndex(VkMemoryPropertyFlags propertyFlag, VkPhysicalDeviceMemoryProperties pMemoryProperties)
{
for (deUint32 memoryTypeIndex = 0u; memoryTypeIndex < VK_MAX_MEMORY_TYPES; ++memoryTypeIndex)
#include "vkQueryUtil.hpp"
#include "vkRefUtil.hpp"
#include "vkTypeUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuImageCompare.hpp"
#include "tcuTexture.hpp"
#include "tcuTextureUtil.hpp"
void ImageClearingTestInstance::submitCommandBuffer (void) const
{
- const Unique<VkFence> fence (createFence(m_vkd, m_device));
-
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask;
- 1u, // deUint32 commandBufferCount;
- &(*m_commandBuffer), // const VkCommandBuffer* pCommandBuffers;
- 0u, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
-
- VK_CHECK(m_vkd.queueSubmit(m_queue, 1, &submitInfo, *fence));
-
- VK_CHECK(m_vkd.waitForFences(m_device, 1, &fence.get(), VK_TRUE, ~0ull));
+ submitCommandsAndWait(m_vkd, m_device, m_queue, m_commandBuffer.get());
}
void ImageClearingTestInstance::pipelineImageBarrier(VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask, VkImageLayout oldLayout, VkImageLayout newLayout) const
#include "vkPrograms.hpp"
#include "vkTypeUtil.hpp"
#include "vkImageUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuTestLog.hpp"
#include "tcuFormatUtil.hpp"
}
// Submit & wait for completion
- {
- const VkFenceCreateInfo fenceParams =
- {
- VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, // sType
- DE_NULL, // pNext
- 0u, // flags
- };
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // sType
- DE_NULL, // pNext
- 0u, // waitSemaphoreCount
- DE_NULL, // pWaitSemaphores
- (const VkPipelineStageFlags*)DE_NULL,
- 1u, // commandBufferCount
- &cmdBuf.get(), // pCommandBuffers
- 0u, // signalSemaphoreCount
- DE_NULL, // pSignalSemaphores
- };
- const Unique<VkFence> fence (createFence(vk, vkDevice, &fenceParams));
-
- VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
- VK_CHECK(vk.waitForFences(vkDevice, 1u, &fence.get(), DE_TRUE, ~0ull));
- }
+ submitCommandsAndWait(vk, vkDevice, queue, cmdBuf.get());
// Read results, render reference, compare
{
}
// Submit & wait for completion
- {
- const VkFenceCreateInfo fenceParams =
- {
- VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, // sType
- DE_NULL, // pNext
- 0u, // flags
- };
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // sType
- DE_NULL, // pNext
- 0u, // waitSemaphoreCount
- DE_NULL, // pWaitSemaphores
- (const VkPipelineStageFlags*)DE_NULL,
- 1u, // commandBufferCount
- &cmdBuf.get(), // pCommandBuffers
- 0u, // signalSemaphoreCount
- DE_NULL, // pSignalSemaphores
- };
- const Unique<VkFence> fence (createFence(vk, vkDevice, &fenceParams));
-
- VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
- VK_CHECK(vk.waitForFences(vkDevice, 1u, &fence.get(), DE_TRUE, ~0ull));
- }
+ submitCommandsAndWait(vk, vkDevice, queue, cmdBuf.get());
// Read results, render reference, compare
{
#include "vkQueryUtil.hpp"
#include "vkImageUtil.hpp"
#include "vkTypeUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuVector.hpp"
#include "tcuVectorUtil.hpp"
const de::MovePtr<vk::Allocation> bufferMemory = allocateAndBindObjectMemory(m_vki, m_device, m_allocator, *buffer, vk::MemoryRequirement::HostVisible);
const vk::Unique<vk::VkCommandBuffer> cmd (vk::allocateCommandBuffer(m_vki, m_device, *m_cmdPool, vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY));
- const vk::Unique<vk::VkFence> cmdCompleteFence (vk::createFence(m_vki, m_device));
- const deUint64 infiniteTimeout = ~(deUint64)0u;
// copy content to buffer
VK_CHECK(m_vki.beginCommandBuffer(*cmd, &cmdBufBeginInfo));
0, (const vk::VkImageMemoryBarrier*)DE_NULL);
VK_CHECK(m_vki.endCommandBuffer(*cmd));
- // wait for transfer to complete
- {
- const vk::VkSubmitInfo submitInfo =
- {
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO,
- DE_NULL,
- 0u,
- (const vk::VkSemaphore*)0,
- (const vk::VkPipelineStageFlags*)DE_NULL,
- 1u,
- &cmd.get(),
- 0u,
- (const vk::VkSemaphore*)0,
- };
-
- VK_CHECK(m_vki.queueSubmit(m_queue, 1, &submitInfo, *cmdCompleteFence));
- }
- VK_CHECK(m_vki.waitForFences(m_device, 1, &cmdCompleteFence.get(), 0u, infiniteTimeout)); // \note: timeout is failure
+ submitCommandsAndWait(m_vki, m_device, m_queue, cmd.get());
dst.setStorage(m_targetFormat, m_targetSize.x(), m_targetSize.y());
};
const vk::Unique<vk::VkCommandBuffer> cmd (vk::allocateCommandBuffer(m_vki, m_device, *m_cmdPool, vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY));
- const vk::Unique<vk::VkFence> fence (vk::createFence(m_vki, m_device));
- const deUint64 infiniteTimeout = ~(deUint64)0u;
VK_CHECK(m_vki.beginCommandBuffer(*cmd, &cmdBufBeginInfo));
m_vki.cmdPipelineBarrier(*cmd, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, vk::VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, (vk::VkDependencyFlags)0,
1, &imageBarrier);
VK_CHECK(m_vki.endCommandBuffer(*cmd));
- {
- const vk::VkSubmitInfo submitInfo =
- {
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO,
- DE_NULL,
- 0u,
- (const vk::VkSemaphore*)0,
- (const vk::VkPipelineStageFlags*)DE_NULL,
- 1u,
- &cmd.get(),
- 0u,
- (const vk::VkSemaphore*)0,
- };
+ submitCommandsAndWait(m_vki, m_device, m_queue, cmd.get());
- VK_CHECK(m_vki.queueSubmit(m_queue, 1u, &submitInfo, *fence));
- }
- VK_CHECK(m_vki.waitForFences(m_device, 1u, &fence.get(), VK_TRUE, infiniteTimeout));
-
- // and then render to
renderToTarget();
}
const vk::Unique<vk::VkCommandBuffer> mainCmd (vk::allocateCommandBuffer(m_vki, m_device, *m_cmdPool, vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY));
const vk::Unique<vk::VkCommandBuffer> passCmd ((m_isPrimaryCmdBuf) ? (vk::Move<vk::VkCommandBuffer>()) : (vk::allocateCommandBuffer(m_vki, m_device, *m_cmdPool, vk::VK_COMMAND_BUFFER_LEVEL_SECONDARY)));
const vk::Unique<vk::VkFence> fence (vk::createFence(m_vki, m_device));
- const deUint64 infiniteTimeout = ~(deUint64)0u;
const vk::VkSubpassContents passContents = (m_isPrimaryCmdBuf) ? (vk::VK_SUBPASS_CONTENTS_INLINE) : (vk::VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS);
VK_CHECK(m_vki.beginCommandBuffer(*mainCmd, &mainCmdBufBeginInfo));
VK_CHECK(m_vki.endCommandBuffer(*mainCmd));
// submit and wait for them to finish before exiting scope. (Killing in-flight objects is a no-no).
- {
- const vk::VkSubmitInfo submitInfo =
- {
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO,
- DE_NULL,
- 0u,
- (const vk::VkSemaphore*)0,
- (const vk::VkPipelineStageFlags*)DE_NULL,
- 1u,
- &mainCmd.get(),
- 0u,
- (const vk::VkSemaphore*)0,
- };
- VK_CHECK(m_vki.queueSubmit(m_queue, 1, &submitInfo, *fence));
- }
- VK_CHECK(m_vki.waitForFences(m_device, 1, &fence.get(), 0u, infiniteTimeout)); // \note: timeout is failure
+ submitCommandsAndWait(m_vki, m_device, m_queue, mainCmd.get());
}
enum DescriptorSetCount
};
const vk::Unique<vk::VkCommandPool> cmdPool (vk::createCommandPool(m_vki, m_device, &cmdPoolCreateInfo));
- const vk::VkFenceCreateInfo fenceCreateInfo =
- {
- vk::VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
- DE_NULL,
- 0u, // flags
- };
-
const vk::VkCommandBufferAllocateInfo cmdBufCreateInfo =
{
vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
(const vk::VkCommandBufferInheritanceInfo*)DE_NULL,
};
- const vk::Unique<vk::VkFence> cmdCompleteFence (vk::createFence(m_vki, m_device, &fenceCreateInfo));
const vk::Unique<vk::VkCommandBuffer> cmd (vk::allocateCommandBuffer(m_vki, m_device, &cmdBufCreateInfo));
- const deUint64 infiniteTimeout = ~(deUint64)0u;
VK_CHECK(m_vki.beginCommandBuffer(*cmd, &cmdBufBeginInfo));
0, (const vk::VkImageMemoryBarrier*)DE_NULL);
VK_CHECK(m_vki.endCommandBuffer(*cmd));
- // run
- {
- const vk::VkSubmitInfo submitInfo =
- {
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO,
- DE_NULL,
- 0u,
- (const vk::VkSemaphore*)0,
- (const vk::VkPipelineStageFlags*)DE_NULL,
- 1u,
- &cmd.get(),
- 0u,
- (const vk::VkSemaphore*)0,
- };
- VK_CHECK(m_vki.queueSubmit(queue, 1, &submitInfo, *cmdCompleteFence));
- }
- VK_CHECK(m_vki.waitForFences(m_device, 1, &cmdCompleteFence.get(), 0u, infiniteTimeout)); // \note: timeout is failure
+ submitCommandsAndWait(m_vki, m_device, queue, cmd.get());
}
//cmdPushDescriptorSet variant
(const vk::VkCommandBufferInheritanceInfo*)DE_NULL,
};
- const vk::Unique<vk::VkFence> cmdCompleteFence (vk::createFence(m_vki, m_device));
const vk::Unique<vk::VkCommandBuffer> cmd (vk::allocateCommandBuffer(m_vki, m_device, *cmdPool, vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY));
- const deUint64 infiniteTimeout = ~(deUint64)0u;
VK_CHECK(m_vki.beginCommandBuffer(*cmd, &cmdBufBeginInfo));
0, (const vk::VkImageMemoryBarrier*)DE_NULL);
VK_CHECK(m_vki.endCommandBuffer(*cmd));
- // run
- {
- const vk::VkSubmitInfo submitInfo =
- {
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO,
- DE_NULL,
- 0u,
- (const vk::VkSemaphore*)0,
- (const vk::VkPipelineStageFlags*)DE_NULL,
- 1u,
- &cmd.get(),
- 0u,
- (const vk::VkSemaphore*)0,
- };
- VK_CHECK(m_vki.queueSubmit(queue, 1, &submitInfo, *cmdCompleteFence));
- }
- VK_CHECK(m_vki.waitForFences(m_device, 1, &cmdCompleteFence.get(), 0u, infiniteTimeout)); // \note: timeout is failure
+ submitCommandsAndWait(m_vki, m_device, queue, cmd.get());
}
class BufferComputeInstance : public vkt::TestInstance
};
const vk::Unique<vk::VkCommandBuffer> cmd (vk::allocateCommandBuffer(vki, device, *cmdPool, vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY));
- const vk::Unique<vk::VkFence> cmdCompleteFence (vk::createFence(vki, device));
- const deUint64 infiniteTimeout = ~(deUint64)0u;
std::vector<vk::VkBufferImageCopy> copySlices;
// copy data to buffer
VK_CHECK(vki.endCommandBuffer(*cmd));
// submit and wait for command buffer to complete before killing it
- {
- const vk::VkSubmitInfo submitInfo =
- {
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO,
- DE_NULL,
- 0u,
- (const vk::VkSemaphore*)0,
- (const vk::VkPipelineStageFlags*)DE_NULL,
- 1u,
- &cmd.get(),
- 0u,
- (const vk::VkSemaphore*)0,
- };
- VK_CHECK(vki.queueSubmit(queue, 1, &submitInfo, *cmdCompleteFence));
- }
- VK_CHECK(vki.waitForFences(device, 1, &cmdCompleteFence.get(), 0u, infiniteTimeout)); // \note: timeout is failure
+ submitCommandsAndWait(vki, device, queue, cmd.get());
}
class ImageFetchInstanceImages : private ImageInstanceImages
#include "vkBuilderUtil.hpp"
#include "vkTypeUtil.hpp"
#include "vkDeviceUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuCommandLine.hpp"
#include "vkMemUtil.hpp"
#include "vkBuilderUtil.hpp"
#include "vkQueryUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuVector.hpp"
#include "tcuVectorUtil.hpp"
#include "vkDeviceUtil.hpp"
#include "vkTypeUtil.hpp"
#include "vkBuilderUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuTestLog.hpp"
#include "tcuFormatUtil.hpp"
VK_CHECK(vk.endCommandBuffer(commandBuffer));
}
-void submitCommandsAndWait (const DeviceInterface& vk,
- const VkDevice device,
- const VkQueue queue,
- const VkCommandBuffer commandBuffer,
- const bool useDeviceGroups,
- const deUint32 deviceMask)
-{
- const Unique<VkFence> fence(createFence(vk, device));
-
- VkDeviceGroupSubmitInfo deviceGroupSubmitInfo =
- {
- VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // uint32_t waitSemaphoreCount;
- DE_NULL, // const uint32_t* pWaitSemaphoreDeviceIndices;
- 1u, // uint32_t commandBufferCount;
- &deviceMask, // const uint32_t* pCommandBufferDeviceMasks;
- 0u, // uint32_t signalSemaphoreCount;
- DE_NULL, // const uint32_t* pSignalSemaphoreDeviceIndices;
- };
-
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- useDeviceGroups ? &deviceGroupSubmitInfo : DE_NULL, // const void* pNext;
- 0u, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const VkPipelineStageFlags*)DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask;
- 1u, // deUint32 commandBufferCount;
- &commandBuffer, // const VkCommandBuffer* pCommandBuffers;
- 0u, // deUint32 signalSemaphoreCount;
- DE_NULL, // const VkSemaphore* pSignalSemaphores;
- };
-
- VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
- VK_CHECK(vk.waitForFences(device, 1u, &fence.get(), DE_TRUE, ~0ull));
-}
-
} // compute
} // vkt
void endCommandBuffer (const vk::DeviceInterface& vk,
const vk::VkCommandBuffer cmdBuffer);
-void submitCommandsAndWait (const vk::DeviceInterface& vk,
- const vk::VkDevice device,
- const vk::VkQueue queue,
- const vk::VkCommandBuffer cmdBuffer,
- const bool useDeviceGroups = false,
- const deUint32 deviceMask = 1);
-
inline vk::VkExtent3D makeExtent3D (const tcu::IVec3& vec)
{
return vk::makeExtent3D(vec.x(), vec.y(), vec.z());
#include "vkRefUtil.hpp"
#include "vkStrUtil.hpp"
#include "vkTypeUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "vktTestCase.hpp"
#include "vktTestCaseUtil.hpp"
#include "vktTestGroupUtil.hpp"
deUint32 getMemoryIndex (deUint32 memoryTypeBits, deUint32 memoryPropertyFlag);
void getDeviceLayers (vector<string>& enabledLayers);
bool isPeerFetchAllowed (deUint32 memoryTypeIndex, deUint32 firstdeviceID, deUint32 seconddeviceID);
- void SubmitBufferAndWaitForIdle (const DeviceDriver& vk, VkCommandBuffer cmdBuf, VkDeviceGroupSubmitInfo);
+ void SubmitBufferAndWaitForIdle (const DeviceDriver& vk, VkCommandBuffer cmdBuf, deUint32 deviceMask);
virtual tcu::TestStatus iterate (void);
Move<VkDevice> m_deviceGroup;
m_deviceGroupQueue = getDeviceQueue(*deviceDriver, *m_deviceGroup, queueFamilyIndex, queueIndex);
}
-void DeviceGroupTestInstance::SubmitBufferAndWaitForIdle(const DeviceDriver& vk, VkCommandBuffer cmdBuf, VkDeviceGroupSubmitInfo deviceGroupSubmitInfo)
+void DeviceGroupTestInstance::SubmitBufferAndWaitForIdle(const DeviceDriver& vk, VkCommandBuffer cmdBuf, deUint32 deviceMask)
{
- const VkFenceCreateInfo fenceParams =
- {
- VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, // sType
- DE_NULL, // pNext
- 0u, // flags
- };
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // sType
- &deviceGroupSubmitInfo, // pNext
- 0u, // waitSemaphoreCount
- DE_NULL, // pWaitSemaphores
- (const VkPipelineStageFlags*)DE_NULL, // pWaitDstStageMask
- 1u, // commandBufferCount
- &cmdBuf, // pCommandBuffers
- 0u, // signalSemaphoreCount
- DE_NULL, // pSignalSemaphores
- };
- const Unique<VkFence> fence(createFence(vk, *m_deviceGroup, &fenceParams));
-
- VK_CHECK(vk.queueSubmit(m_deviceGroupQueue, 1u, &submitInfo, *fence));
- VK_CHECK(vk.waitForFences(*m_deviceGroup, 1u, &fence.get(), DE_TRUE, ~0ull));
+ submitCommandsAndWait(vk, *m_deviceGroup, m_deviceGroupQueue, cmdBuf, true, deviceMask);
VK_CHECK(vk.deviceWaitIdle(*m_deviceGroup));
}
0u, // memoryTypeIndex
};
- VkDeviceGroupSubmitInfo deviceGroupSubmitInfo =
- {
- VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO, // sType
- DE_NULL, // pNext
- 0u, // waitSemaphoreCount
- DE_NULL, // pWaitSemaphoreDeviceIndices
- 0u, // commandBufferCount
- DE_NULL, // pCommandBufferDeviceMasks
- 0u, // signalSemaphoreCount
- DE_NULL, // pSignalSemaphoreDeviceIndices
- };
-
// create vertex buffers
{
const VkBufferCreateInfo stagingVertexBufferParams =
// Submit & wait for completion
{
const deUint32 deviceMask = (1 << firstDeviceID) | (1 << secondDeviceID);
- deviceGroupSubmitInfo.commandBufferCount = 1;
- deviceGroupSubmitInfo.pCommandBufferDeviceMasks = &deviceMask;
- SubmitBufferAndWaitForIdle(vk, cmdBuffer.get(), deviceGroupSubmitInfo);
+ SubmitBufferAndWaitForIdle(vk, cmdBuffer.get(), deviceMask);
}
// Copy image from secondDeviceID in case of AFR and SFR(only if Peer memory as copy source is not allowed)
VK_CHECK(vk.endCommandBuffer(*cmdBuffer));
const deUint32 deviceMask = 1 << firstDeviceID;
- deviceGroupSubmitInfo.pCommandBufferDeviceMasks = &deviceMask;
- SubmitBufferAndWaitForIdle(vk, cmdBuffer.get(), deviceGroupSubmitInfo);
+ SubmitBufferAndWaitForIdle(vk, cmdBuffer.get(), deviceMask);
}
// Copy Image from secondDeviceID to firstDeviceID
VK_CHECK(vk.endCommandBuffer(*cmdBuffer));
const deUint32 deviceMask = 1 << secondDeviceID;
- deviceGroupSubmitInfo.pCommandBufferDeviceMasks = &deviceMask;
- SubmitBufferAndWaitForIdle(vk, cmdBuffer.get(), deviceGroupSubmitInfo);
+ SubmitBufferAndWaitForIdle(vk, cmdBuffer.get(), deviceMask);
}
// Change layout back on firstDeviceID
VK_CHECK(vk.endCommandBuffer(*cmdBuffer));
const deUint32 deviceMask = 1 << firstDeviceID;
- deviceGroupSubmitInfo.pCommandBufferDeviceMasks = &deviceMask;
- SubmitBufferAndWaitForIdle(vk, cmdBuffer.get(), deviceGroupSubmitInfo);
+ SubmitBufferAndWaitForIdle(vk, cmdBuffer.get(), deviceMask);
}
}
}
// Submit & wait for completion
{
const deUint32 deviceMask = 1 << firstDeviceID;
- deviceGroupSubmitInfo.pCommandBufferDeviceMasks = &deviceMask;
- SubmitBufferAndWaitForIdle(vk, cmdBuffer.get(), deviceGroupSubmitInfo);
+ SubmitBufferAndWaitForIdle(vk, cmdBuffer.get(), deviceMask);
}
// Read results and check against reference image
#include "vktDrawBaseClass.hpp"
#include "vkQueryUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "vktTestGroupUtil.hpp"
#include "deDefs.h"
{
tcu::TestLog &log = m_context.getTestContext().getLog();
const vk::VkQueue queue = m_context.getUniversalQueue();
+ const vk::VkDevice device = m_context.getDevice();
beginRenderPass();
m_vk.cmdEndRenderPass(*m_cmdBuffer);
m_vk.endCommandBuffer(*m_cmdBuffer);
- vk::VkSubmitInfo submitInfo =
- {
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const vk::VkPipelineStageFlags*)DE_NULL,
- 1, // deUint32 commandBufferCount;
- &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
- VK_CHECK(m_vk.queueSubmit(queue, 1, &submitInfo, DE_NULL));
+ submitCommandsAndWait(m_vk, device, queue, m_cmdBuffer.get());
// Validation
tcu::TextureLevel refImage (vk::mapVkFormat(m_colorAttachmentFormat), (int)(0.5 + WIDTH), (int)(0.5 + HEIGHT));
}
generateRefImage(refImage.getAccess(), vertices, colors);
- VK_CHECK(m_vk.queueWaitIdle(queue));
-
const vk::VkOffset3D zeroOffset = { 0, 0, 0 };
const tcu::ConstPixelBufferAccess renderedFrame = m_colorTargetImage->readSurface(queue, m_context.getDefaultAllocator(),
vk::VK_IMAGE_LAYOUT_GENERAL, zeroOffset, WIDTH, HEIGHT, vk::VK_IMAGE_ASPECT_COLOR_BIT);
m_vk.cmdEndRenderPass(*m_cmdBuffer);
m_vk.endCommandBuffer(*m_cmdBuffer);
- vk::VkSubmitInfo submitInfo =
- {
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const vk::VkPipelineStageFlags*)DE_NULL,
- 1, // deUint32 commandBufferCount;
- &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
- VK_CHECK(m_vk.queueSubmit(queue, 1, &submitInfo, DE_NULL));
+ submitCommandsAndWait(m_vk, vkDevice, queue, m_cmdBuffer.get());
// Validation
tcu::TextureLevel refImage (vk::mapVkFormat(m_colorAttachmentFormat), (int)(0.5 + WIDTH), (int)(0.5 + HEIGHT));
}
generateRefImage(refImage.getAccess(), vertices, colors);
- VK_CHECK(m_vk.queueWaitIdle(queue));
-
const vk::VkOffset3D zeroOffset = { 0, 0, 0 };
const tcu::ConstPixelBufferAccess renderedFrame = m_colorTargetImage->readSurface(queue, m_context.getDefaultAllocator(),
vk::VK_IMAGE_LAYOUT_GENERAL, zeroOffset, WIDTH, HEIGHT, vk::VK_IMAGE_ASPECT_COLOR_BIT);
m_vk.cmdEndRenderPass(*m_cmdBuffer);
m_vk.endCommandBuffer(*m_cmdBuffer);
- vk::VkSubmitInfo submitInfo =
- {
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const vk::VkPipelineStageFlags*)DE_NULL,
- 1, // deUint32 commandBufferCount;
- &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
- VK_CHECK(m_vk.queueSubmit(queue, 1, &submitInfo, DE_NULL));
+ submitCommandsAndWait(m_vk, vkDevice, queue, m_cmdBuffer.get());
// Validation
tcu::TextureLevel refImage (vk::mapVkFormat(m_colorAttachmentFormat), (int)(0.5 + WIDTH), (int)(0.5 + HEIGHT));
generateRefImage(refImage.getAccess(), vertices, colors);
}
- VK_CHECK(m_vk.queueWaitIdle(queue));
-
const vk::VkOffset3D zeroOffset = { 0, 0, 0 };
const tcu::ConstPixelBufferAccess renderedFrame = m_colorTargetImage->readSurface(queue, m_context.getDefaultAllocator(),
vk::VK_IMAGE_LAYOUT_GENERAL, zeroOffset, WIDTH, HEIGHT, vk::VK_IMAGE_ASPECT_COLOR_BIT);
m_vk.cmdEndRenderPass(*m_cmdBuffer);
m_vk.endCommandBuffer(*m_cmdBuffer);
- vk::VkSubmitInfo submitInfo =
- {
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const vk::VkPipelineStageFlags*)DE_NULL,
- 1, // deUint32 commandBufferCount;
- &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
- VK_CHECK(m_vk.queueSubmit(queue, 1, &submitInfo, DE_NULL));
+ submitCommandsAndWait(m_vk, vkDevice, queue, m_cmdBuffer.get());
// Validation
tcu::TextureLevel refImage (vk::mapVkFormat(m_colorAttachmentFormat), (int)(0.5 + WIDTH), (int)(0.5 + HEIGHT));
generateRefImage(refImage.getAccess(), vertices, colors);
}
- VK_CHECK(m_vk.queueWaitIdle(queue));
-
const vk::VkOffset3D zeroOffset = { 0, 0, 0 };
const tcu::ConstPixelBufferAccess renderedFrame = m_colorTargetImage->readSurface(queue, m_context.getDefaultAllocator(),
vk::VK_IMAGE_LAYOUT_GENERAL, zeroOffset, WIDTH, HEIGHT, vk::VK_IMAGE_ASPECT_COLOR_BIT);
#include "vktDrawBaseClass.hpp"
#include "vkQueryUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "vktTestGroupUtil.hpp"
#include "deDefs.h"
vk.cmdEndRenderPass(*cmdBuffer);
vk.endCommandBuffer(*cmdBuffer);
- VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const VkPipelineStageFlags*)DE_NULL,
- 1, // deUint32 commandBufferCount;
- &cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
-
- VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, DE_NULL));
- VK_CHECK(vk.queueWaitIdle(queue));
+ submitCommandsAndWait(vk, device, queue, cmdBuffer.get());
frames[frameIdx] = colorTargetImages[frameIdx]->readSurface(queue, m_context.getDefaultAllocator(), VK_IMAGE_LAYOUT_GENERAL, zeroOffset, WIDTH, HEIGHT, VK_IMAGE_ASPECT_COLOR_BIT);
}
#include "vkRefUtil.hpp"
#include "vkQueryUtil.hpp"
#include "vkImageUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "vktDrawCreateInfoUtil.hpp"
#include "vktDrawBufferObjectUtil.hpp"
m_vk.cmdCopyImageToBuffer(*copyCmdBuffer, object(), layout, stagingResource->object(), 1, ®ion);
VK_CHECK(m_vk.endCommandBuffer(*copyCmdBuffer));
- vk::VkSubmitInfo submitInfo =
- {
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const vk::VkPipelineStageFlags*)DE_NULL,
- 1, // deUint32 commandBufferCount;
- ©CmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
- m_vk.queueSubmit(queue, 1, &submitInfo, DE_NULL);
-
- // TODO: make this less intrusive
- VK_CHECK(m_vk.queueWaitIdle(queue));
+ submitCommandsAndWait(m_vk, m_device, queue, copyCmdBuffer.get());
}
// Validate the results
m_vk.cmdCopyImage(*copyCmdBuffer, object(), layout, stagingResource->object(), vk::VK_IMAGE_LAYOUT_GENERAL, 1, ®ion);
VK_CHECK(m_vk.endCommandBuffer(*copyCmdBuffer));
- vk::VkSubmitInfo submitInfo =
- {
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const vk::VkPipelineStageFlags*)DE_NULL,
- 1, // deUint32 commandBufferCount;
- ©CmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
- m_vk.queueSubmit(queue, 1, &submitInfo, DE_NULL);
-
- // TODO: make this less intrusive
- VK_CHECK(m_vk.queueWaitIdle(queue));
+ submitCommandsAndWait(m_vk, m_device, queue, copyCmdBuffer.get());
// Validate the results
const vk::Allocation& imgAllocation = stagingResource->getBoundMemory();
vk::VK_IMAGE_LAYOUT_GENERAL, object(), layout, 1, ®ion);
VK_CHECK(m_vk.endCommandBuffer(*copyCmdBuffer));
- vk::VkSubmitInfo submitInfo =
- {
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const vk::VkPipelineStageFlags*)DE_NULL,
- 1, // deUint32 commandBufferCount;
- ©CmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
- m_vk.queueSubmit(queue, 1, &submitInfo, DE_NULL);
-
- // TODO: make this less intrusive
- VK_CHECK(m_vk.queueWaitIdle(queue));
+ submitCommandsAndWait(m_vk, m_device, queue, copyCmdBuffer.get());
}
}
object(), layout, 1, ®ion);
VK_CHECK(m_vk.endCommandBuffer(*copyCmdBuffer));
- vk::VkSubmitInfo submitInfo =
- {
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const vk::VkPipelineStageFlags*)DE_NULL,
- 1, // deUint32 commandBufferCount;
- ©CmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
- m_vk.queueSubmit(queue, 1, &submitInfo, DE_NULL);
-
- // TODO: make this less intrusive
- VK_CHECK(m_vk.queueWaitIdle(queue));
+ submitCommandsAndWait(m_vk, m_device, queue, copyCmdBuffer.get());
}
}
#include "tcuRGBA.hpp"
#include "vkDefs.hpp"
+#include "vkCmdUtil.hpp"
enum
{
tcu::TestStatus DrawIndexed::iterate (void)
{
- tcu::TestLog &log = m_context.getTestContext().getLog();
- const vk::VkQueue queue = m_context.getUniversalQueue();
+ tcu::TestLog& log = m_context.getTestContext().getLog();
+ const vk::VkQueue queue = m_context.getUniversalQueue();
+ const vk::VkDevice device = m_context.getDevice();
beginRenderPass();
m_vk.cmdEndRenderPass(*m_cmdBuffer);
m_vk.endCommandBuffer(*m_cmdBuffer);
- vk::VkSubmitInfo submitInfo =
- {
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const vk::VkPipelineStageFlags*)DE_NULL,
- 1, // deUint32 commandBufferCount;
- &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
-
- VK_CHECK(m_vk.queueSubmit(queue, 1, &submitInfo, DE_NULL));
-
- VK_CHECK(m_vk.queueWaitIdle(queue));
+ submitCommandsAndWait(m_vk, device, queue, m_cmdBuffer.get());
// Validation
tcu::Texture2D referenceFrame(vk::mapVkFormat(m_colorAttachmentFormat), (int)(0.5 + WIDTH), (int)(0.5 + HEIGHT));
tcu::TestStatus DrawInstancedIndexed::iterate (void)
{
- tcu::TestLog &log = m_context.getTestContext().getLog();
- const vk::VkQueue queue = m_context.getUniversalQueue();
+ tcu::TestLog& log = m_context.getTestContext().getLog();
+ const vk::VkQueue queue = m_context.getUniversalQueue();
+ const vk::VkDevice device = m_context.getDevice();
beginRenderPass();
m_vk.cmdEndRenderPass(*m_cmdBuffer);
m_vk.endCommandBuffer(*m_cmdBuffer);
- vk::VkSubmitInfo submitInfo =
- {
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const vk::VkPipelineStageFlags*)DE_NULL,
- 1, // deUint32 commandBufferCount;
- &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
- VK_CHECK(m_vk.queueSubmit(queue, 1, &submitInfo, DE_NULL));
-
- VK_CHECK(m_vk.queueWaitIdle(queue));
+ submitCommandsAndWait(m_vk, device, queue, m_cmdBuffer.get());
// Validation
VK_CHECK(m_vk.queueWaitIdle(queue));
#include "tcuRGBA.hpp"
#include "vkDefs.hpp"
+#include "vkCmdUtil.hpp"
namespace vkt
{
tcu::TestStatus IndirectDraw::iterate (void)
{
- tcu::TestLog &log = m_context.getTestContext().getLog();
- const vk::VkQueue queue = m_context.getUniversalQueue();
+ tcu::TestLog& log = m_context.getTestContext().getLog();
+ const vk::VkQueue queue = m_context.getUniversalQueue();
+ const vk::VkDevice device = m_context.getDevice();
if (m_drawType == DRAW_TYPE_SEQUENTIAL)
{
m_vk.cmdEndRenderPass(*m_cmdBuffer);
m_vk.endCommandBuffer(*m_cmdBuffer);
- vk::VkSubmitInfo submitInfo =
- {
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const vk::VkPipelineStageFlags*)DE_NULL,
- 1, // deUint32 commandBufferCount;
- &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
- VK_CHECK(m_vk.queueSubmit(queue, 1, &submitInfo, DE_NULL));
-
- VK_CHECK(m_vk.queueWaitIdle(queue));
+ submitCommandsAndWait(m_vk, device, queue, m_cmdBuffer.get());
// Validation
tcu::Texture2D referenceFrame(vk::mapVkFormat(m_colorAttachmentFormat), (int)(0.5 + WIDTH), (int)(0.5 + HEIGHT));
template<class FirstInstanceSupport>
tcu::TestStatus IndirectDrawInstanced<FirstInstanceSupport>::iterate (void)
{
- tcu::TestLog &log = m_context.getTestContext().getLog();
- const vk::VkQueue queue = m_context.getUniversalQueue();
+ tcu::TestLog& log = m_context.getTestContext().getLog();
+ const vk::VkQueue queue = m_context.getUniversalQueue();
+ const vk::VkDevice device = m_context.getDevice();
if (m_drawType == DRAW_TYPE_SEQUENTIAL)
{
m_vk.cmdEndRenderPass(*m_cmdBuffer);
m_vk.endCommandBuffer(*m_cmdBuffer);
- vk::VkSubmitInfo submitInfo =
- {
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const vk::VkPipelineStageFlags*)DE_NULL,
- 1, // deUint32 commandBufferCount;
- &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
- VK_CHECK(m_vk.queueSubmit(queue, 1, &submitInfo, DE_NULL));
-
- VK_CHECK(m_vk.queueWaitIdle(queue));
+ submitCommandsAndWait(m_vk, device, queue, m_cmdBuffer.get());
// Validation
VK_CHECK(m_vk.queueWaitIdle(queue));
#include "tcuTextureUtil.hpp"
#include "vkImageUtil.hpp"
#include "vkPrograms.hpp"
+#include "vkCmdUtil.hpp"
#include "vktDrawBufferObjectUtil.hpp"
#include "vktDrawCreateInfoUtil.hpp"
#include "vktDrawImageObjectUtil.hpp"
tcu::TestStatus InstancedDrawInstance::iterate()
{
const vk::VkQueue queue = m_context.getUniversalQueue();
+ const vk::VkDevice device = m_context.getDevice();
static const deUint32 instanceCounts[] = { 0, 1, 2, 4, 20 };
static const deUint32 firstInstanceIndices[] = { 0, 1, 3, 4, 20 };
m_vk.cmdEndRenderPass(*m_cmdBuffer);
m_vk.endCommandBuffer(*m_cmdBuffer);
- vk::VkSubmitInfo submitInfo =
- {
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const vk::VkPipelineStageFlags*)DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask;
- 1, // deUint32 commandBufferCount;
- &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
- VK_CHECK(m_vk.queueSubmit(queue, 1, &submitInfo, DE_NULL));
-
- VK_CHECK(m_vk.queueWaitIdle(queue));
+ submitCommandsAndWait(m_vk, device, queue, m_cmdBuffer.get());
// Reference rendering
std::vector<tcu::Vec4> vetrices;
#include "vkPrograms.hpp"
#include "vkTypeUtil.hpp"
#include "vkImageUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuVector.hpp"
#include "tcuTextureUtil.hpp"
vk.endCommandBuffer(*cmdBuffer);
// Submit
- {
- const Unique<VkFence> fence (createFence(vk, device));
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0, // uint32_t waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const VkPipelineStageFlags*)DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask;
- 1, // uint32_t commandBufferCount;
- &cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0, // uint32_t signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
-
- VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *fence));
- VK_CHECK(vk.waitForFences(device, 1u, &fence.get(), VK_TRUE, ~0ull));
- }
+ submitCommandsAndWait(vk, device, queue, cmdBuffer.get());
// Get result
{
#include "vkTypeUtil.hpp"
#include "vkImageUtil.hpp"
#include "vkQueryUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuVector.hpp"
#include "tcuTextureUtil.hpp"
vk.endCommandBuffer(*cmdBuffer);
// Submit
- {
- const Unique<VkFence> fence (createFence(vk, device));
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0, // uint32_t waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const VkPipelineStageFlags*)DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask;
- 1, // uint32_t commandBufferCount;
- &cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0, // uint32_t signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
-
- VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *fence));
- VK_CHECK(vk.waitForFences(device, 1u, &fence.get(), VK_TRUE, ~0ull));
- }
+ submitCommandsAndWait(vk, device, queue, cmdBuffer.get());
// Get result
{
#include "vktDrawBaseClass.hpp"
#include "vkQueryUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuTestLog.hpp"
#include "tcuImageCompare.hpp"
// Submit
{
const vk::VkQueue queue = m_context.getUniversalQueue();
- const vk::VkSubmitInfo submitInfo =
- {
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const vk::VkPipelineStageFlags*)DE_NULL,
- 1, // deUint32 commandBufferCount;
- &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
- VK_CHECK(m_vk.queueSubmit(queue, 1, &submitInfo, DE_NULL));
- VK_CHECK(m_vk.queueWaitIdle(queue));
+ const vk::VkDevice device = m_context.getDevice();
+
+ submitCommandsAndWait(m_vk, device, queue, m_cmdBuffer.get());
}
// Validate
#include "tcuRGBA.hpp"
#include "vkDefs.hpp"
+#include "vkCmdUtil.hpp"
namespace vkt
{
tcu::TestStatus SimpleDraw::iterate (void)
{
- tcu::TestLog &log = m_context.getTestContext().getLog();
- const vk::VkQueue queue = m_context.getUniversalQueue();
+ tcu::TestLog& log = m_context.getTestContext().getLog();
+ const vk::VkQueue queue = m_context.getUniversalQueue();
+ const vk::VkDevice device = m_context.getDevice();
beginRenderPass();
- const vk::VkDeviceSize vertexBufferOffset = 0;
- const vk::VkBuffer vertexBuffer = m_vertexBuffer->object();
+ const vk::VkDeviceSize vertexBufferOffset = 0;
+ const vk::VkBuffer vertexBuffer = m_vertexBuffer->object();
m_vk.cmdBindVertexBuffers(*m_cmdBuffer, 0, 1, &vertexBuffer, &vertexBufferOffset);
m_vk.cmdBindPipeline(*m_cmdBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, *m_pipeline);
m_vk.cmdEndRenderPass(*m_cmdBuffer);
m_vk.endCommandBuffer(*m_cmdBuffer);
- vk::VkSubmitInfo submitInfo =
- {
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const vk::VkPipelineStageFlags*)DE_NULL,
- 1, // deUint32 commandBufferCount;
- &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
- VK_CHECK(m_vk.queueSubmit(queue, 1, &submitInfo, DE_NULL));
-
- VK_CHECK(m_vk.queueWaitIdle(queue));
+ submitCommandsAndWait(m_vk, device, queue, m_cmdBuffer.get());
// Validation
tcu::Texture2D referenceFrame(vk::mapVkFormat(m_colorAttachmentFormat), (int)(0.5 + WIDTH), (int)(0.5 + HEIGHT));
tcu::TestStatus SimpleDrawInstanced::iterate (void)
{
- tcu::TestLog &log = m_context.getTestContext().getLog();
-
- const vk::VkQueue queue = m_context.getUniversalQueue();
+ tcu::TestLog& log = m_context.getTestContext().getLog();
+ const vk::VkQueue queue = m_context.getUniversalQueue();
+ const vk::VkDevice device = m_context.getDevice();
beginRenderPass();
- const vk::VkDeviceSize vertexBufferOffset = 0;
- const vk::VkBuffer vertexBuffer = m_vertexBuffer->object();
+ const vk::VkDeviceSize vertexBufferOffset = 0;
+ const vk::VkBuffer vertexBuffer = m_vertexBuffer->object();
m_vk.cmdBindVertexBuffers(*m_cmdBuffer, 0, 1, &vertexBuffer, &vertexBufferOffset);
m_vk.cmdEndRenderPass(*m_cmdBuffer);
m_vk.endCommandBuffer(*m_cmdBuffer);
- vk::VkSubmitInfo submitInfo =
- {
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const vk::VkPipelineStageFlags*)DE_NULL,
- 1, // deUint32 commandBufferCount;
- &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
- VK_CHECK(m_vk.queueSubmit(queue, 1, &submitInfo, DE_NULL));
-
- VK_CHECK(m_vk.queueWaitIdle(queue));
+ submitCommandsAndWait(m_vk, device, queue, m_cmdBuffer.get());
// Validation
VK_CHECK(m_vk.queueWaitIdle(queue));
#include "vktDynamicStateTestCaseUtil.hpp"
#include "vkImageUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuImageCompare.hpp"
#include "tcuTextureUtil.hpp"
virtual tcu::TestStatus iterate (void)
{
- tcu::TestLog &log = m_context.getTestContext().getLog();
- const vk::VkQueue queue = m_context.getUniversalQueue();
+ tcu::TestLog& log = m_context.getTestContext().getLog();
+ const vk::VkQueue queue = m_context.getUniversalQueue();
+ const vk::VkDevice device = m_context.getDevice();
const vk::VkClearColorValue clearColor = { { 1.0f, 1.0f, 1.0f, 1.0f } };
beginRenderPassWithClearColor(clearColor);
m_vk.cmdEndRenderPass(*m_cmdBuffer);
m_vk.endCommandBuffer(*m_cmdBuffer);
- vk::VkSubmitInfo submitInfo =
- {
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const vk::VkPipelineStageFlags*)DE_NULL,
- 1, // deUint32 commandBufferCount;
- &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
- m_vk.queueSubmit(queue, 1, &submitInfo, DE_NULL);
- VK_CHECK(m_vk.queueWaitIdle(queue));
+ submitCommandsAndWait(m_vk, device, queue, m_cmdBuffer.get());
//validation
{
#include "vkRefUtil.hpp"
#include "vkImageUtil.hpp"
#include "vkTypeUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "vktDrawCreateInfoUtil.hpp"
#include "vktDrawImageObjectUtil.hpp"
virtual tcu::TestStatus iterate (void)
{
- tcu::TestLog &log = m_context.getTestContext().getLog();
- const vk::VkQueue queue = m_context.getUniversalQueue();
+ tcu::TestLog& log = m_context.getTestContext().getLog();
+ const vk::VkQueue queue = m_context.getUniversalQueue();
+ const vk::VkDevice device = m_context.getDevice();
beginRenderPass();
m_vk.cmdEndRenderPass(*m_cmdBuffer);
m_vk.endCommandBuffer(*m_cmdBuffer);
- vk::VkSubmitInfo submitInfo =
- {
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const vk::VkPipelineStageFlags*)DE_NULL,
- 1, // deUint32 commandBufferCount;
- &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
- m_vk.queueSubmit(queue, 1, &submitInfo, DE_NULL);
+ submitCommandsAndWait(m_vk, device, queue, m_cmdBuffer.get());
// validation
{
- VK_CHECK(m_vk.queueWaitIdle(queue));
-
tcu::Texture2D referenceFrame(vk::mapVkFormat(m_colorAttachmentFormat), (int)(0.5 + WIDTH), (int)(0.5 + HEIGHT));
referenceFrame.allocLevel(0);
m_vk.cmdEndRenderPass(*m_cmdBuffer);
m_vk.endCommandBuffer(*m_cmdBuffer);
- vk::VkSubmitInfo submitInfo =
- {
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const vk::VkPipelineStageFlags*)DE_NULL,
- 1, // deUint32 commandBufferCount;
- &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
- m_vk.queueSubmit(queue, 1, &submitInfo, DE_NULL);
- VK_CHECK(m_vk.queueWaitIdle(queue));
+ submitCommandsAndWait(m_vk, device, queue, m_cmdBuffer.get());
// Validation
{
virtual tcu::TestStatus iterate (void)
{
- tcu::TestLog &log = m_context.getTestContext().getLog();
- const vk::VkQueue queue = m_context.getUniversalQueue();
+ tcu::TestLog& log = m_context.getTestContext().getLog();
+ const vk::VkQueue queue = m_context.getUniversalQueue();
+ const vk::VkDevice device = m_context.getDevice();
beginRenderPass();
m_vk.cmdEndRenderPass(*m_cmdBuffer);
m_vk.endCommandBuffer(*m_cmdBuffer);
- vk::VkSubmitInfo submitInfo =
- {
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const vk::VkPipelineStageFlags*)DE_NULL,
- 1, // deUint32 commandBufferCount;
- &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
- m_vk.queueSubmit(queue, 1, &submitInfo, DE_NULL);
+ submitCommandsAndWait(m_vk, device, queue, m_cmdBuffer.get());
// validation
{
- VK_CHECK(m_vk.queueWaitIdle(queue));
-
tcu::Texture2D referenceFrame(vk::mapVkFormat(m_colorAttachmentFormat), (int)(0.5 + WIDTH), (int)(0.5 + HEIGHT));
referenceFrame.allocLevel(0);
virtual tcu::TestStatus iterate (void)
{
- tcu::TestLog &log = m_context.getTestContext().getLog();
- const vk::VkQueue queue = m_context.getUniversalQueue();
+ tcu::TestLog& log = m_context.getTestContext().getLog();
+ const vk::VkQueue queue = m_context.getUniversalQueue();
+ const vk::VkDevice device = m_context.getDevice();
beginRenderPass();
m_vk.cmdEndRenderPass(*m_cmdBuffer);
m_vk.endCommandBuffer(*m_cmdBuffer);
- vk::VkSubmitInfo submitInfo =
- {
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const vk::VkPipelineStageFlags*)DE_NULL,
- 1, // deUint32 commandBufferCount;
- &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
- m_vk.queueSubmit(queue, 1, &submitInfo, DE_NULL);
+ submitCommandsAndWait(m_vk, device, queue, m_cmdBuffer.get());
// validation
{
- VK_CHECK(m_vk.queueWaitIdle(queue));
-
tcu::Texture2D referenceFrame(vk::mapVkFormat(m_colorAttachmentFormat), (int)(0.5 + WIDTH), (int)(0.5 + HEIGHT));
referenceFrame.allocLevel(0);
#include "tcuRGBA.hpp"
#include "vkDefs.hpp"
+#include "vkCmdUtil.hpp"
namespace vkt
{
virtual tcu::TestStatus iterate (void)
{
- tcu::TestLog& log = m_context.getTestContext().getLog();
- const vk::VkQueue queue = m_context.getUniversalQueue();
+ tcu::TestLog& log = m_context.getTestContext().getLog();
+ const vk::VkQueue queue = m_context.getUniversalQueue();
+ const vk::VkDevice device = m_context.getDevice();
beginRenderPass();
m_vk.cmdEndRenderPass(*m_cmdBuffer);
m_vk.endCommandBuffer(*m_cmdBuffer);
- vk::VkSubmitInfo submitInfo =
- {
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const vk::VkPipelineStageFlags*)DE_NULL,
- 1, // deUint32 commandBufferCount;
- &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
- m_vk.queueSubmit(queue, 1, &submitInfo, DE_NULL);
+ submitCommandsAndWait(m_vk, device, queue, m_cmdBuffer.get());
//validation
- VK_CHECK(m_vk.queueWaitIdle(queue));
-
tcu::Texture2D referenceFrame(vk::mapVkFormat(m_colorAttachmentFormat), (int)(0.5 + WIDTH), (int)(0.5 + HEIGHT));
referenceFrame.allocLevel(0);
virtual tcu::TestStatus iterate (void)
{
- tcu::TestLog &log = m_context.getTestContext().getLog();
- const vk::VkQueue queue = m_context.getUniversalQueue();
+ tcu::TestLog &log = m_context.getTestContext().getLog();
+ const vk::VkQueue queue = m_context.getUniversalQueue();
+ const vk::VkDevice device = m_context.getDevice();
beginRenderPass();
m_vk.cmdEndRenderPass(*m_cmdBuffer);
m_vk.endCommandBuffer(*m_cmdBuffer);
- vk::VkSubmitInfo submitInfo =
- {
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const vk::VkPipelineStageFlags*)DE_NULL,
- 1, // deUint32 commandBufferCount;
- &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
- m_vk.queueSubmit(queue, 1, &submitInfo, DE_NULL);
+ submitCommandsAndWait(m_vk, device, queue, m_cmdBuffer.get());
//validation
- VK_CHECK(m_vk.queueWaitIdle(queue));
-
tcu::Texture2D referenceFrame(vk::mapVkFormat(m_colorAttachmentFormat), (int)(0.5 + WIDTH), (int)(0.5 + HEIGHT));
referenceFrame.allocLevel(0);
virtual tcu::TestStatus iterate(void)
{
- tcu::TestLog &log = m_context.getTestContext().getLog();
- const vk::VkQueue queue = m_context.getUniversalQueue();
+ tcu::TestLog& log = m_context.getTestContext().getLog();
+ const vk::VkQueue queue = m_context.getUniversalQueue();
+ const vk::VkDevice device = m_context.getDevice();
beginRenderPass();
m_vk.cmdEndRenderPass(*m_cmdBuffer);
m_vk.endCommandBuffer(*m_cmdBuffer);
- vk::VkSubmitInfo submitInfo =
- {
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const vk::VkPipelineStageFlags*)DE_NULL,
- 1, // deUint32 commandBufferCount;
- &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
- m_vk.queueSubmit(queue, 1, &submitInfo, DE_NULL);
+ submitCommandsAndWait(m_vk, device, queue, m_cmdBuffer.get());
//validation
- VK_CHECK(m_vk.queueWaitIdle(queue));
-
tcu::Texture2D referenceFrame(vk::mapVkFormat(m_colorAttachmentFormat), (int)(0.5 + WIDTH), (int)(0.5 + HEIGHT));
referenceFrame.allocLevel(0);
#include "vktDynamicStateTestCaseUtil.hpp"
#include "vkImageUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuTextureUtil.hpp"
#include "tcuImageCompare.hpp"
virtual tcu::TestStatus iterate (void)
{
- tcu::TestLog &log = m_context.getTestContext().getLog();
- const vk::VkQueue queue = m_context.getUniversalQueue();
+ tcu::TestLog& log = m_context.getTestContext().getLog();
+ const vk::VkQueue queue = m_context.getUniversalQueue();
+ const vk::VkDevice device = m_context.getDevice();
beginRenderPass();
m_vk.cmdEndRenderPass(*m_cmdBuffer);
m_vk.endCommandBuffer(*m_cmdBuffer);
- vk::VkSubmitInfo submitInfo =
- {
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const vk::VkPipelineStageFlags*)DE_NULL,
- 1, // deUint32 commandBufferCount;
- &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
- m_vk.queueSubmit(queue, 1, &submitInfo, DE_NULL);
+ submitCommandsAndWait(m_vk, device, queue, m_cmdBuffer.get());
// validation
{
virtual tcu::TestStatus iterate (void)
{
- tcu::TestLog &log = m_context.getTestContext().getLog();
- const vk::VkQueue queue = m_context.getUniversalQueue();
+ tcu::TestLog& log = m_context.getTestContext().getLog();
+ const vk::VkQueue queue = m_context.getUniversalQueue();
+ const vk::VkDevice device = m_context.getDevice();
beginRenderPass();
m_vk.cmdEndRenderPass(*m_cmdBuffer);
m_vk.endCommandBuffer(*m_cmdBuffer);
- vk::VkSubmitInfo submitInfo =
- {
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const vk::VkPipelineStageFlags*)DE_NULL,
- 1, // deUint32 commandBufferCount;
- &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
- m_vk.queueSubmit(queue, 1, &submitInfo, DE_NULL);
+ submitCommandsAndWait(m_vk, device, queue, m_cmdBuffer.get());
// validation
{
- VK_CHECK(m_vk.queueWaitIdle(queue));
-
tcu::Texture2D referenceFrame(vk::mapVkFormat(m_colorAttachmentFormat), (int)(0.5 + WIDTH), (int)(0.5 + HEIGHT));
referenceFrame.allocLevel(0);
virtual tcu::TestStatus iterate (void)
{
- tcu::TestLog &log = m_context.getTestContext().getLog();
- const vk::VkQueue queue = m_context.getUniversalQueue();
+ tcu::TestLog& log = m_context.getTestContext().getLog();
+ const vk::VkQueue queue = m_context.getUniversalQueue();
+ const vk::VkDevice device = m_context.getDevice();
beginRenderPass();
m_vk.cmdEndRenderPass(*m_cmdBuffer);
m_vk.endCommandBuffer(*m_cmdBuffer);
- vk::VkSubmitInfo submitInfo =
- {
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const vk::VkPipelineStageFlags*)DE_NULL,
- 1, // deUint32 commandBufferCount;
- &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
- m_vk.queueSubmit(queue, 1, &submitInfo, DE_NULL);
+ submitCommandsAndWait(m_vk, device, queue, m_cmdBuffer.get());
// validation
{
- VK_CHECK(m_vk.queueWaitIdle(queue));
-
tcu::Texture2D referenceFrame(vk::mapVkFormat(m_colorAttachmentFormat), (int)(0.5 + WIDTH), (int)(0.5 + HEIGHT));
referenceFrame.allocLevel(0);
#include "vktDynamicStateTestCaseUtil.hpp"
#include "vkImageUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuTextureUtil.hpp"
#include "tcuImageCompare.hpp"
virtual tcu::TestStatus iterate (void)
{
- tcu::TestLog &log = m_context.getTestContext().getLog();
- const vk::VkQueue queue = m_context.getUniversalQueue();
+ tcu::TestLog& log = m_context.getTestContext().getLog();
+ const vk::VkQueue queue = m_context.getUniversalQueue();
+ const vk::VkDevice device = m_context.getDevice();
beginRenderPass();
m_vk.cmdEndRenderPass(*m_cmdBuffer);
m_vk.endCommandBuffer(*m_cmdBuffer);
- vk::VkSubmitInfo submitInfo =
- {
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const vk::VkPipelineStageFlags*)DE_NULL,
- 1, // deUint32 commandBufferCount;
- &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
- m_vk.queueSubmit(queue, 1, &submitInfo, DE_NULL);
+ submitCommandsAndWait(m_vk, device, queue, m_cmdBuffer.get());
// validation
{
- VK_CHECK(m_vk.queueWaitIdle(queue));
-
tcu::Texture2D referenceFrame = buildReferenceFrame();
const vk::VkOffset3D zeroOffset = { 0, 0, 0 };
}
};
-class ViewportParamTestInstane : public ViewportStateBaseCase
+class ViewportParamTestInstance : public ViewportStateBaseCase
{
public:
- ViewportParamTestInstane (Context& context, ShaderMap shaders)
+ ViewportParamTestInstance (Context& context, ShaderMap shaders)
: ViewportStateBaseCase (context, shaders[glu::SHADERTYPE_VERTEX], shaders[glu::SHADERTYPE_FRAGMENT])
{
ViewportStateBaseCase::initialize();
virtual tcu::TestStatus iterate (void)
{
- tcu::TestLog &log = m_context.getTestContext().getLog();
- const vk::VkQueue queue = m_context.getUniversalQueue();
+ tcu::TestLog& log = m_context.getTestContext().getLog();
+ const vk::VkQueue queue = m_context.getUniversalQueue();
+ const vk::VkDevice device = m_context.getDevice();
beginRenderPass();
m_vk.cmdEndRenderPass(*m_cmdBuffer);
m_vk.endCommandBuffer(*m_cmdBuffer);
- vk::VkSubmitInfo submitInfo =
- {
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const vk::VkPipelineStageFlags*)DE_NULL,
- 1, // deUint32 commandBufferCount;
- &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
- m_vk.queueSubmit(queue, 1, &submitInfo, DE_NULL);
+ submitCommandsAndWait(m_vk, device, queue, m_cmdBuffer.get());
// validation
{
- VK_CHECK(m_vk.queueWaitIdle(queue));
-
tcu::Texture2D referenceFrame(vk::mapVkFormat(m_colorAttachmentFormat), (int)(0.5 + WIDTH), (int)(0.5 + HEIGHT));
referenceFrame.allocLevel(0);
shaderPaths[glu::SHADERTYPE_VERTEX] = "vulkan/dynamic_state/VertexFetch.vert";
shaderPaths[glu::SHADERTYPE_FRAGMENT] = "vulkan/dynamic_state/VertexFetch.frag";
- addChild(new InstanceFactory<ViewportParamTestInstane>(m_testCtx, "viewport", "Set viewport which is twice bigger than screen size", shaderPaths));
+ addChild(new InstanceFactory<ViewportParamTestInstance>(m_testCtx, "viewport", "Set viewport which is twice bigger than screen size", shaderPaths));
addChild(new InstanceFactory<ScissorParamTestInstance>(m_testCtx, "scissor", "Perform a scissor test on 1/4 bottom-left part of the surface", shaderPaths));
shaderPaths[glu::SHADERTYPE_GEOMETRY] = "vulkan/dynamic_state/ViewportArray.geom";
#include "vkTypeUtil.hpp"
#include "vkQueryUtil.hpp"
#include "vkImageUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuTestLog.hpp"
#include "vkTypeUtil.hpp"
#include "vkPrograms.hpp"
#include "vkQueryUtil.hpp"
+#include "vkCmdUtil.hpp"
#include <vector>
namespace vkt
VK_CHECK(vk.beginCommandBuffer(commandBuffer, &info));
}
-void submitCommandsAndWait (const DeviceInterface& vk,
- const VkDevice device,
- const VkQueue queue,
- const VkCommandBuffer commandBuffer)
-{
- const Unique<VkFence> fence(createFence(vk, device));
-
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // uint32_t waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask;
- 1u, // uint32_t commandBufferCount;
- &commandBuffer, // const VkCommandBuffer* pCommandBuffers;
- 0u, // uint32_t signalSemaphoreCount;
- DE_NULL, // const VkSemaphore* pSignalSemaphores;
- };
- VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
- VK_CHECK(vk.waitForFences(device, 1u, &fence.get(), DE_TRUE, ~0ull));
-}
-
Move<VkFramebuffer> makeFramebuffer (const DeviceInterface& vk,
const VkDevice device,
const VkRenderPass renderPass,
de::MovePtr<vk::Allocation> bindImage (const vk::DeviceInterface& vk, const vk::VkDevice device, vk::Allocator& allocator, const vk::VkImage image, const vk::MemoryRequirement requirement);
de::MovePtr<vk::Allocation> bindBuffer (const vk::DeviceInterface& vk, const vk::VkDevice device, vk::Allocator& allocator, const vk::VkBuffer buffer, const vk::MemoryRequirement requirement);
void beginCommandBuffer (const vk::DeviceInterface& vk, const vk::VkCommandBuffer commandBuffer);
-void submitCommandsAndWait (const vk::DeviceInterface& vk, const vk::VkDevice device, const vk::VkQueue queue, const vk::VkCommandBuffer commandBuffer);
inline vk::Move<vk::VkBuffer> makeBuffer (const vk::DeviceInterface& vk, const vk::VkDevice device, const vk::VkBufferCreateInfo& createInfo)
{
#include "vkPrograms.hpp"
#include "vkImageUtil.hpp"
#include "vkQueryUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuTestLog.hpp"
#include "tcuVector.hpp"
#include "vkMemUtil.hpp"
#include "vkPrograms.hpp"
#include "vkImageUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuTestLog.hpp"
#include "tcuVector.hpp"
#include "vkRefUtil.hpp"
#include "vkQueryUtil.hpp"
#include "vkMemUtil.hpp"
+#include "vkCmdUtil.hpp"
#include <string>
#include "vkBuilderUtil.hpp"
#include "vkRefUtil.hpp"
#include "vkQueryUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "vkMemUtil.hpp"
#include "tcuTextureUtil.hpp"
vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &postImageBarrier);
VK_CHECK(vk.endCommandBuffer(*cmdBuffer));
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask;
- 1u, // deUint32 commandBufferCount;
- &cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0u, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
-
- VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *fence));
- VK_CHECK(vk.waitForFences(device, 1, &fence.get(), true, ~(0ull) /* infinity */));
+ submitCommandsAndWait(vk, device, queue, cmdBuffer.get());
}
class GeometryOutputCountTestInstance : public GeometryExpanderRenderTestInstance
#include "vkRefUtil.hpp"
#include "vkTypeUtil.hpp"
#include "vkImageUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuTextureUtil.hpp"
#include "tcuImageCompare.hpp"
#include "vkTypeUtil.hpp"
#include "vkImageUtil.hpp"
#include "vkBuilderUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "deStringUtil.hpp"
#include "deUniquePtr.hpp"
VK_CHECK(vk.endCommandBuffer(commandBuffer));
}
-void submitCommandsAndWait (const DeviceInterface& vk,
- const VkDevice device,
- const VkQueue queue,
- const VkCommandBuffer commandBuffer)
-{
- const Unique<VkFence> fence(createFence(vk, device));
-
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // uint32_t waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask;
- 1u, // uint32_t commandBufferCount;
- &commandBuffer, // const VkCommandBuffer* pCommandBuffers;
- 0u, // uint32_t signalSemaphoreCount;
- DE_NULL, // const VkSemaphore* pSignalSemaphores;
- };
- VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
- VK_CHECK(vk.waitForFences(device, 1u, &fence.get(), DE_TRUE, ~0ull));
-}
-
bool compareWithFileImage (Context& context, const tcu::ConstPixelBufferAccess& resultImage, std::string testName)
{
tcu::TextureLevel referenceImage;
void endRenderPass (const vk::DeviceInterface& vk, const vk::VkCommandBuffer commandBuffer);
void beginCommandBuffer (const vk::DeviceInterface& vk, const vk::VkCommandBuffer commandBuffer);
void endCommandBuffer (const vk::DeviceInterface& vk, const vk::VkCommandBuffer commandBuffer);
-void submitCommandsAndWait (const vk::DeviceInterface& vk, const vk::VkDevice device, const vk::VkQueue queue, const vk::VkCommandBuffer commandBuffer);
bool compareWithFileImage (Context& context, const tcu::ConstPixelBufferAccess& resultImage, std::string name);
#include "vkRef.hpp"
#include "vkRefUtil.hpp"
#include "vkTypeUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuTextureUtil.hpp"
#include "tcuTexture.hpp"
#include "vkRefUtil.hpp"
#include "vkTypeUtil.hpp"
#include "vkQueryUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuTextureUtil.hpp"
#include "tcuTexture.hpp"
#include "vkBuilderUtil.hpp"
#include "vkQueryUtil.hpp"
#include "vkImageUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "deUniquePtr.hpp"
#include "deSharedPtr.hpp"
#include "vkBuilderUtil.hpp"
#include "vkQueryUtil.hpp"
#include "vkImageUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "deUniquePtr.hpp"
#include "vkBuilderUtil.hpp"
#include "vkQueryUtil.hpp"
#include "vkImageUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "deUniquePtr.hpp"
#include "deSharedPtr.hpp"
#include "vkBuilderUtil.hpp"
#include "vkQueryUtil.hpp"
#include "vkTypeUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "deDefs.hpp"
#include "deStringUtil.hpp"
#include "vkMemUtil.hpp"
#include "vkBuilderUtil.hpp"
#include "vkImageUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "deUniquePtr.hpp"
#include "deStringUtil.hpp"
VK_CHECK(vk.endCommandBuffer(commandBuffer));
}
-void submitCommandsAndWait (const DeviceInterface& vk,
- const VkDevice device,
- const VkQueue queue,
- const VkCommandBuffer commandBuffer)
-{
- const Unique<VkFence> fence(createFence(vk, device));
-
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const VkPipelineStageFlags*)DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask;
- 1u, // deUint32 commandBufferCount;
- &commandBuffer, // const VkCommandBuffer* pCommandBuffers;
- 0u, // deUint32 signalSemaphoreCount;
- DE_NULL, // const VkSemaphore* pSignalSemaphores;
- };
-
- VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
- VK_CHECK(vk.waitForFences(device, 1u, &fence.get(), DE_TRUE, ~0ull));
-}
-
tcu::UVec3 getCompressedImageResolutionInBlocks (const vk::VkFormat format, const tcu::UVec3& size)
{
deUint32 blockWidth = getBlockWidth(format);
void endCommandBuffer (const vk::DeviceInterface& vk,
const vk::VkCommandBuffer cmdBuffer);
-void submitCommandsAndWait (const vk::DeviceInterface& vk,
- const vk::VkDevice device,
- const vk::VkQueue queue,
- const vk::VkCommandBuffer cmdBuffer);
-
inline vk::VkDeviceSize getImageSizeBytes (const tcu::IVec3& imageSize, const vk::VkFormat format)
{
return tcu::getPixelSize(vk::mapVkFormat(format)) * imageSize.x() * imageSize.y() * imageSize.z();
#include "vkRefUtil.hpp"
#include "vkTypeUtil.hpp"
#include "vkQueryUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuTextureUtil.hpp"
#include "tcuTexture.hpp"
#include "deSharedPtr.hpp"
#include "vktTestCase.hpp"
#include "vkTypeUtil.hpp"
+#include "vkCmdUtil.hpp"
#include <algorithm>
return cmdBufferBeginInfo;
}
-const VkSubmitInfo makeSubmitInfo (const VkCommandBuffer& commandBuffer)
-{
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const VkPipelineStageFlags*)DE_NULL, // const VkPipelineStageFlags* flags;
- 1u, // deUint32 commandBufferCount;
- &commandBuffer, // const VkCommandBuffer* pCommandBuffers;
- 0u, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
- return submitInfo;
-}
-
Move<VkCommandBuffer> createCommandBuffer (const DeviceInterface& vk,
VkDevice device,
VkCommandPool commandPool)
vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &dstBufferBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
VK_CHECK(vk.endCommandBuffer(*cmdBuffer));
- const VkSubmitInfo submitInfo = makeSubmitInfo(*cmdBuffer);
- Move<VkFence> fence = createFence(vk, vkDevice);
-
- VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *fence));
- VK_CHECK(vk.waitForFences(vkDevice, 1, &*fence, DE_TRUE, ~(0ull)));
+ submitCommandsAndWait(vk, vkDevice, queue, *cmdBuffer);
}
template <>
vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &dstImageBarrier);
VK_CHECK(vk.endCommandBuffer(*cmdBuffer));
- const VkSubmitInfo submitInfo = makeSubmitInfo(*cmdBuffer);
- Move<VkFence> fence = createFence(vk, vkDevice);
-
- VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *fence));
- VK_CHECK(vk.waitForFences(vkDevice, 1, &*fence, DE_TRUE, ~(0ull)));
+ submitCommandsAndWait(vk, vkDevice, queue, *cmdBuffer);
}
template <typename TTarget>
vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT | VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &dstBufferBarrier, 1, &postImageBarrier);
VK_CHECK(vk.endCommandBuffer(*cmdBuffer));
- const VkSubmitInfo submitInfo = makeSubmitInfo(*cmdBuffer);
- Move<VkFence> fence = createFence(vk, vkDevice);
-
- VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *fence));
- VK_CHECK(vk.waitForFences(vkDevice, 1, &*fence, DE_TRUE, ~(0ull)));
+ submitCommandsAndWait(vk, vkDevice, queue, *cmdBuffer);
}
void createBuffer (Move<VkBuffer>& buffer,
#include "vkMemUtil.hpp"
#include "vkTypeUtil.hpp"
#include "vkPrograms.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuMaybe.hpp"
#include "tcuTextureUtil.hpp"
TCU_FAIL("Failed to allocate memory for image");
}
-void queueRun (const vk::DeviceInterface& vkd,
- vk::VkQueue queue,
- vk::VkCommandBuffer commandBuffer)
-{
- const vk::VkSubmitInfo submitInfo =
- {
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO,
- DE_NULL,
-
- 0,
- DE_NULL,
- (const vk::VkPipelineStageFlags*)DE_NULL,
-
- 1,
- &commandBuffer,
-
- 0,
- DE_NULL
- };
-
- VK_CHECK(vkd.queueSubmit(queue, 1, &submitInfo, 0));
- VK_CHECK(vkd.queueWaitIdle(queue));
-}
-
void* mapMemory (const vk::DeviceInterface& vkd,
vk::VkDevice device,
vk::VkDeviceMemory memory,
vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_HOST_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 1, &barrier, 0, (const vk::VkImageMemoryBarrier*)DE_NULL);
VK_CHECK(vkd.endCommandBuffer(*commandBuffer));
- queueRun(vkd, queue, *commandBuffer);
+ submitCommandsAndWait(vkd, device, queue, *commandBuffer);
{
void* const ptr = mapMemory(vkd, device, *m_memory, m_bufferSize);
vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 0, (const vk::VkBufferMemoryBarrier*)DE_NULL, 1, &barrier);
VK_CHECK(vkd.endCommandBuffer(*commandBuffer));
- queueRun(vkd, queue, *commandBuffer);
+ submitCommandsAndWait(vkd, device, queue, *commandBuffer);
}
}
}
VK_CHECK(vkd.endCommandBuffer(*commandBuffer));
- queueRun(vkd, queue, *commandBuffer);
+ submitCommandsAndWait(vkd, device, queue, *commandBuffer);
{
void* const ptr = mapMemory(vkd, device, *memory, 4 * m_imageWidth * m_imageHeight);
vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 0, (const vk::VkBufferMemoryBarrier*)DE_NULL, 1, &postImageBarrier);
VK_CHECK(vkd.endCommandBuffer(*commandBuffer));
- queueRun(vkd, queue, *commandBuffer);
+ submitCommandsAndWait(vkd, device, queue, *commandBuffer);
}
}
vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_HOST_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 1, &barrier, 0, (const vk::VkImageMemoryBarrier*)DE_NULL);
VK_CHECK(vkd.endCommandBuffer(*commandBuffer));
- queueRun(vkd, queue, *commandBuffer);
+ submitCommandsAndWait(vkd, device, queue, *commandBuffer);
reference.setUndefined(0, (size_t)m_imageMemorySize);
{
vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 0, (const vk::VkBufferMemoryBarrier*)DE_NULL, 1, &postImageBarrier);
VK_CHECK(vkd.endCommandBuffer(*commandBuffer));
- queueRun(vkd, queue, *commandBuffer);
+ submitCommandsAndWait(vkd, device, queue, *commandBuffer);
}
}
vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 0, (const vk::VkBufferMemoryBarrier*)DE_NULL, 1, &barrier);
VK_CHECK(vkd.endCommandBuffer(*commandBuffer));
- queueRun(vkd, queue, *commandBuffer);
+ submitCommandsAndWait(vkd, device, queue, *commandBuffer);
}
}
}
VK_CHECK(vkd.endCommandBuffer(*commandBuffer));
- queueRun(vkd, queue, *commandBuffer);
+ submitCommandsAndWait(vkd, device, queue, *commandBuffer);
{
void* const ptr = mapMemory(vkd, device, *memory, 4 * m_imageWidth * m_imageHeight);
vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 0, (const vk::VkBufferMemoryBarrier*)DE_NULL, 1, &postImageBarrier);
VK_CHECK(vkd.endCommandBuffer(*commandBuffer));
- queueRun(vkd, queue, *commandBuffer);
+ submitCommandsAndWait(vkd, device, queue, *commandBuffer);
}
}
vkd.cmdPipelineBarrier(*commandBuffer, vk::VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, (vk::VkDependencyFlags)0, 0, (const vk::VkMemoryBarrier*)DE_NULL, 0, (const vk::VkBufferMemoryBarrier*)DE_NULL, 1, &barrier);
VK_CHECK(vkd.endCommandBuffer(*commandBuffer));
- queueRun(vkd, queue, *commandBuffer);
+ submitCommandsAndWait(vkd, device, queue, *commandBuffer);
}
}
}
VK_CHECK(vkd.endCommandBuffer(*commandBuffer));
- queueRun(vkd, queue, *commandBuffer);
+ submitCommandsAndWait(vkd, device, queue, *commandBuffer);
{
void* const ptr = mapMemory(vkd, device, *memory, 4 * m_dstImageWidth * m_dstImageHeight);
}
VK_CHECK(vkd.endCommandBuffer(*commandBuffer));
- queueRun(vkd, queue, *commandBuffer);
+ submitCommandsAndWait(vkd, device, queue, *commandBuffer);
{
void* const ptr = mapMemory(vkd, device, *memory, 4 * m_targetWidth * m_targetHeight);
#include "vkPlatform.hpp"
#include "vkMemUtil.hpp"
#include "vkImageUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuTestLog.hpp"
#include "tcuResource.hpp"
1u, &barrier);
}
-void submitCommandsAndWait (const DeviceInterface& vk,
- const VkDevice device,
- const VkQueue queue,
- const VkCommandBuffer commandBuffer)
-{
- const VkFenceCreateInfo fenceInfo =
- {
- VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- (VkFenceCreateFlags)0, // VkFenceCreateFlags flags;
- };
- const Unique<VkFence> fence (createFence(vk, device, &fenceInfo));
-
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // uint32_t waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask;
- 1u, // uint32_t commandBufferCount;
- &commandBuffer, // const VkCommandBuffer* pCommandBuffers;
- 0u, // uint32_t signalSemaphoreCount;
- DE_NULL, // const VkSemaphore* pSignalSemaphores;
- };
- VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
- VK_CHECK(vk.waitForFences(device, 1u, &fence.get(), DE_TRUE, ~0ull));
-}
-
} // MultiView
} // vkt
void beginCommandBuffer (const vk::DeviceInterface& vk, const vk::VkCommandBuffer commandBuffer);
void beginSecondaryCommandBuffer (const vk::DeviceInterface& vk, const vk::VkCommandBuffer commandBuffer, const vk::VkRenderPass renderPass, const deUint32 subpass, const vk::VkFramebuffer framebuffer);
void imageBarrier (const vk::DeviceInterface& vk, const vk::VkCommandBuffer cmdBuffer, const vk::VkImage image, const vk::VkImageSubresourceRange subresourceRange, const vk::VkImageLayout oldLayout, const vk::VkImageLayout newLayout, const vk::VkAccessFlags srcAccessMask, const vk::VkAccessFlags dstAccessMask, const vk::VkPipelineStageFlags srcStageMask = vk::VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, const vk::VkPipelineStageFlags dstStageMask = vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT);
-void submitCommandsAndWait (const vk::DeviceInterface& vk, const vk::VkDevice device, const vk::VkQueue queue, const vk::VkCommandBuffer commandBuffer);
} // MultiView
} // vkt
#include "vkQueryUtil.hpp"
#include "vkRef.hpp"
#include "vkRefUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuImageCompare.hpp"
#include "tcuPlatform.hpp"
#include "tcuTextureUtil.hpp"
Move<VkCommandPool> m_cmdPool;
Move<VkCommandBuffer> m_cmdBuffer;
-
- Move<VkFence> m_fence;
};
vk.cmdEndRenderPass(*m_cmdBuffer);
VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
}
-
- // Create fence
- m_fence = createFence(vk, vkDevice);
}
BlendTestInstance::~BlendTestInstance (void)
const DeviceInterface& vk = m_context.getDeviceInterface();
const VkDevice vkDevice = m_context.getDevice();
const VkQueue queue = m_context.getUniversalQueue();
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const VkPipelineStageFlags*)DE_NULL,
- 1u, // deUint32 commandBufferCount;
- &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0u, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
- VK_CHECK(vk.resetFences(vkDevice, 1, &m_fence.get()));
- VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *m_fence));
- VK_CHECK(vk.waitForFences(vkDevice, 1, &m_fence.get(), true, ~(0ull) /* infinity */));
+ submitCommandsAndWait(vk, vkDevice, queue, m_cmdBuffer.get());
return verifyImage();
}
#include "vkQueryUtil.hpp"
#include "vkRef.hpp"
#include "vkRefUtil.hpp"
+#include "vkTypeUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuImageCompare.hpp"
#include "deUniquePtr.hpp"
#include "deMemory.h"
-#include "vkTypeUtil.hpp"
#include <sstream>
#include <vector>
Move<VkCommandPool> m_cmdPool;
Move<VkCommandBuffer> m_cmdBuffer;
- Move<VkFence> m_fence;
Move<VkPipelineCache> m_cache;
};
// Create command buffer
m_cmdBuffer = allocateCommandBuffer(vk, vkDevice, *m_cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
- // Create fence
- m_fence = createFence(vk, vkDevice);
-
// Create the Pipeline Cache
{
const VkPipelineCacheCreateInfo pipelineCacheCreateInfo =
prepareCommandBuffer();
- VK_CHECK(vk.resetFences(vkDevice, 1u, &m_fence.get()));
-
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const VkPipelineStageFlags*)DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask;
- 1u, // deUint32 commandBufferCount;
- &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0u, // deUint32 signalSemaphoreCount;
- DE_NULL, // const VkSemaphore* pSignalSemaphores;
- };
- VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *m_fence));
-
- VK_CHECK(vk.waitForFences(vkDevice, 1u, &m_fence.get(), true, ~(0ull) /* infinity*/));
+ submitCommandsAndWait(vk, vkDevice, queue, m_cmdBuffer.get());
return verifyTestResult();
}
#include "vkRef.hpp"
#include "vkRefUtil.hpp"
#include "vkTypeUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuImageCompare.hpp"
#include "deUniquePtr.hpp"
#include "deStringUtil.hpp"
Move<VkCommandPool> m_cmdPool;
Move<VkCommandBuffer> m_cmdBuffer;
-
- Move<VkFence> m_fence;
};
const float DepthTest::quadDepths[QUAD_COUNT] =
vk.cmdEndRenderPass(*m_cmdBuffer);
VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
}
-
- // Create fence
- m_fence = createFence(vk, vkDevice);
}
DepthTestInstance::~DepthTestInstance (void)
const DeviceInterface& vk = m_context.getDeviceInterface();
const VkDevice vkDevice = m_context.getDevice();
const VkQueue queue = m_context.getUniversalQueue();
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const VkPipelineStageFlags*)DE_NULL,
- 1u, // deUint32 commandBufferCount;
- &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0u, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
- VK_CHECK(vk.resetFences(vkDevice, 1, &m_fence.get()));
- VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *m_fence));
- VK_CHECK(vk.waitForFences(vkDevice, 1, &m_fence.get(), true, ~(0ull) /* infinity*/));
+ submitCommandsAndWait(vk, vkDevice, queue, m_cmdBuffer.get());
return verifyImage();
}
#include "vkBuilderUtil.hpp"
#include "vkPrograms.hpp"
#include "vkImageUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuTextureUtil.hpp"
#include "tcuImageCompare.hpp"
#include "vkPrograms.hpp"
#include "vkQueryUtil.hpp"
#include "vkRefUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuTexLookupVerifier.hpp"
#include "tcuTextureUtil.hpp"
#include "tcuTestLog.hpp"
vk.cmdEndRenderPass(*m_cmdBuffer);
VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
}
-
- // Create fence
- m_fence = createFence(vk, vkDevice);
}
ImageSamplingInstance::~ImageSamplingInstance (void)
const DeviceInterface& vk = m_context.getDeviceInterface();
const VkDevice vkDevice = m_context.getDevice();
const VkQueue queue = m_context.getUniversalQueue();
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- DE_NULL,
- 1u, // deUint32 commandBufferCount;
- &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0u, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
- VK_CHECK(vk.resetFences(vkDevice, 1, &m_fence.get()));
- VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *m_fence));
- VK_CHECK(vk.waitForFences(vkDevice, 1, &m_fence.get(), true, ~(0ull) /* infinity */));
+ submitCommandsAndWait(vk, vkDevice, queue, m_cmdBuffer.get());
return verifyImage();
}
vk::Move<vk::VkCommandPool> m_cmdPool;
vk::Move<vk::VkCommandBuffer> m_cmdBuffer;
-
- vk::Move<vk::VkFence> m_fence;
};
} // pipeline
#include "vkMemUtil.hpp"
#include "vkQueryUtil.hpp"
#include "vkRefUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuTextureUtil.hpp"
#include "tcuAstcUtil.hpp"
#include "deRandom.hpp"
vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &bufferBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
VK_CHECK(vk.endCommandBuffer(*cmdBuffer));
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- DE_NULL,
- 1u, // deUint32 commandBufferCount;
- &cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0u, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
-
- VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *fence));
- VK_CHECK(vk.waitForFences(device, 1, &fence.get(), 0, ~(0ull) /* infinity */));
+ submitCommandsAndWait(vk, device, queue, cmdBuffer.get());
// Read buffer data
invalidateMappedMemoryRange(vk, device, bufferAlloc->getMemory(), bufferAlloc->getOffset(), VK_WHOLE_SIZE);
de::MovePtr<Allocation> bufferAlloc;
Move<VkCommandPool> cmdPool;
Move<VkCommandBuffer> cmdBuffer;
- Move<VkFence> fence;
const VkImageAspectFlags imageAspectFlags = getImageAspectFlags(format);
deUint32 stencilOffset = 0u;
cmdPool = createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, queueFamilyIndex);
cmdBuffer = allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
- // Create fence
- fence = createFence(vk, device);
-
// Barriers for copying buffer to image
const VkBufferMemoryBarrier preBufferBarrier =
{
VK_CHECK(vk.endCommandBuffer(*cmdBuffer));
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- DE_NULL,
- 1u, // deUint32 commandBufferCount;
- &cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0u, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
-
- VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *fence));
- VK_CHECK(vk.waitForFences(device, 1, &fence.get(), true, ~(0ull) /* infinity */));
+ submitCommandsAndWait(vk, device, queue, cmdBuffer.get());
}
bool checkSparseImageFormatSupport (const VkPhysicalDevice physicalDevice,
#include "vkQueryUtil.hpp"
#include "vkRef.hpp"
#include "vkRefUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuImageCompare.hpp"
#include "deMath.h"
#include "deMemory.h"
Move<VkCommandPool> m_cmdPool;
Move<VkCommandBuffer> m_cmdBuffer;
-
- Move<VkFence> m_fence;
};
vk.cmdEndRenderPass(*m_cmdBuffer);
VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
}
-
- // Create fence
- m_fence = createFence(vk, vkDevice);
}
InputAssemblyInstance::~InputAssemblyInstance (void)
const DeviceInterface& vk = m_context.getDeviceInterface();
const VkDevice vkDevice = m_context.getDevice();
const VkQueue queue = m_context.getUniversalQueue();
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const VkPipelineStageFlags*)DE_NULL,
- 1u, // deUint32 commandBufferCount;
- &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0u, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
- VK_CHECK(vk.resetFences(vkDevice, 1, &m_fence.get()));
- VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *m_fence));
- VK_CHECK(vk.waitForFences(vkDevice, 1, &m_fence.get(), true, ~(0ull) /* infinity*/));
+ submitCommandsAndWait(vk, vkDevice, queue, m_cmdBuffer.get());
return verifyImage();
}
VK_CHECK(vk.beginCommandBuffer(commandBuffer, &info));
}
-void submitCommandsAndWait (const DeviceInterface& vk,
- const VkDevice device,
- const VkQueue queue,
- const VkCommandBuffer commandBuffer)
-{
- const Unique<VkFence> fence(createFence(vk, device));
-
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // uint32_t waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask;
- 1u, // uint32_t commandBufferCount;
- &commandBuffer, // const VkCommandBuffer* pCommandBuffers;
- 0u, // uint32_t signalSemaphoreCount;
- DE_NULL, // const VkSemaphore* pSignalSemaphores;
- };
- VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
- VK_CHECK(vk.waitForFences(device, 1u, &fence.get(), DE_TRUE, ~0ull));
-}
-
Move<VkFramebuffer> makeFramebuffer (const DeviceInterface& vk,
const VkDevice device,
const VkRenderPass renderPass,
de::MovePtr<vk::Allocation> bindImageDedicated (const vk::InstanceInterface& vki, const vk::DeviceInterface& vkd, const vk::VkPhysicalDevice physDevice, const vk::VkDevice device, const vk::VkImage image, const vk::MemoryRequirement requirement);
de::MovePtr<vk::Allocation> bindBufferDedicated (const vk::InstanceInterface& vki, const vk::DeviceInterface& vkd, const vk::VkPhysicalDevice physDevice, const vk::VkDevice device, const vk::VkBuffer buffer, const vk::MemoryRequirement requirement);
void beginCommandBuffer (const vk::DeviceInterface& vk, const vk::VkCommandBuffer commandBuffer);
-void submitCommandsAndWait (const vk::DeviceInterface& vk, const vk::VkDevice device, const vk::VkQueue queue, const vk::VkCommandBuffer commandBuffer);
} // pipeline
} // vkt
#include "vktPipelineMakeUtil.hpp"
#include "vkBuilderUtil.hpp"
#include "vkQueryUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuTestLog.hpp"
#include <vector>
#include "vktPipelineMakeUtil.hpp"
#include "vkBuilderUtil.hpp"
#include "vkQueryUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuTestLog.hpp"
#include <vector>
#include "vkBuilderUtil.hpp"
#include "vkPrograms.hpp"
#include "vkImageUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuTextureUtil.hpp"
#include "tcuTestLog.hpp"
#include "vkBuilderUtil.hpp"
#include "vkPrograms.hpp"
#include "vkImageUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "deUniquePtr.hpp"
#include "deRandom.hpp"
#include "vkMemUtil.hpp"
#include "vkPrograms.hpp"
#include "vkQueryUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "vkRef.hpp"
#include "vkRefUtil.hpp"
#include "tcuImageCompare.hpp"
Move<VkCommandPool> m_cmdPool;
Move<VkCommandBuffer> m_cmdBuffer;
- Move<VkFence> m_fence;
-
std::vector<de::SharedPtr<Allocation> > m_allocations;
ImageBackingMode m_backingMode;
VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
}
-
- // Create fence
- m_fence = createFence(vk, vkDevice);
}
MultisampleRenderer::~MultisampleRenderer (void)
const VkDevice vkDevice = m_context.getDevice();
const VkQueue queue = m_context.getUniversalQueue();
const deUint32 queueFamilyIndex = m_context.getUniversalQueueFamilyIndex();
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const VkPipelineStageFlags*)DE_NULL,
- 1u, // deUint32 commandBufferCount;
- &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0u, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
- VK_CHECK(vk.resetFences(vkDevice, 1, &m_fence.get()));
- VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *m_fence));
- VK_CHECK(vk.waitForFences(vkDevice, 1, &m_fence.get(), true, ~(0ull) /* infinity*/));
+ submitCommandsAndWait(vk, vkDevice, queue, m_cmdBuffer.get());
if (m_renderType == RENDER_TYPE_RESOLVE)
{
#include "vkRefUtil.hpp"
#include "vkBuilderUtil.hpp"
#include "vkTypeUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuImageCompare.hpp"
#include "deMemory.h"
#include "deRandom.hpp"
Move<VkCommandPool> m_cmdPool;
Move<VkCommandBuffer> m_cmdBuffer;
-
- Move<VkFence> m_fence;
};
PushConstantGraphicsTest::PushConstantGraphicsTest (tcu::TestContext& testContext,
vk.cmdEndRenderPass(*m_cmdBuffer);
VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
}
-
- // Create fence
- m_fence = createFence(vk, vkDevice);
}
PushConstantGraphicsTestInstance::~PushConstantGraphicsTestInstance (void)
const DeviceInterface& vk = m_context.getDeviceInterface();
const VkDevice vkDevice = m_context.getDevice();
const VkQueue queue = m_context.getUniversalQueue();
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const VkPipelineStageFlags*)DE_NULL,
- 1u, // deUint32 commandBufferCount;
- &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0u, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
- VK_CHECK(vk.resetFences(vkDevice, 1, &m_fence.get()));
- VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *m_fence));
- VK_CHECK(vk.waitForFences(vkDevice, 1, &m_fence.get(), true, ~(0ull) /* infinity*/));
+ submitCommandsAndWait(vk, vkDevice, queue, m_cmdBuffer.get());
return verifyImage();
}
Move<VkCommandPool> m_cmdPool;
Move<VkCommandBuffer> m_cmdBuffer;
-
- Move<VkFence> m_fence;
};
PushConstantComputeTest::PushConstantComputeTest (tcu::TestContext& testContext,
VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
}
-
- // Create fence
- m_fence = createFence(vk, vkDevice);
}
PushConstantComputeTestInstance::~PushConstantComputeTestInstance (void)
const DeviceInterface& vk = m_context.getDeviceInterface();
const VkDevice vkDevice = m_context.getDevice();
const VkQueue queue = m_context.getUniversalQueue();
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const VkPipelineStageFlags*)DE_NULL,
- 1u, // deUint32 commandBufferCount;
- &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0u, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
- VK_CHECK(vk.resetFences(vkDevice, 1, &m_fence.get()));
- VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *m_fence));
- VK_CHECK(vk.waitForFences(vkDevice, 1, &m_fence.get(), true, ~(0ull) /* infinity*/));
+ submitCommandsAndWait(vk, vkDevice, queue, m_cmdBuffer.get());
invalidateMappedMemoryRange(vk, vkDevice, m_outBufferAlloc->getMemory(), m_outBufferAlloc->getOffset(), (size_t)(sizeof(tcu::Vec4) * 8));
#include "vkBuilderUtil.hpp"
#include "vkPrograms.hpp"
#include "vkImageUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuTextureUtil.hpp"
#include "tcuImageCompare.hpp"
#include "vkRefUtil.hpp"
#include "vkTypeUtil.hpp"
#include "vkImageUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "deUniquePtr.hpp"
#include "deStringUtil.hpp"
#include "vkRef.hpp"
#include "vkRefUtil.hpp"
#include "vkTypeUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuImageCompare.hpp"
#include "deMemory.h"
#include "deRandom.hpp"
Move<VkCommandPool> m_cmdPool;
Move<VkCommandBuffer> m_cmdBuffer;
-
- Move<VkFence> m_fence;
};
const VkStencilOp stencilOps[] =
vk.cmdEndRenderPass(*m_cmdBuffer);
VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
}
-
- // Create fence
- m_fence = createFence(vk, vkDevice);
}
StencilTestInstance::~StencilTestInstance (void)
const DeviceInterface& vk = m_context.getDeviceInterface();
const VkDevice vkDevice = m_context.getDevice();
const VkQueue queue = m_context.getUniversalQueue();
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const VkPipelineStageFlags*)DE_NULL,
- 1u, // deUint32 commandBufferCount;
- &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0u, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
- VK_CHECK(vk.resetFences(vkDevice, 1, &m_fence.get()));
- VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *m_fence));
- VK_CHECK(vk.waitForFences(vkDevice, 1, &m_fence.get(), true, ~(0ull) /* infinity*/));
+ submitCommandsAndWait(vk, vkDevice, queue, m_cmdBuffer.get());
return verifyImage();
}
#include "vkQueryUtil.hpp"
#include "vkRef.hpp"
#include "vkRefUtil.hpp"
+#include "vkTypeUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuImageCompare.hpp"
#include "deUniquePtr.hpp"
#include "deStringUtil.hpp"
#include "deMemory.h"
-#include "vkTypeUtil.hpp"
#include <sstream>
#include <vector>
Move<VkCommandPool> m_cmdPool;
Move<VkCommandBuffer> m_cmdBuffer;
- Move<VkFence> m_fence;
Move<VkQueryPool> m_queryPool;
deUint64* m_timestampValues;
};
// Create command buffer
m_cmdBuffer = allocateCommandBuffer(vk, vkDevice, *m_cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
- // Create fence
- {
- const VkFenceCreateInfo fenceParams =
- {
- VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // VkFenceCreateFlags flags;
- };
-
- m_fence = createFence(vk, vkDevice, &fenceParams);
- }
-
// alloc timestamp values
m_timestampValues = new deUint64[m_stages.size()];
}
configCommandBuffer();
- VK_CHECK(vk.resetFences(vkDevice, 1u, &m_fence.get()));
-
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const VkPipelineStageFlags*)DE_NULL,
- 1u, // deUint32 commandBufferCount;
- &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0u, // deUint32 signalSemaphoreCount;
- DE_NULL, // const VkSemaphore* pSignalSemaphores;
- };
- VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *m_fence));
-
- VK_CHECK(vk.waitForFences(vkDevice, 1u, &m_fence.get(), true, ~(0ull) /* infinity*/));
+ submitCommandsAndWait(vk, vkDevice, queue, m_cmdBuffer.get());
// Generate the timestamp mask
deUint64 timestampMask;
#include "vkQueryUtil.hpp"
#include "vkRef.hpp"
#include "vkRefUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuFloat.hpp"
#include "tcuImageCompare.hpp"
#include "deFloat16.h"
Move<VkCommandPool> m_cmdPool;
Move<VkCommandBuffer> m_cmdBuffer;
-
- Move<VkFence> m_fence;
};
const VertexInputTest::GlslTypeDescription VertexInputTest::s_glslTypeDescriptions[GLSL_TYPE_COUNT] =
vk.cmdEndRenderPass(*m_cmdBuffer);
VK_CHECK(vk.endCommandBuffer(*m_cmdBuffer));
}
-
- // Create fence
- m_fence = createFence(vk, vkDevice);
}
VertexInputInstance::~VertexInputInstance (void)
const DeviceInterface& vk = m_context.getDeviceInterface();
const VkDevice vkDevice = m_context.getDevice();
const VkQueue queue = m_context.getUniversalQueue();
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const VkPipelineStageFlags*)DE_NULL,
- 1u, // deUint32 commandBufferCount;
- &m_cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0u, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
- VK_CHECK(vk.resetFences(vkDevice, 1, &m_fence.get()));
- VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *m_fence));
- VK_CHECK(vk.waitForFences(vkDevice, 1, &m_fence.get(), true, ~(0ull) /* infinity*/));
+ submitCommandsAndWait(vk, vkDevice, queue, m_cmdBuffer.get());
return verifyImage();
}
#include "vkBuilderUtil.hpp"
#include "vkRefUtil.hpp"
#include "vkPrograms.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuTestLog.hpp"
#include "tcuResource.hpp"
vk.endCommandBuffer(*cmdBuffer);
- // Submit command buffer
- const vk::VkSubmitInfo submitInfo =
- {
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const vk::VkPipelineStageFlags*)DE_NULL,
- 1, // deUint32 commandBufferCount;
- &cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
- vk.queueSubmit(queue, 1, &submitInfo, DE_NULL);
-
- VK_CHECK(vk.queueWaitIdle(queue));
+ submitCommandsAndWait(vk, device, queue, cmdBuffer.get());
deUint64 queryResults[NUM_QUERIES_IN_POOL] = { 0 };
size_t queryResultsSize = sizeof(queryResults);
#include "vkBuilderUtil.hpp"
#include "vkRefUtil.hpp"
#include "vkPrograms.hpp"
+#include "vkCmdUtil.hpp"
#include "deMath.h"
VK_CHECK(vk.beginCommandBuffer(commandBuffer, &info));
}
-void submitCommandsAndWait (const DeviceInterface& vk,
- const VkDevice device,
- const VkQueue queue,
- const VkCommandBuffer commandBuffer)
-{
- const VkFenceCreateInfo fenceInfo =
- {
- VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- (VkFenceCreateFlags)0, // VkFenceCreateFlags flags;
- };
- const Unique<VkFence> fence (createFence(vk, device, &fenceInfo));
-
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // uint32_t waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask;
- 1u, // uint32_t commandBufferCount;
- &commandBuffer, // const VkCommandBuffer* pCommandBuffers;
- 0u, // uint32_t signalSemaphoreCount;
- DE_NULL, // const VkSemaphore* pSignalSemaphores;
- };
- VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
- VK_CHECK(vk.waitForFences(device, 1u, &fence.get(), DE_TRUE, ~0ull));
-}
-
Move<VkQueryPool> makeQueryPool (const DeviceInterface& vk, const VkDevice device, VkQueryPipelineStatisticFlags statisticFlags)
{
const VkQueryPoolCreateInfo queryPoolCreateInfo =
#include "vkQueryUtil.hpp"
#include "vkBuilderUtil.hpp"
#include "vkTypeUtil.hpp"
+#include "vkCmdUtil.hpp"
#include <vector>
Move<VkShaderModule> m_vertexShaderModule;
Move<VkShaderModule> m_fragmentShaderModule;
- Move<VkFence> m_fence;
-
Move<VkBuffer> m_resultBuffer;
de::MovePtr<Allocation> m_resultBufferMemory;
const VkDeviceSize m_resultBufferSize;
m_fragmentShaderModule = createShaderModule(vkd, vkDevice, m_context.getBinaryCollection().get("fragment_shader"), 0);
}
- // Fence
- m_fence = createFence(vkd, vkDevice);
-
// Result Buffer
{
const VkBufferCreateInfo bufferCreateInfo =
}
// Submit
- {
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask;
- 1u, // deUint32 commandBufferCount;
- &commandBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0u, // deUint32 signalSemaphoreCount;
- DE_NULL, // const VkSemaphore* pSignalSemaphores;
- };
-
- VK_CHECK(vkd.resetFences(vkDevice, 1, &m_fence.get()));
- VK_CHECK(vkd.queueSubmit(queue, 1, &submitInfo, *m_fence));
- VK_CHECK(vkd.waitForFences(vkDevice, 1, &m_fence.get(), true, ~(0ull) /* infinity */));
- }
+ submitCommandsAndWait(vkd, vkDevice, queue, commandBuffer.get());
invalidateMappedMemoryRange(vkd, vkDevice, m_resultBufferMemory->getMemory(), m_resultBufferMemory->getOffset(), m_resultBufferSize);
tcu::copy(result.getAccess(), tcu::ConstPixelBufferAccess(m_textureFormat, tcu::IVec3(m_renderSize, m_renderSize, 1), m_resultBufferMemory->getHostPtr()));
#include "vkRef.hpp"
#include "vkRefUtil.hpp"
#include "vkTypeUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuFloat.hpp"
#include "tcuImageCompare.hpp"
VK_CHECK(vkd.endCommandBuffer(*commandBuffer));
- {
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO,
- DE_NULL,
-
- 0u,
- DE_NULL,
- DE_NULL,
-
- 1u,
- &*commandBuffer,
-
- 0u,
- DE_NULL
- };
-
- VK_CHECK(vkd.queueSubmit(m_context.getUniversalQueue(), 1u, &submitInfo, (VkFence)0u));
-
- VK_CHECK(vkd.queueWaitIdle(m_context.getUniversalQueue()));
- }
+ submitCommandsAndWait(vkd, device, m_context.getUniversalQueue(), *commandBuffer);
}
void MultisampleRenderPassTestInstance::verify (void)
#include "vkRef.hpp"
#include "vkRefUtil.hpp"
#include "vkTypeUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuFloat.hpp"
#include "tcuImageCompare.hpp"
VK_CHECK(vkd.endCommandBuffer(*commandBuffer));
- {
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO,
- DE_NULL,
-
- 0u,
- DE_NULL,
- DE_NULL,
-
- 1u,
- &*commandBuffer,
-
- 0u,
- DE_NULL
- };
-
- VK_CHECK(vkd.queueSubmit(m_context.getUniversalQueue(), 1u, &submitInfo, (VkFence)0u));
-
- VK_CHECK(vkd.queueWaitIdle(m_context.getUniversalQueue()));
- }
+ submitCommandsAndWait(vkd, device, m_context.getUniversalQueue(), *commandBuffer);
{
const tcu::TextureFormat format (mapVkFormat(m_dstFormat));
#include "vkRef.hpp"
#include "vkRefUtil.hpp"
#include "vkTypeUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuImageCompare.hpp"
#include "tcuResultCollector.hpp"
VK_CHECK(vkd.endCommandBuffer(*commandBuffer));
- {
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO,
- DE_NULL,
-
- 0u,
- DE_NULL,
- DE_NULL,
-
- 1u,
- &*commandBuffer,
-
- 0u,
- DE_NULL
- };
-
- VK_CHECK(vkd.queueSubmit(m_context.getUniversalQueue(), 1u, &submitInfo, (VkFence)0u));
-
- VK_CHECK(vkd.queueWaitIdle(m_context.getUniversalQueue()));
- }
+ submitCommandsAndWait(vkd, device, m_context.getUniversalQueue(), *commandBuffer);
{
const tcu::TextureFormat format (mapVkFormat(VK_FORMAT_R32_UINT));
#include "vkRef.hpp"
#include "vkRefUtil.hpp"
#include "vkTypeUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuImageCompare.hpp"
#include "tcuResultCollector.hpp"
VK_CHECK(vkd.endCommandBuffer(*commandBuffer));
- {
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO,
- DE_NULL,
-
- 0u,
- DE_NULL,
- DE_NULL,
-
- 1u,
- &*commandBuffer,
-
- 0u,
- DE_NULL
- };
-
- VK_CHECK(vkd.queueSubmit(m_context.getUniversalQueue(), 1u, &submitInfo, (VkFence)0u));
- VK_CHECK(vkd.queueWaitIdle(m_context.getUniversalQueue()));
- }
+ submitCommandsAndWait(vkd, m_context.getDevice(), m_context.getUniversalQueue(), *commandBuffer);
{
const tcu::TextureFormat format (mapVkFormat(m_format));
#include "vkMemUtil.hpp"
#include "vkTypeUtil.hpp"
#include "vkQueryUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuTexture.hpp"
#include "tcuTestLog.hpp"
&postCopyBarrier);
VK_CHECK(vkd.endCommandBuffer(*cmdBuf));
- {
- const Unique<VkFence> fence (createFence(vkd, device));
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO,
- DE_NULL,
- 0u,
- (const VkSemaphore*)DE_NULL,
- (const VkPipelineStageFlags*)DE_NULL,
- 1u,
- &cmdBuf.get(),
- 0u,
- (const VkSemaphore*)DE_NULL,
- };
-
- VK_CHECK(vkd.queueSubmit(context.getUniversalQueue(), 1u, &submitInfo, *fence));
- VK_CHECK(vkd.waitForFences(device, 1u, &fence.get(), VK_TRUE, ~0ull));
- }
+ submitCommandsAndWait(vkd, device, context.getUniversalQueue(), cmdBuf.get());
}
}
#include "vkTypeUtil.hpp"
#include "vkQueryUtil.hpp"
#include "vkBuilderUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "gluShaderUtil.hpp"
Move<VkCommandPool> cmdPool;
Move<VkCommandBuffer> cmdBuffer;
- Move<VkFence> fence;
-
Unique<VkDescriptorSetLayout> emptyDescriptorSetLayout (createEmptyDescriptorSetLayout(vk, vkDevice));
Unique<VkDescriptorPool> dummyDescriptorPool (createDummyDescriptorPool(vk, vkDevice));
Unique<VkDescriptorSet> emptyDescriptorSet (allocateSingleDescriptorSet(vk, vkDevice, *dummyDescriptorPool, *emptyDescriptorSetLayout));
VK_CHECK(vk.endCommandBuffer(*cmdBuffer));
}
- // Create fence
- fence = createFence(vk, vkDevice);
-
// Execute Draw
- {
-
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // sType
- DE_NULL, // pNext
- 0u, // waitSemaphoreCount
- DE_NULL, // pWaitSemaphores
- (const VkPipelineStageFlags*)DE_NULL,
- 1u, // commandBufferCount
- &cmdBuffer.get(), // pCommandBuffers
- 0u, // signalSemaphoreCount
- DE_NULL // pSignalSemaphores
- };
-
- VK_CHECK(vk.resetFences(vkDevice, 1, &fence.get()));
- VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *fence));
- VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), DE_TRUE, ~(0ull) /* infinity*/));
- }
+ submitCommandsAndWait(vk, vkDevice, queue, cmdBuffer.get());
// Read back result and output
{
Move<VkCommandBuffer> copyCmdBuffer = allocateCommandBuffer(vk, vkDevice, *copyCmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO,
- DE_NULL,
- 0u,
- (const VkSemaphore*)DE_NULL,
- (const VkPipelineStageFlags*)DE_NULL,
- 1u,
- ©CmdBuffer.get(),
- 0u,
- (const VkSemaphore*)DE_NULL,
- };
-
VK_CHECK(vk.beginCommandBuffer(*copyCmdBuffer, &cmdBufferBeginInfo));
vk.cmdCopyImageToBuffer(*copyCmdBuffer, colorImages[outLocation + locNdx].get()->get(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *readImageBuffer, 1u, ©Params);
VK_CHECK(vk.endCommandBuffer(*copyCmdBuffer));
- VK_CHECK(vk.resetFences(vkDevice, 1, &fence.get()));
- VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *fence));
- VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), true, ~(0ull) /* infinity */));
+ submitCommandsAndWait(vk, vkDevice, queue, copyCmdBuffer.get());
}
const VkMappedMemoryRange range =
Move<VkDescriptorSetLayout> descriptorSetLayout;
Move<VkDescriptorSet> descriptorSet;
const deUint32 numDescriptorSets = (m_extraResourcesLayout != 0) ? 2u : 1u;
- Move<VkFence> fence;
DE_ASSERT((m_extraResourcesLayout != 0) == (extraResources != 0));
computePipeline = createComputePipeline(vk, vkDevice, DE_NULL, &computePipelineParams);
}
- // Create fence
- fence = createFence(vk, vkDevice);
-
const int maxValuesPerInvocation = m_context.getDeviceProperties().limits.maxComputeWorkGroupSize[0];
int curOffset = 0;
const deUint32 inputStride = getInputStride();
curOffset += numToExec;
// Execute
- {
- VK_CHECK(vk.resetFences(vkDevice, 1, &fence.get()));
-
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO,
- DE_NULL,
- 0u,
- (const VkSemaphore*)DE_NULL,
- (const VkPipelineStageFlags*)DE_NULL,
- 1u,
- &cmdBuffer.get(),
- 0u,
- (const VkSemaphore*)DE_NULL,
- };
-
- VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *fence));
- VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), true, ~(0ull) /* infinity*/));
- }
+ submitCommandsAndWait(vk, vkDevice, queue, cmdBuffer.get());
}
// Read back data
Move<VkCommandPool> cmdPool;
Move<VkCommandBuffer> cmdBuffer;
- Move<VkFence> fence;
-
Move<VkDescriptorPool> descriptorPool;
Move<VkDescriptorSetLayout> descriptorSetLayout;
Move<VkDescriptorSet> descriptorSet;
VK_CHECK(vk.endCommandBuffer(*cmdBuffer));
}
- // Create fence
- fence = createFence(vk, vkDevice);
-
// Execute Draw
- {
- VK_CHECK(vk.resetFences(vkDevice, 1, &fence.get()));
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO,
- DE_NULL,
- 0u,
- (const VkSemaphore*)0,
- (const VkPipelineStageFlags*)DE_NULL,
- 1u,
- &cmdBuffer.get(),
- 0u,
- (const VkSemaphore*)0,
- };
- VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *fence));
- VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), true, ~(0ull) /* infinity*/));
- }
+ submitCommandsAndWait(vk, vkDevice, queue, cmdBuffer.get());
}
// TessControlExecutor
#include "vkRefUtil.hpp"
#include "vkStrUtil.hpp"
#include "vkTypeUtil.hpp"
+#include "vkCmdUtil.hpp"
#include <vector>
#include <string>
de::MovePtr<Allocation> bufferAlloc;
Move<VkCommandPool> cmdPool;
Move<VkCommandBuffer> cmdBuffer;
- Move<VkFence> fence;
std::vector<VkBufferImageCopy> copyRegions;
std::vector<deUint32> offsetMultiples;
cmdPool = createCommandPool(vk, vkDevice, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, queueFamilyIndex);
cmdBuffer = allocateCommandBuffer(vk, vkDevice, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
- // Create fence
- fence = createFence(vk, vkDevice);
-
// Barriers for copying buffer to image
const VkBufferMemoryBarrier preBufferBarrier =
{
vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &postImageBarrier);
VK_CHECK(vk.endCommandBuffer(*cmdBuffer));
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask;
- 1u, // deUint32 commandBufferCount;
- &cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0u, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
-
- VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *fence));
- VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), true, ~(0ull) /* infinity */));
+ submitCommandsAndWait(vk, vkDevice, queue, cmdBuffer.get());
}
void ShaderRenderCaseInstance::clearImage (const tcu::Sampler& refSampler,
const VkImageAspectFlags aspectMask = isShadowSampler ? VK_IMAGE_ASPECT_DEPTH_BIT : VK_IMAGE_ASPECT_COLOR_BIT;
Move<VkCommandPool> cmdPool;
Move<VkCommandBuffer> cmdBuffer;
- Move<VkFence> fence;
VkClearValue clearValue;
deMemset(&clearValue, 0, sizeof(clearValue));
cmdPool = createCommandPool(vk, vkDevice, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, queueFamilyIndex);
cmdBuffer = allocateCommandBuffer(vk, vkDevice, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
- // Create fence
- fence = createFence(vk, vkDevice);
-
const VkImageMemoryBarrier preImageBarrier =
{
VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 0, (const VkBufferMemoryBarrier*)DE_NULL, 1, &postImageBarrier);
VK_CHECK(vk.endCommandBuffer(*cmdBuffer));
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask;
- 1u, // deUint32 commandBufferCount;
- &cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0u, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
-
- VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *fence));
- VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), true, ~(0ull) /* infinity */));
+ submitCommandsAndWait(vk, vkDevice, queue, cmdBuffer.get());
}
VkExtent3D mipLevelExtents (const VkExtent3D& baseExtents, const deUint32 mipLevel)
vk::Move<vk::VkDescriptorSet> descriptorSet;
vk::Move<vk::VkCommandPool> cmdPool;
vk::Move<vk::VkCommandBuffer> cmdBuffer;
- vk::Move<vk::VkFence> fence;
// Create color image
{
VK_CHECK(vk.endCommandBuffer(*cmdBuffer));
}
- // Create fence
- fence = createFence(vk, vkDevice);
-
// Execute Draw
- {
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO,
- DE_NULL,
- 0u,
- (const VkSemaphore*)DE_NULL,
- (const VkPipelineStageFlags*)DE_NULL,
- 1u,
- &cmdBuffer.get(),
- 0u,
- (const VkSemaphore*)DE_NULL,
- };
-
- VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *fence));
- VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), true, ~(0ull) /* infinity*/));
- }
+ submitCommandsAndWait(vk, vkDevice, queue, cmdBuffer.get());
// Read back the result
{
{ 0u, 0u, 0u }, // VkOffset3D imageOffset;
{ m_renderSize.x(), m_renderSize.y(), 1u } // VkExtent3D imageExtent;
};
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO,
- DE_NULL,
- 0u,
- (const VkSemaphore*)DE_NULL,
- (const VkPipelineStageFlags*)DE_NULL,
- 1u,
- &resultCmdBuffer.get(),
- 0u,
- (const VkSemaphore*)DE_NULL,
- };
VK_CHECK(vk.beginCommandBuffer(*resultCmdBuffer, &cmdBufferBeginInfo));
VK_CHECK(vk.endCommandBuffer(*resultCmdBuffer));
- VK_CHECK(vk.resetFences(vkDevice, 1, &fence.get()));
- VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *fence));
- VK_CHECK(vk.waitForFences(vkDevice, 1, &fence.get(), true, ~(0ull) /* infinity */));
+ submitCommandsAndWait(vk, vkDevice, queue, resultCmdBuffer.get());
invalidateMappedMemoryRange(vk, vkDevice, readImageBufferMemory->getMemory(), readImageBufferMemory->getOffset(), imageSizeBytes);
#include "vkImageUtil.hpp"
#include "vkTypeUtil.hpp"
#include "vkMemUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "deMath.h"
#include "deRandom.hpp"
MovePtr<Allocation> depthInitAllocation;
Move<VkCommandPool> cmdPool;
Move<VkCommandBuffer> transferCmdBuffer;
- Move<VkFence> fence;
Move<VkSampler> depthSampler;
// Create Buffer/Image for validation
transferCmdBuffer = allocateCommandBuffer(vk, device, &cmdBufferAllocInfo);
}
- // Fence for data transfer
- {
- const VkFenceCreateInfo fenceCreateInfo =
- {
- VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, // VkStructureType sType
- DE_NULL, // const void* pNext
- (VkFenceCreateFlags)0 // VkFenceCreateFlags flags
- };
-
- fence = createFence(vk, device, &fenceCreateInfo);
- }
-
// Initialize Marker Buffer
{
VkImageAspectFlags depthImageAspectFlags = VK_IMAGE_ASPECT_DEPTH_BIT;
VK_CHECK(vk.endCommandBuffer(*transferCmdBuffer));
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType
- DE_NULL, // const void* pNext
- 0u, // uint32_t waitSemaphoreCount
- DE_NULL, // const VkSemaphore* pWaitSemaphores
- (const VkPipelineStageFlags*)DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask
- 1u, // uint32_t commandBufferCount
- &transferCmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers
- 0u, // uint32_t signalSemaphoreCount
- DE_NULL // const VkSemaphore* pSignalSemaphores
- };
-
- VK_CHECK(vk.resetFences(device, 1, &fence.get()));
- VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *fence));
- VK_CHECK(vk.waitForFences(device, 1, &fence.get(), true, ~(0ull)));
+ submitCommandsAndWait(vk, device, queue, transferCmdBuffer.get());
}
DE_LENGTH_OF_ARRAY(imageBarrier), imageBarrier);
VK_CHECK(vk.endCommandBuffer(*transferCmdBuffer));
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType
- DE_NULL, // const void* pNext
- 0u, // uint32_t waitSemaphoreCount
- DE_NULL, // const VkSemaphore* pWaitSemaphores
- (const VkPipelineStageFlags*)DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask
- 1u, // uint32_t commandBufferCount
- &transferCmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers
- 0u, // uint32_t signalSemaphoreCount
- DE_NULL // const VkSemaphore* pSignalSemaphores
- };
-
- VK_CHECK(vk.resetFences(device, 1, &fence.get()));
- VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *fence));
- VK_CHECK(vk.waitForFences(device, 1, &fence.get(), true, ~(0ull)));
+ submitCommandsAndWait(vk, device, queue, transferCmdBuffer.get());
}
// Resolve Depth Buffer
0, (const VkImageMemoryBarrier*)DE_NULL);
VK_CHECK(vk.endCommandBuffer(*transferCmdBuffer));
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType
- DE_NULL, // const void* pNext
- 0u, // uint32_t waitSemaphoreCount
- DE_NULL, // const VkSemaphore* pWaitSemaphores
- (const VkPipelineStageFlags*)DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask
- 1u, // uint32_t commandBufferCount
- &transferCmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers
- 0u, // uint32_t signalSemaphoreCount
- DE_NULL // const VkSemaphore* pSignalSemaphores
- };
-
- VK_CHECK(vk.resetFences(device, 1, &fence.get()));
- VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *fence));
- VK_CHECK(vk.waitForFences(device, 1, &fence.get(), true, ~(0ull)));
+ submitCommandsAndWait(vk, device, queue, transferCmdBuffer.get());
}
// Verify depth buffer
0, (const VkImageMemoryBarrier*)DE_NULL);
VK_CHECK(vk.endCommandBuffer(*transferCmdBuffer));
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType
- DE_NULL, // const void* pNext
- 0u, // uint32_t waitSemaphoreCount
- DE_NULL, // const VkSemaphore* pWaitSemaphores
- (const VkPipelineStageFlags*)DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask
- 1u, // uint32_t commandBufferCount
- &transferCmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers
- 0u, // uint32_t signalSemaphoreCount
- DE_NULL // const VkSemaphore* pSignalSemaphores
- };
-
- VK_CHECK(vk.resetFences(device, 1, &fence.get()));
- VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, *fence));
- VK_CHECK(vk.waitForFences(device, 1, &fence.get(), true, ~(0ull)));
+ submitCommandsAndWait(vk, device, queue, transferCmdBuffer.get());
invalidateMappedMemoryRange(vk, device, validationAlloc->getMemory(), validationAlloc->getOffset(), VK_WHOLE_SIZE);
invalidateMappedMemoryRange(vk, device, markerBufferAllocation->getMemory(), markerBufferAllocation->getOffset(), VK_WHOLE_SIZE);
MovePtr<Allocation> sampleLocationBufferAllocation;
Move<VkCommandPool> cmdPool;
Move<VkCommandBuffer> transferCmdBuffer;
- Move<VkFence> fence;
// Coordinate result image
{
transferCmdBuffer = allocateCommandBuffer(vk, device, &cmdBufferAllocInfo);
}
- // Fence for data transfer
- {
- const VkFenceCreateInfo fenceCreateInfo =
- {
- VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, // VkStructureType sType
- DE_NULL, // const void* pNext
- (VkFenceCreateFlags)0 // VkFenceCreateFlags flags
- };
-
- fence = createFence(vk, device, &fenceCreateInfo);
- }
-
// Transition the output image to LAYOUT_GENERAL
{
const VkImageMemoryBarrier barrier =
VK_CHECK(vk.endCommandBuffer(*transferCmdBuffer));
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType
- DE_NULL, // const void* pNext
- 0u, // uint32_t waitSemaphoreCount
- DE_NULL, // const VkSemaphore* pWaitSemaphores
- (const VkPipelineStageFlags*)DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask
- 1u, // uint32_t commandBufferCount
- &transferCmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers
- 0u, // uint32_t signalSemaphoreCount
- DE_NULL // const VkSemaphore* pSignalSemaphores
- };
-
- vk.resetFences(device, 1, &fence.get());
- vk.queueSubmit(queue, 1, &submitInfo, *fence);
- vk.waitForFences(device, 1, &fence.get(), true, ~(0ull));
+ submitCommandsAndWait(vk, device, queue, transferCmdBuffer.get());
}
// Perform draw
0, (const VkImageMemoryBarrier*)DE_NULL);
VK_CHECK(vk.endCommandBuffer(*transferCmdBuffer));
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType
- DE_NULL, // const void* pNext
- 0u, // uint32_t waitSemaphoreCount
- DE_NULL, // const VkSemaphore* pWaitSemaphores
- (const VkPipelineStageFlags*)DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask
- 1u, // uint32_t commandBufferCount
- &transferCmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers
- 0u, // uint32_t signalSemaphoreCount
- DE_NULL // const VkSemaphore* pSignalSemaphores
- };
-
- vk.resetFences(device, 1, &fence.get());
- vk.queueSubmit(queue, 1, &submitInfo, *fence);
- vk.waitForFences(device, 1, &fence.get(), true, ~(0ull));
+ submitCommandsAndWait(vk, device, queue, transferCmdBuffer.get());
invalidateMappedMemoryRange(vk, device, sampleLocationBufferAllocation->getMemory(), sampleLocationBufferAllocation->getOffset(), VK_WHOLE_SIZE);
}
#include "vkRefUtil.hpp"
#include "vkQueryUtil.hpp"
#include "vkTypeUtil.hpp"
+#include "vkCmdUtil.hpp"
namespace
{
VK_CHECK(vkdi.endCommandBuffer(cmdBuffer));
- {
- const VkFenceCreateInfo fenceParams =
- {
- VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // VkFenceCreateFlags flags;
- };
-
- const Unique<VkFence> fence (createFence(vkdi, device, &fenceParams));
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask;
- 1u, // deUint32 commandBufferCount;
- &cmdBuffer, // const VkCommandBuffer* pCommandBuffers;
- 0u, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
-
- VK_CHECK(vkdi.queueSubmit(queue, 1u, &submitInfo, *fence));
- VK_CHECK(vkdi.waitForFences(device, 1u, &fence.get(), DE_TRUE, ~0ull));
- }
+ submitCommandsAndWait(vkdi, device, queue, cmdBuffer);
}
void setMemory (const DeviceInterface& vkdi, const VkDevice& device, Allocation* destAlloc, size_t numBytes, const void* data, bool coherent = false)
vkdi.cmdDispatch(*cmdBuffer, numWorkGroups.x(), numWorkGroups.y(), numWorkGroups.z());
VK_CHECK(vkdi.endCommandBuffer(*cmdBuffer));
- // Create fence and run.
-
- const Unique<VkFence> cmdCompleteFence (createFence(vkdi, device));
- const deUint64 infiniteTimeout = ~(deUint64)0u;
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO,
- DE_NULL,
- 0u,
- (const VkSemaphore*)DE_NULL,
- (const VkPipelineStageFlags*)DE_NULL,
- 1u,
- &cmdBuffer.get(),
- 0u,
- (const VkSemaphore*)DE_NULL,
- };
-
- VK_CHECK(vkdi.queueSubmit(queue, 1, &submitInfo, *cmdCompleteFence));
- VK_CHECK(vkdi.waitForFences(device, 1, &cmdCompleteFence.get(), 0u, infiniteTimeout)); // \note: timeout is failure
+ submitCommandsAndWait(vkdi, device, queue, *cmdBuffer);
// Invalidate output memory ranges before checking on host.
for (size_t outputNdx = 0; outputNdx < m_shaderSpec.outputs.size(); ++outputNdx)
#include "vkStrUtil.hpp"
#include "vkTypeUtil.hpp"
#include "vkImageUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "deUniquePtr.hpp"
VK_CHECK(vk.beginCommandBuffer(commandBuffer, &info));
}
-void submitCommandsAndWait (const DeviceInterface& vk,
- const VkDevice device,
- const VkQueue queue,
- const VkCommandBuffer commandBuffer)
-{
- const VkFenceCreateInfo fenceInfo =
- {
- VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- (VkFenceCreateFlags)0, // VkFenceCreateFlags flags;
- };
- const Unique<VkFence> fence (createFence(vk, device, &fenceInfo));
-
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // uint32_t waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask;
- 1u, // uint32_t commandBufferCount;
- &commandBuffer, // const VkCommandBuffer* pCommandBuffers;
- 0u, // uint32_t signalSemaphoreCount;
- DE_NULL, // const VkSemaphore* pSignalSemaphores;
- };
- VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
- VK_CHECK(vk.waitForFences(device, 1u, &fence.get(), DE_TRUE, ~0ull));
-}
-
void imageBarrier (const DeviceInterface& vk,
const VkCommandBuffer cmdBuffer,
const VkImage image,
#include "vkQueryUtil.hpp"
#include "vkRefUtil.hpp"
#include "vkTypeUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "deRandom.hpp"
VK_CHECK(vk.endCommandBuffer(cmdBuffer));
- {
- const VkFenceCreateInfo fenceParams =
- {
- VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // VkFenceCreateFlags flags;
- };
-
- const Unique<VkFence> fence (createFence(vk, device, &fenceParams));
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask;
- 1u, // deUint32 commandBufferCount;
- &cmdBuffer, // const VkCommandBuffer* pCommandBuffers;
- 0u, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
-
- VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
- VK_CHECK(vk.waitForFences(device, 1u, &fence.get(), DE_TRUE, ~0ull));
- }
+ submitCommandsAndWait(vk, device, queue, cmdBuffer);
}
TestStatus runAndVerifyDefaultPipeline (Context& context, InstanceContext instance)
}
// Submit & wait for completion
- {
- const VkFenceCreateInfo fenceParams =
- {
- VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // VkFenceCreateFlags flags;
- };
- const Unique<VkFence> fence (createFence(vk, device, &fenceParams));
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO,
- DE_NULL,
- 0u,
- (const VkSemaphore*)DE_NULL,
- (const VkPipelineStageFlags*)DE_NULL,
- 1u,
- &cmdBuf.get(),
- 0u,
- (const VkSemaphore*)DE_NULL,
- };
-
- VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
- VK_CHECK(vk.waitForFences(device, 1u, &fence.get(), DE_TRUE, ~0ull));
- }
+ submitCommandsAndWait(vk, device, queue, cmdBuf.get());
const void* imagePtr = readImageBufferMemory->getHostPtr();
const tcu::ConstPixelBufferAccess pixelBuffer(tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8),
#include "vkRef.hpp"
#include "vkRefUtil.hpp"
#include "vkTypeUtil.hpp"
+#include "vkCmdUtil.hpp"
namespace vkt
{
VK_CHECK(vk.endCommandBuffer(*cmdBuffer));
- vk::Move<vk::VkFence> fence (createFence(vk, device));
-
- const vk::VkSubmitInfo submitInfo =
- {
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO,
- DE_NULL,
- 0u,
- (const vk::VkSemaphore*)DE_NULL,
- (const vk::VkPipelineStageFlags*)DE_NULL,
- 1u,
- &cmdBuffer.get(),
- 0u,
- (const vk::VkSemaphore*)DE_NULL,
- };
-
- VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
- VK_CHECK(vk.waitForFences(device, 1u, &fence.get(), DE_TRUE, ~0ull));
+ submitCommandsAndWait(vk, device, queue, cmdBuffer.get());
// Read back ac_numPassed data
bool counterOk;
#include "vkQueryUtil.hpp"
#include "vkMemUtil.hpp"
#include "vkTypeUtil.hpp"
+#include "vkCmdUtil.hpp"
namespace vkt
{
VK_CHECK(vk.endCommandBuffer(*cmdBuf));
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO,
- DE_NULL,
- 0, // waitSemaphoreCount
- DE_NULL, // pWaitSemaphores
- DE_NULL, // pWaitDstStageMask
- 1, // commandBufferCount
- &cmdBuf.get(), // pCommandBuffers
- 0, // signalSemaphoreCount
- DE_NULL, // pSignalSemaphores
- };
- VK_CHECK(vk.queueSubmit(queue, 1, &submitInfo, (vk::VkFence)0));
-
- // Force all work to have completed
- VK_CHECK(vk.deviceWaitIdle(device));
+ submitCommandsAndWait(vk, device, queue, cmdBuf.get());
// Read back output buffer contents
VK_CHECK(vk.invalidateMappedMemoryRanges(device, 1, &range));
#include "vkPlatform.hpp"
#include "vkBuilderUtil.hpp"
#include "vkImageUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuResultCollector.hpp"
#include "vkQueryUtil.hpp"
#include "vkTypeUtil.hpp"
#include "vkPlatform.hpp"
+#include "vkCmdUtil.hpp"
#include "deUniquePtr.hpp"
#include "tcuTestLog.hpp"
#include "vktSynchronizationUtil.hpp"
#include "vkMemUtil.hpp"
#include "vkQueryUtil.hpp"
#include "vkTypeUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "deUniquePtr.hpp"
#include "tcuTestLog.hpp"
#include "vktSynchronizationUtil.hpp"
VK_CHECK(vk.endCommandBuffer(commandBuffer));
}
-void submitCommandsAndWait (const DeviceInterface& vk,
- const VkDevice device,
- const VkQueue queue,
- const VkCommandBuffer commandBuffer)
-{
- const Unique<VkFence> fence(createFence(vk, device));
-
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // uint32_t waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask;
- 1u, // uint32_t commandBufferCount;
- &commandBuffer, // const VkCommandBuffer* pCommandBuffers;
- 0u, // uint32_t signalSemaphoreCount;
- DE_NULL, // const VkSemaphore* pSignalSemaphores;
- };
- VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
- VK_CHECK(vk.waitForFences(device, 1u, &fence.get(), DE_TRUE, ~0ull));
-}
-
void beginRenderPass (const DeviceInterface& vk,
const VkCommandBuffer commandBuffer,
const VkRenderPass renderPass,
void beginCommandBuffer (const vk::DeviceInterface& vk, const vk::VkCommandBuffer commandBuffer);
void endCommandBuffer (const vk::DeviceInterface& vk, const vk::VkCommandBuffer commandBuffer);
-void submitCommandsAndWait (const vk::DeviceInterface& vk, const vk::VkDevice device, const vk::VkQueue queue, const vk::VkCommandBuffer commandBuffer);
void beginRenderPass (const vk::DeviceInterface& vk, const vk::VkCommandBuffer commandBuffer, const vk::VkRenderPass renderPass, const vk::VkFramebuffer framebuffer, const vk::VkRect2D& renderArea, const tcu::Vec4& clearColor);
void beginRenderPassWithRasterizationDisabled (const vk::DeviceInterface& vk, const vk::VkCommandBuffer commandBuffer, const vk::VkRenderPass renderPass, const vk::VkFramebuffer framebuffer);
void endRenderPass (const vk::DeviceInterface& vk, const vk::VkCommandBuffer commandBuffer);
#include "vkImageUtil.hpp"
#include "vkTypeUtil.hpp"
#include "vkStrUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "deUniquePtr.hpp"
#include "deStringUtil.hpp"
#include "vkQueryUtil.hpp"
#include "vkBuilderUtil.hpp"
#include "vkTypeUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "deUniquePtr.hpp"
#include "vkQueryUtil.hpp"
#include "vkBuilderUtil.hpp"
#include "vkTypeUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "deUniquePtr.hpp"
#include "deStringUtil.hpp"
#include "vkBuilderUtil.hpp"
#include "vkTypeUtil.hpp"
#include "vkImageUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "deUniquePtr.hpp"
#include "vkBuilderUtil.hpp"
#include "vkTypeUtil.hpp"
#include "vkImageUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "deUniquePtr.hpp"
#include "vkBuilderUtil.hpp"
#include "vkTypeUtil.hpp"
#include "vkImageUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "deUniquePtr.hpp"
#include "vkBuilderUtil.hpp"
#include "vkImageUtil.hpp"
#include "vkTypeUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "deUniquePtr.hpp"
#include "deStringUtil.hpp"
#include "vkImageUtil.hpp"
#include "vkTypeUtil.hpp"
#include "vkStrUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "deUniquePtr.hpp"
#include "deStringUtil.hpp"
#include "vkBuilderUtil.hpp"
#include "vkImageUtil.hpp"
#include "vkTypeUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "deUniquePtr.hpp"
#include "deStringUtil.hpp"
#include "vkImageUtil.hpp"
#include "vkTypeUtil.hpp"
#include "vkStrUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "deUniquePtr.hpp"
#include "deStringUtil.hpp"
#include "vkImageUtil.hpp"
#include "vkBuilderUtil.hpp"
#include "vkTypeUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "deUniquePtr.hpp"
#include "deSharedPtr.hpp"
VK_CHECK(vk.endCommandBuffer(commandBuffer));
}
-void submitCommandsAndWait (const DeviceInterface& vk,
- const VkDevice device,
- const VkQueue queue,
- const VkCommandBuffer commandBuffer)
-{
- const Unique<VkFence> fence(createFence(vk, device));
-
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // uint32_t waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask;
- 1u, // uint32_t commandBufferCount;
- &commandBuffer, // const VkCommandBuffer* pCommandBuffers;
- 0u, // uint32_t signalSemaphoreCount;
- DE_NULL, // const VkSemaphore* pSignalSemaphores;
- };
- VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
- VK_CHECK(vk.waitForFences(device, 1u, &fence.get(), DE_TRUE, ~0ull));
-}
-
void beginRenderPass (const DeviceInterface& vk,
const VkCommandBuffer commandBuffer,
const VkRenderPass renderPass,
void beginCommandBuffer (const vk::DeviceInterface& vk, const vk::VkCommandBuffer commandBuffer);
void endCommandBuffer (const vk::DeviceInterface& vk, const vk::VkCommandBuffer commandBuffer);
-void submitCommandsAndWait (const vk::DeviceInterface& vk, const vk::VkDevice device, const vk::VkQueue queue, const vk::VkCommandBuffer commandBuffer);
void beginRenderPass (const vk::DeviceInterface& vk, const vk::VkCommandBuffer commandBuffer, const vk::VkRenderPass renderPass, const vk::VkFramebuffer framebuffer, const vk::VkRect2D& renderArea, const tcu::Vec4& clearColor);
void beginRenderPassWithRasterizationDisabled (const vk::DeviceInterface& vk, const vk::VkCommandBuffer commandBuffer, const vk::VkRenderPass renderPass, const vk::VkFramebuffer framebuffer);
void endRenderPass (const vk::DeviceInterface& vk, const vk::VkCommandBuffer commandBuffer);
#include "vkImageUtil.hpp"
#include "vkTypeUtil.hpp"
#include "vkStrUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "deUniquePtr.hpp"
#include "vkTypeUtil.hpp"
#include "vkQueryUtil.hpp"
#include "vkMemUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuTexLookupVerifier.hpp"
#include "tcuTestLog.hpp"
VK_CHECK(vkd.endCommandBuffer(copyBuffer.get()));
- const VkSubmitInfo copySubmitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO,
- DE_NULL,
- 0,
- DE_NULL,
- DE_NULL,
- 1,
- &(copyBuffer.get()),
- 0,
- DE_NULL
- };
-
- VK_CHECK(vkd.queueSubmit(ctx.getUniversalQueue(), 1, ©SubmitInfo, 0));
- VK_CHECK(vkd.queueWaitIdle(ctx.getUniversalQueue()));
+ submitCommandsAndWait(vkd, dev, ctx.getUniversalQueue(), copyBuffer.get());
}
struct TestCaseData
#include "vkQueryUtil.hpp"
#include "vkRefUtil.hpp"
#include "vkTypeUtil.hpp"
+#include "vkCmdUtil.hpp"
#include <map>
#include <string>
#include <vector>
m_descriptorPool = descriptorPoolBuilder.build(vkd, vkDevice, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 2u);
}
- // Fence
- m_fence = createFence(vkd, vkDevice);
-
// Result Buffer
{
const VkBufferCreateInfo bufferCreateInfo =
VK_CHECK(vkd.endCommandBuffer(*commandBuffer));
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask;
- 1u, // deUint32 commandBufferCount;
- &commandBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0u, // deUint32 signalSemaphoreCount;
- DE_NULL, // const VkSemaphore* pSignalSemaphores;
- };
-
- VK_CHECK(vkd.resetFences(vkDevice, 1, &m_fence.get()));
- VK_CHECK(vkd.queueSubmit(queue, 1, &submitInfo, *m_fence));
- VK_CHECK(vkd.waitForFences(vkDevice, 1, &m_fence.get(), true, ~(0ull) /* infinity */));
+ submitCommandsAndWait(vkd, vkDevice, queue, commandBuffer.get());
}
void TextureRenderer::add2DTexture (const TestTexture2DSp& texture, TextureBinding::ImageBackingMode backingMode)
}
// Submit
- {
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask;
- 1u, // deUint32 commandBufferCount;
- &commandBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0u, // deUint32 signalSemaphoreCount;
- DE_NULL, // const VkSemaphore* pSignalSemaphores;
- };
-
- VK_CHECK(vkd.resetFences(vkDevice, 1, &m_fence.get()));
- VK_CHECK(vkd.queueSubmit(queue, 1, &submitInfo, *m_fence));
- VK_CHECK(vkd.waitForFences(vkDevice, 1, &m_fence.get(), true, ~(0ull) /* infinity */));
- }
+ submitCommandsAndWait(vkd, vkDevice, queue, commandBuffer.get());
invalidateMappedMemoryRange(vkd, vkDevice, m_resultBufferMemory->getMemory(), m_resultBufferMemory->getOffset(), VK_WHOLE_SIZE);
static const vk::VkDeviceSize s_vertexIndexBufferSize;
static const deUint16 s_vertexIndices[6];
- vk::Move<vk::VkFence> m_fence;
-
vk::Move<vk::VkBuffer> m_resultBuffer;
de::MovePtr<vk::Allocation> m_resultBufferMemory;
const vk::VkDeviceSize m_resultBufferSize;
#include "vkRef.hpp"
#include "vkRefUtil.hpp"
#include "vkBuilderUtil.hpp"
+#include "vkCmdUtil.hpp"
#include <map>
#include <set>
VK_CHECK(vk.endCommandBuffer(*cmdBuffer));
// Submit the command buffer
- {
- const Unique<vk::VkFence> fence(vk::createFence(vk, device));
-
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // deUint32 waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- (const VkPipelineStageFlags*)DE_NULL,
- 1u, // deUint32 commandBufferCount;
- &cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
- 0u, // deUint32 signalSemaphoreCount;
- DE_NULL // const VkSemaphore* pSignalSemaphores;
- };
-
- VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
- VK_CHECK(vk.waitForFences(device, 1u, &fence.get(), DE_TRUE, ~0ull));
- }
+ submitCommandsAndWait(vk, device, queue, cmdBuffer.get());
// Read back the results
tcu::Surface surface(RENDER_WIDTH, RENDER_HEIGHT);
#include "vkBufferWithMemory.hpp"
#include "vkImageWithMemory.hpp"
#include "vkTypeUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "rrRenderer.hpp"
#include "rrRenderState.hpp"
#include "rrPrimitiveTypes.hpp"
VK_CHECK(vk.endCommandBuffer(commandBuffer));
}
-void submitCommandsAndWait (const DeviceInterface& vk,
- const VkDevice device,
- const VkQueue queue,
- const VkCommandBuffer commandBuffer)
-{
- const VkFenceCreateInfo fenceInfo =
- {
- VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- (VkFenceCreateFlags)0, // VkFenceCreateFlags flags;
- };
- const Unique<VkFence> fence(createFence(vk, device, &fenceInfo));
-
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
- DE_NULL, // const void* pNext;
- 0u, // uint32_t waitSemaphoreCount;
- DE_NULL, // const VkSemaphore* pWaitSemaphores;
- DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask;
- 1u, // uint32_t commandBufferCount;
- &commandBuffer, // const VkCommandBuffer* pCommandBuffers;
- 0u, // uint32_t signalSemaphoreCount;
- DE_NULL, // const VkSemaphore* pSignalSemaphores;
- };
- VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
- VK_CHECK(vk.waitForFences(device, 1u, &fence.get(), DE_TRUE, ~0ull));
-}
-
std::string getPrimitiveTopologyShortName (const VkPrimitiveTopology topology)
{
std::string name(getPrimitiveTopologyName(topology));
#include "vkBuilderUtil.hpp"
#include "vkTypeUtil.hpp"
#include "vkImageUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "gluShaderLibrary.hpp"
#include "gluShaderUtil.hpp"
if (!m_spec.values.uniforms.empty())
writeValuesToMem(m_context, *m_uniformMem, m_uniformLayout, m_spec.values.uniforms, m_subCaseNdx);
- {
- const vk::VkSubmitInfo submitInfo =
- {
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO,
- DE_NULL,
- 0u, // waitSemaphoreCount
- (const vk::VkSemaphore*)0, // pWaitSemaphores
- (const vk::VkPipelineStageFlags*)DE_NULL,
- 1u,
- &m_cmdBuffer.get(),
- 0u, // signalSemaphoreCount
- (const vk::VkSemaphore*)0, // pSignalSemaphores
- };
- const Unique<vk::VkFence> fence (vk::createFence(vkd, device));
-
- VK_CHECK(vkd.queueSubmit (queue, 1u, &submitInfo, *fence));
- VK_CHECK(vkd.waitForFences (device, 1u, &fence.get(), DE_TRUE, ~0ull));
- }
+ submitCommandsAndWait(vkd, device, queue, m_cmdBuffer.get());
// Result was checked in fragment shader
if (m_spec.outputType == glu::sl::OUTPUT_RESULT)
#include "vkQueryUtil.hpp"
#include "vkRefUtil.hpp"
#include "vkTypeUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuSeedBuilder.hpp"
#include "tcuTestLog.hpp"
VK_CHECK(vkd.endCommandBuffer(*cmdBuffer));
- {
- const vk::Unique<vk::VkFence> fence (createFence(vkd, device));
- const vk::VkSubmitInfo submitInfo =
- {
- vk::VK_STRUCTURE_TYPE_SUBMIT_INFO,
- DE_NULL,
- 0u,
- (const vk::VkSemaphore*)DE_NULL,
- (const vk::VkPipelineStageFlags*)DE_NULL,
- 1u,
- &*cmdBuffer,
- 0u,
- (const vk::VkSemaphore*)DE_NULL,
- };
-
- VK_CHECK(vkd.queueSubmit(queue, 1u, &submitInfo, *fence));
- VK_CHECK(vkd.waitForFences(device, 1u, &*fence, VK_TRUE, ~0ull));
- }
+ submitCommandsAndWait(vkd, device, queue, *cmdBuffer);
}
if (config.dst.tiling == vk::VK_IMAGE_TILING_OPTIMAL)
#include "vkQueryUtil.hpp"
#include "vkRefUtil.hpp"
#include "vkTypeUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuTextureUtil.hpp"
#include "deMath.h"
VK_CHECK(vkd.endCommandBuffer(*cmdBuffer));
- {
- const Unique<VkFence> fence (createFence(vkd, device));
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO,
- DE_NULL,
- 0u,
- (const VkSemaphore*)DE_NULL,
- (const VkPipelineStageFlags*)DE_NULL,
- 1u,
- &*cmdBuffer,
- 0u,
- (const VkSemaphore*)DE_NULL,
- };
-
- VK_CHECK(vkd.queueSubmit(queue, 1u, &submitInfo, *fence));
- VK_CHECK(vkd.waitForFences(device, 1u, &*fence, VK_TRUE, ~0ull));
- }
+ submitCommandsAndWait(vkd, device, queue, *cmdBuffer);
}
void fillImageMemory (const vk::DeviceInterface& vkd,
VK_CHECK(vkd.endCommandBuffer(*cmdBuffer));
- {
- const Unique<VkFence> fence (createFence(vkd, device));
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO,
- DE_NULL,
- 0u,
- (const VkSemaphore*)DE_NULL,
- (const VkPipelineStageFlags*)DE_NULL,
- 1u,
- &*cmdBuffer,
- 0u,
- (const VkSemaphore*)DE_NULL,
- };
-
- VK_CHECK(vkd.queueSubmit(queue, 1u, &submitInfo, *fence));
- VK_CHECK(vkd.waitForFences(device, 1u, &*fence, VK_TRUE, ~0ull));
- }
+ submitCommandsAndWait(vkd, device, queue, *cmdBuffer);
}
void downloadImage (const DeviceInterface& vkd,
VK_CHECK(vkd.endCommandBuffer(*cmdBuffer));
- {
- const Unique<VkFence> fence (createFence(vkd, device));
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO,
- DE_NULL,
- 0u,
- (const VkSemaphore*)DE_NULL,
- (const VkPipelineStageFlags*)DE_NULL,
- 1u,
- &*cmdBuffer,
- 0u,
- (const VkSemaphore*)DE_NULL,
- };
-
- VK_CHECK(vkd.queueSubmit(queue, 1u, &submitInfo, *fence));
- VK_CHECK(vkd.waitForFences(device, 1u, &*fence, VK_TRUE, ~0ull));
- }
+ submitCommandsAndWait(vkd, device, queue, *cmdBuffer);
readStagingBuffers(imageData, vkd, device, stagingMemory);
}
VK_CHECK(vkd.endCommandBuffer(*cmdBuffer));
- {
- const Unique<VkFence> fence (createFence(vkd, device));
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO,
- DE_NULL,
- 0u,
- (const VkSemaphore*)DE_NULL,
- (const VkPipelineStageFlags*)DE_NULL,
- 1u,
- &*cmdBuffer,
- 0u,
- (const VkSemaphore*)DE_NULL,
- };
-
- VK_CHECK(vkd.queueSubmit(queue, 1u, &submitInfo, *fence));
- VK_CHECK(vkd.waitForFences(device, 1u, &*fence, VK_TRUE, ~0ull));
- }
+ submitCommandsAndWait(vkd, device, queue, *cmdBuffer);
for (deUint32 planeNdx = 0; planeNdx < formatDesc.numPlanes; ++planeNdx)
{
#include "vkQueryUtil.hpp"
#include "vkMemUtil.hpp"
#include "vkImageUtil.hpp"
+#include "vkCmdUtil.hpp"
#include "tcuTestLog.hpp"
#include "tcuVectorUtil.hpp"
VK_CHECK(vkd.endCommandBuffer(*cmdBuffer));
- {
- const Unique<VkFence> fence (createFence(vkd, device));
- const VkSubmitInfo submitInfo =
- {
- VK_STRUCTURE_TYPE_SUBMIT_INFO,
- DE_NULL,
- 0u,
- (const VkSemaphore*)DE_NULL,
- (const VkPipelineStageFlags*)DE_NULL,
- 1u,
- &*cmdBuffer,
- 0u,
- (const VkSemaphore*)DE_NULL,
- };
-
- VK_CHECK(vkd.queueSubmit(queue, 1u, &submitInfo, *fence));
- VK_CHECK(vkd.waitForFences(device, 1u, &*fence, VK_TRUE, ~0ull));
- }
+ submitCommandsAndWait(vkd, device, queue, *cmdBuffer);
}
struct TestParameters
projects / platform / upstream / VK-GL-CTS.git / commitdiff