From 74c8b028d42a8c5b080bb861e427f38cedd4ad7c Mon Sep 17 00:00:00 2001 From: Alexander Gavriliuk Date: Fri, 15 Dec 2023 18:26:14 +0100 Subject: SL-20743 Use LLMutex in LLImageBase for internal data thread-safety --- indra/newview/lltexturecache.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'indra/newview/lltexturecache.h') diff --git a/indra/newview/lltexturecache.h b/indra/newview/lltexturecache.h index 43e91b3e4c..cba45393f9 100644 --- a/indra/newview/lltexturecache.h +++ b/indra/newview/lltexturecache.h @@ -125,7 +125,7 @@ public: handle_t readFromCache(const LLUUID& id, S32 offset, S32 size, ReadResponder* responder); bool readComplete(handle_t handle, bool abort); - handle_t writeToCache(const LLUUID& id, U8* data, S32 datasize, S32 imagesize, LLPointer rawimage, S32 discardlevel, + handle_t writeToCache(const LLUUID& id, const U8* data, S32 datasize, S32 imagesize, LLPointer rawimage, S32 discardlevel, WriteResponder* responder); LLPointer readFromFastCache(const LLUUID& id, S32& discardlevel); bool writeComplete(handle_t handle, bool abort = false); -- cgit v1.2.3 From 60d3dd98a44230c21803c1606552ee098ed9fa7c Mon Sep 17 00:00:00 2001 From: Ansariel Date: Wed, 21 Feb 2024 21:05:14 +0100 Subject: Convert remaining BOOL to bool --- indra/newview/lltexturecache.h | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) (limited to 'indra/newview/lltexturecache.h') diff --git a/indra/newview/lltexturecache.h b/indra/newview/lltexturecache.h index cba45393f9..3947cb850f 100644 --- a/indra/newview/lltexturecache.h +++ b/indra/newview/lltexturecache.h @@ -87,24 +87,24 @@ public: class Responder : public LLResponder { public: - virtual void setData(U8* data, S32 datasize, S32 imagesize, S32 imageformat, BOOL imagelocal) = 0; + virtual void setData(U8* data, S32 datasize, S32 imagesize, S32 imageformat, bool imagelocal) = 0; }; class ReadResponder : public Responder { public: ReadResponder(); - void setData(U8* data, S32 datasize, S32 imagesize, S32 imageformat, BOOL imagelocal); + void setData(U8* data, S32 datasize, S32 imagesize, S32 imageformat, bool imagelocal); void setImage(LLImageFormatted* image) { mFormattedImage = image; } protected: LLPointer mFormattedImage; S32 mImageSize; - BOOL mImageLocal; + bool mImageLocal; }; class WriteResponder : public Responder { - void setData(U8* data, S32 datasize, S32 imagesize, S32 imageformat, BOOL imagelocal) + void setData(U8* data, S32 datasize, S32 imagesize, S32 imageformat, bool imagelocal) { // not used } @@ -116,8 +116,8 @@ public: /*virtual*/ size_t update(F32 max_time_ms); void purgeCache(ELLPath location, bool remove_dir = true); - void setReadOnly(BOOL read_only) ; - S64 initCache(ELLPath location, S64 maxsize, BOOL texture_cache_mismatch); + void setReadOnly(bool read_only) ; + S64 initCache(ELLPath location, S64 maxsize, bool texture_cache_mismatch); handle_t readFromCache(const std::string& local_filename, const LLUUID& id, S32 offset, S32 size, ReadResponder* responder); @@ -146,8 +146,8 @@ public: S64Bytes getMaxUsage() { return S64Bytes(sCacheMaxTexturesSize); } U32 getEntries() { return mHeaderEntriesInfo.mEntries; } U32 getMaxEntries() { return sCacheMaxEntries; }; - BOOL isInCache(const LLUUID& id) ; - BOOL isInLocal(const LLUUID& id) ; //not thread safe at the moment + bool isInCache(const LLUUID& id) ; + bool isInLocal(const LLUUID& id) ; //not thread safe at the moment protected: // Accessed by LLTextureCacheWorker @@ -214,7 +214,7 @@ private: typedef std::vector, bool> > responder_list_t; responder_list_t mCompletedList; - BOOL mReadOnly; + bool mReadOnly; // HEADERS (Include first mip) std::string mHeaderEntriesFileName; -- cgit v1.2.3 From e2e37cced861b98de8c1a7c9c0d3a50d2d90e433 Mon Sep 17 00:00:00 2001 From: Ansariel Date: Wed, 22 May 2024 21:25:21 +0200 Subject: Fix line endlings --- indra/newview/lltexturecache.h | 510 ++++++++++++++++++++--------------------- 1 file changed, 255 insertions(+), 255 deletions(-) (limited to 'indra/newview/lltexturecache.h') diff --git a/indra/newview/lltexturecache.h b/indra/newview/lltexturecache.h index 5ac0a0428d..70766b0605 100644 --- a/indra/newview/lltexturecache.h +++ b/indra/newview/lltexturecache.h @@ -1,255 +1,255 @@ -/** - * @file lltexturecache.h - * @brief Object for managing texture cachees. - * - * $LicenseInfo:firstyear=2000&license=viewerlgpl$ - * Second Life Viewer Source Code - * Copyright (C) 2010, Linden Research, Inc. - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; - * version 2.1 of the License only. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - * - * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA - * $/LicenseInfo$ - */ - -#ifndef LL_LLTEXTURECACHE_H -#define LL_LLTEXTURECACHE_H - -#include "lldir.h" -#include "llstl.h" -#include "llstring.h" -#include "lluuid.h" - -#include "llworkerthread.h" - -class LLImageFormatted; -class LLTextureCacheWorker; -class LLImageRaw; - -class LLTextureCache : public LLWorkerThread -{ - friend class LLTextureCacheWorker; - friend class LLTextureCacheRemoteWorker; - friend class LLTextureCacheLocalFileWorker; - -private: - -#if LL_WINDOWS -#pragma pack(push,1) -#endif - - // Entries - static const U32 sHeaderEncoderStringSize = 32; - struct EntriesInfo - { - EntriesInfo() : mVersion(0.f), mAdressSize(0), mEntries(0) { memset(mEncoderVersion, 0, sHeaderEncoderStringSize); } - F32 mVersion; - U32 mAdressSize; - char mEncoderVersion[sHeaderEncoderStringSize]; - U32 mEntries; - }; - struct Entry - { - Entry() : - mBodySize(0), - mImageSize(0), - mTime(0) - { - } - Entry(const LLUUID& id, S32 imagesize, S32 bodysize, U32 time) : - mID(id), mImageSize(imagesize), mBodySize(bodysize), mTime(time) {} - void init(const LLUUID& id, U32 time) { mID = id, mImageSize = 0; mBodySize = 0; mTime = time; } - Entry& operator=(const Entry& entry) {mID = entry.mID, mImageSize = entry.mImageSize; mBodySize = entry.mBodySize; mTime = entry.mTime; return *this;} - LLUUID mID; // 16 bytes - S32 mImageSize; // total size of image if known - S32 mBodySize; // size of body file in body cache - U32 mTime; // seconds since 1/1/1970 - }; - -#if LL_WINDOWS -#pragma pack(pop) -#endif - -public: - - class Responder : public LLResponder - { - public: - virtual void setData(U8* data, S32 datasize, S32 imagesize, S32 imageformat, bool imagelocal) = 0; - }; - - class ReadResponder : public Responder - { - public: - ReadResponder(); - void setData(U8* data, S32 datasize, S32 imagesize, S32 imageformat, bool imagelocal); - void setImage(LLImageFormatted* image) { mFormattedImage = image; } - protected: - LLPointer mFormattedImage; - S32 mImageSize; - bool mImageLocal; - }; - - class WriteResponder : public Responder - { - void setData(U8* data, S32 datasize, S32 imagesize, S32 imageformat, bool imagelocal) - { - // not used - } - }; - - LLTextureCache(bool threaded); - ~LLTextureCache(); - - /*virtual*/ size_t update(F32 max_time_ms); - - void purgeCache(ELLPath location, bool remove_dir = true); - void setReadOnly(bool read_only) ; - S64 initCache(ELLPath location, S64 maxsize, bool texture_cache_mismatch); - - handle_t readFromCache(const std::string& local_filename, const LLUUID& id, S32 offset, S32 size, - ReadResponder* responder); - - handle_t readFromCache(const LLUUID& id, S32 offset, S32 size, - ReadResponder* responder); - bool readComplete(handle_t handle, bool abort); - handle_t writeToCache(const LLUUID& id, const U8* data, S32 datasize, S32 imagesize, LLPointer rawimage, S32 discardlevel, - WriteResponder* responder); - LLPointer readFromFastCache(const LLUUID& id, S32& discardlevel); - bool writeComplete(handle_t handle, bool abort = false); - void prioritizeWrite(handle_t handle); - - bool removeFromCache(const LLUUID& id); - - // For LLTextureCacheWorker::Responder - LLTextureCacheWorker* getReader(handle_t handle); - LLTextureCacheWorker* getWriter(handle_t handle); - void lockWorkers() { mWorkersMutex.lock(); } - void unlockWorkers() { mWorkersMutex.unlock(); } - - // debug - S32 getNumReads() { return mReaders.size(); } - S32 getNumWrites() { return mWriters.size(); } - S64Bytes getUsage() { return S64Bytes(mTexturesSizeTotal); } - S64Bytes getMaxUsage() { return S64Bytes(sCacheMaxTexturesSize); } - U32 getEntries() { return mHeaderEntriesInfo.mEntries; } - U32 getMaxEntries() { return sCacheMaxEntries; }; - bool isInCache(const LLUUID& id) ; - bool isInLocal(const LLUUID& id) ; //not thread safe at the moment - -protected: - // Accessed by LLTextureCacheWorker - std::string getLocalFileName(const LLUUID& id); - std::string getTextureFileName(const LLUUID& id); - void addCompleted(Responder* responder, bool success); - -protected: - //void setFileAPRPool(apr_pool_t* pool) { mFileAPRPool = pool ; } - -private: - void setDirNames(ELLPath location); - void readHeaderCache(); - void clearCorruptedCache(); - void purgeAllTextures(bool purge_directories); - void purgeTexturesLazy(F32 time_limit_sec); - void purgeTextures(bool validate); - LLAPRFile* openHeaderEntriesFile(bool readonly, S32 offset); - void closeHeaderEntriesFile(); - void readEntriesHeader(); - void setEntriesHeader(); - void writeEntriesHeader(); - S32 openAndReadEntry(const LLUUID& id, Entry& entry, bool create); - bool updateEntry(S32& idx, Entry& entry, S32 new_image_size, S32 new_body_size); - void updateEntryTimeStamp(S32 idx, Entry& entry) ; - U32 openAndReadEntries(std::vector& entries); - void writeEntriesAndClose(const std::vector& entries); - void readEntryFromHeaderImmediately(S32& idx, Entry& entry) ; - void writeEntryToHeaderImmediately(S32& idx, Entry& entry, bool write_header = false) ; - void removeEntry(S32 idx, Entry& entry, std::string& filename); - void removeCachedTexture(const LLUUID& id) ; - S32 getHeaderCacheEntry(const LLUUID& id, Entry& entry); - S32 setHeaderCacheEntry(const LLUUID& id, Entry& entry, S32 imagesize, S32 datasize); - void writeUpdatedEntries() ; - void updatedHeaderEntriesFile() ; - void lockHeaders() { mHeaderMutex.lock(); } - void unlockHeaders() { mHeaderMutex.unlock(); } - - void openFastCache(bool first_time = false); - void closeFastCache(bool forced = false); - bool writeToFastCache(LLUUID image_id, S32 cache_id, LLPointer raw, S32 discardlevel); - -private: - // Internal - LLMutex mWorkersMutex; - LLMutex mHeaderMutex; - LLMutex mListMutex; - LLMutex mFastCacheMutex; - LLAPRFile* mHeaderAPRFile; - LLVolatileAPRPool* mFastCachePoolp; - - // mLocalAPRFilePoolp is not thread safe and is meant only for workers - // howhever mHeaderEntriesFileName is accessed not from workers' threads - // so it needs own pool (not thread safe by itself, relies onto header's mutex) - LLVolatileAPRPool* mHeaderAPRFilePoolp; - - typedef std::map handle_map_t; - handle_map_t mReaders; - handle_map_t mWriters; - - typedef std::vector handle_list_t; - handle_list_t mPrioritizeWriteList; - - typedef std::vector, bool> > responder_list_t; - responder_list_t mCompletedList; - - bool mReadOnly; - - // HEADERS (Include first mip) - std::string mHeaderEntriesFileName; - std::string mHeaderDataFileName; - std::string mFastCacheFileName; - EntriesInfo mHeaderEntriesInfo; - std::set mFreeList; // deleted entries - std::set mLRU; - typedef std::map id_map_t; - id_map_t mHeaderIDMap; - - LLAPRFile* mFastCachep; - LLFrameTimer mFastCacheTimer; - U8* mFastCachePadBuffer; - - // BODIES (TEXTURES minus headers) - std::string mTexturesDirName; - typedef std::map size_map_t; - size_map_t mTexturesSizeMap; - S64 mTexturesSizeTotal; - LLAtomicBool mDoPurge; - - typedef std::map idx_entry_map_t; - idx_entry_map_t mUpdatedEntryMap; - typedef std::vector > idx_entry_vector_t; - idx_entry_vector_t mPurgeEntryList; - - // Statics - static F32 sHeaderCacheVersion; - static U32 sHeaderCacheAddressSize; - static std::string sHeaderCacheEncoderVersion; - static U32 sCacheMaxEntries; - static S64 sCacheMaxTexturesSize; -}; - -extern const S32 TEXTURE_CACHE_ENTRY_SIZE; - -#endif // LL_LLTEXTURECACHE_H +/** + * @file lltexturecache.h + * @brief Object for managing texture cachees. + * + * $LicenseInfo:firstyear=2000&license=viewerlgpl$ + * Second Life Viewer Source Code + * Copyright (C) 2010, Linden Research, Inc. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; + * version 2.1 of the License only. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA + * $/LicenseInfo$ + */ + +#ifndef LL_LLTEXTURECACHE_H +#define LL_LLTEXTURECACHE_H + +#include "lldir.h" +#include "llstl.h" +#include "llstring.h" +#include "lluuid.h" + +#include "llworkerthread.h" + +class LLImageFormatted; +class LLTextureCacheWorker; +class LLImageRaw; + +class LLTextureCache : public LLWorkerThread +{ + friend class LLTextureCacheWorker; + friend class LLTextureCacheRemoteWorker; + friend class LLTextureCacheLocalFileWorker; + +private: + +#if LL_WINDOWS +#pragma pack(push,1) +#endif + + // Entries + static const U32 sHeaderEncoderStringSize = 32; + struct EntriesInfo + { + EntriesInfo() : mVersion(0.f), mAdressSize(0), mEntries(0) { memset(mEncoderVersion, 0, sHeaderEncoderStringSize); } + F32 mVersion; + U32 mAdressSize; + char mEncoderVersion[sHeaderEncoderStringSize]; + U32 mEntries; + }; + struct Entry + { + Entry() : + mBodySize(0), + mImageSize(0), + mTime(0) + { + } + Entry(const LLUUID& id, S32 imagesize, S32 bodysize, U32 time) : + mID(id), mImageSize(imagesize), mBodySize(bodysize), mTime(time) {} + void init(const LLUUID& id, U32 time) { mID = id, mImageSize = 0; mBodySize = 0; mTime = time; } + Entry& operator=(const Entry& entry) {mID = entry.mID, mImageSize = entry.mImageSize; mBodySize = entry.mBodySize; mTime = entry.mTime; return *this;} + LLUUID mID; // 16 bytes + S32 mImageSize; // total size of image if known + S32 mBodySize; // size of body file in body cache + U32 mTime; // seconds since 1/1/1970 + }; + +#if LL_WINDOWS +#pragma pack(pop) +#endif + +public: + + class Responder : public LLResponder + { + public: + virtual void setData(U8* data, S32 datasize, S32 imagesize, S32 imageformat, bool imagelocal) = 0; + }; + + class ReadResponder : public Responder + { + public: + ReadResponder(); + void setData(U8* data, S32 datasize, S32 imagesize, S32 imageformat, bool imagelocal); + void setImage(LLImageFormatted* image) { mFormattedImage = image; } + protected: + LLPointer mFormattedImage; + S32 mImageSize; + bool mImageLocal; + }; + + class WriteResponder : public Responder + { + void setData(U8* data, S32 datasize, S32 imagesize, S32 imageformat, bool imagelocal) + { + // not used + } + }; + + LLTextureCache(bool threaded); + ~LLTextureCache(); + + /*virtual*/ size_t update(F32 max_time_ms); + + void purgeCache(ELLPath location, bool remove_dir = true); + void setReadOnly(bool read_only) ; + S64 initCache(ELLPath location, S64 maxsize, bool texture_cache_mismatch); + + handle_t readFromCache(const std::string& local_filename, const LLUUID& id, S32 offset, S32 size, + ReadResponder* responder); + + handle_t readFromCache(const LLUUID& id, S32 offset, S32 size, + ReadResponder* responder); + bool readComplete(handle_t handle, bool abort); + handle_t writeToCache(const LLUUID& id, const U8* data, S32 datasize, S32 imagesize, LLPointer rawimage, S32 discardlevel, + WriteResponder* responder); + LLPointer readFromFastCache(const LLUUID& id, S32& discardlevel); + bool writeComplete(handle_t handle, bool abort = false); + void prioritizeWrite(handle_t handle); + + bool removeFromCache(const LLUUID& id); + + // For LLTextureCacheWorker::Responder + LLTextureCacheWorker* getReader(handle_t handle); + LLTextureCacheWorker* getWriter(handle_t handle); + void lockWorkers() { mWorkersMutex.lock(); } + void unlockWorkers() { mWorkersMutex.unlock(); } + + // debug + S32 getNumReads() { return mReaders.size(); } + S32 getNumWrites() { return mWriters.size(); } + S64Bytes getUsage() { return S64Bytes(mTexturesSizeTotal); } + S64Bytes getMaxUsage() { return S64Bytes(sCacheMaxTexturesSize); } + U32 getEntries() { return mHeaderEntriesInfo.mEntries; } + U32 getMaxEntries() { return sCacheMaxEntries; }; + bool isInCache(const LLUUID& id) ; + bool isInLocal(const LLUUID& id) ; //not thread safe at the moment + +protected: + // Accessed by LLTextureCacheWorker + std::string getLocalFileName(const LLUUID& id); + std::string getTextureFileName(const LLUUID& id); + void addCompleted(Responder* responder, bool success); + +protected: + //void setFileAPRPool(apr_pool_t* pool) { mFileAPRPool = pool ; } + +private: + void setDirNames(ELLPath location); + void readHeaderCache(); + void clearCorruptedCache(); + void purgeAllTextures(bool purge_directories); + void purgeTexturesLazy(F32 time_limit_sec); + void purgeTextures(bool validate); + LLAPRFile* openHeaderEntriesFile(bool readonly, S32 offset); + void closeHeaderEntriesFile(); + void readEntriesHeader(); + void setEntriesHeader(); + void writeEntriesHeader(); + S32 openAndReadEntry(const LLUUID& id, Entry& entry, bool create); + bool updateEntry(S32& idx, Entry& entry, S32 new_image_size, S32 new_body_size); + void updateEntryTimeStamp(S32 idx, Entry& entry) ; + U32 openAndReadEntries(std::vector& entries); + void writeEntriesAndClose(const std::vector& entries); + void readEntryFromHeaderImmediately(S32& idx, Entry& entry) ; + void writeEntryToHeaderImmediately(S32& idx, Entry& entry, bool write_header = false) ; + void removeEntry(S32 idx, Entry& entry, std::string& filename); + void removeCachedTexture(const LLUUID& id) ; + S32 getHeaderCacheEntry(const LLUUID& id, Entry& entry); + S32 setHeaderCacheEntry(const LLUUID& id, Entry& entry, S32 imagesize, S32 datasize); + void writeUpdatedEntries() ; + void updatedHeaderEntriesFile() ; + void lockHeaders() { mHeaderMutex.lock(); } + void unlockHeaders() { mHeaderMutex.unlock(); } + + void openFastCache(bool first_time = false); + void closeFastCache(bool forced = false); + bool writeToFastCache(LLUUID image_id, S32 cache_id, LLPointer raw, S32 discardlevel); + +private: + // Internal + LLMutex mWorkersMutex; + LLMutex mHeaderMutex; + LLMutex mListMutex; + LLMutex mFastCacheMutex; + LLAPRFile* mHeaderAPRFile; + LLVolatileAPRPool* mFastCachePoolp; + + // mLocalAPRFilePoolp is not thread safe and is meant only for workers + // howhever mHeaderEntriesFileName is accessed not from workers' threads + // so it needs own pool (not thread safe by itself, relies onto header's mutex) + LLVolatileAPRPool* mHeaderAPRFilePoolp; + + typedef std::map handle_map_t; + handle_map_t mReaders; + handle_map_t mWriters; + + typedef std::vector handle_list_t; + handle_list_t mPrioritizeWriteList; + + typedef std::vector, bool> > responder_list_t; + responder_list_t mCompletedList; + + bool mReadOnly; + + // HEADERS (Include first mip) + std::string mHeaderEntriesFileName; + std::string mHeaderDataFileName; + std::string mFastCacheFileName; + EntriesInfo mHeaderEntriesInfo; + std::set mFreeList; // deleted entries + std::set mLRU; + typedef std::map id_map_t; + id_map_t mHeaderIDMap; + + LLAPRFile* mFastCachep; + LLFrameTimer mFastCacheTimer; + U8* mFastCachePadBuffer; + + // BODIES (TEXTURES minus headers) + std::string mTexturesDirName; + typedef std::map size_map_t; + size_map_t mTexturesSizeMap; + S64 mTexturesSizeTotal; + LLAtomicBool mDoPurge; + + typedef std::map idx_entry_map_t; + idx_entry_map_t mUpdatedEntryMap; + typedef std::vector > idx_entry_vector_t; + idx_entry_vector_t mPurgeEntryList; + + // Statics + static F32 sHeaderCacheVersion; + static U32 sHeaderCacheAddressSize; + static std::string sHeaderCacheEncoderVersion; + static U32 sCacheMaxEntries; + static S64 sCacheMaxTexturesSize; +}; + +extern const S32 TEXTURE_CACHE_ENTRY_SIZE; + +#endif // LL_LLTEXTURECACHE_H -- cgit v1.2.3 From b42f9d836b4c0f7fbd4bdae1734021e2a09fdbe8 Mon Sep 17 00:00:00 2001 From: Ansariel Date: Sat, 1 Jun 2024 15:49:26 +0200 Subject: Re-enable a lot of compiler warnings for MSVC and address the C4267 "possible loss of precision" warnings --- indra/newview/lltexturecache.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'indra/newview/lltexturecache.h') diff --git a/indra/newview/lltexturecache.h b/indra/newview/lltexturecache.h index 70766b0605..faf722dc8f 100644 --- a/indra/newview/lltexturecache.h +++ b/indra/newview/lltexturecache.h @@ -140,8 +140,8 @@ public: void unlockWorkers() { mWorkersMutex.unlock(); } // debug - S32 getNumReads() { return mReaders.size(); } - S32 getNumWrites() { return mWriters.size(); } + S32 getNumReads() { return static_cast(mReaders.size()); } + S32 getNumWrites() { return static_cast(mWriters.size()); } S64Bytes getUsage() { return S64Bytes(mTexturesSizeTotal); } S64Bytes getMaxUsage() { return S64Bytes(sCacheMaxTexturesSize); } U32 getEntries() { return mHeaderEntriesInfo.mEntries; } -- cgit v1.2.3