brl/mutter
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
5085919acc
mutter/cogl/cogl-pipeline-cache.c

211 lines
7.0 KiB
C
Raw Normal View History

fragend-arbfp: Move the pipeline cache to a separate file The pipeline cache is now handled in CoglPipelineCache instead of directly in the ARBfp fragend. The flags needed to hash a pipeline should be exactly the same for the ARBfp and GLSL fragends so it's convenient to share the code. The hash table now stores the actual pipeline as the value instead of the private data so that the two fragends can attach their data to it. That way it's possible to use the same pipeline key with ancestors that are using different fragends. The hash table is created with g_hash_table_new_full to set a destructor for the key and value and there is a destructor for CoglPipelineCache that gets called when the CoglContext is destroyed. That way we no longer leak the pipelines and shader state when the context is desroyed.
2011-06-30 10:55:56 -04:00
/*
* Cogl
*
* An object oriented GL/GLES Abstraction/Utility Layer
*
pipeline-cache: Use a shared hash table wrapper The pipeline cache contains three separate hash tables, one for the state affecting the vertex shaders, one for the fragment shaders and one for the resulting combined program. Previously these hash tables had a fair bit of duplicated code to calculate the hashes, check for equality and copy the pipeline when it is added. This patch moves the common bits of code to a new type called CoglPipelineHashTable which just wraps a GHashTable with a given set of state flags to use for hashing and checking for equality. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 402796430c839038339e531363b8c2463f9b2a9e) Conflicts: cogl/Makefile.am
2013-03-25 12:54:51 -04:00
* Copyright (C) 2011, 2013 Intel Corporation.
fragend-arbfp: Move the pipeline cache to a separate file The pipeline cache is now handled in CoglPipelineCache instead of directly in the ARBfp fragend. The flags needed to hash a pipeline should be exactly the same for the ARBfp and GLSL fragends so it's convenient to share the code. The hash table now stores the actual pipeline as the value instead of the private data so that the two fragends can attach their data to it. That way it's possible to use the same pipeline key with ancestors that are using different fragends. The hash table is created with g_hash_table_new_full to set a destructor for the key and value and there is a destructor for CoglPipelineCache that gets called when the CoglContext is destroyed. That way we no longer leak the pipelines and shader state when the context is desroyed.
2011-06-30 10:55:56 -04:00
*
* 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; either
* version 2 of the License, or (at your option) any later version.
*
* 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, see
* <http://www.gnu.org/licenses/>.
*
*
* Authors:
* Neil Roberts <neil@linux.intel.com>
* Robert Bragg <robert@linux.intel.com>
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
pipeline-cache: Prune old unused pipelines when the cache gets too big Previously when a pipeline is added to the cache it would never be removed. If the application is generating a lot of unique pipelines this can end up effectively leaking a large number of resources including the GL program objects. Arguably this isn't really a problem because if the application is generating that many unique pipelines then it is doing something wrong anyway. It also implies that it will be recompiling shaders very often so the cache leaking will likely be the least of the problems. This patch makes it keep track of which pipelines in the cache are in use. The cache now returns a struct representing the entry instead of directly returning the pipeline. This entry contains a usage counter which the pipeline backends can use to mark when there is a pipeline alive that is using the cache entry. When the hash table decides that it's a good time to prune some entries, it will make a list of all of the pipelines that are not in use and then remove the least recently used half of the pipelines. That way it is less likely to remove pipelines that the application is actually regenerating often even if they aren't in use all of the time. When the cache is pruned the hash table makes a note of how small the cache could be if it removed all of the unused pipelines. The hash table starts pruning when there are more entries than twice this minimum expected size. The idea is that if that case it hit then the hash table is more than half full of useless pipelines so the application is generating lots of redundant pipelines and it is a good time to remove them. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit c21aac22992bb7fef5a8d0913130b8245e67f2eb) Conflicts: cogl/driver/gl/cogl-pipeline-fragend-glsl.c cogl/driver/gl/cogl-pipeline-progend-glsl.c cogl/driver/gl/cogl-pipeline-vertend-glsl.c cogl/driver/gl/gl/cogl-pipeline-fragend-arbfp.c
2013-12-18 10:18:39 -05:00
#include <test-fixtures/test-unit.h>
cogl-pipeline/cogl-pango: Added forgotten includes It seems that cogl-context-private.h needs to be included before including any of the pipeline-related stuff to avoid build errors on C89 compilers. This is due to the recent cogl-pipeline decoupling, seems like. Reviewed-by: Robert Bragg <robert@linux.intel.com>
2011-09-23 04:43:05 -04:00
#include "cogl-context-private.h"
fragend-arbfp: Move the pipeline cache to a separate file The pipeline cache is now handled in CoglPipelineCache instead of directly in the ARBfp fragend. The flags needed to hash a pipeline should be exactly the same for the ARBfp and GLSL fragends so it's convenient to share the code. The hash table now stores the actual pipeline as the value instead of the private data so that the two fragends can attach their data to it. That way it's possible to use the same pipeline key with ancestors that are using different fragends. The hash table is created with g_hash_table_new_full to set a destructor for the key and value and there is a destructor for CoglPipelineCache that gets called when the CoglContext is destroyed. That way we no longer leak the pipelines and shader state when the context is desroyed.
2011-06-30 10:55:56 -04:00
#include "cogl-pipeline-private.h"
#include "cogl-pipeline-cache.h"
pipeline-cache: Use a shared hash table wrapper The pipeline cache contains three separate hash tables, one for the state affecting the vertex shaders, one for the fragment shaders and one for the resulting combined program. Previously these hash tables had a fair bit of duplicated code to calculate the hashes, check for equality and copy the pipeline when it is added. This patch moves the common bits of code to a new type called CoglPipelineHashTable which just wraps a GHashTable with a given set of state flags to use for hashing and checking for equality. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 402796430c839038339e531363b8c2463f9b2a9e) Conflicts: cogl/Makefile.am
2013-03-25 12:54:51 -04:00
#include "cogl-pipeline-hash-table.h"
fragend-arbfp: Move the pipeline cache to a separate file The pipeline cache is now handled in CoglPipelineCache instead of directly in the ARBfp fragend. The flags needed to hash a pipeline should be exactly the same for the ARBfp and GLSL fragends so it's convenient to share the code. The hash table now stores the actual pipeline as the value instead of the private data so that the two fragends can attach their data to it. That way it's possible to use the same pipeline key with ancestors that are using different fragends. The hash table is created with g_hash_table_new_full to set a destructor for the key and value and there is a destructor for CoglPipelineCache that gets called when the CoglContext is destroyed. That way we no longer leak the pipelines and shader state when the context is desroyed.
2011-06-30 10:55:56 -04:00
struct _CoglPipelineCache
{
pipeline-cache: Use a shared hash table wrapper The pipeline cache contains three separate hash tables, one for the state affecting the vertex shaders, one for the fragment shaders and one for the resulting combined program. Previously these hash tables had a fair bit of duplicated code to calculate the hashes, check for equality and copy the pipeline when it is added. This patch moves the common bits of code to a new type called CoglPipelineHashTable which just wraps a GHashTable with a given set of state flags to use for hashing and checking for equality. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 402796430c839038339e531363b8c2463f9b2a9e) Conflicts: cogl/Makefile.am
2013-03-25 12:54:51 -04:00
CoglPipelineHashTable fragment_hash;
CoglPipelineHashTable vertex_hash;
CoglPipelineHashTable combined_hash;
fragend-arbfp: Move the pipeline cache to a separate file The pipeline cache is now handled in CoglPipelineCache instead of directly in the ARBfp fragend. The flags needed to hash a pipeline should be exactly the same for the ARBfp and GLSL fragends so it's convenient to share the code. The hash table now stores the actual pipeline as the value instead of the private data so that the two fragends can attach their data to it. That way it's possible to use the same pipeline key with ancestors that are using different fragends. The hash table is created with g_hash_table_new_full to set a destructor for the key and value and there is a destructor for CoglPipelineCache that gets called when the CoglContext is destroyed. That way we no longer leak the pipelines and shader state when the context is desroyed.
2011-06-30 10:55:56 -04:00
};
pipeline-cache: Use a shared hash table wrapper The pipeline cache contains three separate hash tables, one for the state affecting the vertex shaders, one for the fragment shaders and one for the resulting combined program. Previously these hash tables had a fair bit of duplicated code to calculate the hashes, check for equality and copy the pipeline when it is added. This patch moves the common bits of code to a new type called CoglPipelineHashTable which just wraps a GHashTable with a given set of state flags to use for hashing and checking for equality. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 402796430c839038339e531363b8c2463f9b2a9e) Conflicts: cogl/Makefile.am
2013-03-25 12:54:51 -04:00
CoglPipelineCache *
_cogl_pipeline_cache_new (void)
fragend-arbfp: Move the pipeline cache to a separate file The pipeline cache is now handled in CoglPipelineCache instead of directly in the ARBfp fragend. The flags needed to hash a pipeline should be exactly the same for the ARBfp and GLSL fragends so it's convenient to share the code. The hash table now stores the actual pipeline as the value instead of the private data so that the two fragends can attach their data to it. That way it's possible to use the same pipeline key with ancestors that are using different fragends. The hash table is created with g_hash_table_new_full to set a destructor for the key and value and there is a destructor for CoglPipelineCache that gets called when the CoglContext is destroyed. That way we no longer leak the pipelines and shader state when the context is desroyed.
2011-06-30 10:55:56 -04:00
{
pipeline-cache: Use a shared hash table wrapper The pipeline cache contains three separate hash tables, one for the state affecting the vertex shaders, one for the fragment shaders and one for the resulting combined program. Previously these hash tables had a fair bit of duplicated code to calculate the hashes, check for equality and copy the pipeline when it is added. This patch moves the common bits of code to a new type called CoglPipelineHashTable which just wraps a GHashTable with a given set of state flags to use for hashing and checking for equality. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 402796430c839038339e531363b8c2463f9b2a9e) Conflicts: cogl/Makefile.am
2013-03-25 12:54:51 -04:00
CoglPipelineCache *cache = g_new (CoglPipelineCache, 1);
unsigned long vertex_state;
unsigned long layer_vertex_state;
fragend-arbfp: Move the pipeline cache to a separate file The pipeline cache is now handled in CoglPipelineCache instead of directly in the ARBfp fragend. The flags needed to hash a pipeline should be exactly the same for the ARBfp and GLSL fragends so it's convenient to share the code. The hash table now stores the actual pipeline as the value instead of the private data so that the two fragends can attach their data to it. That way it's possible to use the same pipeline key with ancestors that are using different fragends. The hash table is created with g_hash_table_new_full to set a destructor for the key and value and there is a destructor for CoglPipelineCache that gets called when the CoglContext is destroyed. That way we no longer leak the pipelines and shader state when the context is desroyed.
2011-06-30 10:55:56 -04:00
unsigned int fragment_state;
unsigned int layer_fragment_state;
_COGL_GET_CONTEXT (ctx, 0);
pipeline-cache: Use a shared hash table wrapper The pipeline cache contains three separate hash tables, one for the state affecting the vertex shaders, one for the fragment shaders and one for the resulting combined program. Previously these hash tables had a fair bit of duplicated code to calculate the hashes, check for equality and copy the pipeline when it is added. This patch moves the common bits of code to a new type called CoglPipelineHashTable which just wraps a GHashTable with a given set of state flags to use for hashing and checking for equality. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 402796430c839038339e531363b8c2463f9b2a9e) Conflicts: cogl/Makefile.am
2013-03-25 12:54:51 -04:00
vertex_state =
Don't generate GLSL for the point size for default pipelines Previously on GLES2 where there is no builtin point size uniform then we would always add a line to the vertex shader to write to the builtin point size output because when generating the shader it is not possible to determine if the pipeline will be used to draw points or not. This patch changes it so that the default point size is 0.0f which is documented to have undefined results when drawing points. That way we can avoid adding the point size code to the shader in that case. The assumption is that any application that is drawing points will probably have explicitly set the point size on the pipeline anyway so it is not a big deal to change the default size from 1.0f. This adds a new pipeline state flag to track whether the point size is non-zero. This needs to be its own state because altering it needs to cause a different shader to be added to the pipeline cache. The state flags that affect the vertex shader have been changed from a constant to a runtime function because they will be different depending on whether there is a builtin point size uniform. There is also a unit test to ensure that changing the point size does or doesn't generate a new shader depending on the values. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit b2eba06e16b587acbf5c57944a70ceccecb4f175) Conflicts: cogl/cogl-pipeline-private.h cogl/cogl-pipeline-state-private.h cogl/cogl-pipeline-state.c cogl/cogl-pipeline.c
2013-06-20 08:25:49 -04:00
_cogl_pipeline_get_state_for_vertex_codegen (ctx);
pipeline-cache: Use a shared hash table wrapper The pipeline cache contains three separate hash tables, one for the state affecting the vertex shaders, one for the fragment shaders and one for the resulting combined program. Previously these hash tables had a fair bit of duplicated code to calculate the hashes, check for equality and copy the pipeline when it is added. This patch moves the common bits of code to a new type called CoglPipelineHashTable which just wraps a GHashTable with a given set of state flags to use for hashing and checking for equality. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 402796430c839038339e531363b8c2463f9b2a9e) Conflicts: cogl/Makefile.am
2013-03-25 12:54:51 -04:00
layer_vertex_state =
COGL_PIPELINE_LAYER_STATE_AFFECTS_VERTEX_CODEGEN;
fragend-arbfp: Move the pipeline cache to a separate file The pipeline cache is now handled in CoglPipelineCache instead of directly in the ARBfp fragend. The flags needed to hash a pipeline should be exactly the same for the ARBfp and GLSL fragends so it's convenient to share the code. The hash table now stores the actual pipeline as the value instead of the private data so that the two fragends can attach their data to it. That way it's possible to use the same pipeline key with ancestors that are using different fragends. The hash table is created with g_hash_table_new_full to set a destructor for the key and value and there is a destructor for CoglPipelineCache that gets called when the CoglContext is destroyed. That way we no longer leak the pipelines and shader state when the context is desroyed.
2011-06-30 10:55:56 -04:00
fragment_state =
_cogl_pipeline_get_state_for_fragment_codegen (ctx);
layer_fragment_state =
_cogl_pipeline_get_layer_state_for_fragment_codegen (ctx);
pipeline-cache: Use a shared hash table wrapper The pipeline cache contains three separate hash tables, one for the state affecting the vertex shaders, one for the fragment shaders and one for the resulting combined program. Previously these hash tables had a fair bit of duplicated code to calculate the hashes, check for equality and copy the pipeline when it is added. This patch moves the common bits of code to a new type called CoglPipelineHashTable which just wraps a GHashTable with a given set of state flags to use for hashing and checking for equality. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 402796430c839038339e531363b8c2463f9b2a9e) Conflicts: cogl/Makefile.am
2013-03-25 12:54:51 -04:00
_cogl_pipeline_hash_table_init (&cache->vertex_hash,
vertex_state,
layer_vertex_state,
"vertex shaders");
_cogl_pipeline_hash_table_init (&cache->fragment_hash,
fragment_state,
layer_fragment_state,
"fragment shaders");
_cogl_pipeline_hash_table_init (&cache->combined_hash,
vertex_state | fragment_state,
layer_vertex_state | layer_fragment_state,
"programs");
fragend-arbfp: Move the pipeline cache to a separate file The pipeline cache is now handled in CoglPipelineCache instead of directly in the ARBfp fragend. The flags needed to hash a pipeline should be exactly the same for the ARBfp and GLSL fragends so it's convenient to share the code. The hash table now stores the actual pipeline as the value instead of the private data so that the two fragends can attach their data to it. That way it's possible to use the same pipeline key with ancestors that are using different fragends. The hash table is created with g_hash_table_new_full to set a destructor for the key and value and there is a destructor for CoglPipelineCache that gets called when the CoglContext is destroyed. That way we no longer leak the pipelines and shader state when the context is desroyed.
2011-06-30 10:55:56 -04:00
return cache;
}
void
build: Hide cogl_pipeline_cache_{new,free}() Those symbols should not be public and were exported as they started with cogl_. (cherry picked from commit 68a55f1dc70ea60fcccbe226029e585886feddc2)
2013-01-01 09:15:25 -05:00
_cogl_pipeline_cache_free (CoglPipelineCache *cache)
fragend-arbfp: Move the pipeline cache to a separate file The pipeline cache is now handled in CoglPipelineCache instead of directly in the ARBfp fragend. The flags needed to hash a pipeline should be exactly the same for the ARBfp and GLSL fragends so it's convenient to share the code. The hash table now stores the actual pipeline as the value instead of the private data so that the two fragends can attach their data to it. That way it's possible to use the same pipeline key with ancestors that are using different fragends. The hash table is created with g_hash_table_new_full to set a destructor for the key and value and there is a destructor for CoglPipelineCache that gets called when the CoglContext is destroyed. That way we no longer leak the pipelines and shader state when the context is desroyed.
2011-06-30 10:55:56 -04:00
{
pipeline-cache: Use a shared hash table wrapper The pipeline cache contains three separate hash tables, one for the state affecting the vertex shaders, one for the fragment shaders and one for the resulting combined program. Previously these hash tables had a fair bit of duplicated code to calculate the hashes, check for equality and copy the pipeline when it is added. This patch moves the common bits of code to a new type called CoglPipelineHashTable which just wraps a GHashTable with a given set of state flags to use for hashing and checking for equality. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 402796430c839038339e531363b8c2463f9b2a9e) Conflicts: cogl/Makefile.am
2013-03-25 12:54:51 -04:00
_cogl_pipeline_hash_table_destroy (&cache->fragment_hash);
_cogl_pipeline_hash_table_destroy (&cache->vertex_hash);
_cogl_pipeline_hash_table_destroy (&cache->combined_hash);
fragend-arbfp: Move the pipeline cache to a separate file The pipeline cache is now handled in CoglPipelineCache instead of directly in the ARBfp fragend. The flags needed to hash a pipeline should be exactly the same for the ARBfp and GLSL fragends so it's convenient to share the code. The hash table now stores the actual pipeline as the value instead of the private data so that the two fragends can attach their data to it. That way it's possible to use the same pipeline key with ancestors that are using different fragends. The hash table is created with g_hash_table_new_full to set a destructor for the key and value and there is a destructor for CoglPipelineCache that gets called when the CoglContext is destroyed. That way we no longer leak the pipelines and shader state when the context is desroyed.
2011-06-30 10:55:56 -04:00
g_free (cache);
}
pipeline-cache: Prune old unused pipelines when the cache gets too big Previously when a pipeline is added to the cache it would never be removed. If the application is generating a lot of unique pipelines this can end up effectively leaking a large number of resources including the GL program objects. Arguably this isn't really a problem because if the application is generating that many unique pipelines then it is doing something wrong anyway. It also implies that it will be recompiling shaders very often so the cache leaking will likely be the least of the problems. This patch makes it keep track of which pipelines in the cache are in use. The cache now returns a struct representing the entry instead of directly returning the pipeline. This entry contains a usage counter which the pipeline backends can use to mark when there is a pipeline alive that is using the cache entry. When the hash table decides that it's a good time to prune some entries, it will make a list of all of the pipelines that are not in use and then remove the least recently used half of the pipelines. That way it is less likely to remove pipelines that the application is actually regenerating often even if they aren't in use all of the time. When the cache is pruned the hash table makes a note of how small the cache could be if it removed all of the unused pipelines. The hash table starts pruning when there are more entries than twice this minimum expected size. The idea is that if that case it hit then the hash table is more than half full of useless pipelines so the application is generating lots of redundant pipelines and it is a good time to remove them. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit c21aac22992bb7fef5a8d0913130b8245e67f2eb) Conflicts: cogl/driver/gl/cogl-pipeline-fragend-glsl.c cogl/driver/gl/cogl-pipeline-progend-glsl.c cogl/driver/gl/cogl-pipeline-vertend-glsl.c cogl/driver/gl/gl/cogl-pipeline-fragend-arbfp.c
2013-12-18 10:18:39 -05:00
CoglPipelineCacheEntry *
fragend-arbfp: Move the pipeline cache to a separate file The pipeline cache is now handled in CoglPipelineCache instead of directly in the ARBfp fragend. The flags needed to hash a pipeline should be exactly the same for the ARBfp and GLSL fragends so it's convenient to share the code. The hash table now stores the actual pipeline as the value instead of the private data so that the two fragends can attach their data to it. That way it's possible to use the same pipeline key with ancestors that are using different fragends. The hash table is created with g_hash_table_new_full to set a destructor for the key and value and there is a destructor for CoglPipelineCache that gets called when the CoglContext is destroyed. That way we no longer leak the pipelines and shader state when the context is desroyed.
2011-06-30 10:55:56 -04:00
_cogl_pipeline_cache_get_fragment_template (CoglPipelineCache *cache,
CoglPipeline *key_pipeline)
{
pipeline-cache: Use a shared hash table wrapper The pipeline cache contains three separate hash tables, one for the state affecting the vertex shaders, one for the fragment shaders and one for the resulting combined program. Previously these hash tables had a fair bit of duplicated code to calculate the hashes, check for equality and copy the pipeline when it is added. This patch moves the common bits of code to a new type called CoglPipelineHashTable which just wraps a GHashTable with a given set of state flags to use for hashing and checking for equality. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 402796430c839038339e531363b8c2463f9b2a9e) Conflicts: cogl/Makefile.am
2013-03-25 12:54:51 -04:00
return _cogl_pipeline_hash_table_get (&cache->fragment_hash,
key_pipeline);
fragend-arbfp: Move the pipeline cache to a separate file The pipeline cache is now handled in CoglPipelineCache instead of directly in the ARBfp fragend. The flags needed to hash a pipeline should be exactly the same for the ARBfp and GLSL fragends so it's convenient to share the code. The hash table now stores the actual pipeline as the value instead of the private data so that the two fragends can attach their data to it. That way it's possible to use the same pipeline key with ancestors that are using different fragends. The hash table is created with g_hash_table_new_full to set a destructor for the key and value and there is a destructor for CoglPipelineCache that gets called when the CoglContext is destroyed. That way we no longer leak the pipelines and shader state when the context is desroyed.
2011-06-30 10:55:56 -04:00
}
cogl-pipeline: Use the pipeline cache for the GLSL backends The CoglPipelineCache is now extended to store templates for state affecting vertex shaders and combined programs. The GLSL fragend, vertend and progend now uses this to get cached shaders and a program. When a new pipeline is created it will now get hashed three times if the GLSL backends are in use (once for the fragend, once for the vertend and once for the progend). Ideally we should add some way for the progend to check its cache before the fragends and vertends are checked so that it can bypass them entirely if it can find a cached combined program.
2011-06-30 13:34:05 -04:00
pipeline-cache: Prune old unused pipelines when the cache gets too big Previously when a pipeline is added to the cache it would never be removed. If the application is generating a lot of unique pipelines this can end up effectively leaking a large number of resources including the GL program objects. Arguably this isn't really a problem because if the application is generating that many unique pipelines then it is doing something wrong anyway. It also implies that it will be recompiling shaders very often so the cache leaking will likely be the least of the problems. This patch makes it keep track of which pipelines in the cache are in use. The cache now returns a struct representing the entry instead of directly returning the pipeline. This entry contains a usage counter which the pipeline backends can use to mark when there is a pipeline alive that is using the cache entry. When the hash table decides that it's a good time to prune some entries, it will make a list of all of the pipelines that are not in use and then remove the least recently used half of the pipelines. That way it is less likely to remove pipelines that the application is actually regenerating often even if they aren't in use all of the time. When the cache is pruned the hash table makes a note of how small the cache could be if it removed all of the unused pipelines. The hash table starts pruning when there are more entries than twice this minimum expected size. The idea is that if that case it hit then the hash table is more than half full of useless pipelines so the application is generating lots of redundant pipelines and it is a good time to remove them. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit c21aac22992bb7fef5a8d0913130b8245e67f2eb) Conflicts: cogl/driver/gl/cogl-pipeline-fragend-glsl.c cogl/driver/gl/cogl-pipeline-progend-glsl.c cogl/driver/gl/cogl-pipeline-vertend-glsl.c cogl/driver/gl/gl/cogl-pipeline-fragend-arbfp.c
2013-12-18 10:18:39 -05:00
CoglPipelineCacheEntry *
cogl-pipeline: Use the pipeline cache for the GLSL backends The CoglPipelineCache is now extended to store templates for state affecting vertex shaders and combined programs. The GLSL fragend, vertend and progend now uses this to get cached shaders and a program. When a new pipeline is created it will now get hashed three times if the GLSL backends are in use (once for the fragend, once for the vertend and once for the progend). Ideally we should add some way for the progend to check its cache before the fragends and vertends are checked so that it can bypass them entirely if it can find a cached combined program.
2011-06-30 13:34:05 -04:00
_cogl_pipeline_cache_get_vertex_template (CoglPipelineCache *cache,
CoglPipeline *key_pipeline)
{
pipeline-cache: Use a shared hash table wrapper The pipeline cache contains three separate hash tables, one for the state affecting the vertex shaders, one for the fragment shaders and one for the resulting combined program. Previously these hash tables had a fair bit of duplicated code to calculate the hashes, check for equality and copy the pipeline when it is added. This patch moves the common bits of code to a new type called CoglPipelineHashTable which just wraps a GHashTable with a given set of state flags to use for hashing and checking for equality. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 402796430c839038339e531363b8c2463f9b2a9e) Conflicts: cogl/Makefile.am
2013-03-25 12:54:51 -04:00
return _cogl_pipeline_hash_table_get (&cache->vertex_hash,
key_pipeline);
cogl-pipeline: Use the pipeline cache for the GLSL backends The CoglPipelineCache is now extended to store templates for state affecting vertex shaders and combined programs. The GLSL fragend, vertend and progend now uses this to get cached shaders and a program. When a new pipeline is created it will now get hashed three times if the GLSL backends are in use (once for the fragend, once for the vertend and once for the progend). Ideally we should add some way for the progend to check its cache before the fragends and vertends are checked so that it can bypass them entirely if it can find a cached combined program.
2011-06-30 13:34:05 -04:00
}
pipeline-cache: Prune old unused pipelines when the cache gets too big Previously when a pipeline is added to the cache it would never be removed. If the application is generating a lot of unique pipelines this can end up effectively leaking a large number of resources including the GL program objects. Arguably this isn't really a problem because if the application is generating that many unique pipelines then it is doing something wrong anyway. It also implies that it will be recompiling shaders very often so the cache leaking will likely be the least of the problems. This patch makes it keep track of which pipelines in the cache are in use. The cache now returns a struct representing the entry instead of directly returning the pipeline. This entry contains a usage counter which the pipeline backends can use to mark when there is a pipeline alive that is using the cache entry. When the hash table decides that it's a good time to prune some entries, it will make a list of all of the pipelines that are not in use and then remove the least recently used half of the pipelines. That way it is less likely to remove pipelines that the application is actually regenerating often even if they aren't in use all of the time. When the cache is pruned the hash table makes a note of how small the cache could be if it removed all of the unused pipelines. The hash table starts pruning when there are more entries than twice this minimum expected size. The idea is that if that case it hit then the hash table is more than half full of useless pipelines so the application is generating lots of redundant pipelines and it is a good time to remove them. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit c21aac22992bb7fef5a8d0913130b8245e67f2eb) Conflicts: cogl/driver/gl/cogl-pipeline-fragend-glsl.c cogl/driver/gl/cogl-pipeline-progend-glsl.c cogl/driver/gl/cogl-pipeline-vertend-glsl.c cogl/driver/gl/gl/cogl-pipeline-fragend-arbfp.c
2013-12-18 10:18:39 -05:00
CoglPipelineCacheEntry *
cogl-pipeline: Use the pipeline cache for the GLSL backends The CoglPipelineCache is now extended to store templates for state affecting vertex shaders and combined programs. The GLSL fragend, vertend and progend now uses this to get cached shaders and a program. When a new pipeline is created it will now get hashed three times if the GLSL backends are in use (once for the fragend, once for the vertend and once for the progend). Ideally we should add some way for the progend to check its cache before the fragends and vertends are checked so that it can bypass them entirely if it can find a cached combined program.
2011-06-30 13:34:05 -04:00
_cogl_pipeline_cache_get_combined_template (CoglPipelineCache *cache,
CoglPipeline *key_pipeline)
{
pipeline-cache: Use a shared hash table wrapper The pipeline cache contains three separate hash tables, one for the state affecting the vertex shaders, one for the fragment shaders and one for the resulting combined program. Previously these hash tables had a fair bit of duplicated code to calculate the hashes, check for equality and copy the pipeline when it is added. This patch moves the common bits of code to a new type called CoglPipelineHashTable which just wraps a GHashTable with a given set of state flags to use for hashing and checking for equality. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 402796430c839038339e531363b8c2463f9b2a9e) Conflicts: cogl/Makefile.am
2013-03-25 12:54:51 -04:00
return _cogl_pipeline_hash_table_get (&cache->combined_hash,
key_pipeline);
cogl-pipeline: Use the pipeline cache for the GLSL backends The CoglPipelineCache is now extended to store templates for state affecting vertex shaders and combined programs. The GLSL fragend, vertend and progend now uses this to get cached shaders and a program. When a new pipeline is created it will now get hashed three times if the GLSL backends are in use (once for the fragend, once for the vertend and once for the progend). Ideally we should add some way for the progend to check its cache before the fragends and vertends are checked so that it can bypass them entirely if it can find a cached combined program.
2011-06-30 13:34:05 -04:00
}
pipeline-cache: Prune old unused pipelines when the cache gets too big Previously when a pipeline is added to the cache it would never be removed. If the application is generating a lot of unique pipelines this can end up effectively leaking a large number of resources including the GL program objects. Arguably this isn't really a problem because if the application is generating that many unique pipelines then it is doing something wrong anyway. It also implies that it will be recompiling shaders very often so the cache leaking will likely be the least of the problems. This patch makes it keep track of which pipelines in the cache are in use. The cache now returns a struct representing the entry instead of directly returning the pipeline. This entry contains a usage counter which the pipeline backends can use to mark when there is a pipeline alive that is using the cache entry. When the hash table decides that it's a good time to prune some entries, it will make a list of all of the pipelines that are not in use and then remove the least recently used half of the pipelines. That way it is less likely to remove pipelines that the application is actually regenerating often even if they aren't in use all of the time. When the cache is pruned the hash table makes a note of how small the cache could be if it removed all of the unused pipelines. The hash table starts pruning when there are more entries than twice this minimum expected size. The idea is that if that case it hit then the hash table is more than half full of useless pipelines so the application is generating lots of redundant pipelines and it is a good time to remove them. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit c21aac22992bb7fef5a8d0913130b8245e67f2eb) Conflicts: cogl/driver/gl/cogl-pipeline-fragend-glsl.c cogl/driver/gl/cogl-pipeline-progend-glsl.c cogl/driver/gl/cogl-pipeline-vertend-glsl.c cogl/driver/gl/gl/cogl-pipeline-fragend-arbfp.c
2013-12-18 10:18:39 -05:00
#ifdef ENABLE_UNIT_TESTS
static void
create_pipelines (CoglPipeline **pipelines,
int n_pipelines)
{
int i;
for (i = 0; i < n_pipelines; i++)
{
char *source = g_strdup_printf (" cogl_color_out = "
"vec4 (%f, 0.0, 0.0, 1.0);\n",
i / 255.0f);
CoglSnippet *snippet =
cogl_snippet_new (COGL_SNIPPET_HOOK_FRAGMENT,
NULL, /* declarations */
source);
g_free (source);
pipelines[i] = cogl_pipeline_new (test_ctx);
cogl_pipeline_add_snippet (pipelines[i], snippet);
cogl_object_unref (snippet);
}
/* Test that drawing with them works. This should create the entries
* in the cache */
for (i = 0; i < n_pipelines; i++)
{
cogl_framebuffer_draw_rectangle (test_fb,
pipelines[i],
i, 0,
i + 1, 1);
test_utils_check_pixel_rgb (test_fb, i, 0, i, 0, 0);
}
}
UNIT_TEST (check_pipeline_pruning,
TEST_REQUIREMENT_GLSL, /* requirements */
0 /* no failure cases */)
{
CoglPipeline *pipelines[18];
int fb_width, fb_height;
CoglPipelineHashTable *fragment_hash =
&test_ctx->pipeline_cache->fragment_hash;
CoglPipelineHashTable *combined_hash =
&test_ctx->pipeline_cache->combined_hash;
int i;
fb_width = cogl_framebuffer_get_width (test_fb);
fb_height = cogl_framebuffer_get_height (test_fb);
cogl_framebuffer_orthographic (test_fb,
0, 0,
fb_width,
fb_height,
-1,
100);
/* Create 18 unique pipelines. This should end up being more than
* the initial expected minimum size so it will trigger the garbage
* collection. However all of the pipelines will be in use so they
* won't be collected */
create_pipelines (pipelines, 18);
/* These pipelines should all have unique entries in the cache. We
* should have run the garbage collection once and at that point the
* expected minimum size would have been 17 */
g_assert_cmpint (g_hash_table_size (fragment_hash->table), ==, 18);
g_assert_cmpint (g_hash_table_size (combined_hash->table), ==, 18);
g_assert_cmpint (fragment_hash->expected_min_size, ==, 17);
g_assert_cmpint (combined_hash->expected_min_size, ==, 17);
/* Destroy the original pipelines and create some new ones. This
* should run the garbage collector again but this time the
* pipelines won't be in use so it should free some of them */
for (i = 0; i < 18; i++)
cogl_object_unref (pipelines[i]);
create_pipelines (pipelines, 18);
/* The garbage collection should have freed half of the original 18
* pipelines which means there should now be 18*1.5 = 27 */
g_assert_cmpint (g_hash_table_size (fragment_hash->table), ==, 27);
g_assert_cmpint (g_hash_table_size (combined_hash->table), ==, 27);
/* The 35th pipeline would have caused the garbage collection. At
* that point there would be 35-18=17 used unique pipelines. */
g_assert_cmpint (fragment_hash->expected_min_size, ==, 17);
g_assert_cmpint (combined_hash->expected_min_size, ==, 17);
for (i = 0; i < 18; i++)
cogl_object_unref (pipelines[i]);
}
#endif /* ENABLE_UNIT_TESTS */
Reference in New Issue Copy Permalink