perf: Compute ops per second

Provide a hook for the test to be able to compute the number of ops per
second. For instance, the glyphs test uses it to report the number of
kiloglyph per second Cairo is able to render.

28 files changed, 142 insertions, 92 deletions

diff --git a/perf/cairo-perf-micro.c b/perf/cairo-perf-micro.c
index ec40409c0..e8b28207c 100644
--- a/perf/cairo-perf-micro.c
+++ b/perf/cairo-perf-micro.c
@@ -130,14 +130,16 @@ cairo_perf_calibrate (cairo_perf_t *perf,
     cairo_perf_ticks_t calibration0, calibration;
     unsigned loops, min_loops;
 
-    calibration0 = perf_func (perf->cr, perf->size, perf->size, 1);
+    min_loops = 1;
+    calibration0 = perf_func (perf->cr, perf->size, perf->size, min_loops);
     if (perf->fast_and_sloppy) {
 	calibration = calibration0;
     } else {
-	loops = cairo_perf_ticks_per_second () / 100 / calibration0;
-	if (loops < 3)
-	    loops = 3;
-	calibration = (calibration0 + perf_func (perf->cr, perf->size, perf->size, loops)) / (loops + 1);
+	calibration = 0.01 * cairo_perf_ticks_per_second ();
+	while (calibration0 < calibration) {
+	    min_loops *= 10;
+	    calibration0 = perf_func (perf->cr, perf->size, perf->size, min_loops);
+	}
     }
 
     /* XXX
@@ -151,7 +153,7 @@ cairo_perf_calibrate (cairo_perf_t *perf,
      * a more rigorous analysis of the synchronisation overhead,
      * that is to estimate the time for loop=0.
      */
-    loops = perf->ms_per_iteration * 0.001 * cairo_perf_ticks_per_second () / calibration;
+    loops = perf->ms_per_iteration * 0.001 * cairo_perf_ticks_per_second () * min_loops / calibration;
     min_loops = perf->fast_and_sloppy ? 1 : 10;
     if (loops < min_loops)
 	loops = min_loops;
@@ -162,7 +164,8 @@ cairo_perf_calibrate (cairo_perf_t *perf,
 void
 cairo_perf_run (cairo_perf_t		*perf,
 		const char		*name,
-		cairo_perf_func_t	 perf_func)
+		cairo_perf_func_t	 perf_func,
+		cairo_count_func_t	 count_func)
 {
     static cairo_bool_t first_run = TRUE;
     unsigned int i, similar, has_similar;
@@ -256,8 +259,7 @@ cairo_perf_run (cairo_perf_t		*perf,
 		if (i > 0) {
 		    _cairo_stats_compute (&stats, times, i+1);
 
-		    if (stats.std_dev <= CAIRO_PERF_LOW_STD_DEV)
-		    {
+		    if (stats.std_dev <= CAIRO_PERF_LOW_STD_DEV) {
 			low_std_dev_count++;
 			if (low_std_dev_count >= CAIRO_PERF_STABLE_STD_DEV_COUNT)
 			    break;
@@ -273,12 +275,23 @@ cairo_perf_run (cairo_perf_t		*perf,
 
 	if (perf->summary) {
 	    _cairo_stats_compute (&stats, times, i);
-	    fprintf (perf->summary,
-		     "%10lld %#8.3f %#8.3f %#5.2f%% %3d\n",
-		     (long long) stats.min_ticks,
-		     (stats.min_ticks * 1000.0) / cairo_perf_ticks_per_second (),
-		     (stats.median_ticks * 1000.0) / cairo_perf_ticks_per_second (),
-		     stats.std_dev * 100.0, stats.iterations);
+	    if (count_func != NULL) {
+		double count = count_func (perf->cr, perf->size, perf->size);
+		fprintf (perf->summary,
+			 "%10lld %#8.3f %#8.3f %#5.2f%% %3d: %.2f\n",
+			 (long long) stats.min_ticks,
+			 (stats.min_ticks * 1000.0) / cairo_perf_ticks_per_second (),
+			 (stats.median_ticks * 1000.0) / cairo_perf_ticks_per_second (),
+			 stats.std_dev * 100.0, stats.iterations,
+			 count * cairo_perf_ticks_per_second () / stats.min_ticks);
+	    } else {
+		fprintf (perf->summary,
+			 "%10lld %#8.3f %#8.3f %#5.2f%% %3d\n",
+			 (long long) stats.min_ticks,
+			 (stats.min_ticks * 1000.0) / cairo_perf_ticks_per_second (),
+			 (stats.median_ticks * 1000.0) / cairo_perf_ticks_per_second (),
+			 stats.std_dev * 100.0, stats.iterations);
+	    }
 	    fflush (perf->summary);
 	}
 
@@ -517,8 +530,8 @@ const cairo_perf_case_t perf_cases[] = {
     { fill,   64, 512},
     { stroke, 64, 512},
     { text,   64, 512},
-    { glyphs,   64, 512},
-    { mask,  64, 512},
+    { glyphs, 64, 512},
+    { mask,   64, 512},
     { tessellate, 100, 100},
     { subimage_copy, 16, 512},
     { pattern_create_radial, 16, 16},
diff --git a/perf/cairo-perf.h b/perf/cairo-perf.h
index 6d1741aa3..c4eeb1674 100644
--- a/perf/cairo-perf.h
+++ b/perf/cairo-perf.h
@@ -99,6 +99,9 @@ typedef struct _cairo_perf {
 typedef cairo_perf_ticks_t
 (*cairo_perf_func_t) (cairo_t *cr, int width, int height, int loops);
 
+typedef double
+(*cairo_count_func_t) (cairo_t *cr, int width, int height);
+
 cairo_bool_t
 cairo_perf_can_run (cairo_perf_t	*perf,
 		    const char		*name,
@@ -107,12 +110,14 @@ cairo_perf_can_run (cairo_perf_t	*perf,
 void
 cairo_perf_run (cairo_perf_t		*perf,
 		const char		*name,
-		cairo_perf_func_t	 perf_func);
+		cairo_perf_func_t	 perf_func,
+		cairo_count_func_t	 count_func);
 
 void
 cairo_perf_cover_sources_and_operators (cairo_perf_t		*perf,
 					const char		*name,
-					cairo_perf_func_t	 perf_func);
+					cairo_perf_func_t	 perf_func,
+					cairo_count_func_t	 count_func);
 
 /* reporter convenience routines */
 
diff --git a/perf/micro/box-outline.c b/perf/micro/box-outline.c
index e216b79a1..fe0719f93 100644
--- a/perf/micro/box-outline.c
+++ b/perf/micro/box-outline.c
@@ -97,6 +97,6 @@ box_outline (cairo_perf_t *perf, cairo_t *cr, int width, int height)
     if (! cairo_perf_can_run (perf, "box-outline", NULL))
 	return;
 
-    cairo_perf_run (perf, "box-outline-stroke", box_outline_stroke);
-    cairo_perf_run (perf, "box-outline-fill", box_outline_fill);
+    cairo_perf_run (perf, "box-outline-stroke", box_outline_stroke, NULL);
+    cairo_perf_run (perf, "box-outline-fill", box_outline_fill, NULL);
 }
diff --git a/perf/micro/cairo-perf-cover.c b/perf/micro/cairo-perf-cover.c
index 48f13a8b4..151a2e679 100644
--- a/perf/micro/cairo-perf-cover.c
+++ b/perf/micro/cairo-perf-cover.c
@@ -295,7 +295,8 @@ typedef void (*set_source_func_t) (cairo_t *cr, int width, int height);
 void
 cairo_perf_cover_sources_and_operators (cairo_perf_t		*perf,
 					const char		*name,
-					cairo_perf_func_t	 perf_func)
+					cairo_perf_func_t	 perf_func,
+					cairo_count_func_t	 count_func)
 {
     unsigned int i, j;
     char *expanded_name;
@@ -332,7 +333,7 @@ cairo_perf_cover_sources_and_operators (cairo_perf_t		*perf,
 
 	    xasprintf (&expanded_name, "%s_%s_%s",
 		       name, sources[i].name, operators[j].name);
-	    cairo_perf_run (perf, expanded_name, perf_func);
+	    cairo_perf_run (perf, expanded_name, perf_func, count_func);
 	    free (expanded_name);
 	}
     }
diff --git a/perf/micro/composite-checker.c b/perf/micro/composite-checker.c
index 0e61ec8d3..27dc364f8 100644
--- a/perf/micro/composite-checker.c
+++ b/perf/micro/composite-checker.c
@@ -107,7 +107,7 @@ composite_checker (cairo_perf_t *perf,
     cairo_pattern_set_filter (src_pattern, CAIRO_FILTER_NEAREST);
     cairo_surface_destroy (image);
 
-    cairo_perf_run (perf, "composite-checker", do_composite_checker);
+    cairo_perf_run (perf, "composite-checker", do_composite_checker, NULL);
 
     cairo_pattern_destroy (checkerboard);
     cairo_pattern_destroy (src_pattern);
diff --git a/perf/micro/dragon.c b/perf/micro/dragon.c
index eb8251c86..78da5b2c4 100644
--- a/perf/micro/dragon.c
+++ b/perf/micro/dragon.c
@@ -241,9 +241,9 @@ dragon (cairo_perf_t *perf, cairo_t *cr, int width, int height)
     if (! cairo_perf_can_run (perf, "dragon", NULL))
 	return;
 
-    cairo_perf_run (perf, "dragon-solid", do_dragon_solid);
-    cairo_perf_run (perf, "dragon-solid-aligned-clip", do_dragon_solid_aligned_clip);
-    cairo_perf_run (perf, "dragon-solid-unaligned-clip", do_dragon_solid_unaligned_clip);
-    cairo_perf_run (perf, "dragon-solid-circle-clip", do_dragon_solid_circle_clip);
-    cairo_perf_run (perf, "dragon", do_dragon);
+    cairo_perf_run (perf, "dragon-solid", do_dragon_solid, NULL);
+    cairo_perf_run (perf, "dragon-solid-aligned-clip", do_dragon_solid_aligned_clip, NULL);
+    cairo_perf_run (perf, "dragon-solid-unaligned-clip", do_dragon_solid_unaligned_clip, NULL);
+    cairo_perf_run (perf, "dragon-solid-circle-clip", do_dragon_solid_circle_clip, NULL);
+    cairo_perf_run (perf, "dragon", do_dragon, NULL);
 }
diff --git a/perf/micro/fill.c b/perf/micro/fill.c
index c65a649d5..a11298f73 100644
--- a/perf/micro/fill.c
+++ b/perf/micro/fill.c
@@ -113,7 +113,7 @@ fill (cairo_perf_t *perf, cairo_t *cr, int width, int height)
     if (! cairo_perf_can_run (perf, "fill", NULL))
 	return;
 
-    cairo_perf_cover_sources_and_operators (perf, "fill", do_fill);
-    cairo_perf_cover_sources_and_operators (perf, "fill-annuli", do_fill_annuli);
-    cairo_perf_cover_sources_and_operators (perf, "fill-eo-noaa", do_fill_eo_noaa);
+    cairo_perf_cover_sources_and_operators (perf, "fill", do_fill, NULL);
+    cairo_perf_cover_sources_and_operators (perf, "fill-annuli", do_fill_annuli, NULL);
+    cairo_perf_cover_sources_and_operators (perf, "fill-eo-noaa", do_fill_eo_noaa, NULL);
 }
diff --git a/perf/micro/glyphs.c b/perf/micro/glyphs.c
index 25175d547..0012e85d3 100644
--- a/perf/micro/glyphs.c
+++ b/perf/micro/glyphs.c
@@ -57,11 +57,11 @@ do_glyphs (cairo_t *cr, int width, int height, int loops)
     cairo_scaled_font_glyph_extents (scaled_font,
 				     glyphs, num_glyphs,
 				     &extents);
-    y = 0;
 
     cairo_perf_timer_start ();
 
     while (loops--) {
+	y = 0;
 	do {
 	    x = 0;
 	    do {
@@ -89,11 +89,42 @@ out:
     return cairo_perf_timer_elapsed ();
 }
 
+static double
+count_glyphs (cairo_t *cr, int width, int height)
+{
+    const char text[] = "the jay, pig, fox, zebra and my wolves quack";
+    cairo_scaled_font_t *scaled_font;
+    cairo_glyph_t *glyphs = NULL;
+    cairo_text_extents_t extents;
+    cairo_status_t status;
+    int num_glyphs;
+    int glyphs_per_line, lines_per_loop;
+
+    cairo_set_font_size (cr, 9);
+    scaled_font = cairo_get_scaled_font (cr);
+    status = cairo_scaled_font_text_to_glyphs (scaled_font, 0., 0.,
+					       text, -1,
+					       &glyphs, &num_glyphs,
+					       NULL, NULL,
+					       NULL);
+    if (status)
+	return 0;
+
+    cairo_scaled_font_glyph_extents (scaled_font,
+				     glyphs, num_glyphs,
+				     &extents);
+    cairo_glyph_free (glyphs);
+
+    glyphs_per_line = num_glyphs * width / extents.width + 1;
+    lines_per_loop = height / extents.height + 1;
+    return glyphs_per_line * lines_per_loop / 1000.; /* kiloglyphs */
+}
+
 void
 glyphs (cairo_perf_t *perf, cairo_t *cr, int width, int height)
 {
     if (! cairo_perf_can_run (perf, "glyphs", NULL))
 	return;
 
-    cairo_perf_cover_sources_and_operators (perf, "glyphs", do_glyphs);
+    cairo_perf_cover_sources_and_operators (perf, "glyphs", do_glyphs, count_glyphs);
 }
diff --git a/perf/micro/intersections.c b/perf/micro/intersections.c
index 0418ee319..8f5516530 100644
--- a/perf/micro/intersections.c
+++ b/perf/micro/intersections.c
@@ -149,9 +149,9 @@ intersections (cairo_perf_t *perf, cairo_t *cr, int width, int height)
     if (! cairo_perf_can_run (perf, "intersections", NULL))
 	return;
 
-    cairo_perf_run (perf, "intersections-nz-fill", random_nz);
-    cairo_perf_run (perf, "intersections-eo-fill", random_eo);
+    cairo_perf_run (perf, "intersections-nz-fill", random_nz, NULL);
+    cairo_perf_run (perf, "intersections-eo-fill", random_eo, NULL);
 
-    cairo_perf_run (perf, "intersections-nz-curve-fill", random_curve_nz);
-    cairo_perf_run (perf, "intersections-eo-curve-fill", random_curve_eo);
+    cairo_perf_run (perf, "intersections-nz-curve-fill", random_curve_nz, NULL);
+    cairo_perf_run (perf, "intersections-eo-curve-fill", random_curve_eo, NULL);
 }
diff --git a/perf/micro/long-dashed-lines.c b/perf/micro/long-dashed-lines.c
index c4de24f57..74de15834 100644
--- a/perf/micro/long-dashed-lines.c
+++ b/perf/micro/long-dashed-lines.c
@@ -67,5 +67,5 @@ long_dashed_lines (cairo_perf_t *perf, cairo_t *cr, int width, int height)
     if (! cairo_perf_can_run (perf, "long-dashed-lines", NULL))
 	return;
 
-    cairo_perf_run (perf, "long-dashed-lines", do_long_dashed_lines);
+    cairo_perf_run (perf, "long-dashed-lines", do_long_dashed_lines, NULL);
 }
diff --git a/perf/micro/long-lines.c b/perf/micro/long-lines.c
index 2b72879c1..577f17c87 100644
--- a/perf/micro/long-lines.c
+++ b/perf/micro/long-lines.c
@@ -138,8 +138,8 @@ long_lines (cairo_perf_t *perf, cairo_t *cr, int width, int height)
     if (! cairo_perf_can_run (perf, "long-lines", NULL))
 	return;
 
-    cairo_perf_run (perf, "long-lines-uncropped", long_lines_uncropped);
-    cairo_perf_run (perf, "long-lines-uncropped-once", long_lines_uncropped_once);
-    cairo_perf_run (perf, "long-lines-cropped", long_lines_cropped);
-    cairo_perf_run (perf, "long-lines-cropped-once", long_lines_cropped_once);
+    cairo_perf_run (perf, "long-lines-uncropped", long_lines_uncropped, NULL);
+    cairo_perf_run (perf, "long-lines-uncropped-once", long_lines_uncropped_once, NULL);
+    cairo_perf_run (perf, "long-lines-cropped", long_lines_cropped, NULL);
+    cairo_perf_run (perf, "long-lines-cropped-once", long_lines_cropped_once, NULL);
 }
diff --git a/perf/micro/mask.c b/perf/micro/mask.c
index 3050b447a..840d43fcd 100644
--- a/perf/micro/mask.c
+++ b/perf/micro/mask.c
@@ -279,21 +279,21 @@ mask (cairo_perf_t *perf, cairo_t *cr, int width, int height)
 	return;
 
     cairo_perf_cover_sources_and_operators (perf, "mask-solid",
-					    do_mask_solid);
+					    do_mask_solid, NULL);
     cairo_perf_cover_sources_and_operators (perf, "mask-image",
-					    do_mask_image);
+					    do_mask_image, NULL);
     cairo_perf_cover_sources_and_operators (perf, "mask-image-half",
-					    do_mask_image_half);
+					    do_mask_image_half, NULL);
     cairo_perf_cover_sources_and_operators (perf, "mask-image-double",
-					    do_mask_image_double);
+					    do_mask_image_double, NULL);
     cairo_perf_cover_sources_and_operators (perf, "mask-similar",
-					    do_mask_similar);
+					    do_mask_similar, NULL);
     cairo_perf_cover_sources_and_operators (perf, "mask-similar-half",
-					    do_mask_similar_half);
+					    do_mask_similar_half, NULL);
     cairo_perf_cover_sources_and_operators (perf, "mask-similar-double",
-					    do_mask_similar_double);
+					    do_mask_similar_double, NULL);
     cairo_perf_cover_sources_and_operators (perf, "mask-linear",
-					    do_mask_linear);
+					    do_mask_linear, NULL);
     cairo_perf_cover_sources_and_operators (perf, "mask-radial",
-					    do_mask_radial);
+					    do_mask_radial, NULL);
 }
