isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-12-24 20:12:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

pipeline: Implements _cogl_pipeline_hash function

Browse Source 
This allows us to get a hash for a set of state groups for a given
pipeline. This can be used for example to get a hash of the fragment
processing state of a pipeline so we can implement a cache for compiled
arbfp/glsl programs.
This commit is contained in:
Robert Bragg 2010-11-04 13:57:36 +00:00
parent cc36e49ec5
commit e87c3820ee
6 changed files with 580 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
clutter/cogl/cogl/cogl-color-private.h
View File

@ -32,6 +32,11 @@
#include <glib.h>
/* cogl-pipeline.c wants to be able to hash CoglColor data so it needs
* the exact data size to be able to avoid reading the padding bytes.
*/
#define _COGL_COLOR_DATA_SIZE 4
void
_cogl_color_get_rgba_4ubv (const CoglColor *color,
guint8 *dest);

2
clutter/cogl/cogl/cogl-context.c
View File

@ -127,6 +127,8 @@ cogl_create_context (void)
_cogl_pipeline_init_default_pipeline ();
_cogl_pipeline_init_default_layers ();
_cogl_pipeline_init_state_hash_functions ();
_cogl_pipeline_init_layer_state_hash_functions ();
_context->enable_flags = 0;

18
clutter/cogl/cogl/cogl-pipeline-private.h
View File

@ -390,7 +390,7 @@ typedef struct
{
/* Determines what fragments are discarded based on their alpha */
CoglPipelineAlphaFunc alpha_func;
GLfloat alpha_func_reference;
float alpha_func_reference;
} CoglPipelineAlphaFuncState;
typedef enum _CoglPipelineBlendEnable
@ -886,6 +886,10 @@ void
_cogl_pipeline_get_colorubv (CoglPipeline *pipeline,
guint8 *color);
/* XXX: At some point it could be good for this to accept a mask of
* the state groups we are interested in comparing since we can
* probably use that information in a number situations to reduce
* the work we do. */
unsigned long
_cogl_pipeline_compare_differences (CoglPipeline *pipeline0,
CoglPipeline *pipeline1);
@ -908,6 +912,12 @@ _cogl_pipeline_equal (CoglPipeline *pipeline0,
unsigned long layer_differences,
CoglPipelineEvalFlags flags);
unsigned int
_cogl_pipeline_hash (CoglPipeline *pipeline,
unsigned long differences,
unsigned long layer_differences,
CoglPipelineEvalFlags flags);
CoglPipeline *
_cogl_pipeline_journal_ref (CoglPipeline *pipeline);
@ -1042,5 +1052,11 @@ CoglPipeline *
_cogl_pipeline_find_codegen_authority (CoglPipeline *pipeline,
CoglHandle user_program);
void
_cogl_pipeline_init_state_hash_functions (void);
void
_cogl_pipeline_init_layer_state_hash_functions (void);
#endif /* __COGL_PIPELINE_PRIVATE_H */

520
clutter/cogl/cogl/cogl-pipeline.c
View File

