[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.

src/cairo-color.c

@@ -159,3 +159,10 @@ _cairo_color_get_rgba_premultiplied (cairo_color_t *color,
     *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);
+}

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 ();
 }

src/cairo-directfb-surface.c

@@ -1514,6 +1514,15 @@ _cairo_directfb_surface_show_glyphs ( void                 *abstract_dst,
 }
 #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_directfb_surface_backend = {
 #else
         NULL, /* show_glyphs */
 #endif
-        NULL /* snapshot */
+        NULL, /* snapshot */
+        _cairo_directfb_is_compatible
 };
 
 

src/cairo-glitz-surface.c

@@ -1799,6 +1799,19 @@ _cairo_glitz_surface_scaled_glyph_fini (cairo_scaled_glyph_t *scaled_glyph,
     }
 }
 
+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 cairo_glitz_surface_backend = {
     _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 *

src/cairo-pattern.c

@@ -1020,6 +1020,21 @@ _cairo_pattern_acquire_surface_for_gradient (cairo_gradient_pattern_t *pattern,
     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_solid_pattern_t	     *pattern,
 					  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 (cairo_solid_pattern_t	     *pattern,
     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);
 }
 
 /**

src/cairo-surface.c

@@ -1023,6 +1023,32 @@ _cairo_surface_snapshot (cairo_surface_t *surface)
     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,

src/cairo-win32-surface.c

@@ -1609,6 +1609,16 @@ _cairo_win32_surface_show_glyphs (void			*surface,
     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 cairo_win32_surface_backend = {
     NULL, /* fill */
     _cairo_win32_surface_show_glyphs,
 
-    NULL  /* snapshot */
+    NULL, /* snapshot */
+    _cairo_win32_surface_is_compatible
 };
 
 /*

src/cairo-xcb-surface.c

@@ -1578,6 +1578,10 @@ _cairo_xcb_surface_show_glyphs (void                *abstract_dst,
 				 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 cairo_xcb_surface_backend = {
     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                *abstract_dst,
 
     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);
+}

src/cairo-xlib-surface.c

@@ -74,6 +74,10 @@ _cairo_xlib_surface_show_glyphs (void                *abstract_dst,
 				 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 cairo_xlib_surface_backend = {
     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                *abstract_dst,
 
     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);
+}

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 (cairo_color_t *color,
 				     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_surface_t  *surface,
 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);