diff --git a/perf/micro/mosaic.c b/perf/micro/mosaic.c
index b76210576..a63166cb6 100644
--- a/perf/micro/mosaic.c
+++ b/perf/micro/mosaic.c
@@ -166,8 +166,8 @@ mosaic (cairo_perf_t *perf, cairo_t *cr, int width, int height)
     if (! cairo_perf_can_run (perf, "mosaic", NULL))
 	return;
 
-    cairo_perf_run (perf, "mosaic-fill-curves", mosaic_fill_curves);
-    cairo_perf_run (perf, "mosaic-fill-lines", mosaic_fill_lines);
-    cairo_perf_run (perf, "mosaic-tessellate-curves", mosaic_tessellate_curves);
-    cairo_perf_run (perf, "mosaic-tessellate-lines", mosaic_tessellate_lines);
+    cairo_perf_run (perf, "mosaic-fill-curves", mosaic_fill_curves, NULL);
+    cairo_perf_run (perf, "mosaic-fill-lines", mosaic_fill_lines, NULL);
+    cairo_perf_run (perf, "mosaic-tessellate-curves", mosaic_tessellate_curves, NULL);
+    cairo_perf_run (perf, "mosaic-tessellate-lines", mosaic_tessellate_lines, NULL);
 }
diff --git a/perf/micro/paint-with-alpha.c b/perf/micro/paint-with-alpha.c
index 5c23fe456..048cdb010 100644
--- a/perf/micro/paint-with-alpha.c
+++ b/perf/micro/paint-with-alpha.c
@@ -45,5 +45,5 @@ paint_with_alpha (cairo_perf_t *perf, cairo_t *cr, int width, int height)
 	return;
 
     cairo_perf_cover_sources_and_operators (perf, "paint-with-alpha",
-					    do_paint_with_alpha);
+					    do_paint_with_alpha, NULL);
 }
