FPreloadableArchive Class Reference

#include <PreloadableFile.h>

Inheritance diagram for FPreloadableArchive:

Classes
struct	FSavedReadCompleteArguments

Public Types
enum	Flags {   None = 0x0 , ModeBits = 0x1 , PreloadHandle = 0x0 , PreloadBytes = 0x1 ,   Prime = 0x2 }
enum	{ DefaultPrimeSize = 1024 , DefaultPageSize = 64*1024 }
typedef TUniqueFunction< FArchive *()>	FCreateArchive
typedef TUniqueFunction< IAsyncReadFileHandle *()>	FCreateAsyncArchive

Public Member Functions
CORE_API	FPreloadableArchive (FStringView ArchiveName)
virtual CORE_API	~FPreloadableArchive ()
CORE_API void	SetPageSize (int64 PageSize)
CORE_API void	InitializeAsync (FCreateArchive &&InCreateArchiveFunction, uint32 InFlags=Flags::None, int64 PrimeSize=DefaultPrimeSize)
CORE_API void	InitializeAsync (FCreateAsyncArchive &&InCreateAsyncArchiveFunction, uint32 InFlags=Flags::None, int64 PrimeSize=DefaultPrimeSize)
CORE_API bool	IsInitialized () const
CORE_API void	WaitForInitialization () const
CORE_API bool	StartPreload ()
CORE_API void	StopPreload ()
CORE_API bool	IsPreloading () const
CORE_API bool	AllocateCache ()
CORE_API void	ReleaseCache ()
CORE_API bool	IsCacheAllocated () const
CORE_API FArchive *	DetachLowerLevel ()
CORE_API bool	HasValidData () const
virtual CORE_API void	Serialize (void *V, int64 Length) final
virtual CORE_API void	Seek (int64 InPos) final
virtual CORE_API int64	Tell () final
virtual CORE_API int64	TotalSize () final
virtual CORE_API bool	Close () final
virtual CORE_API FString	GetArchiveName () const final
Public Member Functions inherited from FArchive
	FArchive ()=default
	FArchive (const FArchive &)=default
