vulkan: back sparse terrain arrays at low detail without sparse residency

src/video_core/renderer_opengl/gl_texture_cache.cpp

@@ -1200,7 +1200,7 @@ ImageView::ImageView(TextureCacheRuntime& runtime, const VideoCommon::ImageViewI
 ImageView::ImageView(TextureCacheRuntime&, const VideoCommon::ImageInfo& info,
                      const VideoCommon::ImageViewInfo& view_info, GPUVAddr gpu_addr_)
     : VideoCommon::ImageViewBase{info, view_info, gpu_addr_},
-      buffer_size{VideoCommon::CalculateGuestSizeInBytes(info)} {}
+      buffer_size{static_cast<u32>(VideoCommon::CalculateGuestSizeInBytes(info))} {}
 
 ImageView::ImageView(TextureCacheRuntime&, const VideoCommon::ImageInfo& info,
                      const VideoCommon::ImageViewInfo& view_info)

src/video_core/renderer_vulkan/vk_texture_cache.cpp

@@ -180,7 +180,7 @@ constexpr VkBorderColor ConvertBorderColor(const std::array<float, 4>& color) {
         return false;
     }
     constexpr u32 MinSize = 32U << 20;
-    const u32 size = VideoCommon::CalculateGuestSizeInBytes(info);
+    const u64 size = VideoCommon::CalculateGuestSizeInBytes(info);
     return size >= MinSize && info.type != ImageType::e1D && info.type != ImageType::Buffer &&
            info.type != ImageType::Linear && Tegra::Nx2SparseUnwritten(gpu_addr, size);
 }
@@ -200,10 +200,33 @@ constexpr VkBorderColor ConvertBorderColor(const std::array<float, 4>& color) {
         IsHugeAstcArray(device, info) ||
         (!IsPixelFormatASTC(info.format) &&
          (!IsPixelFormatBCn(info.format) || device.IsOptimalBcnSupported()));
-    const u32 size = VideoCommon::CalculateGuestSizeInBytes(info);
+    const u64 size = VideoCommon::CalculateGuestSizeInBytes(info);
     return layer_uploads && size >= (32U << 20) && Tegra::Nx2InSparseRegion(gpu_addr, size);
 }
 
+// A huge natively sampled color array in a Switch 2 sparse region on a host that cannot leave
+// layers unbound (MoltenVK, AMD): title 1's terrain arrays (8192x8192x68, 1.4 and 5.8 GB) hold
+// full detail in a few layers and the low levels (1024x1024 and below) in all of them. Such an
+// array is backed with its low levels only (see TrimmedHostInfo, Image::CompactLayers).
+[[nodiscard]] bool UsesCompactLayers(const Device& device, const ImageInfo& info,
+                                     GPUVAddr gpu_addr) {
+    // The complement of UsesSparseLayers' device check: AMD has sparse residency but cannot
+    // sample unbound memory.
+    if ((device.IsSparseResidencyImage2DSupported() && device.CanUseUnbackedSparseImages()) ||
+        info.type != ImageType::e2D ||
+        info.resources.layers <= 1 || info.resources.levels <= 1 || info.num_samples != 1 ||
+        info.size.depth != 1 ||
+        VideoCore::Surface::GetFormatType(info.format) !=
+            VideoCore::Surface::SurfaceType::ColorTexture ||
+        (IsPixelFormatASTC(info.format) && !device.IsOptimalAstcSupported()) ||
+        (IsPixelFormatBCn(info.format) && !device.IsOptimalBcnSupported())) {
+        return false;
+    }
+    constexpr u32 MinSize = 256U << 20;
+    const u64 size = VideoCommon::CalculateGuestSizeInBytes(info);
+    return size >= MinSize && Tegra::Nx2InSparseRegion(gpu_addr, size);
+}
+
 // How SparseTiles images leave the blocks without data: unbound (reads give zero), or all bound to
 // one zeroed block where the driver can't sample unbound memory (AMD) but lets blocks share
 // memory. EDEN_NX2_SPARSE_ALIASED=1 takes the shared block wherever it is supported, =0 never.
@@ -243,7 +266,7 @@ enum class SparseTilesMode {
         VideoCore::Surface::GetFormatType(info.format) != VideoCore::Surface::SurfaceType::ColorTexture) {
         return false;
     }
-    const u32 size = VideoCommon::CalculateGuestSizeInBytes(info);
+    const u64 size = VideoCommon::CalculateGuestSizeInBytes(info);
     return size >= (32U << 20) && Tegra::Nx2InSparseRegion(gpu_addr, size);
 }
 