diff --git a/perf/micro/paint.c b/perf/micro/paint.c
index bdc014c76..ce8cfd370 100644
--- a/perf/micro/paint.c
+++ b/perf/micro/paint.c
@@ -44,5 +44,5 @@ paint (cairo_perf_t *perf, cairo_t *cr, int width, int height)
     if (! cairo_perf_can_run (perf, "paint", NULL))
 	return;
 
-    cairo_perf_cover_sources_and_operators (perf, "paint", do_paint);
+    cairo_perf_cover_sources_and_operators (perf, "paint", do_paint, NULL);
 }
diff --git a/perf/micro/pattern_create_radial.c b/perf/micro/pattern_create_radial.c
index 2959e7400..7104c00f3 100644
--- a/perf/micro/pattern_create_radial.c
+++ b/perf/micro/pattern_create_radial.c
@@ -99,5 +99,5 @@ pattern_create_radial (cairo_perf_t *perf, cairo_t *cr, int width, int height)
     }
 
     cairo_perf_run (perf, "pattern-create-radial",
-                          do_pattern_create_radial);
+                          do_pattern_create_radial, NULL);
 }
diff --git a/perf/micro/pythagoras-tree.c b/perf/micro/pythagoras-tree.c
index f2200c98b..964d5c12b 100644
--- a/perf/micro/pythagoras-tree.c
+++ b/perf/micro/pythagoras-tree.c
@@ -87,5 +87,5 @@ pythagoras_tree (cairo_perf_t *perf, cairo_t *cr, int width, int height)
     if (! cairo_perf_can_run (perf, "pythagoras-tree", NULL))
 	return;
 