FArchive &	operator= (const FArchive &ArchiveToCopy)=default
virtual CORE_API	~FArchive ()
virtual FArchive &	operator<< (FName &Value)
virtual CORE_API FArchive &	operator<< (FText &Value)
virtual FArchive &	operator<< (UObject *&Value)
virtual FArchive &	operator<< (FField *&Value)
template<class T >
FArchive &	operator<< (TCheckedObjPtr< T > &Value)
virtual CORE_API FArchive &	operator<< (struct FLazyObjectPtr &Value)
virtual CORE_API FArchive &	operator<< (struct FObjectPtr &Value)
virtual CORE_API FArchive &	operator<< (struct FSoftObjectPtr &Value)
virtual CORE_API FArchive &	operator<< (struct FSoftObjectPath &Value)
virtual CORE_API FArchive &	operator<< (struct FWeakObjectPtr &Value)
virtual void	ForceBlueprintFinalization ()
virtual void	SerializeBits (void *V, int64 LengthBits)
virtual void	SerializeInt (uint32 &Value, uint32 Max)
virtual CORE_API void	SerializeIntPacked (uint32 &Value)
virtual CORE_API void	SerializeIntPacked64 (uint64 &Value)
virtual void	Preload (UObject *Object)
FArchiveState &	GetArchiveState ()
const FArchiveState &	GetArchiveState () const
virtual void	AttachBulkData (UObject *Owner, FBulkData *BulkData)
virtual void	AttachBulkData (UE::Serialization::FEditorBulkData *BulkData)
virtual void	DetachBulkData (FBulkData *BulkData, bool bEnsureBulkDataIsLoaded)
virtual void	DetachBulkData (UE::Serialization::FEditorBulkData *BulkData, bool bEnsureBulkDataIsLoaded)
virtual bool	SerializeBulkData (FBulkData &BulkData, const FBulkDataSerializationParams &Params)
virtual bool	IsProxyOf (FArchive *InOther) const
virtual bool	Precache (int64 PrecacheOffset, int64 PrecacheSize)
virtual void	FlushCache ()
virtual bool	SetCompressionMap (TArray< FCompressedChunk > *CompressedChunks, ECompressionFlags CompressionFlags)
virtual void	Flush ()
CORE_API void	SerializeCompressed (void *V, int64 Length, FName CompressionFormatCannotChange, ECompressionFlags Flags=COMPRESS_NoFlags, bool bTreatBufferAsFileReader=false)
CORE_API void	SerializeCompressedNew (void *V, int64 Length, FName CompressionFormatToEncode, FName CompressionFormatToDecodeOldV1Files, ECompressionFlags Flags=COMPRESS_NoFlags, bool bTreatBufferAsFileReader=false, int64 *OutPartialReadLength=nullptr)
CORE_API void	SerializeCompressedNew (void *V, int64 Length)
CORE_API void	ByteSwap (void *V, int32 Length)
FArchive &	ByteOrderSerialize (void *V, int32 Length)
void	StartSerializingDefaults ()
void	StopSerializingDefaults ()
virtual void	MarkScriptSerializationStart (const UObject *Obj)
virtual void	MarkScriptSerializationEnd (const UObject *Obj)
virtual void	MarkSearchableName (const TObjectPtr< const UObject > &TypeObject, const FName &ValueName) const
template<typename FmtType , typename... Types>
void	Logf (const FmtType &Fmt, Types... Args)
virtual CORE_API void	UsingCustomVersion (const struct FGuid &Guid)
virtual FArchive *	GetCacheableArchive ()
void	SetCookData (FArchiveCookData *InCookData)
FArchiveCookData *	GetCookData ()
virtual CORE_API void	PushSerializedProperty (class FProperty *InProperty, const bool bIsEditorOnlyProperty)
virtual CORE_API void	PopSerializedProperty (class FProperty *InProperty, const bool bIsEditorOnlyProperty)
virtual bool	AttachExternalReadDependency (FExternalReadCallback &ReadCallback)
template<SIZE_T Size>
bool	FastPathLoad (void *InDest)
virtual void	PushFileRegionType (EFileRegionType Type)
virtual void	PopFileRegionType ()
CORE_API void	SetArchiveState (const FArchiveState &InState)
CORE_API void	SetError ()
CORE_API void	ClearError ()
CORE_API void	SetCriticalError ()
virtual FArchiveState &	GetInnermostState ()
virtual void	CountBytes (SIZE_T InNum, SIZE_T InMax)
virtual FLinker *	GetLinker ()
virtual bool	AtEnd ()
bool	IsByteSwapping ()
void	ThisContainsCode ()
void	ThisContainsMap ()
CORE_API void	ThisRequiresLocalizationGather ()
virtual UObject *	GetArchetypeFromLoader (const UObject *Obj)
UE_FORCEINLINE_HINT FPackageFileVersion	UEVer () const
UE_FORCEINLINE_HINT int32	LicenseeUEVer () const
UE_FORCEINLINE_HINT FEngineVersionBase	EngineVer () const
virtual CORE_API uint32	EngineNetVer () const
virtual CORE_API uint32	GameNetVer () const
CORE_API int32	CustomVer (const struct FGuid &Key) const
UE_FORCEINLINE_HINT bool	IsLoading () const
UE_FORCEINLINE_HINT bool	IsLoadingFromCookedPackage () const
UE_FORCEINLINE_HINT bool	IsSaving () const
bool	IsTransacting () const
UE_FORCEINLINE_HINT bool	IsTextFormat () const
UE_FORCEINLINE_HINT bool	WantBinaryPropertySerialization () const
UE_FORCEINLINE_HINT bool	UseUnversionedPropertySerialization () const
UE_FORCEINLINE_HINT bool	IsForcingUnicode () const
UE_FORCEINLINE_HINT bool	IsPersistent () const
UE_FORCEINLINE_HINT bool	GetError () const
UE_FORCEINLINE_HINT bool	IsError () const
UE_FORCEINLINE_HINT bool	IsCriticalError () const
UE_FORCEINLINE_HINT bool	ContainsCode () const
UE_FORCEINLINE_HINT bool	ContainsMap () const
bool	RequiresLocalizationGather () const
UE_FORCEINLINE_HINT bool	ForceByteSwapping () const
UE_FORCEINLINE_HINT bool	IsSerializingDefaults () const
UE_FORCEINLINE_HINT bool	IsIgnoringArchetypeRef () const
UE_FORCEINLINE_HINT bool	DoDelta () const
UE_FORCEINLINE_HINT bool	DoIntraPropertyDelta () const
UE_FORCEINLINE_HINT bool	IsIgnoringOuterRef () const
UE_FORCEINLINE_HINT bool	IsIgnoringClassGeneratedByRef () const
UE_FORCEINLINE_HINT bool	IsIgnoringClassRef () const
UE_FORCEINLINE_HINT bool	IsAllowingLazyLoading () const
UE_FORCEINLINE_HINT bool	IsObjectReferenceCollector () const
UE_FORCEINLINE_HINT bool	IsModifyingWeakAndStrongReferences () const
UE_FORCEINLINE_HINT bool	IsCountingMemory () const
UE_FORCEINLINE_HINT uint32	GetPortFlags () const
UE_FORCEINLINE_HINT bool	HasAnyPortFlags (uint32 Flags) const
UE_FORCEINLINE_HINT bool	HasAllPortFlags (uint32 Flags) const
uint32	GetDebugSerializationFlags () const
UE_FORCEINLINE_HINT bool	ShouldSkipBulkData () const
UE_FORCEINLINE_HINT int64	GetMaxSerializeSize () const
virtual CORE_API const FCustomVersionContainer &	GetCustomVersions () const
virtual CORE_API void	SetCustomVersions (const FCustomVersionContainer &CustomVersionContainer)
virtual CORE_API void	ResetCustomVersions ()
CORE_API void	SetCustomVersion (const struct FGuid &Key, int32 Version, FName FriendlyName)
void	SetByteSwapping (bool Enabled)
void	SetPortFlags (uint32 InPortFlags)
virtual void	SetDebugSerializationFlags (uint32 InCustomFlags)
bool	IsFilterEditorOnly () const
virtual void	SetFilterEditorOnly (bool InFilterEditorOnly)
bool	IsSavingOptionalObject () const
virtual void	SetSavingOptionalObject (bool InSavingOptionalObject)
bool	IsSaveGame () const
UE_FORCEINLINE_HINT bool	IsNetArchive () const
UE_FORCEINLINE_HINT bool	IsCooking () const
UE_FORCEINLINE_HINT const ITargetPlatform *	CookingTarget () const
void	SetSavePackageData (FArchiveSavePackageData *InSavePackageData)
FArchiveSavePackageData *	GetSavePackageData ()
UE_FORCEINLINE_HINT FArchiveCookContext *	GetCookContext ()
virtual bool	UseToResolveEnumerators () const
virtual bool	ShouldSkipProperty (const FProperty *InProperty) const
virtual void	SetSerializedProperty (FProperty *InProperty)
UE_FORCEINLINE_HINT class FProperty *	GetSerializedProperty () const
CORE_API void	GetSerializedPropertyChain (TArray< class FProperty * > &OutProperties) const
UE_FORCEINLINE_HINT const FArchiveSerializedPropertyChain *	GetSerializedPropertyChain () const
virtual CORE_API void	SetSerializedPropertyChain (const FArchiveSerializedPropertyChain *InSerializedPropertyChain, class FProperty *InSerializedPropertyOverride=nullptr)
virtual void	SetSerializeContext (FUObjectSerializeContext *InLoadContext)
virtual CORE_API void	Reset ()
virtual CORE_API void	SetIsLoading (bool bInIsLoading)
virtual CORE_API void	SetIsLoadingFromCookedPackage (bool bInIsLoadingFromCookedPackage)
virtual CORE_API void	SetIsSaving (bool bInIsSaving)
virtual CORE_API void	SetIsTransacting (bool bInIsTransacting)
virtual CORE_API void	SetIsTextFormat (bool bInIsTextFormat)
virtual CORE_API void	SetWantBinaryPropertySerialization (bool bInWantBinaryPropertySerialization)
virtual CORE_API void	SetUseUnversionedPropertySerialization (bool bInUseUnversioned)
virtual CORE_API void	SetForceUnicode (bool bInForceUnicode)
virtual CORE_API void	SetIsPersistent (bool bInIsPersistent)
virtual CORE_API void	SetUEVer (FPackageFileVersion InVer)
virtual CORE_API void	SetLicenseeUEVer (int32 InVer)
virtual CORE_API void	SetEngineVer (const FEngineVersionBase &InVer)
virtual CORE_API void	SetEngineNetVer (const uint32 InEngineNetVer)
virtual CORE_API void	SetGameNetVer (const uint32 InGameNetVer)
UE_FORCEINLINE_HINT bool	ShouldSkipCompilingAssets () const
CORE_API void	SetShouldSkipUpdateCustomVersion (bool bShouldSkip)
UE_FORCEINLINE_HINT bool	ShouldSkipUpdateCustomVersion () const
CORE_API void	SetMigratingRemoteObjects (bool bMigrating)
UE_FORCEINLINE_HINT constexpr bool	IsMigratingRemoteObjects () const
virtual const FUObjectMigrationContext *	GetMigrationContext () const

