[cairo-commit] src/cairo-color.c src/cairo-debug.c
src/cairo-directfb-surface.c src/cairo-glitz-surface.c
src/cairoint.h src/cairo-pattern.c src/cairo-surface.c
src/cairo-win32-surface.c src/cairo-xcb-surface.c
src/cairo-xlib-surface.c
Behdad Esfahbod
behdad at kemper.freedesktop.org
Wed Feb 14 15:28:48 PST 2007
src/cairo-color.c | 7 +++
src/cairo-debug.c | 2
src/cairo-directfb-surface.c | 12 +++++
src/cairo-glitz-surface.c | 24 ++++++++++-
src/cairo-pattern.c | 91 +++++++++++++++++++++++++++++++++++++++----
src/cairo-surface.c | 26 ++++++++++++
src/cairo-win32-surface.c | 13 +++++-
src/cairo-xcb-surface.c | 17 +++++++-
src/cairo-xlib-surface.c | 17 +++++++-
src/cairoint.h | 15 +++++++
10 files changed, 212 insertions(+), 12 deletions(-)
New commits:
diff-tree 2715f2098127d04d2f9e304580a26cd0842c0e64 (from b31179478bf8c18245917caa1bee19bb61f336c1)
Author: Jorn Baayen <jorn at openedhand.com>
Date: Wed Feb 14 18:28:56 2007 -0800
[cairo-pattern] Cache surface for solid patterns
We use a small cache of size 16 for surfaces created for solid patterns.
This mainly helps with the X backends where we don't have to create a
pattern for every operation, so we save a lot on X traffic. Xft uses a
similar cache, so cairo's text rendering traffic with the xlib backend
now completely matches that of Xft.
The cache uses an static index variable, which itself acts like a cache of
size 1, remembering the most recently used solid pattern. So repeated
lookups for the same pattern hit immediately. If that fails, the cache is
searched linearly, and if that fails too, a new surface is created and a
random member of the cache is evicted.
Only surfaces that are "compatible" are used. The definition of compatible
is backend specific. For the xlib backend, it means that the two surfaces
are allocated on the same display. Implementations for compatibility are
provided for all backends that it makes sense.
diff --git a/src/cairo-color.c b/src/cairo-color.c
index a348839..0688167 100644
--- a/src/cairo-color.c
+++ b/src/cairo-color.c
@@ -159,3 +159,10 @@ _cairo_color_get_rgba_premultiplied (cai
*blue = color->blue * color->alpha;
*alpha = color->alpha;
}
+
+cairo_bool_t
+_cairo_color_equal (cairo_color_t *color_a,
+ cairo_color_t *color_b)
+{
+ return (memcmp (color_a, color_b, sizeof (cairo_color_t)) == 0);
+}
diff --git a/src/cairo-debug.c b/src/cairo-debug.c
index 7c29932..dd57dd7 100644
--- a/src/cairo-debug.c
+++ b/src/cairo-debug.c
@@ -68,4 +68,6 @@ cairo_debug_reset_static_data (void)
#if CAIRO_HAS_FT_FONT
_cairo_ft_font_reset_static_data ();
#endif
+
+ _cairo_pattern_reset_static_data ();
}
diff --git a/src/cairo-directfb-surface.c b/src/cairo-directfb-surface.c
index 686510d..96ee212 100644
--- a/src/cairo-directfb-surface.c
+++ b/src/cairo-directfb-surface.c
@@ -1514,6 +1514,15 @@ _cairo_directfb_surface_show_glyphs ( vo
}
#endif /* DFB_SHOW_GLYPHS */
+static cairo_bool_t
+_cairo_directfb_surface_is_compatible (void *surface_a,
+ void *surface_b)
+{
+ cairo_directfb_surface_t *a = (cairo_directfb_surface_t*) surface_a;
+ cairo_directfb_surface_t *b = (cairo_directfb_surface_t*) surface_b;
+
+ return (a->dfb == b->dfb);
+}
static cairo_surface_backend_t cairo_directfb_surface_backend = {
CAIRO_SURFACE_TYPE_DIRECTFB, /*type*/
@@ -1564,7 +1573,8 @@ static cairo_surface_backend_t cairo_dir
#else
NULL, /* show_glyphs */
#endif
- NULL /* snapshot */
+ NULL, /* snapshot */
+ _cairo_directfb_is_compatible
};
diff --git a/src/cairo-glitz-surface.c b/src/cairo-glitz-surface.c
index f492739..817eb88 100644
--- a/src/cairo-glitz-surface.c
+++ b/src/cairo-glitz-surface.c
@@ -1799,6 +1799,19 @@ _cairo_glitz_surface_scaled_glyph_fini (
}
}
+static cairo_bool_t
+_cairo_glitz_surface_is_compatible (void *surface_a,
+ void *surface_b)
+{
+ cairo_glitz_surface_t *a = (cairo_glitz_surface_t*) surface_a;
+ cairo_glitz_surface_t *b = (cairo_glitz_surface_t*) surface_b;
+
+ glitz_drawable_t *drawable_a = glitz_surface_get_drawable (a->surface);
+ glitz_drawable_t *drawable_b = glitz_surface_get_drawable (b->surface);
+
+ return (drawable_a == drawable_b);
+}
+
#define FIXED_TO_FLOAT(f) (((glitz_float_t) (f)) / 65536)
static cairo_status_t
@@ -2194,7 +2207,16 @@ static const cairo_surface_backend_t cai
_cairo_glitz_surface_flush,
NULL, /* mark_dirty_rectangle */
_cairo_glitz_surface_scaled_font_fini,
- _cairo_glitz_surface_scaled_glyph_fini
+ _cairo_glitz_surface_scaled_glyph_fini,
+
+ NULL, /* paint */
+ NULL, /* mask */
+ NULL, /* stroke */
+ NULL, /* fill */
+ NULL, /* show_glyphs */
+
+ NULL, /* snapshot */
+ _cairo_glitz_surface_is_compatible
};
static const cairo_surface_backend_t *
diff --git a/src/cairo-pattern.c b/src/cairo-pattern.c
index 35c0739..ae271f8 100644
--- a/src/cairo-pattern.c
+++ b/src/cairo-pattern.c
@@ -1020,6 +1020,21 @@ _cairo_pattern_acquire_surface_for_gradi
return status;
}
+/* We have a small cache here, because we don't want to constantly
+ * recreate surfaces for simple solid colors */
+#define MAX_SURFACE_CACHE_SIZE 16
+
+static struct {
+ struct {
+ cairo_color_t color;
+ cairo_surface_t *surface;
+ } cache[MAX_SURFACE_CACHE_SIZE];
+
+ int size;
+} surface_cache;
+
+CAIRO_MUTEX_DECLARE (surface_cache_lock);
+
static cairo_int_status_t
_cairo_pattern_acquire_surface_for_solid (cairo_solid_pattern_t *pattern,
cairo_surface_t *dst,
@@ -1030,12 +1045,53 @@ _cairo_pattern_acquire_surface_for_solid
cairo_surface_t **out,
cairo_surface_attributes_t *attribs)
{
- *out = _cairo_surface_create_similar_solid (dst,
- CAIRO_CONTENT_COLOR_ALPHA,
- 1, 1,
- &pattern->color);
- if ((*out)->status)
- return CAIRO_STATUS_NO_MEMORY;
+ static int i = 0;
+
+ cairo_surface_t *surface;
+ cairo_status_t status;
+
+ CAIRO_MUTEX_LOCK (surface_cache_lock);
+
+ /* Check cache first */
+ if (i < surface_cache.size)
+ if (_cairo_color_equal (&surface_cache.cache[i].color,
+ &pattern->color) &&
+ _cairo_surface_is_compatible (surface_cache.cache[i].surface, dst))
+ goto DONE;
+
+ for (i = 0; i < surface_cache.size; i++)
+ if (_cairo_color_equal (&surface_cache.cache[i].color,
+ &pattern->color) &&
+ _cairo_surface_is_compatible (surface_cache.cache[i].surface, dst))
+ goto DONE;
+
+ /* Not cached, need to create new */
+ surface = _cairo_surface_create_similar_solid (dst,
+ CAIRO_CONTENT_COLOR_ALPHA,
+ 1, 1,
+ &pattern->color);
+ if (surface->status) {
+ status = CAIRO_STATUS_NO_MEMORY;
+
+ goto UNLOCK;
+ }
+
+ /* Cache new */
+ if (surface_cache.size < MAX_SURFACE_CACHE_SIZE)
+ surface_cache.size++;
+ else {
+ i = rand () % MAX_SURFACE_CACHE_SIZE;
+
+ /* Evict old */
+ cairo_surface_destroy (surface_cache.cache[i].surface);
+ }
+
+ surface_cache.cache[i].color = pattern->color;
+ surface_cache.cache[i].surface = surface;
+
+DONE:
+
+ *out = cairo_surface_reference (surface_cache.cache[i].surface);
attribs->x_offset = attribs->y_offset = 0;
cairo_matrix_init_identity (&attribs->matrix);
@@ -1043,7 +1099,28 @@ _cairo_pattern_acquire_surface_for_solid
attribs->filter = CAIRO_FILTER_NEAREST;
attribs->acquired = FALSE;
- return CAIRO_STATUS_SUCCESS;
+ status = CAIRO_STATUS_SUCCESS;
+
+UNLOCK:
+
+ CAIRO_MUTEX_UNLOCK (surface_cache_lock);
+
+ return status;
+}
+
+void
+_cairo_pattern_reset_static_data (void)
+{
+ int i;
+
+ CAIRO_MUTEX_LOCK (surface_cache_lock);
+
+ for (i = 0; i < surface_cache.size; i++)
+ cairo_surface_destroy (surface_cache.cache[i].surface);
+
+ surface_cache.size = 0;
+
+ CAIRO_MUTEX_UNLOCK (surface_cache_lock);
}
/**
diff --git a/src/cairo-surface.c b/src/cairo-surface.c
index ec19c8b..3c9df99 100644
--- a/src/cairo-surface.c
+++ b/src/cairo-surface.c
@@ -1023,6 +1023,32 @@ _cairo_surface_snapshot (cairo_surface_t
return _cairo_surface_fallback_snapshot (surface);
}
+/**
+ * _cairo_surface_is_compatible
+ * @surface_a: a #cairo_surface_t
+ * @surface_b: a #cairo_surface_t
+ *
+ * Find out whether the given surfaces share the same backend,
+ * and if so, whether they can be considered compatible.
+ *
+ * The definition of "compatible" depends on the backend. In the
+ * xlib case, it means the surfaces share the same display.
+ *
+ * Return value: TRUE if the surfaces are compatible.
+ **/
+cairo_bool_t
+_cairo_surface_is_compatible (cairo_surface_t *surface_a,
+ cairo_surface_t *surface_b)
+{
+ if (surface_a->backend != surface_b->backend)
+ return FALSE;
+
+ if (surface_a->backend->is_compatible)
+ return surface_a->backend->is_compatible (surface_a, surface_b);
+
+ return TRUE;
+}
+
cairo_status_t
_cairo_surface_composite (cairo_operator_t op,
cairo_pattern_t *src,
diff --git a/src/cairo-win32-surface.c b/src/cairo-win32-surface.c
index 6899c95..b3772a6 100644
--- a/src/cairo-win32-surface.c
+++ b/src/cairo-win32-surface.c
@@ -1609,6 +1609,16 @@ _cairo_win32_surface_show_glyphs (void
return (win_result) ? CAIRO_STATUS_SUCCESS : CAIRO_INT_STATUS_UNSUPPORTED;
}
+static cairo_bool_t
+_cairo_win32_surface_is_compatible (void *surface_a,
+ void *surface_b)
+{
+ cairo_win32_surface_t *a = (cairo_win32_surface_t*) surface_a;
+ cairo_win32_surface_t *b = (cairo_win32_surface_t*) surface_b;
+
+ return (a->dc == b->dc);
+}
+
#undef STACK_GLYPH_SIZE
/**
@@ -1879,7 +1889,8 @@ static const cairo_surface_backend_t cai
NULL, /* fill */
_cairo_win32_surface_show_glyphs,
- NULL /* snapshot */
+ NULL, /* snapshot */
+ _cairo_win32_surface_is_compatible
};
/*
diff --git a/src/cairo-xcb-surface.c b/src/cairo-xcb-surface.c
index 2fdf8a1..8df859d 100644
--- a/src/cairo-xcb-surface.c
+++ b/src/cairo-xcb-surface.c
@@ -1578,6 +1578,10 @@ _cairo_xcb_surface_show_glyphs (void
int num_glyphs,
cairo_scaled_font_t *scaled_font);
+static cairo_bool_t
+_cairo_xcb_surface_is_compatible (void *surface_a,
+ void *surface_b);
+
/* XXX: move this to the bottom of the file, XCB and Xlib */
static const cairo_surface_backend_t cairo_xcb_surface_backend = {
@@ -1609,7 +1613,8 @@ static const cairo_surface_backend_t cai
NULL, /* stroke */
NULL, /* fill */
_cairo_xcb_surface_show_glyphs,
- NULL /* snapshot */
+ NULL, /* snapshot */
+ _cairo_xcb_surface_is_compatible
};
/**
@@ -2451,3 +2456,13 @@ _cairo_xcb_surface_show_glyphs (void
return status;
}
+
+static cairo_bool_t
+_cairo_xcb_surface_is_compatible (void *surface_a,
+ void *surface_b)
+{
+ cairo_xcb_surface_t *a = (cairo_xcb_surface_t*) surface_a;
+ cairo_xcb_surface_t *b = (cairo_xcb_surface_t*) surface_b;
+
+ return (a->dpy == b->dpy);
+}
diff --git a/src/cairo-xlib-surface.c b/src/cairo-xlib-surface.c
index 6a0d3e4..9228c95 100644
--- a/src/cairo-xlib-surface.c
+++ b/src/cairo-xlib-surface.c
@@ -74,6 +74,10 @@ _cairo_xlib_surface_show_glyphs (void
int num_glyphs,
cairo_scaled_font_t *scaled_font);
+static cairo_bool_t
+_cairo_xlib_surface_is_compatible (void *surface_a,
+ void *surface_b);
+
/*
* Instead of taking two round trips for each blending request,
* assume that if a particular drawable fails GetImage that it will
@@ -1783,7 +1787,8 @@ static const cairo_surface_backend_t cai
NULL, /* stroke */
NULL, /* fill */
_cairo_xlib_surface_show_glyphs,
- NULL /* snapshot */
+ NULL, /* snapshot */
+ _cairo_xlib_surface_is_compatible
};
/**
@@ -2913,3 +2918,13 @@ _cairo_xlib_surface_show_glyphs (void
return status;
}
+
+static cairo_bool_t
+_cairo_xlib_surface_is_compatible (void *surface_a,
+ void *surface_b)
+{
+ cairo_xlib_surface_t *a = (cairo_xlib_surface_t*) surface_a;
+ cairo_xlib_surface_t *b = (cairo_xlib_surface_t*) surface_b;
+
+ return (a->dpy == b->dpy);
+}
diff --git a/src/cairoint.h b/src/cairoint.h
index 20160fd..2c145e0 100755
--- a/src/cairoint.h
+++ b/src/cairoint.h
@@ -1004,6 +1004,10 @@ struct _cairo_surface_backend {
cairo_surface_t *
(*snapshot) (void *surface);
+
+ cairo_bool_t
+ (*is_compatible) (void *surface_a,
+ void *surface_b);
};
typedef struct _cairo_format_masks {
@@ -1568,6 +1572,10 @@ _cairo_color_get_rgba_premultiplied (cai
double *blue,
double *alpha);
+cairo_private cairo_bool_t
+_cairo_color_equal (cairo_color_t *color_a,
+ cairo_color_t *color_b);
+
/* cairo-font.c */
cairo_private void
@@ -1994,6 +2002,10 @@ _cairo_surface_clone_similar (cairo_surf
cairo_private cairo_surface_t *
_cairo_surface_snapshot (cairo_surface_t *surface);
+cairo_private cairo_bool_t
+_cairo_surface_is_compatible (cairo_surface_t *surface_a,
+ cairo_surface_t *surface_b);
+
cairo_private unsigned int
_cairo_surface_get_current_clip_serial (cairo_surface_t *surface);
@@ -2425,6 +2437,9 @@ cairo_private cairo_status_t
_cairo_pattern_get_extents (cairo_pattern_t *pattern,
cairo_rectangle_int16_t *extents);
+cairo_private void
+_cairo_pattern_reset_static_data (void);
+
cairo_private cairo_status_t
_cairo_gstate_set_antialias (cairo_gstate_t *gstate,
cairo_antialias_t antialias);
More information about the cairo-commit
mailing list