SignedArchiveReader.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "HAL/ThreadSafeCounter.h"
#include "Containers/LockFreeList.h"
#include "IPlatformFilePak.h"
#include "HAL/PlatformProcess.h"
#include "HAL/Runnable.h"
#include "Math/BigInt.h"
 
struct FChunkBuffer
{
    uint8* Data;
    int32 LockCount;
    int32 ChunkIndex;
    double LastAccessTime;
 
    FChunkBuffer()
        : Data(NULL)
        , LockCount(0)
        , ChunkIndex(INDEX_NONE)
        , LastAccessTime(0.0)
    {
        Data = (uint8*)FMemory::Malloc(FPakInfo::MaxChunkDataSize);
    }
 
    ~FChunkBuffer()
    {
        FMemory::Free(Data);
        Data = NULL;
    }
};
 
struct FChunkRequest
{
    int32 Index;
    int64 Offset;
    int64 Size;
    FChunkBuffer* Buffer;
    FThreadSafeCounter IsTrusted;
    FThreadSafeCounter RefCount;
    FEvent* Event;
 
    FChunkRequest()
        : Index(INDEX_NONE)
        , Offset(0)
        , Size(0)
        , Buffer(nullptr)
        , IsTrusted(0)
        , RefCount(0)
        , Event(nullptr)
    {}
 
    FORCEINLINE void WaitUntilReady() const
    {
        while (IsTrusted.GetValue() == 0)
        {
            FPlatformProcess::Sleep(0.0f);
        }
    }
    FORCEINLINE bool IsReady() const
    {
        return IsTrusted.GetValue() != 0;
    }
};
 
class FChunkCacheWorker : public FRunnable
{   
    enum
    {
        MaxCachedChunks = 8     
    };
 
    TSharedPtr<const FPakSignatureFile, ESPMode::ThreadSafe> Signatures;
    TPakChunkHash OriginalSignatureFileHash;
    FRunnableThread* Thread;
    TUniquePtr<FArchive> Reader;
    FChunkBuffer CachedChunks[MaxCachedChunks];
    TArray<FChunkRequest*> RequestQueue;    
    FCriticalSection QueueLock;
    FThreadSafeCounter PendingQueueCounter;
    FEvent* QueuedRequestsEvent;
    TArray<FChunkRequest*> ActiveRequests;
    FThreadSafeCounter StopTaskCounter;
    TLockFreePointerListUnordered<FChunkRequest, PLATFORM_CACHE_LINE_SIZE> FreeChunkRequests;
    TLockFreePointerListUnordered<FEvent,PLATFORM_CACHE_LINE_SIZE> EventsToRelease;
 
    int32 ProcessQueue();
    bool CheckSignature(const FChunkRequest& ChunkInfo);
    FChunkBuffer* GetCachedChunkBuffer(int32 ChunkIndex);
    FChunkBuffer* GetFreeBuffer();
    void ReleaseBuffer(int32 ChunkIndex);
    FORCEINLINE bool IsMultithreaded() const 
    { 
        return Thread != nullptr;
    }
    FEvent* AcquireNotificationEvent() const;
    void ReleaseNotificationEvent(FEvent* Event);
 
public:
 
    FChunkCacheWorker(TUniquePtr<FArchive> InReader, const TCHAR* Filename);
    virtual ~FChunkCacheWorker();
 
    //~ Begin FRunnable Interface.
    virtual bool Init();
    virtual uint32 Run();
    virtual void Stop();
    //~ End FRunnable Interface
 
    TSharedPtr<const FPakSignatureFile, ESPMode::ThreadSafe> GetSignatures() const
    {
        return Signatures;
    }
 
    FChunkRequest& RequestChunk(int32 ChunkIndex, int64 StartOffset, int64 ChunkSize, FEvent* Event);
    void ReleaseChunk(FChunkRequest& Chunk);
 
 
    bool IsValid() const;
 
    friend class FSignedArchiveReader;
};
 
 
class FSignedArchiveReader : public FArchive
{
    struct FReadInfo
    {
        FChunkRequest* Request;
        FChunkBuffer* PreCachedChunk;
        int64 SourceOffset;
        int64 DestOffset;
        int64 Size;
    };
 
    int64 ChunkCount;   
    FArchive* PakReader;
    int64 SizeOnDisk;
    int64 PakSize;
    int64 PakOffset;
    FChunkCacheWorker* SignatureChecker;
    FChunkBuffer LastCachedChunk;
 
    FORCEINLINE int64 CalculateChunkIndex(int64 ReadOffset) const
    {
        return (ReadOffset / FPakInfo::MaxChunkDataSize);
    }   
 
    FORCEINLINE int64 CalculateChunkOffsetFromIndex(int64 BufferIndex) const
    {
        return BufferIndex * FPakInfo::MaxChunkDataSize;
    }
 
    FORCEINLINE int64 CalculateChunkOffset(int64 ReadOffset, int64& OutDataOffset) const
    {
        const int64 ChunkIndex = CalculateChunkIndex(ReadOffset);
        OutDataOffset = ReadOffset;
        return CalculateChunkOffsetFromIndex(ChunkIndex);
    }
    
    int64 CalculateChunkSize(int64 ChunkIndex) const;
 
    int64 PrecacheChunks(TArray<FReadInfo>& Chunks, int64 Length, FEvent* Event);
 
public:
 
    FSignedArchiveReader(FArchive* InPakReader, FChunkCacheWorker* InSignatureChecker);
    virtual ~FSignedArchiveReader();
 
    //~ Begin FArchive Interface
    virtual void Serialize(void* Data, int64 Length) override;
    virtual int64 Tell() override
    {
        return PakOffset;
    }
    virtual int64 TotalSize() override
    {
        return PakSize;
    }
    virtual void Seek(int64 InPos) override
    {
        PakOffset = InPos;
    }
    //~ End FArchive Interface
};