Protected Member Functions
CORE_API void	InitializeInternalAsync (FCreateArchive &&InCreateArchiveFunction, FCreateAsyncArchive &&InCreateAsyncArchiveFunction, uint32 InFlags, int64 PrimeSize)
CORE_API void	InitializeInternal (FCreateArchive &&InCreateArchiveFunction, FCreateAsyncArchive &&InCreateAsyncArchiveFunction, uint32 Flags, int64 PrimeSize)
CORE_API void	PausePreload ()
CORE_API void	ResumePreload ()
CORE_API bool	ResumePreloadNonRecursive ()
CORE_API void	OnReadComplete (bool bCanceled, IAsyncReadRequest *ReadRequest)
CORE_API void	FreeRetiredRequests ()
CORE_API void	SerializeSynchronously (void *V, int64 Length)
Protected Member Functions inherited from FArchive
void	SetShouldSkipCompilingAssets (bool Enabled)

Protected Attributes
FString	ArchiveName
int64	Pos = 0
int64	Size = -1
FEvent *	PendingAsyncComplete = nullptr
TAtomic< bool >	bInitialized
TAtomic< bool >	bIsPreloading
TAtomic< bool >	bIsPreloadingPaused
uint8 *	CacheBytes = nullptr
TAtomic< int64 >	CacheEnd
TUniquePtr< IAsyncReadFileHandle >	AsynchronousHandle
TUniquePtr< FArchive >	SynchronousArchive
TArray< IAsyncReadRequest * >	RetiredRequests
int64	PageSize = DefaultPageSize
FCriticalSection	PreloadLock
bool	bReadCompleteWasCalledInline = false
bool	bIsInlineReadComplete = false
struct FPreloadableArchive::FSavedReadCompleteArguments	SavedReadCompleteArguments

