Enhanced Texture Manager (ff4c2359) · Commits · CAMP / campvis-public

ext/cgt/texturemanager.cpp

+163 −11

Original line number	Diff line number	Diff line
		#include "texturemanager.h"
		#include "texture.h"
		#include "singleton.h"
		#include "gltextureformattraits.h"


		cgt::TextureManager::TextureManager()
		namespace {
		/// private class to format iostream to use points as a thousands separator
		class PointSeparator : public std::numpunct<char>
		{
		public:
		PointSeparator(std::size_t refs) : std::numpunct<char>(refs) {}
		protected:
		char do_thousands_sep() const { return '.'; }
		std::string do_grouping() const { return "\03"; }
		};
		}

		const std::string cgt::TextureManager::loggerCat_("cgt.TextureManager");

		cgt::TextureManager::TextureManager()
		: RunnableWithConditionalWait("Texture Manager")
		, activeAllocatedMemory_(0)
		, texturePoolMemory_(0)
		{
		#ifdef ENABLE_TEXTURE_POOL
		// start the garbage collection thread
		start();
		#endif ENABLE_TEXTURE_POOl
		}

		cgt::TextureManager::~TextureManager()
		{
		std::lock_guard<std::mutex> scope_lock(accessMutex_);
		std::cout << "[TextureManager] releasing texture pool with " << texturePool_.size() << " textures..." << std::endl;
		for (auto& it : texturePool_) {
		std::cout << "Deleting texture of size [" << std::get<1>(it.first) << "," << std::get<2>(it.first) << "," << std::get<3>(it.first)
		<< "] of type " << std::get<0>(it.first) << " " << std::get<3>(it.first) << std::endl;
		#ifdef ENABLE_TEXTURE_POOL
		// stop the GC thread and clear the pool
		stop();
		forceClearPool();
		#endif ENABLE_TEXTURE_POOL

		cgtAssert(texturePool_.empty(), "Texture pool not empty at the end of texture manager's life!");
		cgtAssert(activeAllocatedMemory_ == 0, "There are still Textures in use after the Texture Manager is destroyed! This most likely means you are leaking cgt::Texture instances!");
		}

		void cgt::TextureManager::clearPool()
		{
		std::stringstream dbgOut;
		dbgOut.imbue(std::locale(std::cout.getloc(), new PointSeparator(1)));

		dbgOut << texturePoolMemory_ << " Bytes of in texture pool, additionally " << activeAllocatedMemory_ << " Bytes still in use.";
		LDEBUG(dbgOut.str());
		LDEBUG("releasing texture pool with " << texturePool_.size() << " textures...");
		size_t totalBytes = 0;

		std::stringstream ss;
		for (auto& it : texturePool_)
		{
		auto tft = GLTextureFormatTraits::get(std::get<INTERNAL_FORMAT>(it.first));
		cgt::svec3 size(std::get<SIZE_X>(it.first), std::get<SIZE_Y>(it.first), std::get<SIZE_Z>(it.first));
		GLenum textureType = std::get<TEX_TYPE>(it.first);
		ss << "\t * [" << size.x << "," << size.y << "," << size.z
		<< "] " << textureTypeToStr(textureType) << " " << tft.internalFormatName() << std::endl;

		glDeleteTextures(1, &it.second);

		totalBytes += textureByteSize(it.first);
		texturePoolMemory_ -= textureByteSize(it.first);
		}
		texturePool_.clear();

		std::stringstream ss3;
		ss3 << "Released " << totalBytes << " Bytes of texture data:" << std::endl << ss.str();
		LDEBUG(ss3.str());
		}

		void cgt::TextureManager::performGarbageCollection()
		{
		std::stringstream dbgOut;
		dbgOut.imbue(std::locale(std::cout.getloc(), new PointSeparator(1)));

		dbgOut << texturePoolMemory_ << " Bytes of in texture pool, additionally " << activeAllocatedMemory_ << " Bytes still in use.";
		LDEBUG(dbgOut.str());
		LDEBUG("releasing texture pool with " << texturePool_.size() << " textures...");
		size_t totalBytes = 0;

		std::stringstream ss;
		for (auto& it : texturePool_)
		{
		auto tft = GLTextureFormatTraits::get(std::get<INTERNAL_FORMAT>(it.first));
		cgt::svec3 size(std::get<SIZE_X>(it.first), std::get<SIZE_Y>(it.first), std::get<SIZE_Z>(it.first));
		GLenum textureType = std::get<TEX_TYPE>(it.first);
		ss << "\t * [" << size.x << "," << size.y << "," << size.z
		<< "] " << textureTypeToStr(textureType) << " " << tft.internalFormatName() << std::endl;

		glDeleteTextures(1, &it.second);

		totalBytes += textureByteSize(it.first);
		texturePoolMemory_ -= textureByteSize(it.first);
		}
		texturePool_.clear();

		std::stringstream ss3;
		ss3 << "Released " << totalBytes << " Bytes of texture data:" << std::endl << ss.str();
		LDEBUG(ss3.str());
		}

		void cgt::TextureManager::forceGarbageCollection()
		{
		#ifdef ENABLE_TEXTURE_POOL
		std::lock_guard<std::mutex> scope_lock(accessMutex_);

		performGarbageCollection();
		#endif ENABLE_TEXTURE_POOL
		}

		void cgt::TextureManager::forceClearPool()
		{
		#ifdef ENABLE_TEXTURE_POOL
		std::lock_guard<std::mutex> scope_lock(accessMutex_);

		clearPool();
		#endif ENABLE_TEXTURE_POOL
		}

		GLuint cgt::TextureManager::generateId(GLenum type, const cgt::svec3 & dimensions, GLenum internalFormat)
		{
		cache_key_t cacheKey(type, dimensions.x, dimensions.y, dimensions.z, internalFormat);

		#ifdef ENABLE_TEXTURE_POOL
		std::lock_guard<std::mutex> scope_lock(accessMutex_);

		GLuint id;
		auto it = texturePool_.find(std::make_tuple(type, dimensions.x, dimensions.y, dimensions.z, internalFormat));
		auto it = texturePool_.find(cacheKey);
		if (it != texturePool_.end()) {
		id = it->second;
		texturePool_.erase(it);

		activeAllocatedMemory_ += textureByteSize(cacheKey);
		texturePoolMemory_ -= textureByteSize(cacheKey);
		}
		else {
		glGenTextures(1, &id);
		@@ -54,6 +161,8 @@ GLuint cgt::TextureManager::generateId(GLenum type, const cgt::svec3 & dimension
		break;
		}
		LGL_ERROR;

		activeAllocatedMemory_ += textureByteSize(cacheKey);
		}
		#else
		GLuint id;
		@@ -80,6 +189,9 @@ GLuint cgt::TextureManager::generateId(GLenum type, const cgt::svec3 & dimension
		break;
		}
		LGL_ERROR;

		activeAllocatedMemory_ += textureByteSize(cacheKey);

		#endif
		return id;
		}
		@@ -88,8 +200,48 @@ void cgt::TextureManager::releaseId(GLuint id, GLenum type, const cgt::svec3 & d
		{
		#ifdef ENABLE_TEXTURE_POOL
		std::lock_guard<std::mutex> scope_lock(accessMutex_);
		texturePool_.insert(std::make_pair(std::make_tuple(type, dimensions.x, dimensions.y, dimensions.z, internalFormat), id));
		cache_key_t cacheKey(type, dimensions.x, dimensions.y, dimensions.z, internalFormat);
		texturePool_.insert(std::make_pair(cacheKey, id));
		activeAllocatedMemory_ -= textureByteSize(cacheKey);
		texturePoolMemory_ += textureByteSize(cacheKey);
		#else
		glDeleteTextures(1, &id);
		activeAllocatedMemory_ -= textureByteSize(cacheKey);
		#endif
		}

		void cgt::TextureManager::run()
		{
		std::unique_lock<std::mutex> scope_lock(accessMutex_);

		while (!_stopExecution) {
		_evaluationCondition.wait_for(scope_lock, std::chrono::milliseconds(garbageCollectionDelayMs));

		// could have changed in the meantime
		if(!_stopExecution)
		performGarbageCollection();
		}
		}

		constexpr size_t cgt::TextureManager::textureByteSize(const cache_key_t & key)
		{
		return std::get<SIZE_X>(key) * std::get<SIZE_Y>(key) * std::get<SIZE_Z>(key) * GLTextureFormatTraits::get(std::get<INTERNAL_FORMAT>(key)).bpp();
		}

		std::string cgt::TextureManager::textureTypeToStr(GLenum tt)
		{
		switch (tt) {
		case GL_TEXTURE_1D:
		return "GL_TEXTURE_1D";
		case GL_TEXTURE_1D_ARRAY:
		return "GL_TEXTURE_1D_ARRAY";
		case GL_TEXTURE_2D:
		return "GL_TEXTURE_2D";
		case GL_TEXTURE_2D_ARRAY:
		return "GL_TEXTURE_2D_ARRAY";
		case GL_TEXTURE_3D:
		return "GL_TEXTURE_3D";
		default:
		return "Unknown";
		}
		}

ext/cgt/texturemanager.h

+56 −5

Original line number	Diff line number	Diff line
		@@ -2,30 +2,81 @@
		#define TEXTUREMANAGER_H__

		#include "cgt/cgt_gl.h"
		#include "cgt/runnable.h"
		#include "cgt/singleton.h"
		#include "cgt/vector.h"


		#include <mutex>
		#include <map>
		#include <mutex>
		#include <tuple>

		namespace cgt {

		class TextureManager : public Singleton<TextureManager> {
		class TextureManager : public Singleton<TextureManager>, public RunnableWithConditionalWait {
		public:
		TextureManager();

		~TextureManager();

		/**
		* Forces the manager to perform a (synchronous) garbage collection. Can be called manually by user code if
		* GPU memory seems low. This method is threadsafe.
		*/
		void forceGarbageCollection();

		/**
		* Forces the texture pool to be cleared synchronously. This method is threadsafe.
		*/
		void forceClearPool();

		GLuint generateId(GLenum type, const cgt::svec3& dimensions, GLenum internalFormat);

		void releaseId(GLuint id, GLenum type, const cgt::svec3& dimensions, GLenum internalFormat);

		/// \see Runnable::run()
		void run() override;

		private:
		std::mutex accessMutex_;
		static const std::string loggerCat_;
		using cache_key_t = std::tuple<GLenum, size_t, size_t, size_t, GLenum>;
		enum CacheEntryTupleIndex {
		TEX_TYPE = 0,
		SIZE_X = 1,
		SIZE_Y = 2,
		SIZE_Z = 3,
		INTERNAL_FORMAT = 4
		};

		/// GC will be performed regularly at this interval, in [ms]
		const size_t garbageCollectionDelayMs = 15000;

		std::multimap<std::tuple<GLenum, size_t, size_t, size_t, GLenum>, GLuint> texturePool_;
		/// Compute the memory size from the cache entry key
		static constexpr size_t textureByteSize(const cache_key_t& key);

		/// Convert the texture type to a humanly readable string
		static std::string textureTypeToStr(GLenum tt);

		/**
		* Performs a garbage collection event. This method is NOT threadsafe.
		*/
		void performGarbageCollection();

		/**
		* Clears the current texture pool. This method is NOT threadsafe.
		*/
		void clearPool();

		/// the actual texture pool containing all textures not in use
		std::multimap<cache_key_t, GLuint> texturePool_;

		/// Currently allocated GPU memory from textures still in use
		size_t activeAllocatedMemory_;

		/// Allocated GPU memory from textures in the texture pool
		size_t texturePoolMemory_;

		/// Mutex ensuring thread safety
		std::mutex accessMutex_;
		};

		}