-    cairo_perf_run (perf, "pythagoras-tree", do_pythagoras_tree);
+    cairo_perf_run (perf, "pythagoras-tree", do_pythagoras_tree, NULL);
 }
diff --git a/perf/micro/rectangles.c b/perf/micro/rectangles.c
index 601a0c594..6bfbc6571 100644
--- a/perf/micro/rectangles.c
+++ b/perf/micro/rectangles.c
@@ -112,7 +112,7 @@ rectangles (cairo_perf_t *perf, cairo_t *cr, int width, int height)
         rects[i].height = (rand () % (height / 10)) + 1;
     }
 
-    MODE (perf, "one-rectangle", do_rectangle);
-    MODE (perf, "rectangles", do_rectangles);
-    MODE (perf, "rectangles-once", do_rectangles_once);
+    MODE (perf, "one-rectangle", do_rectangle, NULL);
+    MODE (perf, "rectangles", do_rectangles, NULL);
+    MODE (perf, "rectangles-once", do_rectangles_once, NULL);
 }
diff --git a/perf/micro/rounded-rectangles.c b/perf/micro/rounded-rectangles.c
index 477abf2c9..4db62fc80 100644
--- a/perf/micro/rounded-rectangles.c
+++ b/perf/micro/rounded-rectangles.c
@@ -135,7 +135,7 @@ rounded_rectangles (cairo_perf_t *perf, cairo_t *cr, int width, int height)
         rects[i].height = (rand () % (height / 10)) + 1;
     }
 