Friends
class	FPreloadableFileProxy

Additional Inherited Members
Public Attributes inherited from FArchive
FFastPathLoadBuffer *	ActiveFPLB
FFastPathLoadBuffer	InlineFPLB
uint8	ArContainsCode: 1
uint8	ArContainsMap: 1
UE_DEPRECATED(5.6, "Public access to ArRequiresLocalizationGather has been deprecated - please use Ar.RequiresLocalizationGather() and Ar.ThisRequiresLocalizationGather() for getting and setting respectively.") uint8 ArRequiresLocalizationGather uint8	ArForceByteSwapping: 1
uint8	ArIgnoreArchetypeRef: 1
uint8	ArNoDelta: 1
uint8	ArNoIntraPropertyDelta: 1
uint8	ArIgnoreOuterRef: 1
uint8	ArIgnoreClassGeneratedByRef: 1
uint8	ArIgnoreClassRef: 1
uint8	ArAllowLazyLoading: 1
uint8	ArIsObjectReferenceCollector: 1
uint8	ArIsModifyingWeakAndStrongReferences: 1
uint8	ArIsCountingMemory: 1
uint8	ArShouldSkipBulkData: 1
uint8	ArIsFilterEditorOnly: 1
uint8	ArIsSavingOptionalObject: 1
uint8	ArIsSaveGame: 1
uint8	ArIsNetArchive: 1
uint8	ArUseCustomPropertyList: 1
int32	ArSerializingDefaults
uint32	ArPortFlags
int64	ArMaxSerializeSize
uint8	ArMergeOverrides: 1
uint8	ArPreserveArrayElements: 1
const struct FCustomPropertyListNode *	ArCustomPropertyList
Static Protected Member Functions inherited from FArchive
static CORE_API void	LinkProxy (FArchiveState &Inner, FArchiveState &Proxy)
static CORE_API void	UnlinkProxy (FArchiveState &Inner, FArchiveState &Proxy)

