split barrier fix & collect undefined layout before bfs (#14569)

This commit is contained in:
Zeqiang Li
2023-03-14 23:24:03 +08:00
committed by GitHub
parent 2ff383c2bb
commit c86934fcbd
3 changed files with 142 additions and 93 deletions
@@ -78,7 +78,7 @@ void CCVKCommandBuffer::doDestroy() {
cleanEvent(pair.second);
}
}
_gpuCommandBuffer = nullptr;
}
@@ -650,8 +650,8 @@ void CCVKCommandBuffer::pipelineBarrier(const GeneralBarrier *barrier, const Buf
VkPipelineStageFlags splitDstStageMask = VK_PIPELINE_STAGE_NONE_KHR;
VkMemoryBarrier const *pMemoryBarrier = nullptr;
ccstd::vector<VkImageMemoryBarrier> splitImageBarriers;
ccstd::vector<VkBufferMemoryBarrier> splitBufferBarriers;
ccstd::vector<std::pair<uint32_t, VkImageMemoryBarrier>> splitImageBarriers;
ccstd::vector<std::pair<uint32_t, VkBufferMemoryBarrier>> splitBufferBarriers;
ccstd::vector<VkImageMemoryBarrier> fullImageBarriers;
ccstd::vector<VkBufferMemoryBarrier> fullBufferBarriers;
ccstd::vector<VkEvent> scheduledEvents;
@@ -688,24 +688,36 @@ void CCVKCommandBuffer::pipelineBarrier(const GeneralBarrier *barrier, const Buf
signalEvent(ccTexture, gpuBarrier->srcStageMask);
} else {
bool fullBarrier = ccBarrier->getInfo().type == BarrierType::FULL;
if (!fullBarrier) {
CC_ASSERT(_barrierEvents.find(ccTexture) != _barrierEvents.end());
bool missed = _barrierEvents.find(ccTexture) == _barrierEvents.end();
if (!fullBarrier && !missed) {
//CC_ASSERT(_barrierEvents.find(ccTexture) != _barrierEvents.end());
VkEvent event = _barrierEvents.at(ccTexture);
scheduledEvents.push_back(event);
}
auto &vkImageBarriers = fullBarrier ? fullImageBarriers : splitImageBarriers;
auto &srcStageMask = fullBarrier ? fullSrcStageMask : splitSrcStageMask;
auto &dstStageMask = fullBarrier ? fullDstStageMask : splitDstStageMask;
gpuTexture->currentAccessTypes.assign(gpuBarrier->barrier.pNextAccesses, gpuBarrier->barrier.pNextAccesses + gpuBarrier->barrier.nextAccessCount);
vkImageBarriers.push_back(gpuBarrier->vkBarrier);
vkImageBarriers.back().subresourceRange.aspectMask = gpuTexture->aspectMask;
if (gpuTexture->swapchain) {
vkImageBarriers.back().image = gpuTexture->swapchainVkImages[gpuTexture->swapchain->curImageIndex];
gpuTexture->currentAccessTypes.assign(gpuBarrier->barrier.pNextAccesses, gpuBarrier->barrier.pNextAccesses + gpuBarrier->barrier.nextAccessCount);
auto srcStageMask = gpuBarrier->srcStageMask & VK_PIPELINE_STAGE_HOST_BIT ? 0x0 : gpuBarrier->srcStageMask;
auto &barrier = splitImageBarriers.emplace_back(i, gpuBarrier->vkBarrier);
barrier.second.subresourceRange.aspectMask = gpuTexture->aspectMask;
if (gpuTexture->swapchain) {
barrier.second.image = gpuTexture->swapchainVkImages[gpuTexture->swapchain->curImageIndex];
} else {
barrier.second.image = gpuTexture->vkImage;
}
splitSrcStageMask |= gpuBarrier->srcStageMask;
splitDstStageMask |= gpuBarrier->dstStageMask;
} else {
vkImageBarriers.back().image = gpuTexture->vkImage;
gpuTexture->currentAccessTypes.assign(gpuBarrier->barrier.pNextAccesses, gpuBarrier->barrier.pNextAccesses + gpuBarrier->barrier.nextAccessCount);
fullImageBarriers.push_back(gpuBarrier->vkBarrier);
fullImageBarriers.back().srcAccessMask = missed ? VK_IMAGE_LAYOUT_UNDEFINED : fullImageBarriers.back().srcAccessMask;
fullImageBarriers.back().subresourceRange.aspectMask = gpuTexture->aspectMask;
if (gpuTexture->swapchain) {
fullImageBarriers.back().image = gpuTexture->swapchainVkImages[gpuTexture->swapchain->curImageIndex];
} else {
fullImageBarriers.back().image = gpuTexture->vkImage;
}
fullSrcStageMask |= gpuBarrier->srcStageMask;
fullDstStageMask |= gpuBarrier->dstStageMask;
}
srcStageMask |= gpuBarrier->srcStageMask;
dstStageMask |= gpuBarrier->dstStageMask;
}
}
}
@@ -721,20 +733,25 @@ void CCVKCommandBuffer::pipelineBarrier(const GeneralBarrier *barrier, const Buf
signalEvent(ccBuffer, gpuBarrier->srcStageMask);
} else {
bool fullBarrier = ccBarrier->getInfo().type == BarrierType::FULL;
if (!fullBarrier) {
bool missed = _barrierEvents.find(ccBuffer) != _barrierEvents.end();
if (!fullBarrier && !missed) {
CC_ASSERT(_barrierEvents.find(ccBuffer) != _barrierEvents.end());
VkEvent event = _barrierEvents.at(ccBuffer);
scheduledEvents.push_back(event);
}
auto &vkBufferBarriers = fullBarrier ? fullBufferBarriers : splitBufferBarriers;
auto &srcStageMask = fullBarrier ? fullSrcStageMask : splitSrcStageMask;
auto &dstStageMask = fullBarrier ? fullDstStageMask : splitDstStageMask;
gpuBuffer->currentAccessTypes.assign(gpuBarrier->barrier.pNextAccesses, gpuBarrier->barrier.pNextAccesses + gpuBarrier->barrier.nextAccessCount);
vkBufferBarriers.push_back(gpuBarrier->vkBarrier);
vkBufferBarriers.back().buffer = gpuBuffer->vkBuffer;
srcStageMask |= gpuBarrier->srcStageMask;
dstStageMask |= gpuBarrier->dstStageMask;
gpuBuffer->currentAccessTypes.assign(gpuBarrier->barrier.pNextAccesses, gpuBarrier->barrier.pNextAccesses + gpuBarrier->barrier.nextAccessCount);
auto &splitBarrier = splitBufferBarriers.emplace_back(i, gpuBarrier->vkBarrier);
splitBarrier.second.buffer = gpuBuffer->vkBuffer;
splitSrcStageMask |= gpuBarrier->srcStageMask;
splitDstStageMask |= gpuBarrier->dstStageMask;
} else {
gpuBuffer->currentAccessTypes.assign(gpuBarrier->barrier.pNextAccesses, gpuBarrier->barrier.pNextAccesses + gpuBarrier->barrier.nextAccessCount);
fullBufferBarriers.push_back(gpuBarrier->vkBarrier);
fullBufferBarriers.back().srcAccessMask = missed ? VK_IMAGE_LAYOUT_UNDEFINED : fullBufferBarriers.back().srcAccessMask;
fullBufferBarriers.back().buffer = gpuBuffer->vkBuffer;
fullSrcStageMask |= gpuBarrier->srcStageMask;
fullDstStageMask |= gpuBarrier->dstStageMask;
}
}
}
}
@@ -755,24 +772,37 @@ void CCVKCommandBuffer::pipelineBarrier(const GeneralBarrier *barrier, const Buf
if (textureBarrierCount || bufferBarrierCount || barrier) {
// split end detect
if (!splitBufferBarriers.empty() || !splitImageBarriers.empty()) {
vkCmdWaitEvents(_gpuCommandBuffer->vkCommandBuffer, scheduledEvents.size(), scheduledEvents.data(), splitSrcStageMask, splitDstStageMask, 0, nullptr, splitBufferBarriers.size(),
splitBufferBarriers.data(), splitImageBarriers.size(), splitImageBarriers.data());
{
ccstd::vector<VkImageMemoryBarrier> vkImageBarriers(splitImageBarriers.size());
ccstd::vector<VkBufferMemoryBarrier> vkBufferBarriers(splitBufferBarriers.size());
for (size_t idx = 0; idx < splitImageBarriers.size(); ++idx) {
vkImageBarriers[idx] = splitImageBarriers[idx].second;
}
for (size_t idx = 0; idx < splitBufferBarriers.size(); ++idx) {
vkBufferBarriers[idx] = splitBufferBarriers[idx].second;
}
for (size_t i = 0; i < textureBarrierCount; ++i) {
VkEvent event = _barrierEvents.at(textures[i]);
const auto *ccBarrier = static_cast<const CCVKTextureBarrier *const>(textureBarriers[i]);
const auto *gpuBarrier = ccBarrier->gpuBarrier();
vkCmdResetEvent(_gpuCommandBuffer->vkCommandBuffer, event, gpuBarrier->dstStageMask);
_barrierEvents.erase(textures[i]);
_availableEvents.push(event);
vkCmdWaitEvents(_gpuCommandBuffer->vkCommandBuffer, scheduledEvents.size(), scheduledEvents.data(), splitSrcStageMask, splitDstStageMask, 0, nullptr, vkBufferBarriers.size(),
vkBufferBarriers.data(), vkImageBarriers.size(), vkImageBarriers.data());
}
for (size_t i = 0; i < bufferBarrierCount; ++i) {
VkEvent event = _barrierEvents.at(buffers[i]);
const auto *ccBarrier = static_cast<const CCVKBufferBarrier *const>(bufferBarriers[i]);
for (size_t i = 0; i < splitImageBarriers.size(); ++i) { // NOLINT (range-based-for)
auto index = splitImageBarriers[i].first;
VkEvent event = _barrierEvents.at(textures[index]);
const auto *ccBarrier = static_cast<const CCVKTextureBarrier *const>(textureBarriers[index]);
const auto *gpuBarrier = ccBarrier->gpuBarrier();
vkCmdResetEvent(_gpuCommandBuffer->vkCommandBuffer, event, gpuBarrier->dstStageMask);
_barrierEvents.erase(buffers[i]);
_barrierEvents.erase(textures[index]);
_availableEvents.push(event);
}
for (size_t i = 0; i < splitBufferBarriers.size(); ++i) { // NOLINT (range-based-for)
auto index = splitBufferBarriers[i].first;
VkEvent event = _barrierEvents.at(buffers[index]);
const auto *ccBarrier = static_cast<const CCVKBufferBarrier *const>(bufferBarriers[index]);
const auto *gpuBarrier = ccBarrier->gpuBarrier();
vkCmdResetEvent(_gpuCommandBuffer->vkCommandBuffer, event, gpuBarrier->dstStageMask);
_barrierEvents.erase(buffers[index]);
_availableEvents.push(event);
}
}
@@ -438,12 +438,7 @@ struct BarrierVisitor : public boost::bfs_visitor<> {
[](const AccessStatus &lhs, const AccessStatus &rhs) {
return lhs.vertID < rhs.vertID;
});
auto checkMeet = [&](const AccessStatus &status) {
const auto &resName = get(ResourceGraph::NameTag{}, resourceGraph, status.vertID);
return resourceNames.find(resName) == resourceNames.end();
};
bool newRes = std::any_of(srcStatus.begin(), srcStatus.end(), checkMeet) || std::any_of(dstStatus.begin(), dstStatus.end(), checkMeet);
if (commonResources.empty() && !newRes) {
if (commonResources.empty()) {
// this edge is a logic edge added during pass reorder,
// no real dependency between this two vertices.
return;
@@ -572,7 +567,7 @@ struct BarrierVisitor : public boost::bfs_visitor<> {
}
//----------------------------------------------check external----------------------------------------------
auto barrierExternalResOrFirstMeet = [&](const AccessStatus &resourcecAccess, Vertex vert) {
auto barrierExternalRes = [&](const AccessStatus &resourcecAccess, Vertex vert) {
uint32_t rescID = resourcecAccess.vertID;
const auto &states = get(ResourceGraph::StatesTag{}, resourceGraph, rescID);
const auto &traits = get(ResourceGraph::TraitsTag{}, resourceGraph, rescID);
@@ -646,43 +641,15 @@ struct BarrierVisitor : public boost::bfs_visitor<> {
}
}
}
} else {
if (resourceNames.find(resName) == resourceNames.end()) {
auto lastRescAccess = AccessStatus{
vert,
gfx::ShaderStageFlagBit::NONE,
gfx::MemoryAccessBit::NONE,
gfx::PassType::RASTER,
gfx::AccessFlagBit::NONE,
gfx::TextureUsageBit::NONE,
TextureRange{},
};
auto currRescAccess = resourcecAccess;
// resource id in access -> pass id in barrier
currRescAccess.vertID = vert;
lastRescAccess.accessFlag = gfx::AccessFlagBit::NONE;
// add undefined layout -> write at first meet
barrierMap[vert].blockBarrier.frontBarriers.emplace_back(Barrier{
rescID,
gfx::BarrierType::FULL,
nullptr,
lastRescAccess,
currRescAccess,
});
resourceNames.emplace(resName);
}
}
};
for (const AccessStatus &rescAccess : srcStatus) {
barrierExternalResOrFirstMeet(rescAccess, from.vertID);
barrierExternalRes(rescAccess, from.vertID);
}
for (const AccessStatus &rescAccess : dstStatus) {
barrierExternalResOrFirstMeet(rescAccess, to.vertID);
barrierExternalRes(rescAccess, to.vertID);
}
//---------------------------------------------------------------------------------------------------------
}
@@ -812,7 +779,7 @@ struct BarrierVisitor : public boost::bfs_visitor<> {
BarrierMap &barrierMap;
const ResourceGraph &resourceGraph;
ExternalResMap &externalMap; // last frame to curr frame status transition
ResourceNames &resourceNames; // isExternal ? record those which been written : record those which first meet
ResourceNames &resourceNames; // record those which been written
ResourceLifeRecordMap &resourceLifeRecord;
};
@@ -835,8 +802,55 @@ void buildBarriers(FrameGraphDispatcher &fgDispatcher) {
// found pass id in this map ? barriers you should commit when run into this pass
// : or no extra barrier needed.
BarrierMap &batchedBarriers = fgDispatcher.barrierMap;
{
// barrier first meet
// O(N) actually
ccstd::set<ResourceGraph::vertex_descriptor> firstMeet;
for (size_t i = 0; i < rag.access.size(); ++i) {
const auto *status = &rag.access[i];
while (status) {
for (const auto& attachment : status->attachmentStatus) {
if (get(ResourceGraph::TraitsTag{}, resourceGraph, attachment.vertID).hasSideEffects()) {
continue;
}
if (firstMeet.find(attachment.vertID) == firstMeet.end()) {
firstMeet.emplace(attachment.vertID);
if (batchedBarriers.find(i) == batchedBarriers.end()) {
batchedBarriers.emplace(i, BarrierNode{});
}
auto &blockFrontBarrier = batchedBarriers.at(i).blockBarrier.frontBarriers;
auto resIter = std::find_if(blockFrontBarrier.begin(), blockFrontBarrier.end(), [&attachment](const Barrier &barrier) { return barrier.resourceID == attachment.vertID; });
if (resIter == blockFrontBarrier.end()) {
Barrier firstMeetBarrier{
attachment.vertID,
gfx::BarrierType::FULL,
nullptr,
{
static_cast<uint32_t>(i),
gfx::ShaderStageFlagBit::NONE,
gfx::MemoryAccessBit::NONE,
gfx::PassType::RASTER,
gfx::AccessFlagBit::NONE,
gfx::TextureUsageBit::NONE,
TextureRange{},
},
attachment,
};
blockFrontBarrier.emplace_back(firstMeetBarrier);
}
}
}
status = status->nextSubpass;
}
}
}
ResourceNames namesSet;
{
// barrier between passes
BarrierVisitor visitor(resourceGraph, batchedBarriers, externalResMap, namesSet, rag.accessRecord, rag.resourceLifeRecord);
auto colors = rag.colors(scratch);
boost::queue<AccessVertex> q;
@@ -80,9 +80,11 @@ TEST(simpleClosedBarrierTest, test11) {
ExpectEq(node3.blockBarrier.rearBarriers.size() == 2, true);
ExpectEq(node3.subpassBarriers.empty(), true);
ExpectEq(node3.blockBarrier.frontBarriers[0].type == cc::gfx::BarrierType::SPLIT_END, true);
ExpectEq(node3.blockBarrier.frontBarriers[0].beginStatus.vertID == 1, true);
ExpectEq(node3.blockBarrier.frontBarriers[0].endStatus.vertID == 3, true);
const auto& res1Index = std::find_if(node3.blockBarrier.frontBarriers.begin(), node3.blockBarrier.frontBarriers.end(), [](const Barrier& barrier) { return barrier.resourceID == 1; });
ExpectEq(res1Index != node3.blockBarrier.frontBarriers.end(), true);
ExpectEq(res1Index->type == cc::gfx::BarrierType::SPLIT_END, true);
ExpectEq(res1Index->beginStatus.vertID == 1, true);
ExpectEq(res1Index->endStatus.vertID == 3, true);
// res 5
ExpectEq(node3.blockBarrier.rearBarriers[0].type == cc::gfx::BarrierType::FULL, true);
ExpectEq(node3.blockBarrier.rearBarriers[0].beginStatus.vertID == 3, true);
@@ -97,10 +99,11 @@ TEST(simpleClosedBarrierTest, test11) {
ExpectEq(node4.blockBarrier.rearBarriers.size() == 1, true);
ExpectEq(node4.subpassBarriers.empty(), true);
ExpectEq(node4.blockBarrier.frontBarriers[0].resourceID == 3, true);
ExpectEq(node4.blockBarrier.frontBarriers[0].type == cc::gfx::BarrierType::SPLIT_END, true);
ExpectEq(node4.blockBarrier.frontBarriers[0].beginStatus.vertID == 2, true);
ExpectEq(node4.blockBarrier.frontBarriers[0].endStatus.vertID == 4, true);
const auto& res3Index = std::find_if(node4.blockBarrier.frontBarriers.begin(), node4.blockBarrier.frontBarriers.end(), [](const Barrier& barrier) { return barrier.resourceID == 3; });
ExpectEq(res3Index != node4.blockBarrier.frontBarriers.end(), true);
ExpectEq(res3Index->type == cc::gfx::BarrierType::SPLIT_END, true);
ExpectEq(res3Index->beginStatus.vertID == 2, true);
ExpectEq(res3Index->endStatus.vertID == 4, true);
ExpectEq(node4.blockBarrier.rearBarriers[0].resourceID == 6, true);
ExpectEq(node4.blockBarrier.rearBarriers[0].type == cc::gfx::BarrierType::FULL, true);
@@ -112,14 +115,16 @@ TEST(simpleClosedBarrierTest, test11) {
ExpectEq(node5.blockBarrier.rearBarriers.size() == 1, true);
ExpectEq(node5.subpassBarriers.empty(), true);
ExpectEq(node5.blockBarrier.frontBarriers[0].resourceID == 2, true);
ExpectEq(node5.blockBarrier.frontBarriers[0].type == cc::gfx::BarrierType::SPLIT_END, true);
ExpectEq(node5.blockBarrier.frontBarriers[0].beginStatus.vertID == 2, true);
ExpectEq(node5.blockBarrier.frontBarriers[0].endStatus.vertID == 5, true);
ExpectEq(node5.blockBarrier.frontBarriers[2].resourceID == 4, true);
ExpectEq(node5.blockBarrier.frontBarriers[2].type == cc::gfx::BarrierType::SPLIT_END, true);
ExpectEq(node5.blockBarrier.frontBarriers[2].beginStatus.vertID == 3, true);
ExpectEq(node5.blockBarrier.frontBarriers[2].endStatus.vertID == 5, true);
const auto& res2Index = std::find_if(node5.blockBarrier.frontBarriers.begin(), node5.blockBarrier.frontBarriers.end(), [](const Barrier& barrier) { return barrier.resourceID == 2; });
ExpectEq(res2Index != node5.blockBarrier.frontBarriers.end(), true);
ExpectEq(res2Index->type == cc::gfx::BarrierType::SPLIT_END, true);
ExpectEq(res2Index->beginStatus.vertID == 2, true);
ExpectEq(res2Index->endStatus.vertID == 5, true);
const auto& res4Index = std::find_if(node5.blockBarrier.frontBarriers.begin(), node5.blockBarrier.frontBarriers.end(), [](const Barrier& barrier) { return barrier.resourceID == 4; });
ExpectEq(res4Index != node5.blockBarrier.frontBarriers.end(), true);
ExpectEq(res4Index->type == cc::gfx::BarrierType::SPLIT_END, true);
ExpectEq(res4Index->beginStatus.vertID == 3, true);
ExpectEq(res4Index->endStatus.vertID == 5, true);
ExpectEq(node5.blockBarrier.rearBarriers[0].resourceID == 7, true);
ExpectEq(node5.blockBarrier.rearBarriers[0].type == cc::gfx::BarrierType::SPLIT_BEGIN, true);