-    MODE (perf, "one-rounded-rectangle", do_rectangle);
-    MODE (perf, "rounded-rectangles", do_rectangles);
-    MODE (perf, "rounded-rectangles-once", do_rectangles_once);
+    MODE (perf, "one-rounded-rectangle", do_rectangle, NULL);
+    MODE (perf, "rounded-rectangles", do_rectangles, NULL);
+    MODE (perf, "rounded-rectangles-once", do_rectangles_once, NULL);
 }
diff --git a/perf/micro/spiral.c b/perf/micro/spiral.c
index 046351c0a..10bb91845 100644
--- a/perf/micro/spiral.c
+++ b/perf/micro/spiral.c
@@ -332,18 +332,18 @@ spiral (cairo_perf_t *perf, cairo_t *cr, int width, int height)
     if (! cairo_perf_can_run (perf, "spiral", NULL))
 	return;
 
-    cairo_perf_run (perf, "spiral-box-nonalign-evenodd-fill", draw_spiral_eo_na_box);
-    cairo_perf_run (perf, "spiral-box-nonalign-nonzero-fill", draw_spiral_nz_na_box);
-    cairo_perf_run (perf, "spiral-box-pixalign-evenodd-fill", draw_spiral_eo_pa_box);
-    cairo_perf_run (perf, "spiral-box-pixalign-nonzero-fill", draw_spiral_nz_pa_box);
-    cairo_perf_run (perf, "spiral-diag-nonalign-evenodd-fill", draw_spiral_eo_na_di);
-    cairo_perf_run (perf, "spiral-diag-nonalign-nonzero-fill", draw_spiral_nz_na_di);
-    cairo_perf_run (perf, "spiral-diag-pixalign-evenodd-fill", draw_spiral_eo_pa_di);
-    cairo_perf_run (perf, "spiral-diag-pixalign-nonzero-fill", draw_spiral_nz_pa_di);
-    cairo_perf_run (perf, "spiral-rect-nonalign-evenodd-fill", draw_spiral_eo_na_re);
-    cairo_perf_run (perf, "spiral-rect-nonalign-nonzero-fill", draw_spiral_nz_na_re);
-    cairo_perf_run (perf, "spiral-rect-pixalign-evenodd-fill", draw_spiral_eo_pa_re);
-    cairo_perf_run (perf, "spiral-rect-pixalign-nonzero-fill", draw_spiral_nz_pa_re);
-    cairo_perf_run (perf, "spiral-nonalign-stroke", draw_spiral_stroke_na);
-    cairo_perf_run (perf, "spiral-pixalign-stroke", draw_spiral_stroke_pa);
+    cairo_perf_run (perf, "spiral-box-nonalign-evenodd-fill", draw_spiral_eo_na_box, NULL);
+    cairo_perf_run (perf, "spiral-box-nonalign-nonzero-fill", draw_spiral_nz_na_box, NULL);
+    cairo_perf_run (perf, "spiral-box-pixalign-evenodd-fill", draw_spiral_eo_pa_box, NULL);
+    cairo_perf_run (perf, "spiral-box-pixalign-nonzero-fill", draw_spiral_nz_pa_box, NULL);
+    cairo_perf_run (perf, "spiral-diag-nonalign-evenodd-fill", draw_spiral_eo_na_di, NULL);
+    cairo_perf_run (perf, "spiral-diag-nonalign-nonzero-fill", draw_spiral_nz_na_di, NULL);
+    cairo_perf_run (perf, "spiral-diag-pixalign-evenodd-fill", draw_spiral_eo_pa_di, NULL);
+    cairo_perf_run (perf, "spiral-diag-pixalign-nonzero-fill", draw_spiral_nz_pa_di, NULL);
+    cairo_perf_run (perf, "spiral-rect-nonalign-evenodd-fill", draw_spiral_eo_na_re, NULL);
+    cairo_perf_run (perf, "spiral-rect-nonalign-nonzero-fill", draw_spiral_nz_na_re, NULL);
+    cairo_perf_run (perf, "spiral-rect-pixalign-evenodd-fill", draw_spiral_eo_pa_re, NULL);
+    cairo_perf_run (perf, "spiral-rect-pixalign-nonzero-fill", draw_spiral_nz_pa_re, NULL);
+    cairo_perf_run (perf, "spiral-nonalign-stroke", draw_spiral_stroke_na, NULL);
+    cairo_perf_run (perf, "spiral-pixalign-stroke", draw_spiral_stroke_pa, NULL);
 }
