TexturePagePool.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "VirtualTextureShared.h"
#include "Containers/BinaryHeap.h"
#include "Containers/HashTable.h"
 
union FVirtualTextureLocalTile;
class FVirtualTexturePhysicalSpace;
union FVirtualTextureProducerHandle;
class FVirtualTextureSpace;
class FVirtualTextureSystem;
struct FVTProducerDescription;
 
class FTexturePagePool
{
public:
    FTexturePagePool();
    ~FTexturePagePool();
 
    void Initialize(uint32 InNumPages);
 
    FCriticalSection& GetLock() { return CriticalSection; }
 
    uint32 GetNumPages() const { return FMath::Max(NumPages, NumReservedPages) - NumReservedPages; }
    uint32 GetNumLockedPages() const { return GetNumPages() - FreeHeap.Num(); }
    uint32 GetNumMappedPages() const { return NumPagesMapped; }
    uint32 GetNumAllocatedPages() const { return NumPagesAllocated; }
 
    void EvictAllPages(FVirtualTextureSystem* System);
 
    void EvictPages(FVirtualTextureSystem* System, const FVirtualTextureProducerHandle& ProducerHandle);
 
    void EvictPages(FVirtualTextureSystem* System, FVirtualTextureProducerHandle const& ProducerHandle, FVTProducerDescription const& Desc, FIntRect const& TextureRegion, uint32 MaxLevelToEvict, 
                    uint32 MinFrameToKeepMapped, EVTInvalidatePriority InvalidatePriority, TSet<union FVirtualTextureLocalTileRequest>& OutDirtyMapped);
 
    void UnmapAllPagesForSpace(FVirtualTextureSystem* System, uint8 SpaceID, uint32 vAddress, uint32 Width, uint32 Height, uint32 MaxLevel);
 
    void RemapPages(FVirtualTextureSystem* System, uint8 SpaceID, FVirtualTexturePhysicalSpace* PhysicalSpace, FVirtualTextureProducerHandle const& ProducerHandleOld, uint32 OldVirtualAddress, FVirtualTextureProducerHandle const& ProducerHandleNew, uint32 NewVirtualAddress, int32 vLevelBias, uint32 Frame);
 
    void GetAllLockedPages(FVirtualTextureSystem* System, TSet<union FVirtualTextureLocalTile>& OutPages);
 
    FVirtualTextureLocalTile GetLocalTileFromPhysicalAddress(uint16 pAddress);
    
    inline uint8 GetLocalLevelForAddress(uint16 pAddress) const { check(Pages[pAddress].PackedValue != 0u); return Pages[pAddress].Local_vLevel; }
 
    bool AnyFreeAvailable( uint32 Frame, uint32 FreeThreshold ) const;
 
    uint32      FindPageAddress(const FVirtualTextureProducerHandle& ProducerHandle, uint8 GroupIndex, uint32 Local_vAddress, uint8 Local_vLevel) const;
 
    uint32      FindNearestPageAddress(const FVirtualTextureProducerHandle& ProducerHandle, uint8 GroupIndex, uint32 Local_vAddress, uint8 Local_vLevel, uint8 MaxLevel) const;
 
    uint32      FindNearestPageLevel(const FVirtualTextureProducerHandle& ProducerHandle, uint8 GroupIndex, uint32 Local_vAddress, uint8 Local_vLevel) const;
    
    uint32      Alloc(FVirtualTextureSystem* System, uint32 Frame, const FVirtualTextureProducerHandle& ProducerHandle, uint8 GroupIndex, uint32 Local_vAddress, uint8 Local_vLevel, bool bLock);
 
    void        Free(FVirtualTextureSystem* System, uint16 pAddress);
 
    void        Lock(uint16 pAddress);
 
    void        Unlock(uint32 Frame, uint16 pAddress);
 
    void        UpdateUsage(uint32 Frame, uint16 pAddress);
 
    uint32      GetNumVisiblePages(uint32 Frame) const;
 
    void        CollectProducerCounts(TMap<uint32, FUintVector2>& OutProducerCountMap) const;
 
