MappedFileHandle.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Misc/AssertionMacros.h"
#include "Stats/Stats.h"
 
 
DECLARE_MEMORY_STAT_EXTERN(TEXT("Mapped File Handle Memory"), STAT_MappedFileMemory, STATGROUP_Memory, CORE_API);
DECLARE_DWORD_ACCUMULATOR_STAT_EXTERN(TEXT("Num Mapped File Handles"), STAT_MappedFileHandles, STATGROUP_Memory, CORE_API);
DECLARE_DWORD_ACCUMULATOR_STAT_EXTERN(TEXT("Num Mapped File Regions"), STAT_MappedFileRegions, STATGROUP_Memory, CORE_API);
 
// Note on threading. Like the rest of the filesystem platform abstraction, these methods are threadsafe, but it is expected you are not concurrently _using_ these data structures. 
 
class IMappedFileRegion
{
    const uint8* MappedPtr;
    size_t MappedSize;
    FString DebugFilename;
    size_t DebugOffsetRelativeToFile;
 
    UE_FORCEINLINE_HINT void CheckInvariants()
    {
        check(MappedPtr && MappedSize);
    }
 
public:
 
    inline IMappedFileRegion(const uint8* InMappedPtr, size_t InMappedSize, const FString& InDebugFilename, size_t InDebugOffsetRelativeToFile)
        : MappedPtr(InMappedPtr)
        , MappedSize(InMappedSize)
        , DebugFilename(InDebugFilename)
        , DebugOffsetRelativeToFile(InDebugOffsetRelativeToFile)
    {
        CheckInvariants();
        INC_DWORD_STAT(STAT_MappedFileRegions);
        INC_MEMORY_STAT_BY(STAT_MappedFileMemory, MappedSize);
    }
 
    virtual ~IMappedFileRegion()
    {
        check(MappedSize);  
        DEC_MEMORY_STAT_BY(STAT_MappedFileMemory, MappedSize);
        DEC_DWORD_STAT(STAT_MappedFileRegions);
    }
 
 
    inline const uint8* GetMappedPtr()
    {
        CheckInvariants();
        return MappedPtr;
    }
 
    inline int64 GetMappedSize()
    {
        CheckInvariants();
        return MappedSize;
    }
 
    virtual void PreloadHint(int64 PreloadOffset = 0, int64 BytesToPreload = MAX_int64)
    {
    }
 
    virtual void Flush(int64 FlushOffset = 0, int64 BytesToFlush = MAX_int64)
    {
    }
 
    // Non-copyable
    IMappedFileRegion(const IMappedFileRegion&) = delete;
    IMappedFileRegion& operator=(const IMappedFileRegion&) = delete;
};
 
enum class EMappedFileFlags
{
    ENone = 0,              // Do nothing
    EPreloadHint = 1,       // Preload the data. This is only a hint and might be ignored, see IMappedFileRegion::PreloadHint
    EFileWritable = 2,      // Make the mapped file writable. Requires OpenMappedEx to be called with OpenOptions set to EOpenReadFlags::AllowWrite.
                            // This will create a shared mapping on Unix platform to allow any writes to be flushed to disk
};
 
ENUM_CLASS_FLAGS(EMappedFileFlags);
 
 
struct FFileMappingFlags
{
    FFileMappingFlags() : Flags(EMappedFileFlags::ENone) {}
    FFileMappingFlags(bool bPreloadHint) : Flags(bPreloadHint ? EMappedFileFlags::EPreloadHint : EMappedFileFlags::ENone) {}
    FFileMappingFlags(EMappedFileFlags InFlags) : Flags(InFlags) {}
    EMappedFileFlags Flags;
};
 
class IMappedFileHandle
{
    size_t MappedFileSize;
 
public:
    IMappedFileHandle(size_t InFileSize)
        : MappedFileSize(InFileSize)
    {
        INC_DWORD_STAT(STAT_MappedFileHandles);
    }
    virtual ~IMappedFileHandle()
    {
        DEC_DWORD_STAT(STAT_MappedFileHandles);
    }
 
    UE_FORCEINLINE_HINT int64 GetFileSize() const
    {
        return MappedFileSize;
    }
 
    virtual IMappedFileRegion* MapRegion(int64 Offset = 0, int64 BytesToMap = MAX_int64, FFileMappingFlags Flags = EMappedFileFlags::ENone) = 0;
 
    virtual void Flush(void)
    {
    }
 
    // Non-copyable
    IMappedFileHandle(const IMappedFileHandle&) = delete;
    IMappedFileHandle& operator=(const IMappedFileHandle&) = delete;
};