Detailed Description

A read-only archive that adds support for asynchronous preloading and priming to an inner archive.

This class supports two mutually-exclusive modes: PreloadBytes: An asynchronous inner archive is opened using the passed-in CreateAsyncArchive function; this call is made asynchronously on a TaskGraph thread. The size is read during initialization. After initialization, when StartPreload is called, an array of bytes equal in size to the inner archive's size is allocated, and an asynchronous ReadRequest is sent to the IAsyncReadFileHandle to read the first <PageSize> bytes of the file. Upon completion of each in-flight ReadRequest, another asynchronous ReadRequest is issued, until the entire file has been read. If serialize functions are called beyond the bytes of the file that have been cached so far, they requests are satisfied by synchronous reads.

Activate this mode by passing an FCreateArchive to InitializeAsync. PreloadHandle: A synchronous inner archive is opened using the passed-in CreateArchive function; this call is made asynchronously on a TaskGraph thread. Optionally, a precache request is sent to the inner archive for the first <PrimeSize> bytes; this call is also made asynchronously. The created and primed lower-level FArchive can then be detached from this class and handed off to a new owner.

Activate this mode by passing an FCreateAsyncArchive and (optionally, for the precache request) Flags::Prime to InitializeAsync.

This class is not threadsafe. The public interface can be used at the same time as internal asynchronous tasks are executing, but the public interface can not be used from multiple threads at once.

Member Typedef Documentation

FCreateArchive

typedef TUniqueFunction<FArchive* ()> FPreloadableArchive::FCreateArchive

FCreateAsyncArchive

typedef TUniqueFunction<IAsyncReadFileHandle* ()> FPreloadableArchive::FCreateAsyncArchive

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
DefaultPrimeSize
DefaultPageSize

Flags

enum FPreloadableArchive::Flags

Enumerator
None
ModeBits
PreloadHandle
PreloadBytes
Prime

Constructor & Destructor Documentation

FPreloadableArchive()

FPreloadableArchive::FPreloadableArchive

(

FStringView

ArchiveName

)

~FPreloadableArchive()

FPreloadableArchive::~FPreloadableArchive ( )

virtual

Member Function Documentation

AllocateCache()

bool FPreloadableArchive::AllocateCache

(

)

When in PreloadBytes mode, allocate if necessary the memory for the preloaded bytes. Return whether the memory is now allocated.

Close()

bool FPreloadableArchive::Close ( )

finalvirtual

Attempts to close and finalize any handles used for backing data storage, returns true if it succeeded.

Reimplemented from FArchive.

DetachLowerLevel()

FArchive * FPreloadableArchive::DetachLowerLevel

(

)

Return the LowerLevel FArchive if it has been allocated. May return null, even if the FPreloadableFile is currently active. If return value is non-null, caller is responsible for deleting it.

FreeRetiredRequests()

void FPreloadableArchive::FreeRetiredRequests ( )

protected

GetArchiveName()

FString FPreloadableArchive::GetArchiveName ( ) const

finalvirtual

Returns the name of the Archive. Useful for getting the name of the package a struct or object is in when a loading error occurs.

This is overridden for the specific Archive Types

Reimplemented from FArchive.

HasValidData()

bool FPreloadableArchive::HasValidData

(

)

const