@ -41,6 +41,7 @@
#include "cogl-blend-string.h"
#include "cogl-journal-private.h"
#include "cogl-color-private.h"
#include "cogl-util.h"
#include "cogl-profile.h"
#include <glib.h>
@ -188,6 +189,8 @@ _cogl_pipeline_init_default_pipeline (void)
{
/* Create new - blank - pipeline */
CoglPipeline *pipeline = g_slice_new0 (CoglPipeline);
/* XXX: NB: It's important that we zero this to avoid polluting
* pipeline hash values with un-initialized data */
CoglPipelineBigState *big_state = g_slice_new0 (CoglPipelineBigState);
CoglPipelineLightingState *lighting_state = &big_state->lighting_state;
CoglPipelineAlphaFuncState *alpha_state = &big_state->alpha_state;
@ -5508,6 +5511,523 @@ _cogl_pipeline_set_static_breadcrumb (CoglPipeline *pipeline,
pipeline->static_breadcrumb = breadcrumb;
}
typedef struct _HashState
{
unsigned long pipeline_differences;
unsigned long layer_differences;
CoglPipelineEvalFlags flags;
unsigned int hash;
} HashState;
static void
_cogl_pipeline_layer_hash_unit_state (CoglPipelineLayer *authority,
CoglPipelineLayer **authorities,
HashState *state)
{
int unit = authority->unit_index;
state->hash =
_cogl_util_one_at_a_time_hash (state->hash, &unit, sizeof (unit));
}
static void
_cogl_pipeline_layer_hash_texture_state (CoglPipelineLayer *authority,
CoglPipelineLayer **authorities,
HashState *state)
{
GLuint gl_handle;
GLenum gl_target;
unsigned long hash = state->hash;
cogl_texture_get_gl_texture (authority->texture, &gl_handle, &gl_target);
hash = _cogl_util_one_at_a_time_hash (hash, &gl_target, sizeof (gl_target));
if (!(state->flags & COGL_PIPELINE_EVAL_FLAG_IGNORE_TEXTURE_DATA))
hash = _cogl_util_one_at_a_time_hash (hash, &gl_handle, sizeof (gl_handle));
state->hash = hash;
}
static void
_cogl_pipeline_layer_hash_filters_state (CoglPipelineLayer *authority,
CoglPipelineLayer **authorities,
HashState *state)
{
unsigned int hash = state->hash;
hash = _cogl_util_one_at_a_time_hash (hash, &authority->mag_filter,
sizeof (authority->mag_filter));
hash = _cogl_util_one_at_a_time_hash (hash, &authority->min_filter,
sizeof (authority->min_filter));
state->hash = hash;
}
static void
_cogl_pipeline_layer_hash_wrap_modes_state (CoglPipelineLayer *authority,
CoglPipelineLayer **authorities,
HashState *state)
{
unsigned int hash = state->hash;
hash = _cogl_util_one_at_a_time_hash (hash, &authority->wrap_mode_s,
sizeof (authority->wrap_mode_s));
hash = _cogl_util_one_at_a_time_hash (hash, &authority->wrap_mode_t,
sizeof (authority->wrap_mode_t));
hash = _cogl_util_one_at_a_time_hash (hash, &authority->wrap_mode_p,
sizeof (authority->wrap_mode_p));
state->hash = hash;
}
static void
_cogl_pipeline_layer_hash_combine_state (CoglPipelineLayer *authority,
CoglPipelineLayer **authorities,
HashState *state)
{
unsigned int hash = state->hash;
CoglPipelineLayerBigState *b = authority->big_state;
int n_args;
int i;
hash = _cogl_util_one_at_a_time_hash (hash, &b->texture_combine_rgb_func,
sizeof (b->texture_combine_rgb_func));
n_args = _cogl_get_n_args_for_combine_func (b->texture_combine_rgb_func);
for (i = 0; i < n_args; i++)
{
hash =
_cogl_util_one_at_a_time_hash (hash, &b->texture_combine_rgb_src[i],
sizeof (b->texture_combine_rgb_src[i]));
hash =
_cogl_util_one_at_a_time_hash (hash, &b->texture_combine_rgb_op[i],
sizeof (b->texture_combine_rgb_op[i]));
}
hash = _cogl_util_one_at_a_time_hash (hash, &b->texture_combine_alpha_func,
sizeof (b->texture_combine_alpha_func));
n_args = _cogl_get_n_args_for_combine_func (b->texture_combine_alpha_func);
for (i = 0; i < n_args; i++)
{
hash =
_cogl_util_one_at_a_time_hash (hash, &b->texture_combine_alpha_src[i],
sizeof (b->texture_combine_alpha_src[i]));
hash =
_cogl_util_one_at_a_time_hash (hash, &b->texture_combine_alpha_op[i],
sizeof (b->texture_combine_alpha_op[i]));
}
state->hash = hash;
}
static void
_cogl_pipeline_layer_hash_combine_constant_state (CoglPipelineLayer *authority,
CoglPipelineLayer **authorities,
HashState *state)
{
CoglPipelineLayerBigState *b = authority->big_state;
gboolean need_hash = FALSE;
int n_args;
int i;
/* XXX: If the user also asked to hash the ALPHA_FUNC_STATE then it
* would be nice if we could combine the n_args loops in this
* function and _cogl_pipeline_layer_hash_combine_state.
*/
n_args = _cogl_get_n_args_for_combine_func (b->texture_combine_rgb_func);
for (i = 0; i < n_args; i++)
{
if (b->texture_combine_rgb_src[i] == GL_CONSTANT_COLOR ||
b->texture_combine_rgb_src[i] == GL_CONSTANT_ALPHA)
{
/* XXX: should we be careful to only hash the alpha
* component in the GL_CONSTANT_ALPHA case? */
need_hash = TRUE;
goto done;
}
}
n_args = _cogl_get_n_args_for_combine_func (b->texture_combine_alpha_func);
for (i = 0; i < n_args; i++)
{
if (b->texture_combine_alpha_src[i] == GL_CONSTANT_COLOR ||
b->texture_combine_alpha_src[i] == GL_CONSTANT_ALPHA)
{
/* XXX: should we be careful to only hash the alpha
* component in the GL_CONSTANT_ALPHA case? */
need_hash = TRUE;
goto done;
}
}
done:
if (need_hash)
{
float *constant = b->texture_combine_constant;
state->hash = _cogl_util_one_at_a_time_hash (state->hash, constant,
sizeof (float) * 4);
}
}
static void
_cogl_pipeline_layer_hash_user_matrix_state (CoglPipelineLayer *authority,
CoglPipelineLayer **authorities,
HashState *state)
{
CoglPipelineLayerBigState *big_state = authority->big_state;
state->hash = _cogl_util_one_at_a_time_hash (state->hash, &big_state->matrix,
sizeof (float) * 16);
}
static void
_cogl_pipeline_layer_hash_point_sprite_state (CoglPipelineLayer *authority,
CoglPipelineLayer **authorities,
HashState *state)
{
CoglPipelineLayerBigState *big_state = authority->big_state;
state->hash =
_cogl_util_one_at_a_time_hash (state->hash, &big_state->point_sprite_coords,
sizeof (big_state->point_sprite_coords));
}
typedef void (*LayerStateHashFunction) (CoglPipelineLayer *authority,
CoglPipelineLayer **authorities,
HashState *state);
static LayerStateHashFunction
layer_state_hash_functions[COGL_PIPELINE_LAYER_STATE_SPARSE_COUNT];
/* XXX: We don't statically initialize the array of hash functions, so
* we won't get caught out by later re-indexing the groups for some
* reason. */
void
_cogl_pipeline_init_layer_state_hash_functions (void)
{
CoglPipelineLayerStateIndex _index;
layer_state_hash_functions[COGL_PIPELINE_LAYER_STATE_UNIT_INDEX] =
_cogl_pipeline_layer_hash_unit_state;
layer_state_hash_functions[COGL_PIPELINE_LAYER_STATE_TEXTURE_INDEX] =
_cogl_pipeline_layer_hash_texture_state;
layer_state_hash_functions[COGL_PIPELINE_LAYER_STATE_FILTERS_INDEX] =
_cogl_pipeline_layer_hash_filters_state;
layer_state_hash_functions[COGL_PIPELINE_LAYER_STATE_WRAP_MODES_INDEX] =
_cogl_pipeline_layer_hash_wrap_modes_state;
layer_state_hash_functions[COGL_PIPELINE_LAYER_STATE_COMBINE_INDEX] =
_cogl_pipeline_layer_hash_combine_state;
layer_state_hash_functions[COGL_PIPELINE_LAYER_STATE_COMBINE_CONSTANT_INDEX] =
_cogl_pipeline_layer_hash_combine_constant_state;
layer_state_hash_functions[COGL_PIPELINE_LAYER_STATE_USER_MATRIX_INDEX] =
_cogl_pipeline_layer_hash_user_matrix_state;
_index = COGL_PIPELINE_LAYER_STATE_POINT_SPRITE_COORDS_INDEX;
layer_state_hash_functions[_index] =
_cogl_pipeline_layer_hash_point_sprite_state;
/* So we get a big error if we forget to update this code! */
g_assert (COGL_PIPELINE_LAYER_STATE_SPARSE_COUNT == 8);
}
static gboolean
_cogl_pipeline_hash_layer_cb (CoglPipelineLayer *layer,
void *user_data)
{
HashState *state = user_data;
unsigned long differences = state->layer_differences;
CoglPipelineLayer *authorities[COGL_PIPELINE_LAYER_STATE_COUNT];
unsigned long mask;
int i;
/* Theoretically we would hash non-sparse layer state here but
* currently layers don't have any. */
/* XXX: we resolve all the authorities here - not just those
* corresponding to hash_state->layer_differences - because
* the hashing of some state groups actually depends on the values
* in other groups. For example we don't hash layer combine
* constants if they are aren't referenced by the current layer
* combine function.
*/
mask = COGL_PIPELINE_LAYER_STATE_ALL_SPARSE;
_cogl_pipeline_layer_resolve_authorities (layer,
mask,
authorities);
/* So we go right ahead and hash the sparse state... */
for (i = 0; i < COGL_PIPELINE_LAYER_STATE_COUNT; i++)
{
unsigned long current_state = (1L<<i);
/* XXX: we are hashing the un-mixed hash values of all the
* individual state groups; we should provide a means to test
* the quality of the final hash values we are getting with this
* approach... */
if (differences & current_state)
{
CoglPipelineLayer *authority = authorities[i];
layer_state_hash_functions[i] (authority, authorities, state);
}
if (current_state > differences)
break;
}
return TRUE;
}
static void
_cogl_pipeline_hash_color_state (CoglPipeline *authority,
HashState *state)
{
state->hash = _cogl_util_one_at_a_time_hash (state->hash, &authority->color,
_COGL_COLOR_DATA_SIZE);
}
static void
_cogl_pipeline_hash_blend_enable_state (CoglPipeline *authority,
HashState *state)
{
guint8 blend_enable = authority->blend_enable;
state->hash = _cogl_util_one_at_a_time_hash (state->hash, &blend_enable, 1);
}
static void
_cogl_pipeline_hash_layers_state (CoglPipeline *authority,
HashState *state)
{
state->hash =
_cogl_util_one_at_a_time_hash (state->hash, &authority->n_layers,
sizeof (authority->n_layers));
_cogl_pipeline_foreach_layer_internal (authority,
_cogl_pipeline_hash_layer_cb,
state);
}
static void
_cogl_pipeline_hash_lighting_state (CoglPipeline *authority,
HashState *state)
{
CoglPipelineLightingState *lighting_state =
&authority->big_state->lighting_state;
state->hash =
_cogl_util_one_at_a_time_hash (state->hash, lighting_state,
sizeof (CoglPipelineLightingState));
}
static void
_cogl_pipeline_hash_alpha_func_state (CoglPipeline *authority,
HashState *state)
{
CoglPipelineAlphaFuncState *alpha_state = &authority->big_state->alpha_state;
state->hash =
_cogl_util_one_at_a_time_hash (state->hash, &alpha_state->alpha_func,
sizeof (alpha_state->alpha_func));
}
static void
_cogl_pipeline_hash_alpha_func_reference_state (CoglPipeline *authority,
HashState *state)
{
CoglPipelineAlphaFuncState *alpha_state = &authority->big_state->alpha_state;
float ref = alpha_state->alpha_func_reference;
state->hash =
_cogl_util_one_at_a_time_hash (state->hash, &ref, sizeof (float));
}
static void
_cogl_pipeline_hash_blend_state (CoglPipeline *authority,
HashState *state)
{
CoglPipelineBlendState *blend_state = &authority->big_state->blend_state;
unsigned int hash;
if (!authority->real_blend_enable)
return;
hash = state->hash;
#ifndef HAVE_COGL_GLES
hash =
_cogl_util_one_at_a_time_hash (hash, &blend_state->blend_equation_rgb,
sizeof (blend_state->blend_equation_rgb));
hash =
_cogl_util_one_at_a_time_hash (hash, &blend_state->blend_equation_alpha,
sizeof (blend_state->blend_equation_alpha));
hash =
_cogl_util_one_at_a_time_hash (hash, &blend_state->blend_src_factor_alpha,
sizeof (blend_state->blend_src_factor_alpha));
hash =
_cogl_util_one_at_a_time_hash (hash, &blend_state->blend_dst_factor_alpha,
sizeof (blend_state->blend_dst_factor_alpha));
if (blend_state->blend_src_factor_rgb == GL_ONE_MINUS_CONSTANT_COLOR ||
blend_state->blend_src_factor_rgb == GL_CONSTANT_COLOR ||
blend_state->blend_dst_factor_rgb == GL_ONE_MINUS_CONSTANT_COLOR ||
blend_state->blend_dst_factor_rgb == GL_CONSTANT_COLOR)
{
hash =
_cogl_util_one_at_a_time_hash (hash, &blend_state->blend_constant,
sizeof (blend_state->blend_constant));
}
#endif
hash =
_cogl_util_one_at_a_time_hash (hash, &blend_state->blend_src_factor_rgb,
sizeof (blend_state->blend_src_factor_rgb));
hash =
_cogl_util_one_at_a_time_hash (hash, &blend_state->blend_dst_factor_rgb,
sizeof (blend_state->blend_dst_factor_rgb));
state->hash = hash;
}
static void
_cogl_pipeline_hash_user_shader_state (CoglPipeline *authority,
HashState *state)
{
CoglHandle user_program = authority->big_state->user_program;
state->hash = _cogl_util_one_at_a_time_hash (state->hash, &user_program,
sizeof (user_program));
}
static void
_cogl_pipeline_hash_depth_state (CoglPipeline *authority,
HashState *state)
{
CoglPipelineDepthState *depth_state = &authority->big_state->depth_state;
unsigned int hash = state->hash;
if (depth_state->depth_test_enabled)
{
guint8 enabled = depth_state->depth_test_enabled;
CoglDepthTestFunction function = depth_state->depth_test_function;
hash = _cogl_util_one_at_a_time_hash (hash, &enabled, sizeof (enabled));
hash = _cogl_util_one_at_a_time_hash (hash, &function, sizeof (function));
}
if (depth_state->depth_writing_enabled)
{
guint8 enabled = depth_state->depth_writing_enabled;
float near = depth_state->depth_range_near;
float far = depth_state->depth_range_far;
hash = _cogl_util_one_at_a_time_hash (hash, &enabled, sizeof (enabled));
hash = _cogl_util_one_at_a_time_hash (hash, &near, sizeof (near));
hash = _cogl_util_one_at_a_time_hash (hash, &far, sizeof (far));
}
state->hash = hash;
}
static void
_cogl_pipeline_hash_fog_state (CoglPipeline *authority,
HashState *state)
{
CoglPipelineFogState *fog_state = &authority->big_state->fog_state;
unsigned long hash = state->hash;
if (!fog_state->enabled)
hash = _cogl_util_one_at_a_time_hash (hash, &fog_state->enabled,
sizeof (fog_state->enabled));
else
hash = _cogl_util_one_at_a_time_hash (hash, &fog_state,
sizeof (CoglPipelineFogState));
state->hash = hash;
}
static void
_cogl_pipeline_hash_point_size_state (CoglPipeline *authority,
HashState *state)
{
float point_size = authority->big_state->point_size;
state->hash = _cogl_util_one_at_a_time_hash (state->hash, &point_size,
sizeof (point_size));
}
typedef void (*StateHashFunction) (CoglPipeline *authority, HashState *state);
static StateHashFunction
state_hash_functions[COGL_PIPELINE_STATE_SPARSE_COUNT];
/* We don't statically initialize the array of hash functions
* so we won't get caught out by later re-indexing the groups for
* some reason. */
void
_cogl_pipeline_init_state_hash_functions (void)
{
state_hash_functions[COGL_PIPELINE_STATE_COLOR_INDEX] =
_cogl_pipeline_hash_color_state;
state_hash_functions[COGL_PIPELINE_STATE_BLEND_ENABLE_INDEX] =
_cogl_pipeline_hash_blend_enable_state;
state_hash_functions[COGL_PIPELINE_STATE_LAYERS_INDEX] =
_cogl_pipeline_hash_layers_state;
state_hash_functions[COGL_PIPELINE_STATE_LIGHTING_INDEX] =
_cogl_pipeline_hash_lighting_state;
state_hash_functions[COGL_PIPELINE_STATE_ALPHA_FUNC_INDEX] =
_cogl_pipeline_hash_alpha_func_state;
state_hash_functions[COGL_PIPELINE_STATE_ALPHA_FUNC_REFERENCE_INDEX] =
_cogl_pipeline_hash_alpha_func_reference_state;
state_hash_functions[COGL_PIPELINE_STATE_BLEND_INDEX] =
_cogl_pipeline_hash_blend_state;
state_hash_functions[COGL_PIPELINE_STATE_USER_SHADER_INDEX] =
_cogl_pipeline_hash_user_shader_state;
state_hash_functions[COGL_PIPELINE_STATE_DEPTH_INDEX] =
_cogl_pipeline_hash_depth_state;
state_hash_functions[COGL_PIPELINE_STATE_FOG_INDEX] =
_cogl_pipeline_hash_fog_state;
state_hash_functions[COGL_PIPELINE_STATE_POINT_SIZE_INDEX] =
_cogl_pipeline_hash_point_size_state;
/* So we get a big error if we forget to update this code! */
g_assert (COGL_PIPELINE_STATE_SPARSE_COUNT == 11);
}
unsigned int
_cogl_pipeline_hash (CoglPipeline *pipeline,
unsigned long differences,
unsigned long layer_differences,
CoglPipelineEvalFlags flags)
{
CoglPipeline *authorities[COGL_PIPELINE_STATE_SPARSE_COUNT];
unsigned long mask;
int i;
HashState state;
unsigned int final_hash = 0;
state.hash = 0;
state.layer_differences = layer_differences;
/* hash non-sparse state */
if (differences & COGL_PIPELINE_STATE_REAL_BLEND_ENABLE)
{
gboolean enable = pipeline->real_blend_enable;
state.hash =
_cogl_util_one_at_a_time_hash (state.hash, &enable, sizeof (enable));
}
/* hash sparse state */
mask = differences & COGL_PIPELINE_STATE_ALL_SPARSE;
_cogl_pipeline_resolve_authorities (pipeline, mask, authorities);
for (i = 0; i < COGL_PIPELINE_STATE_SPARSE_COUNT; i++)
{
unsigned long current_state = (1L<<i);
/* XXX: we are hashing the un-mixed hash values of all the
* individual state groups; we should provide a means to test
* the quality of the final hash values we are getting with this
* approach... */
if (differences & current_state)
{
CoglPipeline *authority = authorities[i];
state_hash_functions[i] (authority, &state);
final_hash = _cogl_util_one_at_a_time_hash (final_hash, &state.hash,
sizeof (state.hash));
}
if (current_state > differences)
break;
}
return _cogl_util_one_at_a_time_mix (final_hash);
}
typedef struct
{
int parent_id;

9
clutter/cogl/cogl/cogl-util.c
View File

@ -208,4 +208,13 @@ cogl_fixed_get_type (void)
return _cogl_fixed_type;
}
unsigned int
_cogl_util_one_at_a_time_mix (unsigned int hash)
{
hash += ( hash << 3 );
hash ^= ( hash >> 11 );
hash += ( hash << 15 );
return hash;
}

27
clutter/cogl/cogl/cogl-util.h
View File

@ -68,4 +68,31 @@ _cogl_util_is_pot (unsigned int num)
return (num & (num - 1)) == 0;
}
/* Split Bob Jenkins' One-at-a-Time hash
*
* This uses the One-at-a-Time hash algorithm designed by Bob Jenkins
* but the mixing step is split out so the function can be used in a
* more incremental fashion.
*/
static inline unsigned int
_cogl_util_one_at_a_time_hash (unsigned int hash,
void *key,
size_t bytes)
{
unsigned char *p = key;
int i;
for (i = 0; i < bytes; i++)
{
hash += p[i];
hash += (hash << 10);
hash ^= (hash >> 6);
}
return hash;
}
unsigned int
_cogl_util_one_at_a_time_mix (unsigned int hash);
#endif /* __COGL_UTIL_H */