diff --git a/perf/micro/stroke.c b/perf/micro/stroke.c
index 660dce574..950fb4868 100644
--- a/perf/micro/stroke.c
+++ b/perf/micro/stroke.c
@@ -92,6 +92,6 @@ stroke (cairo_perf_t *perf, cairo_t *cr, int width, int height)
     if (! cairo_perf_can_run (perf, "stroke", NULL))
 	return;
 
-    cairo_perf_cover_sources_and_operators (perf, "stroke", do_stroke);
-    cairo_perf_cover_sources_and_operators (perf, "strokes", do_strokes);
+    cairo_perf_cover_sources_and_operators (perf, "stroke", do_stroke, NULL);
+    cairo_perf_cover_sources_and_operators (perf, "strokes", do_strokes, NULL);
 }
diff --git a/perf/micro/subimage_copy.c b/perf/micro/subimage_copy.c
index 0bfad80ce..8c70464ab 100644
--- a/perf/micro/subimage_copy.c
+++ b/perf/micro/subimage_copy.c
@@ -73,5 +73,5 @@ subimage_copy (cairo_perf_t *perf, cairo_t *cr, int width, int height)
     cairo_set_source_surface (cr, image, 0, 0);
     cairo_surface_destroy (image);
 
-    cairo_perf_run (perf, "subimage-copy", do_subimage_copy);
+    cairo_perf_run (perf, "subimage-copy", do_subimage_copy, NULL);
 }