Return whether this archive has an inner archive it can provide data out of. Serialize will fail if this returns false.

InitializeAsync() [1/2]

void FPreloadableArchive::InitializeAsync	(	FCreateArchive &&	InCreateArchiveFunction,
		uint32	InFlags = Flags::None,
		int64	PrimeSize = DefaultPrimeSize
	)

Initialize the FPreloadableFile asynchronously, performing FileOpen operations on another thread. Use IsInitialized or WaitForInitialization to check progress.

InitializeAsync() [2/2]

void FPreloadableArchive::InitializeAsync	(	FCreateAsyncArchive &&	InCreateAsyncArchiveFunction,
		uint32	InFlags = Flags::None,
		int64	PrimeSize = DefaultPrimeSize
	)

InitializeInternal()

void FPreloadableArchive::InitializeInternal ( FCreateArchive &&  InCreateArchiveFunction, FCreateAsyncArchive &&  InCreateAsyncArchiveFunction, uint32  Flags, int64  PrimeSize  )

protected

Helper function for InitializeAsync, called from a TaskGraph thread.

InitializeInternalAsync()

void FPreloadableArchive::InitializeInternalAsync ( FCreateArchive &&  InCreateArchiveFunction, FCreateAsyncArchive &&  InCreateAsyncArchiveFunction, uint32  InFlags, int64  PrimeSize  )

protected

Helper function for InitializeAsync, sets up the asynchronous call to InitializeInternal

IsCacheAllocated()

bool FPreloadableArchive::IsCacheAllocated

(

)

const

Return whether the cache is currently allocated.

IsInitialized()

bool FPreloadableArchive::IsInitialized

(

)

const

Return whether InitializeAsync has completed. If Close is called, state returns to false until the next call to InitializeAsync.

IsPreloading()

bool FPreloadableArchive::IsPreloading

(

)

const

Return whether preloading is in progress. Value may not be up to date since asynchronous work might complete in a race condition.

OnReadComplete()

void FPreloadableArchive::OnReadComplete ( bool  bCanceled, IAsyncReadRequest *  ReadRequest  )

protected

PausePreload()

void FPreloadableArchive::PausePreload ( )

protected

ReleaseCache()

void FPreloadableArchive::ReleaseCache

(

)

Free all memory used by the cache or for preloading (calling StopPreload if necessary).

ResumePreload()

void FPreloadableArchive::ResumePreload ( )

protected

ResumePreloadNonRecursive()

bool FPreloadableArchive::ResumePreloadNonRecursive ( )

protected

Seek()

void FPreloadableArchive::Seek ( int64  InPos )

finalvirtual

Attempts to set the current offset into backing data storage, this will do nothing if there is no storage.

Reimplemented from FArchive.

Serialize()

void FPreloadableArchive::Serialize ( void *  V, int64  Length  )

finalvirtual

Reimplemented from FArchive.

SerializeSynchronously()

void FPreloadableArchive::SerializeSynchronously ( void *  V, int64  Length  )

protected

SetPageSize()

void FPreloadableArchive::SetPageSize

(

int64

PageSize

)

Set the PageSize used read requests made to the LowerLevel Archive in PreloadBytes mode when reading bytes into the In-Memory cache. Invalid to set after Initialization; PageSize must be constant during use.

StartPreload()

bool FPreloadableArchive::StartPreload

(

)

When in PreloadBytes mode, if not already preloading, allocate if necessary the memory for the preloaded bytes and start the chain of asynchronous ReadRequests for the bytes. Returns whether preloading is now active.

StopPreload()

void FPreloadableArchive::StopPreload

(

)

Cancel any current asynchronous ReadRequests and wait for the asynchronous work to exit.

Tell()

int64 FPreloadableArchive::Tell ( )

finalvirtual

Returns the current location within the backing data storage, which can possibly be passed to Seek later to restore a read/write location. If this returns -1, there is no backing data storage and Seek will not function.

Reimplemented from FArchive.

TotalSize()

int64 FPreloadableArchive::TotalSize ( )

finalvirtual

Return the size of the file, or -1 if the file does not exist. This is also the amount of memory that will be allocated by AllocateCache.