@@ -350,12 +373,59 @@ constexpr std::array<VkFormat, 2> OpaqueAstcViewFormats{VK_FORMAT_BC1_RGBA_UNORM
     return device.GetDeviceLocalMemory() < (u64{7} << 30) ? (u64{256} << 20) : (u64{512} << 20);
 }
 
+// The most a compact layered array keeps on the host: 256 MiB. EDEN_NX2_COMPACT_ARRAY_MIB=<MiB>
+// sets it.
+[[nodiscard]] u64 CompactLayersLimit() {
+    static const u64 limit = [] {
+        const char* value = std::getenv("EDEN_NX2_COMPACT_ARRAY_MIB");
+        const u64 mib = value != nullptr ? std::strtoull(value, nullptr, 10) : 0;
+        return (mib != 0 ? mib : 256) << 20;
+    }();
+    return limit;
+}
+
+// The host shape of a UsesCompactLayers array: the mip levels from `level_offset` on, the first
+// level count that fits CompactLayersLimit. Normalized coordinates and derivative LOD still
+// address it correctly.
+[[nodiscard]] ImageInfo CompactHostInfo(const ImageInfo& info, u32& level_offset) {
+    const u64 block_bytes = VideoCore::Surface::BytesPerBlock(info.format);
+    const u32 block_width = VideoCore::Surface::DefaultBlockWidth(info.format);
+    const u32 block_height = VideoCore::Surface::DefaultBlockHeight(info.format);
+    const auto host_bytes = [&](u32 skip) {
+        u64 bytes = 0;
+        for (s32 level = static_cast<s32>(skip); level < info.resources.levels; ++level) {
+            bytes += u64{Common::DivCeil((std::max)(info.size.width >> level, 1U), block_width)} *
+                     Common::DivCeil((std::max)(info.size.height >> level, 1U), block_height) *
+                     block_bytes;
+        }
+        return bytes * info.resources.layers;
+    };
+    while (level_offset + 1 < static_cast<u32>(info.resources.levels) &&
+           host_bytes(level_offset) > CompactLayersLimit()) {
+        ++level_offset;
+    }
+    ImageInfo host = info;
+    host.size.width = (std::max)(info.size.width >> level_offset, 1U);
+    host.size.height = (std::max)(info.size.height >> level_offset, 1U);
+    host.resources.levels -= static_cast<s32>(level_offset);
+    LOG_WARNING(Render_Vulkan,
+                "{}x{}x{} array in a sparse region is {} MiB; keeping mip levels {}+ ({}x{}, "
+                "{} MiB)",
+                info.size.width, info.size.height, info.resources.layers, host_bytes(0) >> 20,
+                level_offset, host.size.width, host.size.height, host_bytes(level_offset) >> 20);
+    return host;
+}
+
 // The host shape of an image whose decoded copy would not fit in VRAM: a GPU-decoded ASTC array
 // over 1 GiB as RGBA8 (title 1's 8192x8192x68 ASTC 8x8 virtual textures are 24 GB each) keeps only
 // its mip levels from `level_offset` on, so host mip 0 is guest mip `level_offset`. Normalized
 // coordinates and derivative LOD still address it correctly; explicit LODs sample one level lower.
