X-Git-Url: https://git.sesse.net/?p=movit;a=blobdiff_plain;f=resource_pool.h;h=5cc2e829e8f836635b04980978372973d3618639;hp=a6e4327b2e953ca5747f6b6dfac8d6e8811426f3;hb=825c90789c229f502520bf0b665596d473f2636d;hpb=edb0700c0a8ea225ce9add1cb4f70d42af6de381 diff --git a/resource_pool.h b/resource_pool.h index a6e4327..5cc2e82 100644 --- a/resource_pool.h +++ b/resource_pool.h @@ -15,13 +15,23 @@ // Thread-safety: All functions except the constructor and destructor can be // safely called from multiple threads at the same time, provided they have // separate (but sharing) OpenGL contexts. +// +// Memory management (only relevant if you use multiple contexts): Some objects, +// like FBOs, are not shareable across contexts, and can only be deleted from +// the context they were created in. Thus, you will need to tell the +// ResourcePool explicitly if you delete a context, or they will leak (and the +// ResourcePool destructor will assert-fail). See clean_context(). +#include +#include +#include #include #include #include #include -#include -#include +#include + +namespace movit { class ResourcePool { public: @@ -29,7 +39,16 @@ public: // around after they are no longer in use (in case another EffectChain // wants that exact program later). Shaders are expensive to compile and do not // need a lot of resources to keep around, so this should be a reasonable number. - ResourcePool(size_t program_freelist_max_length = 100); + // + // texture_freelist_max_bytes is how many bytes of unused textures to keep around + // after they are no longer in use (in case a new texture of the same dimensions + // and format is needed). Note that the size estimate is very coarse; it does not + // take into account padding, metadata, and most importantly mipmapping. + // This means you should be prepared for actual memory usage of the freelist being + // twice this estimate or more. + ResourcePool(size_t program_freelist_max_length = 100, + size_t texture_freelist_max_bytes = 100 << 20, // 100 MB. + size_t fbo_freelist_max_length = 100); // Per context. ~ResourcePool(); // All remaining functions are intended for calls from EffectChain only. @@ -38,17 +57,63 @@ public: // compiled program from the cache if possible. Keeps ownership of the // program; you must call release_glsl_program() instead of deleting it // when you no longer want it. - GLuint compile_glsl_program(const std::string& vertex_shader, const std::string& fragment_shader); + // + // If contains more than one value, the given + // outputs will be bound to fragment shader output colors in the order + // they appear in the vector. Otherwise, output order is undefined and + // determined by the OpenGL driver. + GLuint compile_glsl_program(const std::string& vertex_shader, + const std::string& fragment_shader, + const std::vector& frag_shader_outputs); void release_glsl_program(GLuint glsl_program_num); + // Allocate a 2D texture of the given internal format and dimensions, + // or fetch a previous used if possible. Unbinds GL_TEXTURE_2D afterwards. + // Keeps ownership of the texture; you must call release_2d_texture() instead + // of deleting it when you no longer want it. + GLuint create_2d_texture(GLint internal_format, GLsizei width, GLsizei height); + void release_2d_texture(GLuint texture_num); + + // Allocate an FBO with the the given texture(s) bound as framebuffer attachment(s), + // or fetch a previous used if possible. Unbinds GL_FRAMEBUFFER afterwards. + // Keeps ownership of the FBO; you must call release_fbo() of deleting + // it when you no longer want it. + // + // NOTE: In principle, the FBO doesn't have a resolution or pixel format; + // you can bind almost whatever texture you want to it. However, changing + // textures can have an adverse effect on performance due to validation, + // in particular on NVidia cards. Also, keep in mind that FBOs are not + // shareable across contexts, so you must have the context that's supposed + // to own the FBO current when you create or release it. + GLuint create_fbo(GLuint texture0_num, + GLuint texture1_num = 0, + GLuint texture2_num = 0, + GLuint texture3_num = 0); + void release_fbo(GLuint fbo_num); + + // Informs the ResourcePool that the current context is going away soon, + // and that any resources held for it in the freelist should be deleted. + // + // You do not need to do this for the last context; the regular destructor + // will take care of that. This means that if you only ever use one + // thread/context, you never need to call this function. + void clean_context(); + private: // Delete the given program and both its shaders. void delete_program(GLuint program_num); + // Deletes all FBOs for the given context that belong to deleted textures. + void cleanup_unlinked_fbos(void *context); + + // Remove FBOs off the end of the freelist for , until it + // is no more than elements long. + void shrink_fbo_freelist(void *context, size_t max_length); + // Protects all the other elements in the class. pthread_mutex_t lock; - size_t program_freelist_max_length; + size_t program_freelist_max_length, texture_freelist_max_bytes, fbo_freelist_max_length; // A mapping from vertex/fragment shader source strings to compiled program number. std::map, GLuint> programs; @@ -62,8 +127,53 @@ private: std::map > program_shaders; // A list of programs that are no longer in use, most recently freed first. - // Once this reaches , + // Once this reaches , the last element + // will be deleted. std::list program_freelist; + + struct Texture2D { + GLint internal_format; + GLsizei width, height; + }; + + // A mapping from texture number to format details. This is filled if the + // texture is given out to a client or on the freelist, but not if it is + // deleted from the freelist. + std::map texture_formats; + + // A list of all textures that are release but not freed (most recently freed + // first), and an estimate of their current memory usage. Once + // goes above , + // elements are deleted off the end of the list until we are under the limit + // again. + std::list texture_freelist; + size_t texture_freelist_bytes; + + static const unsigned num_fbo_attachments = 4; + struct FBO { + GLuint fbo_num; + // GL_INVALID_INDEX means associated to a texture that has since been deleted. + // 0 means the output isn't bound. + GLuint texture_num[num_fbo_attachments]; + }; + + // For each context, a mapping from FBO number to format details. This is + // filled if the FBO is given out to a client or on the freelist, but + // not if it is deleted from the freelist. + std::map, FBO> fbo_formats; + typedef std::map, FBO>::iterator FBOFormatIterator; + + // For each context, a list of all FBOs that are released but not freed + // (most recently freed first). Once this reaches , + // the last element will be deleted. + // + // We store iterators directly into for efficiency. + std::map > fbo_freelist; + + // See the caveats at the constructor. + static size_t estimate_texture_size(const Texture2D &texture_format); }; +} // namespace movit + #endif // !defined(_MOVIT_RESOURCE_POOL_H)