diff --git a/perf/micro/tessellate.c b/perf/micro/tessellate.c
index 9debc539f..38effff80 100644
--- a/perf/micro/tessellate.c
+++ b/perf/micro/tessellate.c
@@ -147,9 +147,9 @@ tessellate (cairo_perf_t *perf, cairo_t *cr, int width, int height)
     if (! cairo_perf_can_run (perf, "tessellate", NULL))
 	return;
 
-    cairo_perf_run (perf, "tessellate-16", tessellate_16);
-    cairo_perf_run (perf, "tessellate-64", tessellate_64);
-    cairo_perf_run (perf, "tessellate-256", tessellate_256);
+    cairo_perf_run (perf, "tessellate-16", tessellate_16, NULL);
+    cairo_perf_run (perf, "tessellate-64", tessellate_64, NULL);
+    cairo_perf_run (perf, "tessellate-256", tessellate_256, NULL);
 }
 
 #if 0
diff --git a/perf/micro/text.c b/perf/micro/text.c
index 827bb8830..190c3c28d 100644
--- a/perf/micro/text.c
+++ b/perf/micro/text.c
@@ -62,5 +62,5 @@ text (cairo_perf_t *perf, cairo_t *cr, int width, int height)
     if (! cairo_perf_can_run (perf, "text", NULL))
 	return;
 