-[[nodiscard]] ImageInfo TrimmedHostInfo(const Device& device, const ImageInfo& info, u32& level_offset) {
+[[nodiscard]] ImageInfo TrimmedHostInfo(const Device& device, const ImageInfo& info,
+                                        u32& level_offset, GPUVAddr gpu_addr) {
     level_offset = 0;
+    if (UsesCompactLayers(device, info, gpu_addr)) {
+        return CompactHostInfo(info, level_offset);
+    }
     if (!WillUseAcceleratedAstcDecode(device, info) || info.type != ImageType::e2D) {
         return info;
     }
@@ -759,20 +829,26 @@ TransformBufferCopies(std::span<const VideoCommon::BufferCopy> copies, size_t bu
     };
 }
 
-// A guest view's levels on a host image that keeps only levels >= host_level_offset.
-[[nodiscard]] SubresourceRange HostRange(const Image& image, SubresourceRange range) {
-    const s32 skip = static_cast<s32>(image.host_level_offset);
+// A guest view's levels on a host image of `levels` guest levels that keeps only levels >=
+// host_level_offset.
+[[nodiscard]] SubresourceRange HostRange(u32 host_level_offset, s32 levels,
+                                         SubresourceRange range) {
+    const s32 skip = static_cast<s32>(host_level_offset);
     if (skip == 0) {
         return range;
     }
-    const s32 host_levels = image.info.resources.levels - skip;
+    const s32 host_levels = levels - skip;
     const s32 base = std::clamp(range.base.level - skip, 0, host_levels - 1);
     const s32 end = std::clamp(range.base.level + range.extent.levels - skip, base + 1, host_levels);
     range.base.level = base;
     range.extent.levels = end - base;
     return range;
 }
 
+[[nodiscard]] SubresourceRange HostRange(const Image& image, SubresourceRange range) {
+    return HostRange(image.host_level_offset, image.info.resources.levels, range);
+}
+
 [[nodiscard]] VkImageSubresourceRange MakeSubresourceRange(const ImageView* image_view) {
     SubresourceRange range = image_view->range;
     if (True(image_view->flags & VideoCommon::ImageViewFlagBits::Slice)) {
@@ -2628,7 +2704,7 @@ Image::Image(TextureCacheRuntime& runtime_, const ImageInfo& info_, GPUVAddr gpu
     : VideoCommon::ImageBase(info_, gpu_addr_, cpu_addr_), scheduler{&runtime_.scheduler},
       runtime{&runtime_},
       original_image(MakeImage(runtime_.device, runtime_.memory_allocator,
-                               TrimmedHostInfo(runtime_.device, info, host_level_offset),
+                               TrimmedHostInfo(runtime_.device, info, host_level_offset, gpu_addr_),
                                IsHugeAstcArray(runtime_.device, info)
                                    ? std::span<const VkFormat>{HugeAstcViewFormats}
                                : IsOpaqueBc1Astc(runtime_.device, info)
@@ -2643,7 +2719,8 @@ Image::Image(TextureCacheRuntime& runtime_, const ImageInfo& info_, GPUVAddr gpu
       aspect_mask(ImageAspectMask(info.format)) {
     if (original_image.IsUnbacked()) {
         flags |= VideoCommon::ImageFlagBits::Unbacked;
-        const ImageInfo host_info = TrimmedHostInfo(runtime_.device, info, host_level_offset);
+        const ImageInfo host_info =
+            TrimmedHostInfo(runtime_.device, info, host_level_offset, gpu_addr_);
         const u64 texels = u64{host_info.size.width} * host_info.size.height *
                            host_info.size.depth * static_cast<u64>(host_info.resources.layers);
         if (UsesSparseLayers(runtime_.device, info, gpu_addr_) && InitSparseLayers()) {
@@ -2658,6 +2735,9 @@ Image::Image(TextureCacheRuntime& runtime_, const ImageInfo& info_, GPUVAddr gpu
     }
     if (host_level_offset != 0) {
         flags |= VideoCommon::ImageFlagBits::TrimmedLevels;
+        if (UsesCompactLayers(runtime_.device, info, gpu_addr_) && !original_image.IsUnbacked()) {
+            flags |= VideoCommon::ImageFlagBits::CompactLayers;
+        }
     }
     if (IsHugeAstcArray(runtime->device, info)) {
         flags |= VideoCommon::ImageFlagBits::AcceleratedUpload;
@@ -3141,7 +3221,7 @@ bool Image::InitSparseLayers() {
     s.requirements = device.GetLogical().GetImageMemoryRequirements(handle);
     s.sparse = *it;
     u32 offset = host_level_offset;
-    const ImageInfo host = TrimmedHostInfo(device, info, offset);
+    const ImageInfo host = TrimmedHostInfo(device, info, offset, gpu_addr);
     s.width = host.size.width;
     s.height = host.size.height;
     s.levels = static_cast<u32>(host.resources.levels);
@@ -3909,6 +3989,7 @@ ImageView::ImageView(TextureCacheRuntime& runtime, const VideoCommon::ImageViewI
                      ImageId image_id_, Image& image)
     : VideoCommon::ImageViewBase{info, image.info, image_id_, image.gpu_addr},
       device{&runtime.device}, image_handle{image.Handle()},
+      host_level_offset{image.host_level_offset}, image_levels{image.info.resources.levels},
       samples(ConvertSampleCount(image.info.num_samples)) {
     using Shader::TextureType;
 
@@ -4039,7 +4120,7 @@ ImageView::ImageView(TextureCacheRuntime& runtime, const VideoCommon::ImageViewI
 ImageView::ImageView(TextureCacheRuntime& runtime, const VideoCommon::ImageInfo& info,
                      const VideoCommon::ImageViewInfo& view_info, GPUVAddr gpu_addr_)
     : VideoCommon::ImageViewBase{info, view_info, gpu_addr_},
-      buffer_size{VideoCommon::CalculateGuestSizeInBytes(info)} {}
+      buffer_size{static_cast<u32>(VideoCommon::CalculateGuestSizeInBytes(info))} {}
 
 ImageView::ImageView(TextureCacheRuntime& runtime, const VideoCommon::NullImageViewParams& params)
     : VideoCommon::ImageViewBase{params}, device{&runtime.device} {
@@ -4125,7 +4206,8 @@ bool ImageView::IsRescaled() const noexcept {
 vk::ImageView ImageView::MakeView(VkFormat vk_format, VkImageAspectFlags aspect_mask,
                                   std::optional<Shader::TextureType> texture_type) {
     VkImageViewType view_type = ImageViewType(type);
-    VkImageSubresourceRange subresource_range = MakeSubresourceRange(aspect_mask, range);
+    VkImageSubresourceRange subresource_range =
+        MakeSubresourceRange(aspect_mask, HostRange(host_level_offset, image_levels, range));
     const auto is_3d = [](VkImageViewType t) { return t == VK_IMAGE_VIEW_TYPE_3D; };
     if (texture_type && is_3d(ImageViewType(*texture_type)) != is_3d(view_type)) {
         // A 3D view of a 2D image (or the reverse) is invalid in Vulkan and aborts on Metal; keep

src/video_core/renderer_vulkan/vk_texture_cache.h

@@ -730,6 +730,8 @@ class ImageView : public VideoCommon::ImageViewBase {
     vk::Image null_image;
     VkImage image_handle = VK_NULL_HANDLE;
     VkImageView render_target = VK_NULL_HANDLE;
+    u32 host_level_offset = 0; // the image's (see Image::host_level_offset)
+    s32 image_levels = 0;
     VkSampleCountFlagBits samples = VK_SAMPLE_COUNT_1_BIT;
     u32 buffer_size = 0;
 

src/video_core/texture_cache/image_base.h

@@ -60,6 +60,10 @@ enum class ImageFlagBits : u32 {
     /// device memory when the guest memory under it can hold data (Image::BindTiles), and only
     /// the parts written are uploaded.
     SparseTiles = 1 << 23,
+    /// A large array over Switch 2 sparse blocks on a host that cannot leave it unbound: backed,
+    /// but only its mip levels from host_level_offset on (the written parts of title 1's terrain
+    /// arrays are the low levels of every layer), uploaded layer by layer.
+    CompactLayers = 1 << 24,
 };
 DECLARE_ENUM_FLAG_OPERATORS(ImageFlagBits)
 
@@ -104,7 +108,7 @@ struct ImageBase {
 
     ImageInfo info;
 
-    u32 guest_size_bytes = 0;
+    u64 guest_size_bytes = 0;
     u32 unswizzled_size_bytes = 0;
     u32 converted_size_bytes = 0;
     u32 scale_rating = 0;

src/video_core/texture_cache/texture_cache.h

@@ -1666,6 +1666,10 @@ void TextureCache<P>::RefreshContents(Image& image, ImageId image_id) {
         RefreshSparseLayers(image);
         return;
     }
+    if (True(image.flags & ImageFlagBits::CompactLayers)) {
+        RefreshCompactLayers(image);
+        return;
+    }
     if (True(image.flags & ImageFlagBits::SparseTiles)) {
         RefreshSparseTiles(image);
         return;
@@ -1769,7 +1773,7 @@ bool TextureCache<P>::UploadsByLayer(const ImageBase& image) const noexcept {
     // Title 1's terrain arrays (8192x8192x68 ASTC, 1.45 GB each) get a few layers streamed in at a
     // time; re-decoding all of them for each took a 2 GiB staging buffer and stalled the GPU.
     if constexpr (requires { &Runtime::AccelerateImageUploadLayers; }) {
-        if (True(image.flags & ImageFlagBits::SparseLayers)) {
+        if (True(image.flags & (ImageFlagBits::SparseLayers | ImageFlagBits::CompactLayers))) {
             return true;
         }
         return True(image.flags & ImageFlagBits::AcceleratedUpload) &&
@@ -1926,6 +1930,29 @@ void TextureCache<P>::RefreshSparseLayers(Image& image) {
     }
 }
 
+template <class P>
+void TextureCache<P>::RefreshCompactLayers(Image& image) {
+    if constexpr (requires { &Runtime::AccelerateImageUploadLayers; }) {
+        // A new image takes every layer (what the game never wrote reads as zero from guest
+        // memory, and the host image starts undefined); later only the layers written since.
+        const u32 num_layers = static_cast<u32>(image.info.resources.layers);
+        std::vector<u32> layers;
+        for (u32 layer = 0; layer < num_layers; ++layer) {
+            if (image.dirty_layers.empty() ||
+                ((image.dirty_layers[layer / 64] >> (layer % 64)) & 1) != 0) {
+                layers.push_back(layer);
+            }
+        }
+        image.dirty_layers.clear();
+        constexpr size_t LayersPerUpload = 16;
+        for (size_t first = 0; first < layers.size(); first += LayersPerUpload) {
+            const size_t count = (std::min)(LayersPerUpload, layers.size() - first);
+            UploadLayers(image, std::span<const u32>{layers.data() + first, count});
+        }
+        runtime.InsertUploadMemoryBarrier();
+    }
+}
+
 template <class P>
 std::vector<u32> TextureCache<P>::BindSparseLayers(Image& image, std::span<const u32> layers) {
     if constexpr (requires { &Image::BindLayers; }) {
@@ -1945,20 +1972,32 @@ template <class P>
 void TextureCache<P>::UploadLayers(Image& image, std::span<const u32> layers) {
     if constexpr (requires { &Runtime::AccelerateImageUploadLayers; }) {
         if (False(image.flags & ImageFlagBits::AcceleratedUpload)) {
-            // Plain formats: each layer unswizzled on its own into its layer of the image.
+            // Plain formats: each layer unswizzled on its own into its layer of the image. Of a
+            // trimmed image only the levels the host keeps are read.
             ImageInfo layer_info = image.info;
             layer_info.resources.layers = 1;
-            const size_t layer_size = CalculateUnswizzledSizeBytes(layer_info);
+            const s32 first_level = static_cast<s32>(image.host_level_offset);
+            size_t level_offset = 0;
+            ImageInfo host_info = layer_info;
+            if (first_level != 0) {
+                level_offset = FullUploadSwizzles(layer_info)[first_level].buffer_offset;
+                host_info.size.width = (std::max)(layer_info.size.width >> first_level, 1U);
+                host_info.size.height = (std::max)(layer_info.size.height >> first_level, 1U);
+                host_info.resources.levels -= first_level;
+            }
+            const size_t layer_size = CalculateUnswizzledSizeBytes(host_info);
             auto staging = runtime.UploadStagingBuffer(layer_size * layers.size());
             std::vector<BufferImageCopy> copies;
             for (size_t i = 0; i < layers.size(); ++i) {
-                const GPUVAddr layer_addr = image.gpu_addr + u64{layers[i]} * image.info.layer_stride;
+                const GPUVAddr layer_addr =
+                    image.gpu_addr + u64{layers[i]} * image.info.layer_stride + level_offset;
                 Tegra::Memory::GpuGuestMemory<u8, Tegra::Memory::GuestMemoryFlags::UnsafeRead>
-                    swizzle_data(*gpu_memory, layer_addr, image.info.layer_stride,
+                    swizzle_data(*gpu_memory, layer_addr, image.info.layer_stride - level_offset,
                                  &swizzle_data_buffer);
                 auto layer_copies =
                     UnswizzleImage(*gpu_memory, layer_addr, layer_info, swizzle_data,
-                                   staging.mapped_span.subspan(i * layer_size, layer_size));
+                                   staging.mapped_span.subspan(i * layer_size, layer_size),
+                                   first_level);
                 for (BufferImageCopy copy : layer_copies) {
                     copy.buffer_offset += i * layer_size;
                     copy.image_subresource.base_layer = static_cast<s32>(layers[i]);
@@ -1998,7 +2037,6 @@ template <typename StagingBuffer>
 void TextureCache<P>::UploadImageContents(Image& image, StagingBuffer& staging) {
     const std::span<u8> mapped_span = staging.mapped_span;
     const GPUVAddr gpu_addr = image.gpu_addr;
-
     if (True(image.flags & ImageFlagBits::AcceleratedUpload) && image.host_level_offset != 0) {
         // Only levels >= host_level_offset exist on the host: read each layer's tail of the mip
         // chain into a compact buffer (layer stride = that tail's size) and decode those levels.
@@ -2225,6 +2263,10 @@ u64 TextureCache<P>::ImageMemoryBytes(const Image& image) const {
         return 0;
     }
     u64 tentative_size = (std::max)(image.guest_size_bytes, image.unswizzled_size_bytes);
+    if (True(image.flags & ImageFlagBits::CompactLayers)) {
+        // Each level is a quarter of the one before.
+        tentative_size >>= 2 * image.host_level_offset;
+    }
     if ((IsPixelFormatASTC(image.info.format) &&
          True(image.flags & ImageFlagBits::AcceleratedUpload)) ||
         True(image.flags & ImageFlagBits::Converted)) {