    void        MapPage(FVirtualTextureSpace* Space, FVirtualTexturePhysicalSpace* PhysicalSpace, uint8 PageTableLayerIndex, uint8 MaxLevel, uint8 vLogSize, uint32 vAddress, uint8 Local_vLevel, uint16 pAddress);
 
private:
    // Allocate 24 bits to store next/prev indices, pack layer index into 8 bits
    static const uint32 PAGE_MAPPING_CAPACITY = 0x00ffffff;
 
    struct FPageMapping
    {
        uint32 vAddress : 24;
        uint32 vLogSize : 4;
        uint32 MaxLevel : 4;
 
        uint32 NextIndex : 24;
        uint32 SpaceID : 8;
 
        uint32 PrevIndex : 24;
        uint32 PageTableLayerIndex : 8;
    };
 
    union FPageEntry
    {
        uint64 PackedValue;
        struct 
        {
            uint32 PackedProducerHandle;
            uint32 Local_vAddress : 24;
            uint32 Local_vLevel : 4;
            uint32 GroupIndex : 4;
        };
    };
 
    static uint16 GetPageHash(const FPageEntry& Entry);
 
    void UnmapPageMapping(FVirtualTextureSystem* System, uint32 MappingIndex, bool bMapAncestorPage);
    void UnmapAllPages(FVirtualTextureSystem* System, uint16 pAddress, bool bMapAncestorPages);
 
    void RemoveMappingFromList(uint32 Index)
    {
        FPageMapping& Mapping = PageMapping[Index];
        PageMapping[Mapping.PrevIndex].NextIndex = Mapping.NextIndex;
        PageMapping[Mapping.NextIndex].PrevIndex = Mapping.PrevIndex;
        Mapping.NextIndex = Mapping.PrevIndex = Index;
    }
 
    void AddMappingToList(uint32 HeadIndex, uint32 Index)
    {
        FPageMapping& Head = PageMapping[HeadIndex];
        FPageMapping& Mapping = PageMapping[Index];
        check(Index > NumPages); // make sure we're not trying to add a list head to another list
        check(Index <= PAGE_MAPPING_CAPACITY);
 
        // make sure we're not currently in any list
        check(Mapping.NextIndex == Index);
        check(Mapping.PrevIndex == Index);
 
        Mapping.NextIndex = HeadIndex;
        Mapping.PrevIndex = Head.PrevIndex;
        PageMapping[Head.PrevIndex].NextIndex = Index;
        Head.PrevIndex = Index;
    }
 
    uint32 AcquireMapping()
    {
        const uint32 FreeHeadIndex = NumPages;
        FPageMapping& FreeHead = PageMapping[FreeHeadIndex];
        uint32 Index = FreeHead.NextIndex;
        if (Index != FreeHeadIndex)
        {
            RemoveMappingFromList(Index);
            return Index;
        }
 
        Index = PageMapping.AddDefaulted();
        check(Index <= PAGE_MAPPING_CAPACITY);
        FPageMapping& Mapping = PageMapping[Index];
        Mapping.NextIndex = Mapping.PrevIndex = Index;
        return Index;
    }
 
    void ReleaseMapping(uint32 Index)
    {
        const uint32 FreeHeadIndex = NumPages;
        RemoveMappingFromList(Index);
        AddMappingToList(FreeHeadIndex, Index);
    }
 
    FCriticalSection CriticalSection;
 
    FBinaryHeap<uint32, uint16> FreeHeap;
 
    FHashTable PageHash;
    FHashTable ProducerToPageIndex;
    TArray<FPageEntry> Pages;
 
    // Holds linked lists of mappings for each  physical page in the pool
    // Indices [0, NumPages) hold the list head for list of mappings for each page
    // Index 'NumPages' holds the list head for the free list
    // Additional indices are list elements belonging to one of the prior lists
    TArray<FPageMapping> PageMapping;
 
    uint32 NumPages;
    uint32 NumPagesMapped;
    uint32 NumPagesAllocated;
 
    static const uint32 NumReservedPages;
};