blob: 02e0e29f99d068f244d109be0268d98bc3b75511 [file] [log] [blame]
/* -*- Mode: c; c-basic-offset: 4; indent-tabs-mode: t; tab-width: 8; -*- */
/*
* Copyright © 2006 Mozilla Corporation
* Copyright © 2006 Red Hat, Inc.
* Copyright © 2009 Chris Wilson
*
* Permission to use, copy, modify, distribute, and sell this software
* and its documentation for any purpose is hereby granted without
* fee, provided that the above copyright notice appear in all copies
* and that both that copyright notice and this permission notice
* appear in supporting documentation, and that the name of
* the authors not be used in advertising or publicity pertaining to
* distribution of the software without specific, written prior
* permission. The authors make no representations about the
* suitability of this software for any purpose. It is provided "as
* is" without express or implied warranty.
*
* THE AUTHORS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
* SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
* FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL,
* INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
* RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
* IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
* Authors: Vladimir Vukicevic <vladimir@pobox.com>
* Carl Worth <cworth@cworth.org>
* Chris Wilson <chris@chris-wilson.co.uk>
*/
#define _GNU_SOURCE 1 /* for sched_getaffinity() and getline() */
#include "../cairo-version.h" /* for the real version */
#include "cairo-missing.h"
#include "cairo-perf.h"
#include "cairo-stats.h"
#include "cairo-boilerplate-getopt.h"
#include <cairo-script-interpreter.h>
#include <cairo-types-private.h> /* for INTERNAL_SURFACE_TYPE */
/* rudely reuse bits of the library... */
#include "../src/cairo-hash-private.h"
#include "../src/cairo-error-private.h"
/* For basename */
#ifdef HAVE_LIBGEN_H
#include <libgen.h>
#endif
#include <ctype.h> /* isspace() */
#include <sys/types.h>
#include <sys/stat.h>
#ifdef _MSC_VER
#include "dirent-win32.h"
static char *
basename_no_ext (char *path)
{
static char name[_MAX_FNAME + 1];
_splitpath (path, NULL, NULL, name, NULL);
name[_MAX_FNAME] = '\0';
return name;
}
#else
#include <dirent.h>
static char *
basename_no_ext (char *path)
{
char *dot, *name;
name = basename (path);
dot = strrchr (name, '.');
if (dot)
*dot = '\0';
return name;
}
#endif
#if HAVE_UNISTD_H
#include <unistd.h>
#endif
#include <signal.h>
#if HAVE_FCFINI
#include <fontconfig/fontconfig.h>
#endif
#define CAIRO_PERF_ITERATIONS_DEFAULT 15
#define CAIRO_PERF_LOW_STD_DEV 0.05
#define CAIRO_PERF_MIN_STD_DEV_COUNT 3
#define CAIRO_PERF_STABLE_STD_DEV_COUNT 3
struct trace {
const cairo_boilerplate_target_t *target;
void *closure;
cairo_surface_t *surface;
cairo_bool_t observe;
int tile_size;
};
cairo_bool_t
cairo_perf_can_run (cairo_perf_t *perf,
const char *name,
cairo_bool_t *is_explicit)
{
unsigned int i;
char *copy, *dot;
cairo_bool_t ret;
if (is_explicit)
*is_explicit = FALSE;
if (perf->exact_names) {
if (is_explicit)
*is_explicit = TRUE;
return TRUE;
}
if (perf->num_names == 0 && perf->num_exclude_names == 0)
return TRUE;
copy = xstrdup (name);
dot = strrchr (copy, '.');
if (dot != NULL)
*dot = '\0';
if (perf->num_names) {
ret = TRUE;
for (i = 0; i < perf->num_names; i++)
if (strstr (copy, perf->names[i])) {
if (is_explicit)
*is_explicit = strcmp (copy, perf->names[i]) == 0;
goto check_exclude;
}
ret = FALSE;
goto done;
}
check_exclude:
if (perf->num_exclude_names) {
ret = FALSE;
for (i = 0; i < perf->num_exclude_names; i++)
if (strstr (copy, perf->exclude_names[i])) {
if (is_explicit)
*is_explicit = strcmp (copy, perf->exclude_names[i]) == 0;
goto done;
}
ret = TRUE;
goto done;
}
done:
free (copy);
return ret;
}
static void
fill_surface (cairo_surface_t *surface)
{
cairo_t *cr = cairo_create (surface);
/* This needs to be an operation that the backends can't optimise away */
cairo_set_source_rgba (cr, 0.5, 0.5, 0.5, 0.5);
cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
cairo_paint (cr);
cairo_destroy (cr);
}
struct scache {
cairo_hash_entry_t entry;
cairo_content_t content;
int width, height;
cairo_surface_t *surface;
};
static cairo_hash_table_t *surface_cache;
static cairo_surface_t *surface_holdovers[16];
static cairo_bool_t
scache_equal (const void *A,
const void *B)
{
const struct scache *a = A, *b = B;
return a->entry.hash == b->entry.hash;
}
static void
scache_mark_active (cairo_surface_t *surface)
{
cairo_surface_t *t0, *t1;
unsigned n;
if (surface_cache == NULL)
return;
t0 = cairo_surface_reference (surface);
for (n = 0; n < ARRAY_LENGTH (surface_holdovers); n++) {
if (surface_holdovers[n] == surface) {
surface_holdovers[n] = t0;
t0 = surface;
break;
}
t1 = surface_holdovers[n];
surface_holdovers[n] = t0;
t0 = t1;
}
cairo_surface_destroy (t0);
}
static void
scache_clear (void)
{
unsigned n;
if (surface_cache == NULL)
return;
for (n = 0; n < ARRAY_LENGTH (surface_holdovers); n++) {
cairo_surface_destroy (surface_holdovers[n]);
surface_holdovers[n] = NULL;
}
}
static void
scache_remove (void *closure)
{
_cairo_hash_table_remove (surface_cache, closure);
free (closure);
}
static cairo_surface_t *
_similar_surface_create (void *closure,
cairo_content_t content,
double width,
double height,
long uid)
{
struct trace *args = closure;
cairo_surface_t *surface;
struct scache skey, *s;
if (args->observe)
return cairo_surface_create_similar (args->surface,
content, width, height);
if (uid == 0 || surface_cache == NULL)
return args->target->create_similar (args->surface, content, width, height);
skey.entry.hash = uid;
s = _cairo_hash_table_lookup (surface_cache, &skey.entry);
if (s != NULL) {
if (s->content == content &&
s->width == width &&
s->height == height)
{
return cairo_surface_reference (s->surface);
}
/* The surface has been resized, allow the original entry to expire
* as it becomes inactive.
*/
}
surface = args->target->create_similar (args->surface, content, width, height);
s = malloc (sizeof (struct scache));
if (s == NULL)
return surface;
s->entry.hash = uid;
s->content = content;
s->width = width;
s->height = height;
s->surface = surface;
if (_cairo_hash_table_insert (surface_cache, &s->entry)) {
free (s);
} else if (cairo_surface_set_user_data
(surface,
(const cairo_user_data_key_t *) &surface_cache,
s, scache_remove))
{
scache_remove (s);
}
return surface;
}
static cairo_surface_t *
_source_image_create (void *closure,
cairo_format_t format,
int width,
int height,
long uid)
{
struct trace *args = closure;
return cairo_surface_create_similar_image (args->surface,
format, width, height);
}
static cairo_t *
_context_create (void *closure,
cairo_surface_t *surface)
{
scache_mark_active (surface);
return cairo_create (surface);
}
static int user_interrupt;
static void
interrupt (int sig)
{
if (user_interrupt) {
signal (sig, SIG_DFL);
raise (sig);
}
user_interrupt = 1;
}
static void
describe (cairo_perf_t *perf,
void *closure)
{
char *description = NULL;
if (perf->has_described_backend)
return;
perf->has_described_backend = TRUE;
if (perf->target->describe)
description = perf->target->describe (closure);
if (description == NULL)
return;
if (perf->raw) {
printf ("[ # ] %s: %s\n", perf->target->name, description);
}
if (perf->summary) {
fprintf (perf->summary,
"[ # ] %8s: %s\n",
perf->target->name,
description);
}
free (description);
}
static void
usage (const char *argv0)
{
fprintf (stderr,
"Usage: %s [-clrsv] [-i iterations] [-t tile-size] [-x exclude-file] [test-names ... | traces ...]\n"
"\n"
"Run the cairo performance test suite over the given tests (all by default)\n"
"The command-line arguments are interpreted as follows:\n"
"\n"
" -c use surface cache; keep a cache of surfaces to be reused\n"
" -i iterations; specify the number of iterations per test case\n"
" -l list only; just list selected test case names without executing\n"
" -r raw; display each time measurement instead of summary statistics\n"
" -s sync; only sum the elapsed time of the indiviual operations\n"
" -t tile size; draw to tiled surfaces\n"
" -v verbose; in raw mode also show the summaries\n"
" -x exclude; specify a file to read a list of traces to exclude\n"
"\n"
"If test names are given they are used as sub-string matches so a command\n"
"such as \"%s firefox\" can be used to run all firefox traces.\n"
"Alternatively, you can specify a list of filenames to execute.\n",
argv0, argv0);
}
static cairo_bool_t
read_excludes (cairo_perf_t *perf,
const char *filename)
{
FILE *file;
char *line = NULL;
size_t line_size = 0;
char *s, *t;
file = fopen (filename, "r");
if (file == NULL)
return FALSE;
while (getline (&line, &line_size, file) != -1) {
/* terminate the line at a comment marker '#' */
s = strchr (line, '#');
if (s)
*s = '\0';
/* whitespace delimits */
s = line;
while (*s != '\0' && isspace (*s))
s++;
t = s;
while (*t != '\0' && ! isspace (*t))
t++;
if (s != t) {
int i = perf->num_exclude_names;
perf->exclude_names = xrealloc (perf->exclude_names,
sizeof (char *) * (i+1));
perf->exclude_names[i] = strndup (s, t-s);
perf->num_exclude_names++;
}
}
free (line);
fclose (file);
return TRUE;
}
static void
parse_options (cairo_perf_t *perf,
int argc,
char *argv[])
{
int c;
const char *iters;
char *end;
int verbose = 0;
int use_surface_cache = 0;
if ((iters = getenv ("CAIRO_PERF_ITERATIONS")) && *iters)
perf->iterations = strtol (iters, NULL, 0);
else
perf->iterations = CAIRO_PERF_ITERATIONS_DEFAULT;
perf->exact_iterations = 0;
perf->raw = FALSE;
perf->observe = FALSE;
perf->list_only = FALSE;
perf->tile_size = 0;
perf->names = NULL;
perf->num_names = 0;
perf->summary = stdout;
perf->summary_continuous = FALSE;
perf->exclude_names = NULL;
perf->num_exclude_names = 0;
while (1) {
c = _cairo_getopt (argc, argv, "ci:lrst:vx:");
if (c == -1)
break;
switch (c) {
case 'c':
use_surface_cache = 1;
break;
case 'i':
perf->exact_iterations = TRUE;
perf->iterations = strtoul (optarg, &end, 10);
if (*end != '\0') {
fprintf (stderr, "Invalid argument for -i (not an integer): %s\n",
optarg);
exit (1);
}
break;
case 'l':
perf->list_only = TRUE;
break;
case 'r':
perf->raw = TRUE;
perf->summary = NULL;
break;
case 's':
perf->observe = TRUE;
break;
case 't':
perf->tile_size = strtoul (optarg, &end, 10);
if (*end != '\0') {
fprintf (stderr, "Invalid argument for -t (not an integer): %s\n",
optarg);
exit (1);
}
break;
case 'v':
verbose = 1;
break;
case 'x':
if (! read_excludes (perf, optarg)) {
fprintf (stderr, "Invalid argument for -x (not readable file): %s\n",
optarg);
exit (1);
}
break;
default:
fprintf (stderr, "Internal error: unhandled option: %c\n", c);
/* fall-through */
case '?':
usage (argv[0]);
exit (1);
}
}
if (perf->observe && perf->tile_size) {
fprintf (stderr, "Can't mix observer and tiling. Sorry.\n");
exit (1);
}
if (verbose && perf->summary == NULL)
perf->summary = stderr;
#if HAVE_UNISTD_H
if (perf->summary && isatty (fileno (perf->summary)))
perf->summary_continuous = TRUE;
#endif
if (optind < argc) {
perf->names = &argv[optind];
perf->num_names = argc - optind;
}
if (use_surface_cache)
surface_cache = _cairo_hash_table_create (scache_equal);
}
static void
cairo_perf_fini (cairo_perf_t *perf)
{
cairo_boilerplate_free_targets (perf->targets);
cairo_boilerplate_fini ();
free (perf->times);
cairo_debug_reset_static_data ();
#if HAVE_FCFINI
FcFini ();
#endif
}
static cairo_bool_t
have_trace_filenames (cairo_perf_t *perf)
{
unsigned int i;
if (perf->num_names == 0)
return FALSE;
#if HAVE_UNISTD_H
for (i = 0; i < perf->num_names; i++)
if (access (perf->names[i], R_OK) == 0)
return TRUE;
#endif
return FALSE;
}
static void
_tiling_surface_finish (cairo_surface_t *observer,
cairo_surface_t *target,
void *closure)
{
struct trace *args = closure;
cairo_surface_t *surface;
cairo_content_t content;
cairo_rectangle_t r;
int width, height;
int x, y, w, h;
cairo_recording_surface_get_extents (target, &r);
w = r.width;
h = r.height;
content = cairo_surface_get_content (target);
for (y = 0; y < h; y += args->tile_size) {
height = args->tile_size;
if (y + height > h)
height = h - y;
for (x = 0; x < w; x += args->tile_size) {
cairo_t *cr;
width = args->tile_size;
if (x + width > w)
width = w - x;
/* XXX to correctly observe the playback we would need
* to replay the target onto the observer directly.
*/
surface = args->target->create_similar (args->surface,
content, width, height);
cr = cairo_create (surface);
cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
cairo_set_source_surface (cr, target, -x, -y);
cairo_paint (cr);
cairo_destroy (cr);
cairo_surface_destroy (surface);
}
}
}
static cairo_surface_t *
_tiling_surface_create (void *closure,
cairo_content_t content,
double width,
double height,
long uid)
{
cairo_rectangle_t r;
cairo_surface_t *surface, *observer;
r.x = r.y = 0;
r.width = width;
r.height = height;
surface = cairo_recording_surface_create (content, &r);
observer = cairo_surface_create_observer (surface,
CAIRO_SURFACE_OBSERVER_NORMAL);
cairo_surface_destroy (surface);
cairo_surface_observer_add_finish_callback (observer,
_tiling_surface_finish,
closure);
return observer;
}
static void
cairo_perf_trace (cairo_perf_t *perf,
const cairo_boilerplate_target_t *target,
const char *trace)
{
static cairo_bool_t first_run = TRUE;
unsigned int i;
cairo_time_t *times, *paint, *mask, *fill, *stroke, *glyphs;
cairo_stats_t stats = {0.0, 0.0};
struct trace args = { target };
int low_std_dev_count;
char *trace_cpy, *name;
const cairo_script_interpreter_hooks_t hooks = {
&args,
perf->tile_size ? _tiling_surface_create : _similar_surface_create,
NULL, /* surface_destroy */
_context_create,
NULL, /* context_destroy */
NULL, /* show_page */
NULL, /* copy_page */
_source_image_create,
};
args.tile_size = perf->tile_size;
args.observe = perf->observe;
trace_cpy = xstrdup (trace);
name = basename_no_ext (trace_cpy);
if (perf->list_only) {
printf ("%s\n", name);
free (trace_cpy);
return;
}
if (first_run) {
if (perf->raw) {
printf ("[ # ] %s.%-s %s %s %s ...\n",
"backend", "content", "test-size", "ticks-per-ms", "time(ticks)");
}
if (perf->summary) {
if (perf->observe) {
fprintf (perf->summary,
"[ # ] %8s %28s %9s %9s %9s %9s %9s %9s %5s\n",
"backend", "test",
"total(s)", "paint(s)", "mask(s)", "fill(s)", "stroke(s)", "glyphs(s)",
"count");
} else {
fprintf (perf->summary,
"[ # ] %8s %28s %8s %5s %5s %s\n",
"backend", "test", "min(s)", "median(s)",
"stddev.", "count");
}
}
first_run = FALSE;
}
times = perf->times;
paint = times + perf->iterations;
mask = paint + perf->iterations;
stroke = mask + perf->iterations;
fill = stroke + perf->iterations;
glyphs = fill + perf->iterations;
low_std_dev_count = 0;
for (i = 0; i < perf->iterations && ! user_interrupt; i++) {
cairo_script_interpreter_t *csi;
cairo_status_t status;
unsigned int line_no;
args.surface = target->create_surface (NULL,
CAIRO_CONTENT_COLOR_ALPHA,
1, 1,
1, 1,
CAIRO_BOILERPLATE_MODE_PERF,
&args.closure);
fill_surface(args.surface); /* remove any clear flags */
if (perf->observe) {
cairo_surface_t *obs;
obs = cairo_surface_create_observer (args.surface,
CAIRO_SURFACE_OBSERVER_NORMAL);
cairo_surface_destroy (args.surface);
args.surface = obs;
}
if (cairo_surface_status (args.surface)) {
fprintf (stderr,
"Error: Failed to create target surface: %s\n",
target->name);
return;
}
cairo_perf_timer_set_synchronize (target->synchronize, args.closure);
if (i == 0) {
describe (perf, args.closure);
if (perf->summary) {
fprintf (perf->summary,
"[%3d] %8s %28s ",
perf->test_number,
perf->target->name,
name);
fflush (perf->summary);
}
}
csi = cairo_script_interpreter_create ();
cairo_script_interpreter_install_hooks (csi, &hooks);
if (! perf->observe) {
cairo_perf_yield ();
cairo_perf_timer_start ();
}
cairo_script_interpreter_run (csi, trace);
line_no = cairo_script_interpreter_get_line_number (csi);
/* Finish before querying timings in case we are using an intermediate
* target and so need to destroy all surfaces before rendering
* commences.
*/
cairo_script_interpreter_finish (csi);
if (perf->observe) {
cairo_device_t *observer = cairo_surface_get_device (args.surface);
times[i] = _cairo_time_from_s (1.e-9 * cairo_device_observer_elapsed (observer));
paint[i] = _cairo_time_from_s (1.e-9 * cairo_device_observer_paint_elapsed (observer));
mask[i] = _cairo_time_from_s (1.e-9 * cairo_device_observer_mask_elapsed (observer));
stroke[i] = _cairo_time_from_s (1.e-9 * cairo_device_observer_stroke_elapsed (observer));
fill[i] = _cairo_time_from_s (1.e-9 * cairo_device_observer_fill_elapsed (observer));
glyphs[i] = _cairo_time_from_s (1.e-9 * cairo_device_observer_glyphs_elapsed (observer));
} else {
fill_surface (args.surface); /* queue a write to the sync'ed surface */
cairo_perf_timer_stop ();
times[i] = cairo_perf_timer_elapsed ();
}
scache_clear ();
cairo_surface_destroy (args.surface);
if (target->cleanup)
target->cleanup (args.closure);
status = cairo_script_interpreter_destroy (csi);
if (status) {
if (perf->summary) {
fprintf (perf->summary, "Error during replay, line %d: %s\n",
line_no,
cairo_status_to_string (status));
}
goto out;
}
if (perf->raw) {
if (i == 0)
printf ("[*] %s.%s %s.%d %g",
perf->target->name,
"rgba",
name,
0,
_cairo_time_to_double (_cairo_time_from_s (1)) / 1000.);
printf (" %lld", (long long) times[i]);
fflush (stdout);
} else if (! perf->exact_iterations) {
if (i > CAIRO_PERF_MIN_STD_DEV_COUNT) {
_cairo_stats_compute (&stats, times, i+1);
if (stats.std_dev <= CAIRO_PERF_LOW_STD_DEV) {
if (++low_std_dev_count >= CAIRO_PERF_STABLE_STD_DEV_COUNT)
break;
} else {
low_std_dev_count = 0;
}
}
}
if (perf->summary && perf->summary_continuous) {
_cairo_stats_compute (&stats, times, i+1);
fprintf (perf->summary,
"\r[%3d] %8s %28s ",
perf->test_number,
perf->target->name,
name);
if (perf->observe) {
fprintf (perf->summary,
" %#9.3f", _cairo_time_to_s (stats.median_ticks));
_cairo_stats_compute (&stats, paint, i+1);
fprintf (perf->summary,
" %#9.3f", _cairo_time_to_s (stats.median_ticks));
_cairo_stats_compute (&stats, mask, i+1);
fprintf (perf->summary,
" %#9.3f", _cairo_time_to_s (stats.median_ticks));
_cairo_stats_compute (&stats, fill, i+1);
fprintf (perf->summary,
" %#9.3f", _cairo_time_to_s (stats.median_ticks));
_cairo_stats_compute (&stats, stroke, i+1);
fprintf (perf->summary,
" %#9.3f", _cairo_time_to_s (stats.median_ticks));
_cairo_stats_compute (&stats, glyphs, i+1);
fprintf (perf->summary,
" %#9.3f", _cairo_time_to_s (stats.median_ticks));
fprintf (perf->summary,
" %5d", i+1);
} else {
fprintf (perf->summary,
"%#8.3f %#8.3f %#6.2f%% %4d/%d",
_cairo_time_to_s (stats.min_ticks),
_cairo_time_to_s (stats.median_ticks),
stats.std_dev * 100.0,
stats.iterations, i+1);
}
fflush (perf->summary);
}
}
user_interrupt = 0;
if (perf->summary) {
_cairo_stats_compute (&stats, times, i);
if (perf->summary_continuous) {
fprintf (perf->summary,
"\r[%3d] %8s %28s ",
perf->test_number,
perf->target->name,
name);
}
if (perf->observe) {
fprintf (perf->summary,
" %#9.3f", _cairo_time_to_s (stats.median_ticks));
_cairo_stats_compute (&stats, paint, i);
fprintf (perf->summary,
" %#9.3f", _cairo_time_to_s (stats.median_ticks));
_cairo_stats_compute (&stats, mask, i);
fprintf (perf->summary,
" %#9.3f", _cairo_time_to_s (stats.median_ticks));
_cairo_stats_compute (&stats, fill, i);
fprintf (perf->summary,
" %#9.3f", _cairo_time_to_s (stats.median_ticks));
_cairo_stats_compute (&stats, stroke, i);
fprintf (perf->summary,
" %#9.3f", _cairo_time_to_s (stats.median_ticks));
_cairo_stats_compute (&stats, glyphs, i);
fprintf (perf->summary,
" %#9.3f", _cairo_time_to_s (stats.median_ticks));
fprintf (perf->summary,
" %5d\n", i);
} else {
fprintf (perf->summary,
"%#8.3f %#8.3f %#6.2f%% %4d/%d\n",
_cairo_time_to_s (stats.min_ticks),
_cairo_time_to_s (stats.median_ticks),
stats.std_dev * 100.0,
stats.iterations, i);
}
fflush (perf->summary);
}
out:
if (perf->raw) {
printf ("\n");
fflush (stdout);
}
perf->test_number++;
free (trace_cpy);
}
static void
warn_no_traces (const char *message,
const char *trace_dir)
{
fprintf (stderr,
"Error: %s '%s'.\n"
"Have you cloned the cairo-traces repository and uncompressed the traces?\n"
" git clone git://anongit.freedesktop.org/cairo-traces\n"
" cd cairo-traces && make\n"
"Or set the env.var CAIRO_TRACE_DIR to point to your traces?\n",
message, trace_dir);
}
static int
cairo_perf_trace_dir (cairo_perf_t *perf,
const cairo_boilerplate_target_t *target,
const char *dirname)
{
DIR *dir;
struct dirent *de;
int num_traces = 0;
cairo_bool_t force;
cairo_bool_t is_explicit;
dir = opendir (dirname);
if (dir == NULL)
return 0;
force = FALSE;
if (cairo_perf_can_run (perf, dirname, &is_explicit))
force = is_explicit;
while ((de = readdir (dir)) != NULL) {
char *trace;
struct stat st;
if (de->d_name[0] == '.')
continue;
xasprintf (&trace, "%s/%s", dirname, de->d_name);
if (stat (trace, &st) != 0)
goto next;
if (S_ISDIR(st.st_mode)) {
num_traces += cairo_perf_trace_dir (perf, target, trace);
} else {
const char *dot;
dot = strrchr (de->d_name, '.');
if (dot == NULL)
goto next;
if (strcmp (dot, ".trace"))
goto next;
num_traces++;
if (!force && ! cairo_perf_can_run (perf, de->d_name, NULL))
goto next;
cairo_perf_trace (perf, target, trace);
}
next:
free (trace);
}
closedir (dir);
return num_traces;
}
int
main (int argc,
char *argv[])
{
cairo_perf_t perf;
const char *trace_dir = "cairo-traces:/usr/src/cairo-traces:/usr/share/cairo-traces";
unsigned int n;
int i;
parse_options (&perf, argc, argv);
signal (SIGINT, interrupt);
if (getenv ("CAIRO_TRACE_DIR") != NULL)
trace_dir = getenv ("CAIRO_TRACE_DIR");
perf.targets = cairo_boilerplate_get_targets (&perf.num_targets, NULL);
perf.times = xmalloc (6 * perf.iterations * sizeof (cairo_time_t));
/* do we have a list of filenames? */
perf.exact_names = have_trace_filenames (&perf);
for (i = 0; i < perf.num_targets; i++) {
const cairo_boilerplate_target_t *target = perf.targets[i];
if (! perf.list_only && ! target->is_measurable)
continue;
perf.target = target;
perf.test_number = 0;
perf.has_described_backend = FALSE;
if (perf.exact_names) {
for (n = 0; n < perf.num_names; n++) {
struct stat st;
if (stat (perf.names[n], &st) == 0) {
if (S_ISDIR (st.st_mode)) {
cairo_perf_trace_dir (&perf, target, perf.names[n]);
} else
cairo_perf_trace (&perf, target, perf.names[n]);
}
}
} else {
int num_traces = 0;
const char *dir;
dir = trace_dir;
do {
char buf[1024];
const char *end = strchr (dir, ':');
if (end != NULL) {
memcpy (buf, dir, end-dir);
buf[end-dir] = '\0';
end++;
dir = buf;
}
num_traces += cairo_perf_trace_dir (&perf, target, dir);
dir = end;
} while (dir != NULL);
if (num_traces == 0) {
warn_no_traces ("Found no traces in", trace_dir);
return 1;
}
}
if (perf.list_only)
break;
}
cairo_perf_fini (&perf);
return 0;
}