Reimplemented from FArchive.

WaitForInitialization()

void FPreloadableArchive::WaitForInitialization

(

)

const

Wait for InitializeAsync to complete if it is running, otherwise return immediately.

Friends And Related Symbol Documentation

FPreloadableFileProxy

friend class FPreloadableFileProxy

friend

Member Data Documentation

ArchiveName

FString FPreloadableArchive::ArchiveName

protected

AsynchronousHandle

TUniquePtr<IAsyncReadFileHandle> FPreloadableArchive::AsynchronousHandle

protected

The handle used for PreloadBytes mode, to fulfull ReadReqeusts.

bInitialized

TAtomic<bool> FPreloadableArchive::bInitialized

protected

Threadsafe variable that returns true only after all asynchronous initialization is complete. Is also reset to false when public-interface users call Close().

bIsInlineReadComplete

bool FPreloadableArchive::bIsInlineReadComplete = false

protected

Set to true during the ReadRequest call to allow us to detect if OnReadComplete is called inline on the same thread from ReadRequest.

bIsPreloading

TAtomic<bool> FPreloadableArchive::bIsPreloading

protected

Threadsafe variable that is true only during the period between initialization until Preloading stops (either due to EOF reached or due to Serialize turning it off.

bIsPreloadingPaused

TAtomic<bool> FPreloadableArchive::bIsPreloadingPaused

protected

Variable that is set to true from the public interface thread to signal that (temporarily) no further ReadRequests should be sent when the currently active one completes.

bReadCompleteWasCalledInline

bool FPreloadableArchive::bReadCompleteWasCalledInline = false

protected

Set to true if OnReadComplete is called inline on the same thread from ReadRequest; we need special handling for this case.

CacheBytes

uint8* FPreloadableArchive::CacheBytes = nullptr

protected

An array of bytes of size Size. Non-null only in PreloadBytes mode and in-between calls to AllocateCache/ReleaseCache.

CacheEnd

TAtomic<int64> FPreloadableArchive::CacheEnd

protected

Number of bytes in CacheBytes that have already been read. This is used in Serialize to check which bytes are available and in preloading to know for which bytes to issue a read request. This variable is read-only threadsafe. It is guaranteed to be written only after the bytes in CacheBytes have finished writing, and it is guaranteed to be written before bIsPreloading is written. It is not fully threadsafe; threads that need to write to CacheEnd need to do their Read/Write within the PreloadLock CriticalSection.

PageSize

int64 FPreloadableArchive::PageSize = DefaultPageSize

protected

The number of bytes requested from the AsynchronousHandle in each ReadRequest. Larger values have slightly faster results due to per-call overhead, but add greater latency to Serialize calls that read past the end of the cache.

PendingAsyncComplete

FEvent* FPreloadableArchive::PendingAsyncComplete = nullptr

protected

An Event used for synchronization with asynchronous tasks - InitializingAsync or receiving ReadRequests from the AsynchronousHandle.

Pos

int64 FPreloadableArchive::Pos = 0

protected

The Offset into the file or preloaded bytes that will be used in the next call to Serialize.

PreloadLock

FCriticalSection FPreloadableArchive::PreloadLock

protected

CriticalSection used to synchronize access to the CacheBytes.

RetiredRequests

TArray<IAsyncReadRequest*> FPreloadableArchive::RetiredRequests

protected

ReadRequests that have completed but we have not yet deleted.

SavedReadCompleteArguments

struct FPreloadableArchive::FSavedReadCompleteArguments FPreloadableArchive::SavedReadCompleteArguments

protected

Size

int64 FPreloadableArchive::Size = -1

protected

The number of bytes in the file.

SynchronousArchive

TUniquePtr<FArchive> FPreloadableArchive::SynchronousArchive

protected

The archive used in PreloadHandle mode or to service Serialize requests that are beyond CacheEnd when in PreloadBytes mode.

---

The documentation for this class was generated from the following files:

• Engine/Source/Runtime/Core/Public/Misc/PreloadableFile.h
• Engine/Source/Runtime/Core/Private/Misc/PreloadableFile.cpp