-    cairo_perf_cover_sources_and_operators (perf, "text", do_text);
+    cairo_perf_cover_sources_and_operators (perf, "text", do_text, NULL);
 }
diff --git a/perf/micro/twin.c b/perf/micro/twin.c
index b2c37a25d..2bc01edf5 100644
--- a/perf/micro/twin.c
+++ b/perf/micro/twin.c
@@ -52,5 +52,5 @@ twin (cairo_perf_t *perf,
     if (! cairo_perf_can_run (perf, "twin", NULL))
 	return;
 
-    cairo_perf_run (perf, "twin", do_twin);
+    cairo_perf_run (perf, "twin", do_twin, NULL);
 }
diff --git a/perf/micro/unaligned-clip.c b/perf/micro/unaligned-clip.c
index 284c832a2..adc44fe82 100644
--- a/perf/micro/unaligned-clip.c
+++ b/perf/micro/unaligned-clip.c
@@ -66,5 +66,5 @@ unaligned_clip (cairo_perf_t *perf, cairo_t *cr, int width, int height)
     if (! cairo_perf_can_run (perf, "unaligned-clip", NULL))
 	return;
 
-    cairo_perf_run (perf, "unaligned-clip", do_unaligned_clip);
+    cairo_perf_run (perf, "unaligned-clip", do_unaligned_clip, NULL);
 }
diff --git a/perf/micro/world-map.c b/perf/micro/world-map.c
index 2a455002c..42b8da516 100644
--- a/perf/micro/world-map.c
+++ b/perf/micro/world-map.c
@@ -112,5 +112,5 @@ world_map (cairo_perf_t *perf, cairo_t *cr, int width, int height)
     if (! cairo_perf_can_run (perf, "world-map", NULL))
 	return;
 
-    cairo_perf_run (perf, "world-map", do_world_map);
+    cairo_perf_run (perf, "world-map", do_world_map, NULL);
 }
diff --git a/perf/micro/zrusin.c b/perf/micro/zrusin.c
index 24aff142d..87c8da336 100644
--- a/perf/micro/zrusin.c
+++ b/perf/micro/zrusin.c
@@ -90,6 +90,6 @@ zrusin (cairo_perf_t *perf, cairo_t *cr, int width, int height)
     if (! cairo_perf_can_run (perf, "zrusin", NULL))
 	return;
 
-    cairo_perf_run (perf, "zrusin-another-tessellate", zrusin_another_tessellate);
-    cairo_perf_run (perf, "zrusin-another-fill", zrusin_another_fill);
+    cairo_perf_run (perf, "zrusin-another-tessellate", zrusin_another_tessellate, NULL);
+    cairo_perf_run (perf, "zrusin-another-fill", zrusin_another_fill, NULL);
 }