mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-18 20:36:04 +00:00
The flow solver starts at flowFinest_, but its images, uniform buffers and descriptor sets were allocated for every pyramid level. Keep the seven-level indices and allocate flow resources only where the solver reads and writes them. The default preset avoids three unused RGBA16F images, saving 38,707,200 bytes of pixel payload at 2560x1440 without changing the shaders or recorded GPU work. Add native allocation/dispatch regressions and document the resource budgets.
243 lines
13 KiB
C++
243 lines
13 KiB
C++
#include "framegen.hpp"
|
|
#include "embedded_shaders.hpp"
|
|
#include "log.hpp"
|
|
#include <cmath>
|
|
#include <cstdio>
|
|
|
|
namespace ddfg {
|
|
|
|
#define VKOK(x) do { if ((x) != VK_SUCCESS) { DDFG_LOGE("vk fail: %s", #x); return false; } } while (0)
|
|
|
|
uint32_t FrameGen::findMemType(uint32_t bits, VkMemoryPropertyFlags props) const {
|
|
for (uint32_t i = 0; i < memProps_.memoryTypeCount; ++i)
|
|
if ((bits & (1u << i)) && (memProps_.memoryTypes[i].propertyFlags & props) == props)
|
|
return i;
|
|
return 0;
|
|
}
|
|
|
|
bool FrameGen::makeImage(Img& out, VkExtent2D ext, VkFormat fmt, VkImageUsageFlags usage) {
|
|
out.extent = ext; out.fmt = fmt;
|
|
VkImageCreateInfo ci{VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO};
|
|
ci.imageType = VK_IMAGE_TYPE_2D;
|
|
ci.format = fmt;
|
|
ci.extent = {ext.width, ext.height, 1};
|
|
ci.mipLevels = 1; ci.arrayLayers = 1;
|
|
ci.samples = VK_SAMPLE_COUNT_1_BIT;
|
|
ci.tiling = VK_IMAGE_TILING_OPTIMAL;
|
|
ci.usage = usage;
|
|
ci.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
|
ci.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
|
VKOK(dd_->CreateImage(device_, &ci, nullptr, &out.image));
|
|
VkMemoryRequirements mr; dd_->GetImageMemoryRequirements(device_, out.image, &mr);
|
|
VkMemoryAllocateInfo ai{VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO};
|
|
ai.allocationSize = mr.size;
|
|
ai.memoryTypeIndex = findMemType(mr.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
|
|
VKOK(dd_->AllocateMemory(device_, &ai, nullptr, &out.mem));
|
|
VKOK(dd_->BindImageMemory(device_, out.image, out.mem, 0));
|
|
VkImageViewCreateInfo vi{VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO};
|
|
vi.image = out.image; vi.viewType = VK_IMAGE_VIEW_TYPE_2D; vi.format = fmt;
|
|
vi.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1};
|
|
VKOK(dd_->CreateImageView(device_, &vi, nullptr, &out.view));
|
|
return true;
|
|
}
|
|
|
|
void FrameGen::destroyImage(Img& i) {
|
|
if (i.view) dd_->DestroyImageView(device_, i.view, nullptr);
|
|
if (i.image) dd_->DestroyImage(device_, i.image, nullptr);
|
|
if (i.mem) dd_->FreeMemory(device_, i.mem, nullptr);
|
|
i = Img{};
|
|
}
|
|
|
|
bool FrameGen::makeGmBuffers() {
|
|
const VkDeviceSize sz = (VkDeviceSize)kGmThreads * kGmStride * sizeof(float);
|
|
const VkMemoryPropertyFlags want = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
|
|
for (int s = 0; s < kGmSlots; ++s) {
|
|
VkBufferCreateInfo bi{VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO};
|
|
bi.size = sz; bi.usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT; bi.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
|
VKOK(dd_->CreateBuffer(device_, &bi, nullptr, &gmSsbo_[s]));
|
|
VkMemoryRequirements mr; dd_->GetBufferMemoryRequirements(device_, gmSsbo_[s], &mr);
|
|
VkMemoryAllocateInfo ai{VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO};
|
|
ai.allocationSize = mr.size; ai.memoryTypeIndex = findMemType(mr.memoryTypeBits, want);
|
|
VKOK(dd_->AllocateMemory(device_, &ai, nullptr, &gmSsboMem_[s]));
|
|
VKOK(dd_->BindBufferMemory(device_, gmSsbo_[s], gmSsboMem_[s], 0));
|
|
VKOK(dd_->MapMemory(device_, gmSsboMem_[s], 0, sz, 0, &gmSsboPtr_[s]));
|
|
std::memset(gmSsboPtr_[s], 0, (size_t)sz);
|
|
gmSlotValid_[s] = false;
|
|
}
|
|
gmBuffersReady_ = true;
|
|
return true;
|
|
}
|
|
|
|
bool FrameGen::makePipe(Pipe& p, int shaderId,
|
|
const std::vector<VkDescriptorType>&) {
|
|
embedded::Blob b = embedded::blob((embedded::Shader)shaderId);
|
|
VkShaderModuleCreateInfo mi{VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO};
|
|
mi.codeSize = b.words * 4; mi.pCode = b.code;
|
|
VKOK(dd_->CreateShaderModule(device_, &mi, nullptr, &p.module));
|
|
VkPipelineLayoutCreateInfo li{VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO};
|
|
li.setLayoutCount = 1; li.pSetLayouts = &p.setLayout;
|
|
VKOK(dd_->CreatePipelineLayout(device_, &li, nullptr, &p.layout));
|
|
VkComputePipelineCreateInfo pi{VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO};
|
|
pi.stage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
|
|
pi.stage.stage = VK_SHADER_STAGE_COMPUTE_BIT;
|
|
pi.stage.module = p.module; pi.stage.pName = "main";
|
|
pi.layout = p.layout;
|
|
VKOK(dd_->CreateComputePipelines(device_, VK_NULL_HANDLE, 1, &pi, nullptr, &p.pipeline));
|
|
return true;
|
|
}
|
|
|
|
void FrameGen::destroyPipe(Pipe& p) {
|
|
if (p.pipeline) dd_->DestroyPipeline(device_, p.pipeline, nullptr);
|
|
if (p.layout) dd_->DestroyPipelineLayout(device_, p.layout, nullptr);
|
|
if (p.setLayout) dd_->DestroyDescriptorSetLayout(device_, p.setLayout, nullptr);
|
|
if (p.module) dd_->DestroyShaderModule(device_, p.module, nullptr);
|
|
p = Pipe{};
|
|
}
|
|
|
|
static bool buildSetLayout(const DeviceDispatch* dd, VkDevice dev,
|
|
const std::vector<std::pair<uint32_t, VkDescriptorType>>& binds,
|
|
VkDescriptorSetLayout& out) {
|
|
std::vector<VkDescriptorSetLayoutBinding> b;
|
|
for (auto& kv : binds)
|
|
b.push_back({kv.first, kv.second, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr});
|
|
VkDescriptorSetLayoutCreateInfo ci{VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO};
|
|
ci.bindingCount = (uint32_t)b.size(); ci.pBindings = b.data();
|
|
return dd->CreateDescriptorSetLayout(dev, &ci, nullptr, &out) == VK_SUCCESS;
|
|
}
|
|
|
|
bool FrameGen::init(const DeviceDispatch* dd, const InstanceDispatch* id,
|
|
VkPhysicalDevice phys, VkDevice dev, uint32_t queueFamily, VkQueue queue) {
|
|
dd_ = dd; id_ = id; phys_ = phys; device_ = dev; queueFamily_ = queueFamily; queue_ = queue;
|
|
id_->GetPhysicalDeviceMemoryProperties(phys_, &memProps_);
|
|
|
|
VkSamplerCreateInfo si{VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO};
|
|
si.magFilter = si.minFilter = VK_FILTER_LINEAR;
|
|
si.addressModeU = si.addressModeV = si.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
|
|
VKOK(dd_->CreateSampler(device_, &si, nullptr, &linear_));
|
|
|
|
VkDescriptorPoolSize sizes[] = {
|
|
{VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 256},
|
|
{VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 256},
|
|
{VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 64},
|
|
{VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 16},
|
|
};
|
|
VkDescriptorPoolCreateInfo pci{VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO};
|
|
pci.flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT;
|
|
pci.maxSets = 256; pci.poolSizeCount = 4; pci.pPoolSizes = sizes;
|
|
VKOK(dd_->CreateDescriptorPool(device_, &pci, nullptr, &descPool_));
|
|
|
|
using B = std::pair<uint32_t, VkDescriptorType>;
|
|
const auto S = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
|
|
const auto W = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
|
|
const auto U = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
|
|
const auto SB = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
|
|
|
|
if (!buildSetLayout(dd_, dev, {B{32,S},B{48,W}}, pLuma_.setLayout)) return false;
|
|
if (!buildSetLayout(dd_, dev, {B{32,S},B{48,W}}, pDown_.setLayout)) return false;
|
|
if (!buildSetLayout(dd_, dev, {B{0,U},B{32,S},B{33,S},B{34,S},B{48,W}}, pFlow_.setLayout)) return false;
|
|
if (!buildSetLayout(dd_, dev, {B{0,U},B{32,S},B{33,S},B{34,S},B{48,W}}, pFlowM4_.setLayout)) return false;
|
|
if (!buildSetLayout(dd_, dev, {B{0,U},B{1,U},B{32,S},B{48,W},B{49,W}}, pExpand_.setLayout)) return false;
|
|
if (!buildSetLayout(dd_, dev, {B{0,U},B{1,U},B{32,S},B{48,W},B{49,W}}, pExpandM4_.setLayout)) return false;
|
|
if (!buildSetLayout(dd_, dev, {B{0,U},B{32,S},B{33,S},B{34,S},B{35,S},B{48,W}}, pSynth_.setLayout)) return false;
|
|
if (!buildSetLayout(dd_, dev, {B{1,U},B{16,SB},B{32,S},B{33,S}}, pGmReduce_.setLayout)) return false;
|
|
if (!buildSetLayout(dd_, dev, {B{1,U},B{32,S},B{48,W}}, pGmPrewarp_.setLayout)) return false;
|
|
if (!buildSetLayout(dd_, dev, {B{0,U},B{32,S},B{33,S},B{34,S},B{48,W}}, pFlowReg_.setLayout)) return false;
|
|
|
|
std::vector<VkDescriptorType> unused;
|
|
if (!makePipe(pLuma_, embedded::OF3_LUMA, unused)) return false;
|
|
if (!makePipe(pDown_, embedded::OF3_DOWNSAMPLE, unused)) return false;
|
|
if (!makePipe(pFlow_, embedded::OF3_FLOW, unused)) return false;
|
|
if (!makePipe(pFlowM4_, embedded::OF3_FLOW_M4, unused)) return false;
|
|
if (!makePipe(pExpand_, embedded::OF3_EXPAND, unused)) return false;
|
|
if (!makePipe(pExpandM4_, embedded::OF3_EXPAND_M4, unused)) return false;
|
|
if (!makePipe(pGmReduce_, embedded::OF3_GM_REDUCE, unused)) return false;
|
|
if (!makePipe(pGmPrewarp_, embedded::OF3_GM_PREWARP, unused)) return false;
|
|
if (!makePipe(pFlowReg_, embedded::OF3_FLOWREG, unused)) return false;
|
|
if (!makePipe(pSynth_, embedded::DDFG_SYNTH, unused)) return false;
|
|
if (!makeGmBuffers()) { DDFG_LOGE("framegen: GM SSBO alloc failed - C1 disabled"); }
|
|
DDFG_LOGI("framegen init ok (queueFamily=%u, 10 pipelines, model=%d, C1 gm=%d, C2 flow_reg=%d iters=%d)",
|
|
queueFamily_, cfg_.model, cfg_.gmMode, cfg_.frMode, cfg_.frIters);
|
|
return true;
|
|
}
|
|
|
|
static VkExtent2D levelExtent(VkExtent2D e, int l) {
|
|
return { e.width >> l ? e.width >> l : 1u, e.height >> l ? e.height >> l : 1u };
|
|
}
|
|
|
|
bool FrameGen::onResize(VkExtent2D extent, VkFormat , bool force) {
|
|
|
|
|
|
if (!force && ready_ && extent.width == extent_.width && extent.height == extent_.height) return true;
|
|
for (auto& i : pyrA_) destroyImage(i); pyrA_.clear();
|
|
for (auto& i : pyrB_) destroyImage(i); pyrB_.clear();
|
|
for (auto& i : pyrAs_) destroyImage(i); pyrAs_.clear();
|
|
for (auto& i : flowLvl_) destroyImage(i); flowLvl_.clear();
|
|
destroyImage(flowExpA_); destroyImage(flowExpB_);
|
|
destroyImage(flowRegA_); destroyImage(flowRegB_);
|
|
extent_ = extent; ready_ = false;
|
|
|
|
const VkImageUsageFlags lumaUsage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT;
|
|
const VkImageUsageFlags flowUsage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
|
|
const VkImageUsageFlags regUsage = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
|
|
pyrA_.resize(kLevels); pyrB_.resize(kLevels); flowLvl_.resize(kLevels);
|
|
for (int l = 0; l < kLevels; ++l) {
|
|
VkExtent2D e = levelExtent(extent, l);
|
|
if (!makeImage(pyrA_[l], e, VK_FORMAT_R32_SFLOAT, lumaUsage)) return false;
|
|
if (!makeImage(pyrB_[l], e, VK_FORMAT_R32_SFLOAT, lumaUsage)) return false;
|
|
}
|
|
for (int l = flowFinest_; l < kLevels; ++l)
|
|
if (!makeImage(flowLvl_[l], levelExtent(extent, l), VK_FORMAT_R16G16B16A16_SFLOAT, flowUsage)) return false;
|
|
pyrAs_.resize(kLevels);
|
|
for (int l = flowFinest_; l < kLevels; ++l)
|
|
if (!makeImage(pyrAs_[l], levelExtent(extent, l), VK_FORMAT_R32_SFLOAT, lumaUsage)) return false;
|
|
if (!makeImage(flowExpA_, extent, VK_FORMAT_R16G16B16A16_SFLOAT, flowUsage)) return false;
|
|
if (!makeImage(flowExpB_, extent, VK_FORMAT_R16G16B16A16_SFLOAT, flowUsage)) return false;
|
|
if (!makeImage(flowRegA_, levelExtent(extent, flowFinest_), VK_FORMAT_R16G16B16A16_SFLOAT, regUsage)) return false;
|
|
if (!makeImage(flowRegB_, levelExtent(extent, flowFinest_), VK_FORMAT_R16G16B16A16_SFLOAT, regUsage)) return false;
|
|
ready_ = true;
|
|
DDFG_LOGI("framegen resized to %ux%u (%d pyramid levels, kFlowFinest=%d perf_preset=%d)",
|
|
extent.width, extent.height, kLevels, flowFinest_, cfg_.perfPreset);
|
|
return true;
|
|
}
|
|
|
|
void FrameGen::barrier(VkCommandBuffer cmd, VkImage img, VkImageLayout from, VkImageLayout to) {
|
|
VkImageMemoryBarrier b{VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER};
|
|
b.oldLayout = from; b.newLayout = to;
|
|
b.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT;
|
|
b.dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT;
|
|
b.image = img; b.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1};
|
|
b.srcQueueFamilyIndex = b.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
|
|
dd_->CmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
|
|
VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0, 0, nullptr, 0, nullptr, 1, &b);
|
|
}
|
|
|
|
|
|
void FrameGen::destroy() {
|
|
if (!device_) return;
|
|
dd_->DeviceWaitIdle(device_);
|
|
for (auto& i : pyrA_) destroyImage(i); pyrA_.clear();
|
|
for (auto& i : pyrB_) destroyImage(i); pyrB_.clear();
|
|
for (auto& i : pyrAs_) destroyImage(i); pyrAs_.clear();
|
|
for (auto& i : flowLvl_) destroyImage(i); flowLvl_.clear();
|
|
destroyImage(flowExpA_); destroyImage(flowExpB_);
|
|
destroyImage(flowRegA_); destroyImage(flowRegB_);
|
|
destroyPipe(pLuma_); destroyPipe(pDown_); destroyPipe(pFlow_); destroyPipe(pFlowM4_);
|
|
destroyPipe(pExpand_); destroyPipe(pExpandM4_); destroyPipe(pSynth_);
|
|
destroyPipe(pGmReduce_); destroyPipe(pGmPrewarp_);
|
|
destroyPipe(pFlowReg_);
|
|
for (int s = 0; s < kGmSlots; ++s) {
|
|
if (gmSsboMem_[s]) dd_->UnmapMemory(device_, gmSsboMem_[s]);
|
|
if (gmSsbo_[s]) dd_->DestroyBuffer(device_, gmSsbo_[s], nullptr);
|
|
if (gmSsboMem_[s]) dd_->FreeMemory(device_, gmSsboMem_[s], nullptr);
|
|
gmSsbo_[s] = VK_NULL_HANDLE; gmSsboMem_[s] = VK_NULL_HANDLE; gmSsboPtr_[s] = nullptr;
|
|
}
|
|
gmBuffersReady_ = false;
|
|
if (descPool_) dd_->DestroyDescriptorPool(device_, descPool_, nullptr);
|
|
if (linear_) dd_->DestroySampler(device_, linear_, nullptr);
|
|
descPool_ = VK_NULL_HANDLE; linear_ = VK_NULL_HANDLE; device_ = VK_NULL_HANDLE; ready_ = false;
|
|
}
|
|
|
|
}
|
|
|
|
#include "record_impl.inc"
|