isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-11-26 01:50:42 -05:00
Code Issues Packages Projects Releases Wiki Activity

Drop the UProf dependency

Browse Source 
Nobody has been compiling Clutter with profiling enabled in a long time.

UProf itself hasn't been updated in 5 years, and it still depends on
deprecated components like dbus-glib, with no port to GDBus in sight.

The profiling code was moderately useful in the past, but these days
it's probably better to profile Cogl than Clutter itself; timing
information can be extracted by the timestamp on each diagnostic message
that is now available by default in the CLUTTER_NOTE macro, and we can
add ad hoc counters where needed.
This commit is contained in:
Emmanuele Bassi 2015-03-03 17:37:02 +00:00
parent df15f04fc0
commit 253292802c
16 changed files with 4 additions and 810 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
README.in
View File

@ -60,14 +60,6 @@ GObject-Introspection is available from:
git://git.gnome.org/gobject-introspection git://git.gnome.org/gobject-introspection
If you want support for profiling Clutter you will also need:
• UProf ≥ @UPROF_REQ_VERSION@
UProf is available from:
git://github.com/rib/UProf.git
RESOURCES RESOURCES
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
@ -162,10 +154,6 @@ Clutter has additional command line options for the configure script:
Build Clutter with coverage report support, provided by gcov. This Build Clutter with coverage report support, provided by gcov. This
feature only works with the GNU Compiler Suite and gcov installed. feature only works with the GNU Compiler Suite and gcov installed.
--enable-profile=[no/yes]
Build Clutter with profiling instrumentation. Requires the GNU
C Compiler and the UProf library.
--disable-tests --disable-tests
Disable building the Clutter tests suite. Disable building the Clutter tests suite.

4
README.md
View File

@ -40,10 +40,6 @@ If you are building the Introspection data you will also need:
* [GObject-Introspection](http://git.gnome.org/browse/gobject-introspection) * [GObject-Introspection](http://git.gnome.org/browse/gobject-introspection)
If you want support for profiling Clutter you will also need:
* [UProf](git://github.com/rib/UProf.git)
Resources Resources
--------- ---------

5
clutter/Makefile.am
View File

@ -30,7 +30,6 @@ AM_CPPFLAGS = \
-I$(top_builddir)/clutter \ -I$(top_builddir)/clutter \
$(CLUTTER_DEPRECATED_CFLAGS) \ $(CLUTTER_DEPRECATED_CFLAGS) \
$(CLUTTER_DEBUG_CFLAGS) \ $(CLUTTER_DEBUG_CFLAGS) \
$(CLUTTER_PROFILE_CFLAGS) \
$(CLUTTER_HIDDEN_VISIBILITY_CFLAGS) \ $(CLUTTER_HIDDEN_VISIBILITY_CFLAGS) \
$(NULL) $(NULL)
@ -240,7 +239,6 @@ source_h_priv = \
clutter-paint-node-private.h \ clutter-paint-node-private.h \
clutter-paint-volume-private.h \ clutter-paint-volume-private.h \
clutter-private.h \ clutter-private.h \
clutter-profile.h \
clutter-script-private.h \ clutter-script-private.h \
clutter-settings-private.h \ clutter-settings-private.h \
clutter-stage-manager-private.h \ clutter-stage-manager-private.h \
@ -253,7 +251,6 @@ source_c_priv = \
clutter-easing.c \ clutter-easing.c \
clutter-event-translator.c \ clutter-event-translator.c \
clutter-id-pool.c \ clutter-id-pool.c \
clutter-profile.c \
$(NULL) $(NULL)
# deprecated installed headers # deprecated installed headers
@ -844,7 +841,7 @@ clutter_deprecated_HEADERS = $(deprecated_h)
lib_LTLIBRARIES += libclutter-@CLUTTER_API_VERSION@.la lib_LTLIBRARIES += libclutter-@CLUTTER_API_VERSION@.la
libclutter_@CLUTTER_API_VERSION@_la_LIBADD = $(LIBM) $(CLUTTER_LIBS) $(CLUTTER_PROFILE_LIBS) libclutter_@CLUTTER_API_VERSION@_la_LIBADD = $(LIBM) $(CLUTTER_LIBS)
libclutter_@CLUTTER_API_VERSION@_la_DEPENDENCIES = $(win32_resources) libclutter_@CLUTTER_API_VERSION@_la_DEPENDENCIES = $(win32_resources)
libclutter_@CLUTTER_API_VERSION@_la_SOURCES = \ libclutter_@CLUTTER_API_VERSION@_la_SOURCES = \

15
clutter/clutter-actor.c
View File

@ -627,7 +627,6 @@
#include "clutter-paint-node-private.h" #include "clutter-paint-node-private.h"
#include "clutter-paint-volume-private.h" #include "clutter-paint-volume-private.h"
#include "clutter-private.h" #include "clutter-private.h"
#include "clutter-profile.h"
#include "clutter-property-transition.h" #include "clutter-property-transition.h"
#include "clutter-scriptable.h" #include "clutter-scriptable.h"
#include "clutter-script-private.h" #include "clutter-script-private.h"
@ -3676,16 +3675,6 @@ clutter_actor_paint (ClutterActor *self)
gboolean shader_applied = FALSE; gboolean shader_applied = FALSE;
ClutterStage *stage; ClutterStage *stage;
CLUTTER_STATIC_COUNTER (actor_paint_counter,
"Actor real-paint counter",
"Increments each time any actor is painted",
0 /* no application private data */);
CLUTTER_STATIC_COUNTER (actor_pick_counter,
"Actor pick-paint counter",
"Increments each time any actor is painted "
"for picking",
0 /* no application private data */);
g_return_if_fail (CLUTTER_IS_ACTOR (self)); g_return_if_fail (CLUTTER_IS_ACTOR (self));
if (CLUTTER_ACTOR_IN_DESTRUCTION (self)) if (CLUTTER_ACTOR_IN_DESTRUCTION (self))
@ -3796,16 +3785,12 @@ clutter_actor_paint (ClutterActor *self)
if (pick_mode == CLUTTER_PICK_NONE) if (pick_mode == CLUTTER_PICK_NONE)
{ {
CLUTTER_COUNTER_INC (_clutter_uprof_context, actor_paint_counter);
/* We check whether we need to add the flatten effect before /* We check whether we need to add the flatten effect before
each paint so that we can avoid having a mechanism for each paint so that we can avoid having a mechanism for
applications to notify when the value of the applications to notify when the value of the
has_overlaps virtual changes. */ has_overlaps virtual changes. */
add_or_remove_flatten_effect (self); add_or_remove_flatten_effect (self);
} }
else
CLUTTER_COUNTER_INC (_clutter_uprof_context, actor_pick_counter);
/* We save the current paint volume so that the next time the /* We save the current paint volume so that the next time the
* actor queues a redraw we can constrain the redraw to just * actor queues a redraw we can constrain the redraw to just

1
clutter/clutter-backend.c
View File

@ -49,7 +49,6 @@
#include "clutter-event-private.h" #include "clutter-event-private.h"
#include "clutter-marshal.h" #include "clutter-marshal.h"
#include "clutter-private.h" #include "clutter-private.h"
#include "clutter-profile.h"
#include "clutter-stage-manager-private.h" #include "clutter-stage-manager-private.h"
#include "clutter-stage-private.h" #include "clutter-stage-private.h"
#include "clutter-stage-window.h" #include "clutter-stage-window.h"

135
clutter/clutter-main.c
View File

@ -65,7 +65,6 @@
#include "clutter-main.h" #include "clutter-main.h"
#include "clutter-master-clock.h" #include "clutter-master-clock.h"
#include "clutter-private.h" #include "clutter-private.h"
#include "clutter-profile.h"
#include "clutter-settings-private.h" #include "clutter-settings-private.h"
#include "clutter-stage-manager.h" #include "clutter-stage-manager.h"
#include "clutter-stage-private.h" #include "clutter-stage-private.h"
@ -128,9 +127,6 @@ guint clutter_debug_flags = 0;
guint clutter_paint_debug_flags = 0; guint clutter_paint_debug_flags = 0;
guint clutter_pick_debug_flags = 0; guint clutter_pick_debug_flags = 0;
/* profile flags */
guint clutter_profile_flags = 0;
const guint clutter_major_version = CLUTTER_MAJOR_VERSION; const guint clutter_major_version = CLUTTER_MAJOR_VERSION;
const guint clutter_minor_version = CLUTTER_MINOR_VERSION; const guint clutter_minor_version = CLUTTER_MINOR_VERSION;
const guint clutter_micro_version = CLUTTER_MICRO_VERSION; const guint clutter_micro_version = CLUTTER_MICRO_VERSION;
@ -171,13 +167,6 @@ static const GDebugKey clutter_paint_debug_keys[] = {
{ "paint-deform-tiles", CLUTTER_DEBUG_PAINT_DEFORM_TILES }, { "paint-deform-tiles", CLUTTER_DEBUG_PAINT_DEFORM_TILES },
}; };
#ifdef CLUTTER_ENABLE_PROFILE
static const GDebugKey clutter_profile_keys[] = {
{"picking-only", CLUTTER_PROFILE_PICKING_ONLY },
{"disable-report", CLUTTER_PROFILE_DISABLE_REPORT }
};
#endif /* CLUTTER_ENABLE_DEBUG */
static void static void
clutter_threads_impl_lock (void) clutter_threads_impl_lock (void)
{ {
@ -787,28 +776,6 @@ clutter_main_level (void)
return clutter_main_loop_level; return clutter_main_loop_level;
} }
#ifdef CLUTTER_ENABLE_PROFILE
static gint (*prev_poll) (GPollFD *ufds, guint nfsd, gint timeout_) = NULL;
static gint
timed_poll (GPollFD *ufds,
guint nfsd,
gint timeout_)
{
gint ret;
CLUTTER_STATIC_TIMER (poll_timer,
"Mainloop", /* parent */
"Mainloop Idle",
"The time spent idle in poll()",
0 /* no application private data */);
CLUTTER_TIMER_START (uprof_get_mainloop_context (), poll_timer);
ret = prev_poll (ufds, nfsd, timeout_);
CLUTTER_TIMER_STOP (uprof_get_mainloop_context (), poll_timer);
return ret;
}
#endif
/** /**
* clutter_main: * clutter_main:
* *
@ -826,14 +793,6 @@ clutter_main (void)
return; return;
} }
#ifdef CLUTTER_ENABLE_PROFILE
if (!prev_poll)
{
prev_poll = g_main_context_get_poll_func (NULL);
g_main_context_set_poll_func (NULL, timed_poll);
}
#endif
clutter_main_loop_level++; clutter_main_loop_level++;
CLUTTER_NOTE (MISC, "Entering main loop level %d", clutter_main_loop_level); CLUTTER_NOTE (MISC, "Entering main loop level %d", clutter_main_loop_level);
@ -1361,32 +1320,6 @@ clutter_arg_no_debug_cb (const char *key,
} }
#endif /* CLUTTER_ENABLE_DEBUG */ #endif /* CLUTTER_ENABLE_DEBUG */
#ifdef CLUTTER_ENABLE_PROFILE
static gboolean
clutter_arg_profile_cb (const char *key,
const char *value,
gpointer user_data)
{
clutter_profile_flags |=
g_parse_debug_string (value,
clutter_profile_keys,
G_N_ELEMENTS (clutter_profile_keys));
return TRUE;
}
static gboolean
clutter_arg_no_profile_cb (const char *key,
const char *value,
gpointer user_data)
{
clutter_profile_flags &=
~g_parse_debug_string (value,
clutter_profile_keys,
G_N_ELEMENTS (clutter_profile_keys));
return TRUE;
}
#endif /* CLUTTER_ENABLE_PROFILE */
GQuark GQuark
clutter_init_error_quark (void) clutter_init_error_quark (void)
{ {
@ -1399,14 +1332,6 @@ clutter_init_real (GError **error)
ClutterMainContext *ctx; ClutterMainContext *ctx;
ClutterBackend *backend; ClutterBackend *backend;
#ifdef CLUTTER_ENABLE_PROFILE
CLUTTER_STATIC_TIMER (mainloop_timer,
NULL, /* no parent */
"Mainloop",
"The time spent in the clutter mainloop",
0 /* no application private data */);
#endif
/* Note, creates backend if not already existing, though parse args will /* Note, creates backend if not already existing, though parse args will
* have likely created it * have likely created it
*/ */
@ -1453,27 +1378,6 @@ clutter_init_real (GError **error)
if (!_clutter_feature_init (error)) if (!_clutter_feature_init (error))
return CLUTTER_INIT_ERROR_BACKEND; return CLUTTER_INIT_ERROR_BACKEND;
#ifdef CLUTTER_ENABLE_PROFILE
/* We need to be absolutely sure that uprof has been initialized
* before calling _clutter_uprof_init. uprof_init (NULL, NULL)
* will be a NOP if it has been initialized but it will also
* mean subsequent parsing of the UProf GOptionGroup will have no
* affect.
*
* Sadly GOptionGroup based library initialization is extremly
* fragile by design because GOptionGroups have no notion of
* dependencies and our post_parse_hook may be called before
* the cogl or uprof groups get parsed.
*/
uprof_init (NULL, NULL);
_clutter_uprof_init ();
CLUTTER_TIMER_START (uprof_get_mainloop_context (), mainloop_timer);
if (clutter_profile_flags & CLUTTER_PROFILE_PICKING_ONLY)
_clutter_profile_suspend ();
#endif
clutter_text_direction = clutter_get_text_direction (); clutter_text_direction = clutter_get_text_direction ();
/* Initiate event collection */ /* Initiate event collection */
@ -1511,12 +1415,6 @@ static GOptionEntry clutter_args[] = {
{ "clutter-no-debug", 0, 0, G_OPTION_ARG_CALLBACK, clutter_arg_no_debug_cb, { "clutter-no-debug", 0, 0, G_OPTION_ARG_CALLBACK, clutter_arg_no_debug_cb,
N_("Clutter debugging flags to unset"), "FLAGS" }, N_("Clutter debugging flags to unset"), "FLAGS" },
#endif /* CLUTTER_ENABLE_DEBUG */ #endif /* CLUTTER_ENABLE_DEBUG */
#ifdef CLUTTER_ENABLE_PROFILE
{ "clutter-profile", 0, 0, G_OPTION_ARG_CALLBACK, clutter_arg_profile_cb,
N_("Clutter profiling flags to set"), "FLAGS" },
{ "clutter-no-profile", 0, 0, G_OPTION_ARG_CALLBACK, clutter_arg_no_profile_cb,
N_("Clutter profiling flags to unset"), "FLAGS" },
#endif /* CLUTTER_ENABLE_PROFILE */
{ "clutter-enable-accessibility", 0, 0, G_OPTION_ARG_NONE, &clutter_enable_accessibility, { "clutter-enable-accessibility", 0, 0, G_OPTION_ARG_NONE, &clutter_enable_accessibility,
N_("Enable accessibility"), NULL }, N_("Enable accessibility"), NULL },
{ NULL, }, { NULL, },
@ -1566,18 +1464,6 @@ pre_parse_hook (GOptionContext *context,
} }
#endif /* CLUTTER_ENABLE_DEBUG */ #endif /* CLUTTER_ENABLE_DEBUG */
#ifdef CLUTTER_ENABLE_PROFILE
env_string = g_getenv ("CLUTTER_PROFILE");
if (env_string != NULL)
{
clutter_profile_flags =
g_parse_debug_string (env_string,
clutter_profile_keys,
G_N_ELEMENTS (clutter_profile_keys));
env_string = NULL;
}
#endif /* CLUTTER_ENABLE_PROFILE */
env_string = g_getenv ("CLUTTER_PICK"); env_string = g_getenv ("CLUTTER_PICK");
if (env_string != NULL) if (env_string != NULL)
{ {
@ -1831,14 +1717,6 @@ clutter_init_with_args (int *argc,
group = cogl_get_option_group (); group = cogl_get_option_group ();
g_option_context_add_group (context, group); g_option_context_add_group (context, group);
/* Note: That due to the implementation details of glib's goption
* parsing; cogl and uprof will not actually have there arguments
* parsed before the post_parse_hook is called! */
#ifdef CLUTTER_ENABLE_PROFILE
group = uprof_get_option_group ();
g_option_context_add_group (context, group);
#endif
if (entries) if (entries)
g_option_context_add_main_entries (context, entries, translation_domain); g_option_context_add_main_entries (context, entries, translation_domain);
@ -1872,9 +1750,6 @@ clutter_parse_args (int *argc,
{ {
GOptionContext *option_context; GOptionContext *option_context;
GOptionGroup *clutter_group, *cogl_group; GOptionGroup *clutter_group, *cogl_group;
#ifdef CLUTTER_ENABLE_PROFILE
GOptionGroup *uprof_group;
#endif
GError *internal_error = NULL; GError *internal_error = NULL;
gboolean ret = TRUE; gboolean ret = TRUE;
@ -1892,11 +1767,6 @@ clutter_parse_args (int *argc,
cogl_group = cogl_get_option_group (); cogl_group = cogl_get_option_group ();
g_option_context_add_group (option_context, cogl_group); g_option_context_add_group (option_context, cogl_group);
#ifdef CLUTTER_ENABLE_PROFILE
uprof_group = uprof_get_option_group ();
g_option_context_add_group (option_context, uprof_group);
#endif
if (!g_option_context_parse (option_context, argc, argv, &internal_error)) if (!g_option_context_parse (option_context, argc, argv, &internal_error))
{ {
g_propagate_error (error, internal_error); g_propagate_error (error, internal_error);
@ -3850,11 +3720,6 @@ _clutter_debug_messagev (const char *format,
g_logv (G_LOG_DOMAIN, G_LOG_LEVEL_MESSAGE, fmt, var_args); g_logv (G_LOG_DOMAIN, G_LOG_LEVEL_MESSAGE, fmt, var_args);
#ifdef CLUTTER_ENABLE_PROFILE
if (_clutter_uprof_context != NULL)
uprof_context_vtrace_message (_clutter_uprof_context, format, var_args);
#endif
g_free (fmt); g_free (fmt);
} }

31
clutter/clutter-master-clock-default.c
View File

@ -37,7 +37,6 @@
#include "clutter-master-clock-default.h" #include "clutter-master-clock-default.h"
#include "clutter-debug.h" #include "clutter-debug.h"
#include "clutter-private.h" #include "clutter-private.h"
#include "clutter-profile.h"
#include "clutter-stage-manager-private.h" #include "clutter-stage-manager-private.h"
#include "clutter-stage-private.h" #include "clutter-stage-private.h"
@ -354,20 +353,10 @@ master_clock_process_events (ClutterMasterClockDefault *master_clock,
gint64 start = g_get_monotonic_time (); gint64 start = g_get_monotonic_time ();
#endif #endif
CLUTTER_STATIC_TIMER (master_event_process,
"Master Clock",
"Event Processing",
"The time spent processing events on all stages",
0);
CLUTTER_TIMER_START (_clutter_uprof_context, master_event_process);
/* Process queued events */ /* Process queued events */
for (l = stages; l != NULL; l = l->next) for (l = stages; l != NULL; l = l->next)
_clutter_stage_process_queued_events (l->data); _clutter_stage_process_queued_events (l->data);
CLUTTER_TIMER_STOP (_clutter_uprof_context, master_event_process);
#ifdef CLUTTER_ENABLE_DEBUG #ifdef CLUTTER_ENABLE_DEBUG
if (_clutter_diagnostic_enabled ()) if (_clutter_diagnostic_enabled ())
clutter_warn_if_over_budget (master_clock, start, "Event processing"); clutter_warn_if_over_budget (master_clock, start, "Event processing");
@ -392,12 +381,6 @@ master_clock_advance_timelines (ClutterMasterClockDefault *master_clock)
gint64 start = g_get_monotonic_time (); gint64 start = g_get_monotonic_time ();
#endif #endif
CLUTTER_STATIC_TIMER (master_timeline_advance,
"Master Clock",
"Timelines Advancement",
"The time spent advancing all timelines",
0);
/* we protect ourselves from timelines being removed during /* we protect ourselves from timelines being removed during
* the advancement by other timelines by copying the list of * the advancement by other timelines by copying the list of
* timelines, taking a reference on them, iterating over the * timelines, taking a reference on them, iterating over the
@ -421,13 +404,9 @@ master_clock_advance_timelines (ClutterMasterClockDefault *master_clock)
timelines = g_slist_copy (master_clock->timelines); timelines = g_slist_copy (master_clock->timelines);
g_slist_foreach (timelines, (GFunc) g_object_ref, NULL); g_slist_foreach (timelines, (GFunc) g_object_ref, NULL);
CLUTTER_TIMER_START (_clutter_uprof_context, master_timeline_advance);
for (l = timelines; l != NULL; l = l->next) for (l = timelines; l != NULL; l = l->next)
_clutter_timeline_do_tick (l->data, master_clock->cur_tick / 1000); _clutter_timeline_do_tick (l->data, master_clock->cur_tick / 1000);
CLUTTER_TIMER_STOP (_clutter_uprof_context, master_timeline_advance);
g_slist_foreach (timelines, (GFunc) g_object_unref, NULL); g_slist_foreach (timelines, (GFunc) g_object_unref, NULL);
g_slist_free (timelines); g_slist_free (timelines);
@ -548,14 +527,6 @@ clutter_clock_dispatch (GSource *source,
gboolean stages_updated = FALSE; gboolean stages_updated = FALSE;
GSList *stages; GSList *stages;
CLUTTER_STATIC_TIMER (master_dispatch_timer,
"Mainloop",
"Master Clock",
"Master clock dispatch",
0);
CLUTTER_TIMER_START (_clutter_uprof_context, master_dispatch_timer);
CLUTTER_NOTE (SCHEDULER, "Master clock [tick]"); CLUTTER_NOTE (SCHEDULER, "Master clock [tick]");
_clutter_threads_acquire_lock (); _clutter_threads_acquire_lock ();
@ -603,8 +574,6 @@ clutter_clock_dispatch (GSource *source,
_clutter_threads_release_lock (); _clutter_threads_release_lock ();
CLUTTER_TIMER_STOP (_clutter_uprof_context, master_dispatch_timer);
return TRUE; return TRUE;
} }

283
clutter/clutter-profile.c
View File

@ -1,283 +0,0 @@
#ifdef CLUTTER_ENABLE_PROFILE
#include <stdlib.h>
/* XXX - we need this for g_atexit() */
#define G_DISABLE_DEPRECATION_WARNINGS
#include "clutter-profile.h"
UProfContext *_clutter_uprof_context;
static UProfReport *clutter_uprof_report;
static gboolean searched_for_gl_uprof_context = FALSE;
static UProfContext *gl_uprof_context = NULL;
typedef struct _ClutterUProfReportState
{
gulong n_frames;
float fps;
gulong n_picks;
float msecs_picking;
} ClutterUProfReportState;
static char *
timer_per_frame_cb (UProfReport *report,
UProfTimerResult *timer,
void *user_data)
{
ClutterUProfReportState *state = user_data;
int n_frames = state->n_frames ? state->n_frames : 1;
return g_strdup_printf ("%-10.2f",
uprof_timer_result_get_total_msecs (timer) /
(float)n_frames);
}
static char *
counter_per_frame_cb (UProfReport *report,
UProfCounterResult *counter,
void *user_data)
{
ClutterUProfReportState *state = user_data;
int n_frames = state->n_frames ? state->n_frames : 1;
return g_strdup_printf ("%-5ld",
uprof_counter_result_get_count (counter) /
n_frames);
}
static char *
get_n_frames_cb (UProfReport *report,
const char *statistic,
const char *attribute,
void *user_data)
{
ClutterUProfReportState *state = user_data;
return g_strdup_printf ("%lu", state->n_frames);
}
static char *
get_fps_cb (UProfReport *report,
const char *statistic,
const char *attribute,
void *user_data)
{
ClutterUProfReportState *state = user_data;
return g_strdup_printf ("%5.2f\n", state->fps);
}
static char *
get_n_picks_cb (UProfReport *report,
const char *statistic,
const char *attribute,
void *user_data)
{
ClutterUProfReportState *state = user_data;
return g_strdup_printf ("%lu", state->n_picks);
}
static char *
get_picks_per_frame_cb (UProfReport *report,
const char *statistic,
const char *attribute,
void *user_data)
{
ClutterUProfReportState *state = user_data;
int n_frames = state->n_frames ? state->n_frames : 1;
return g_strdup_printf ("%3.2f",
(float)state->n_picks / (float)n_frames);
}
static char *
get_msecs_per_pick_cb (UProfReport *report,
const char *statistic,
const char *attribute,
void *user_data)
{
ClutterUProfReportState *state = user_data;
int n_picks = state->n_picks ? state->n_picks : 1;
return g_strdup_printf ("%3.2f", state->msecs_picking / (float)n_picks);
}
static gboolean
_clutter_uprof_report_prepare (UProfReport *report,
void **closure_ret,
void *user_data)
{
UProfContext *mainloop_context;
UProfTimerResult *mainloop_timer;
UProfTimerResult *stage_paint_timer;
UProfTimerResult *do_pick_timer;
ClutterUProfReportState *state;
/* NB: uprof provides a shared context for mainloop statistics which allows
* this to work even if the application and not Clutter owns the mainloop.
*
* This is the case when running Mutter for example but because Mutter will
* follow the same convention of using the shared context then we can always
* be sure of where to look for the mainloop results. */
mainloop_context = uprof_get_mainloop_context ();
mainloop_timer = uprof_context_get_timer_result (mainloop_context,
"Mainloop");
/* just bail out if the mainloop timer wasn't hit */
if (!mainloop_timer)
return FALSE;
state = g_new0 (ClutterUProfReportState, 1);
*closure_ret = state;
stage_paint_timer = uprof_context_get_timer_result (_clutter_uprof_context,
"Redrawing");
if (stage_paint_timer)
{
state->n_frames = uprof_timer_result_get_start_count (stage_paint_timer);
uprof_report_add_statistic (report,
"Frames",
"Frame count information");
uprof_report_add_statistic_attribute (report, "Frames",
"Count", "Count",
"The total number of frames",
UPROF_ATTRIBUTE_TYPE_INT,
get_n_frames_cb,
state);
state->fps = (float) state->n_frames
/ (uprof_timer_result_get_total_msecs (mainloop_timer)
/ 1000.0);
uprof_report_add_statistic_attribute (report, "Frames",
"Average FPS", "Average\nFPS",
"The average frames per second",
UPROF_ATTRIBUTE_TYPE_FLOAT,
get_fps_cb,
state);
}
do_pick_timer = uprof_context_get_timer_result (_clutter_uprof_context,
"Picking");
if (do_pick_timer)
{
state->n_picks = uprof_timer_result_get_start_count (do_pick_timer);
state->msecs_picking =
uprof_timer_result_get_total_msecs (do_pick_timer);
uprof_report_add_statistic (report,
"Picks",
"Picking information");
uprof_report_add_statistic_attribute (report, "Picks",
"Count", "Count",
"The total number of picks",
UPROF_ATTRIBUTE_TYPE_INT,
get_n_picks_cb,
state);
uprof_report_add_statistic_attribute (report, "Picks",
"Picks Per Frame",
"Picks\nPer Frame",
"The average number of picks "
"per frame",
UPROF_ATTRIBUTE_TYPE_FLOAT,
get_picks_per_frame_cb,
state);
uprof_report_add_statistic_attribute (report, "Picks",
"Msecs Per Pick",
"Msecs\nPer Pick",
"The average number of "
"milliseconds per pick",
UPROF_ATTRIBUTE_TYPE_FLOAT,
get_msecs_per_pick_cb,
state);
}
uprof_report_add_counters_attribute (clutter_uprof_report,
"Per Frame",
"Per Frame",
"The number of counts per frame",
UPROF_ATTRIBUTE_TYPE_INT,
counter_per_frame_cb,
state);
uprof_report_add_timers_attribute (clutter_uprof_report,
"Per Frame\nmsecs",
"Per Frame",
"The time spent in the timer per frame",
UPROF_ATTRIBUTE_TYPE_FLOAT,
timer_per_frame_cb,
state);
return TRUE;
}
static void
_clutter_uprof_report_done (UProfReport *report, void *closure, void *user_data)
{
g_free (closure);
}
static void
print_exit_report (void)
{
if (!(clutter_profile_flags & CLUTTER_PROFILE_DISABLE_REPORT))
uprof_report_print (clutter_uprof_report);
uprof_report_unref (clutter_uprof_report);
uprof_context_unref (_clutter_uprof_context);
}
void
_clutter_uprof_init (void)
{
UProfContext *cogl_context;
_clutter_uprof_context = uprof_context_new ("Clutter");
uprof_context_link (_clutter_uprof_context, uprof_get_mainloop_context ());
g_atexit (print_exit_report);
cogl_context = uprof_find_context ("Cogl");
if (cogl_context)
uprof_context_link (_clutter_uprof_context, cogl_context);
/* We make the report object up-front so we can use uprof-tool
* to fetch reports at runtime via dbus... */
clutter_uprof_report = uprof_report_new ("Clutter report");
uprof_report_add_context (clutter_uprof_report, _clutter_uprof_context);
uprof_report_set_init_fini_callbacks (clutter_uprof_report,
_clutter_uprof_report_prepare,
_clutter_uprof_report_done,
NULL);
}
void
_clutter_profile_suspend (void)
{
if (G_UNLIKELY (!searched_for_gl_uprof_context))
{
gl_uprof_context = uprof_find_context ("OpenGL");
searched_for_gl_uprof_context = TRUE;
}
if (gl_uprof_context)
uprof_context_suspend (gl_uprof_context);
/* NB: The Cogl context is linked to this so it will also be suspended... */
uprof_context_suspend (_clutter_uprof_context);
}
void
_clutter_profile_resume (void)
{
if (gl_uprof_context)
uprof_context_resume (gl_uprof_context);
/* NB: The Cogl context is linked to this so it will also be resumed... */
uprof_context_resume (_clutter_uprof_context);
}
#endif

74
clutter/clutter-profile.h
View File

@ -1,74 +0,0 @@
/*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2009 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __CLUTTER_PROFILE_H__
#define __CLUTTER_PROFILE_H__
#include <glib.h>
G_BEGIN_DECLS
typedef enum {
CLUTTER_PROFILE_PICKING_ONLY = 1 << 0,
CLUTTER_PROFILE_DISABLE_REPORT = 1 << 1
} ClutterProfileFlag;
#ifdef CLUTTER_ENABLE_PROFILE
#include <uprof.h>
extern UProfContext * _clutter_uprof_context;
extern guint clutter_profile_flags;
#define CLUTTER_STATIC_TIMER UPROF_STATIC_TIMER
#define CLUTTER_STATIC_COUNTER UPROF_STATIC_COUNTER
#define CLUTTER_COUNTER_INC UPROF_COUNTER_INC
#define CLUTTER_COUNTER_DEC UPROF_COUNTER_DEC
#define CLUTTER_TIMER_START UPROF_TIMER_START
#define CLUTTER_TIMER_STOP UPROF_TIMER_STOP
void _clutter_uprof_init (void);
void _clutter_profile_suspend (void);
void _clutter_profile_resume (void);
#else /* CLUTTER_ENABLE_PROFILE */
#ifdef __COUNTER__
#define CLUTTER_STATIC_TIMER(A,B,C,D,E) extern void G_PASTE (_clutter_dummy_decl, __COUNTER__) (void)
#define CLUTTER_STATIC_COUNTER(A,B,C,D) extern void G_PASTE (_clutter_dummy_decl, __COUNTER__) (void)
#else
#define CLUTTER_STATIC_TIMER(A,B,C,D,E) extern void G_PASTE (_clutter_dummy_decl, __LINE__) (void)
#define CLUTTER_STATIC_COUNTER(A,B,C,D) extern void G_PASTE (_clutter_dummy_decl, __LINE__) (void)
#endif
#define CLUTTER_COUNTER_INC(A,B) G_STMT_START { } G_STMT_END
#define CLUTTER_COUNTER_DEC(A,B) G_STMT_START { } G_STMT_END
#define CLUTTER_TIMER_START(A,B) G_STMT_START { } G_STMT_END
#define CLUTTER_TIMER_STOP(A,B) G_STMT_START { } G_STMT_END
#define _clutter_uprof_init G_STMT_START { } G_STMT_END
#define _clutter_profile_suspend G_STMT_START { } G_STMT_END
#define _clutter_profile_resume G_STMT_START { } G_STMT_END
#endif /* CLUTTER_ENABLE_PROFILE */
G_END_DECLS
#endif /* _CLUTTER_PROFILE_H_ */

119
clutter/clutter-stage.c
View File

@ -71,7 +71,6 @@
#include "clutter-master-clock.h" #include "clutter-master-clock.h"
#include "clutter-paint-volume-private.h" #include "clutter-paint-volume-private.h"
#include "clutter-private.h" #include "clutter-private.h"
#include "clutter-profile.h"
#include "clutter-stage-manager-private.h" #include "clutter-stage-manager-private.h"
#include "clutter-stage-private.h" #include "clutter-stage-private.h"
#include "clutter-version.h" /* For flavour */ #include "clutter-version.h" /* For flavour */
@ -705,56 +704,6 @@ clutter_stage_paint (ClutterActor *self)
clutter_actor_paint (child); clutter_actor_paint (child);
} }
#if 0
/* the Stage is cleared in clutter_actor_paint_node() */
static void
clutter_stage_paint (ClutterActor *self)
{
ClutterStagePrivate *priv = CLUTTER_STAGE (self)->priv;
CoglBufferBit clear_flags;
ClutterColor bg_color;
CoglColor stage_color;
ClutterActorIter iter;
ClutterActor *child;
guint8 real_alpha;
CLUTTER_STATIC_TIMER (stage_clear_timer,
"Painting actors", /* parent */
"Stage clear",
"The time spent clearing the stage",
0 /* no application private data */);
CLUTTER_NOTE (PAINT, "Initializing stage paint");
/* composite the opacity to the stage color */
clutter_actor_get_background_color (self, &bg_color);
real_alpha = clutter_actor_get_opacity (self)
* bg_color.alpha
/ 255;
clear_flags = COGL_BUFFER_BIT_DEPTH;
if (!STAGE_NO_CLEAR_ON_PAINT (self))
clear_flags |= COGL_BUFFER_BIT_COLOR;
CLUTTER_TIMER_START (_clutter_uprof_context, stage_clear_timer);
/* we use the real alpha to clear the stage if :use-alpha is
* set; the effect depends entirely on the Clutter backend
*/
cogl_color_init_from_4ub (&stage_color,
bg_color.red,
bg_color.green,
bg_color.blue,
priv->use_alpha ? real_alpha : 255);
cogl_color_premultiply (&stage_color);
cogl_clear (&stage_color, clear_flags);
CLUTTER_TIMER_STOP (_clutter_uprof_context, stage_clear_timer);
clutter_actor_iter_init (&iter, self);
while (clutter_actor_iter_next (&iter, &child))
clutter_actor_paint (child);
}
#endif
static void static void
clutter_stage_pick (ClutterActor *self, clutter_stage_pick (ClutterActor *self,
const ClutterColor *color) const ClutterColor *color)
@ -1117,11 +1066,6 @@ _clutter_stage_maybe_relayout (ClutterActor *actor)
ClutterStagePrivate *priv = stage->priv; ClutterStagePrivate *priv = stage->priv;
gfloat natural_width, natural_height; gfloat natural_width, natural_height;
ClutterActorBox box = { 0, }; ClutterActorBox box = { 0, };
CLUTTER_STATIC_TIMER (relayout_timer,
"Mainloop", /* no parent */
"Layouting",
"The time spent reallocating the stage",
0 /* no application private data */);
if (!priv->relayout_pending) if (!priv->relayout_pending)
return; return;
@ -1131,7 +1075,6 @@ _clutter_stage_maybe_relayout (ClutterActor *actor)
{ {
priv->relayout_pending = FALSE; priv->relayout_pending = FALSE;
CLUTTER_TIMER_START (_clutter_uprof_context, relayout_timer);
CLUTTER_NOTE (ACTOR, "Recomputing layout"); CLUTTER_NOTE (ACTOR, "Recomputing layout");
CLUTTER_SET_PRIVATE_FLAGS (stage, CLUTTER_IN_RELAYOUT); CLUTTER_SET_PRIVATE_FLAGS (stage, CLUTTER_IN_RELAYOUT);
@ -1154,7 +1097,6 @@ _clutter_stage_maybe_relayout (ClutterActor *actor)
&box, CLUTTER_ALLOCATION_NONE); &box, CLUTTER_ALLOCATION_NONE);
CLUTTER_UNSET_PRIVATE_FLAGS (stage, CLUTTER_IN_RELAYOUT); CLUTTER_UNSET_PRIVATE_FLAGS (stage, CLUTTER_IN_RELAYOUT);
CLUTTER_TIMER_STOP (_clutter_uprof_context, relayout_timer);
} }
} }
@ -1165,16 +1107,6 @@ clutter_stage_do_redraw (ClutterStage *stage)
ClutterActor *actor = CLUTTER_ACTOR (stage); ClutterActor *actor = CLUTTER_ACTOR (stage);
ClutterStagePrivate *priv = stage->priv; ClutterStagePrivate *priv = stage->priv;
CLUTTER_STATIC_COUNTER (redraw_counter,
"clutter_stage_do_redraw counter",
"Increments for each Stage redraw",
0 /* no application private data */);
CLUTTER_STATIC_TIMER (redraw_timer,
"Master Clock", /* parent */
"Redrawing",
"The time spent redrawing everything",
0 /* no application private data */);
if (CLUTTER_ACTOR_IN_DESTRUCTION (stage)) if (CLUTTER_ACTOR_IN_DESTRUCTION (stage))
return; return;
@ -1195,13 +1127,8 @@ clutter_stage_do_redraw (ClutterStage *stage)
_clutter_stage_maybe_setup_viewport (stage); _clutter_stage_maybe_setup_viewport (stage);
CLUTTER_COUNTER_INC (_clutter_uprof_context, redraw_counter);
CLUTTER_TIMER_START (_clutter_uprof_context, redraw_timer);
_clutter_stage_window_redraw (priv->impl); _clutter_stage_window_redraw (priv->impl);
CLUTTER_TIMER_STOP (_clutter_uprof_context, redraw_timer);
if (_clutter_context_get_show_fps ()) if (_clutter_context_get_show_fps ())
{ {
priv->timer_n_frames += 1; priv->timer_n_frames += 1;
@ -1462,31 +1389,6 @@ _clutter_stage_do_pick (ClutterStage *stage,
float stage_width, stage_height; float stage_width, stage_height;
int window_scale; int window_scale;
CLUTTER_STATIC_COUNTER (do_pick_counter,
"_clutter_stage_do_pick counter",
"Increments for each full pick run",
0 /* no application private data */);
CLUTTER_STATIC_TIMER (pick_timer,
"Mainloop", /* parent */
"Picking",
"The time spent picking",
0 /* no application private data */);
CLUTTER_STATIC_TIMER (pick_clear,
"Picking", /* parent */
"Stage clear (pick)",
"The time spent clearing stage for picking",
0 /* no application private data */);
CLUTTER_STATIC_TIMER (pick_paint,
"Picking", /* parent */
"Painting actors (pick mode)",
"The time spent painting actors in pick mode",
0 /* no application private data */);
CLUTTER_STATIC_TIMER (pick_read,
"Picking", /* parent */
"Read Pixels",
"The time spent issuing a read pixels",
0 /* no application private data */);
priv = stage->priv; priv = stage->priv;
if (CLUTTER_ACTOR_IN_DESTRUCTION (stage)) if (CLUTTER_ACTOR_IN_DESTRUCTION (stage))
@ -1502,14 +1404,6 @@ _clutter_stage_do_pick (ClutterStage *stage,
if (x < 0 || x >= stage_width || y < 0 || y >= stage_height) if (x < 0 || x >= stage_width || y < 0 || y >= stage_height)
return actor; return actor;
#ifdef CLUTTER_ENABLE_PROFILE
if (clutter_profile_flags & CLUTTER_PROFILE_PICKING_ONLY)
_clutter_profile_resume ();
#endif /* CLUTTER_ENABLE_PROFILE */
CLUTTER_COUNTER_INC (_clutter_uprof_context, do_pick_counter);
CLUTTER_TIMER_START (_clutter_uprof_context, pick_timer);
context = _clutter_context_get_default (); context = _clutter_context_get_default ();
clutter_stage_ensure_current (stage); clutter_stage_ensure_current (stage);
window_scale = _clutter_stage_window_get_scale_factor (priv->impl); window_scale = _clutter_stage_window_get_scale_factor (priv->impl);
@ -1536,10 +1430,8 @@ _clutter_stage_do_pick (ClutterStage *stage,
CLUTTER_NOTE (PICK, "Performing pick at %i,%i", x, y); CLUTTER_NOTE (PICK, "Performing pick at %i,%i", x, y);
CLUTTER_TIMER_START (_clutter_uprof_context, pick_clear);
cogl_color_init_from_4ub (&stage_pick_id, 255, 255, 255, 255); cogl_color_init_from_4ub (&stage_pick_id, 255, 255, 255, 255);
cogl_clear (&stage_pick_id, COGL_BUFFER_BIT_COLOR | COGL_BUFFER_BIT_DEPTH); cogl_clear (&stage_pick_id, COGL_BUFFER_BIT_COLOR | COGL_BUFFER_BIT_DEPTH);
CLUTTER_TIMER_STOP (_clutter_uprof_context, pick_clear);
/* Disable dithering (if any) when doing the painting in pick mode */ /* Disable dithering (if any) when doing the painting in pick mode */
dither_enabled_save = cogl_framebuffer_get_dither_enabled (fb); dither_enabled_save = cogl_framebuffer_get_dither_enabled (fb);
@ -1548,11 +1440,9 @@ _clutter_stage_do_pick (ClutterStage *stage,
/* Render the entire scence in pick mode - just single colored silhouette's /* Render the entire scence in pick mode - just single colored silhouette's
* are drawn offscreen (as we never swap buffers) * are drawn offscreen (as we never swap buffers)
*/ */
CLUTTER_TIMER_START (_clutter_uprof_context, pick_paint);
context->pick_mode = mode; context->pick_mode = mode;
_clutter_stage_do_paint (stage, NULL); _clutter_stage_do_paint (stage, NULL);
context->pick_mode = CLUTTER_PICK_NONE; context->pick_mode = CLUTTER_PICK_NONE;
CLUTTER_TIMER_STOP (_clutter_uprof_context, pick_paint);
/* Read the color of the screen co-ords pixel. RGBA_8888_PRE is used /* Read the color of the screen co-ords pixel. RGBA_8888_PRE is used
even though we don't care about the alpha component because under even though we don't care about the alpha component because under
@ -1561,12 +1451,10 @@ _clutter_stage_do_pick (ClutterStage *stage,
used. The format is requested as pre-multiplied because Cogl used. The format is requested as pre-multiplied because Cogl
assumes that all pixels in the framebuffer are premultiplied so assumes that all pixels in the framebuffer are premultiplied so
it avoids a conversion. */ it avoids a conversion. */
CLUTTER_TIMER_START (_clutter_uprof_context, pick_read);
cogl_read_pixels (read_x, read_y, 1, 1, cogl_read_pixels (read_x, read_y, 1, 1,
COGL_READ_PIXELS_COLOR_BUFFER, COGL_READ_PIXELS_COLOR_BUFFER,
COGL_PIXEL_FORMAT_RGBA_8888_PRE, COGL_PIXEL_FORMAT_RGBA_8888_PRE,
pixel); pixel);
CLUTTER_TIMER_STOP (_clutter_uprof_context, pick_read);
if (G_UNLIKELY (clutter_pick_debug_flags & CLUTTER_DEBUG_DUMP_PICK_BUFFERS)) if (G_UNLIKELY (clutter_pick_debug_flags & CLUTTER_DEBUG_DUMP_PICK_BUFFERS))
{ {
@ -1597,13 +1485,6 @@ _clutter_stage_do_pick (ClutterStage *stage,
retval = _clutter_stage_get_actor_by_pick_id (stage, id_); retval = _clutter_stage_get_actor_by_pick_id (stage, id_);
} }
CLUTTER_TIMER_STOP (_clutter_uprof_context, pick_timer);
#ifdef CLUTTER_ENABLE_PROFILE
if (clutter_profile_flags & CLUTTER_PROFILE_PICKING_ONLY)
_clutter_profile_suspend ();
#endif
return retval; return retval;
} }

28
clutter/clutter-text.c
View File

@ -58,7 +58,6 @@
#include "clutter-main.h" #include "clutter-main.h"
#include "clutter-marshal.h" #include "clutter-marshal.h"
#include "clutter-private.h" /* includes <cogl-pango/cogl-pango.h> */ #include "clutter-private.h" /* includes <cogl-pango/cogl-pango.h> */
#include "clutter-profile.h"
#include "clutter-property-transition.h" #include "clutter-property-transition.h"
#include "clutter-text-buffer.h" #include "clutter-text-buffer.h"
#include "clutter-units.h" #include "clutter-units.h"
@ -488,14 +487,6 @@ clutter_text_create_layout_no_cache (ClutterText *text,
gchar *contents; gchar *contents;
gsize contents_len; gsize contents_len;
CLUTTER_STATIC_TIMER (text_layout_timer,
"Mainloop",
"Text Layout",
"Layout creation",
0);
CLUTTER_TIMER_START (_clutter_uprof_context, text_layout_timer);
layout = clutter_actor_create_pango_layout (CLUTTER_ACTOR (text), NULL); layout = clutter_actor_create_pango_layout (CLUTTER_ACTOR (text), NULL);
pango_layout_set_font_description (layout, priv->font_desc); pango_layout_set_font_description (layout, priv->font_desc);
@ -581,8 +572,6 @@ clutter_text_create_layout_no_cache (ClutterText *text,
g_free (contents); g_free (contents);
CLUTTER_TIMER_STOP (_clutter_uprof_context, text_layout_timer);
return layout; return layout;
} }
@ -716,15 +705,6 @@ clutter_text_create_layout (ClutterText *text,
PangoEllipsizeMode ellipsize = PANGO_ELLIPSIZE_NONE; PangoEllipsizeMode ellipsize = PANGO_ELLIPSIZE_NONE;
int i; int i;
CLUTTER_STATIC_COUNTER (text_cache_hit_counter,
"Text layout cache hit counter",
"Increments for each layout cache hit",
0);
CLUTTER_STATIC_COUNTER (text_cache_miss_counter,
"Text layout cache miss counter",
"Increments for each layout cache miss",
0);
/* First determine the width, height, and ellipsize mode that /* First determine the width, height, and ellipsize mode that
* we need for the layout. The ellipsize mode depends on * we need for the layout. The ellipsize mode depends on
* allocation_width/allocation_size as follows: * allocation_width/allocation_size as follows:
@ -819,9 +799,6 @@ clutter_text_create_layout (ClutterText *text,
allocation_width, allocation_width,
allocation_height); allocation_height);
CLUTTER_COUNTER_INC (_clutter_uprof_context,
text_cache_hit_counter);
return priv->cached_layouts[i].layout; return priv->cached_layouts[i].layout;
} }
@ -853,9 +830,6 @@ clutter_text_create_layout (ClutterText *text,
allocation_width, allocation_width,
allocation_height); allocation_height);
CLUTTER_COUNTER_INC (_clutter_uprof_context,
text_cache_hit_counter);
return priv->cached_layouts[i].layout; return priv->cached_layouts[i].layout;
} }
} }
@ -873,8 +847,6 @@ clutter_text_create_layout (ClutterText *text,
allocation_width, allocation_width,
allocation_height); allocation_height);
CLUTTER_COUNTER_INC (_clutter_uprof_context, text_cache_miss_counter);
/* If we make it here then we didn't have a cached version so we /* If we make it here then we didn't have a cached version so we
need to recreate the layout */ need to recreate the layout */
if (oldest_cache->layout) if (oldest_cache->layout)

27
clutter/cogl/clutter-stage-cogl.c
View File

@ -44,7 +44,6 @@
#include "clutter-feature.h" #include "clutter-feature.h"
#include "clutter-main.h" #include "clutter-main.h"
#include "clutter-private.h" #include "clutter-private.h"
#include "clutter-profile.h"
#include "clutter-stage-private.h" #include "clutter-stage-private.h"
static void clutter_stage_window_iface_init (ClutterStageWindowIface *iface); static void clutter_stage_window_iface_init (ClutterStageWindowIface *iface);
@ -409,29 +408,11 @@ clutter_stage_cogl_redraw (ClutterStageWindow *stage_window)
gboolean force_swap; gboolean force_swap;
int window_scale; int window_scale;
CLUTTER_STATIC_TIMER (painting_timer,
"Redrawing", /* parent */
"Painting actors",
"The time spent painting actors",
0 /* no application private data */);
CLUTTER_STATIC_TIMER (swapbuffers_timer,
"Redrawing", /* parent */
"SwapBuffers",
"The time spent blocked by SwapBuffers",
0 /* no application private data */);
CLUTTER_STATIC_TIMER (blit_sub_buffer_timer,
"Redrawing", /* parent */
"blit_sub_buffer",
"The time spent in blit_sub_buffer",
0 /* no application private data */);
wrapper = CLUTTER_ACTOR (stage_cogl->wrapper); wrapper = CLUTTER_ACTOR (stage_cogl->wrapper);
if (!stage_cogl->onscreen) if (!stage_cogl->onscreen)
return; return;
CLUTTER_TIMER_START (_clutter_uprof_context, painting_timer);
can_blit_sub_buffer = can_blit_sub_buffer =
cogl_clutter_winsys_has_feature (COGL_WINSYS_FEATURE_SWAP_REGION); cogl_clutter_winsys_has_feature (COGL_WINSYS_FEATURE_SWAP_REGION);
@ -610,8 +591,6 @@ clutter_stage_cogl_redraw (ClutterStageWindow *stage_window)
cogl_object_unref (prim); cogl_object_unref (prim);
} }
CLUTTER_TIMER_STOP (_clutter_uprof_context, painting_timer);
/* push on the screen */ /* push on the screen */
if (use_clipped_redraw && !force_swap) if (use_clipped_redraw && !force_swap)
{ {
@ -640,11 +619,7 @@ clutter_stage_cogl_redraw (ClutterStageWindow *stage_window)
copy_area[0], copy_area[1], copy_area[2], copy_area[3]); copy_area[0], copy_area[1], copy_area[2], copy_area[3]);
CLUTTER_TIMER_START (_clutter_uprof_context, blit_sub_buffer_timer);
cogl_onscreen_swap_region (stage_cogl->onscreen, copy_area, 1); cogl_onscreen_swap_region (stage_cogl->onscreen, copy_area, 1);
CLUTTER_TIMER_STOP (_clutter_uprof_context, blit_sub_buffer_timer);
} }
else else
{ {
@ -657,9 +632,7 @@ clutter_stage_cogl_redraw (ClutterStageWindow *stage_window)
if (clutter_feature_available (CLUTTER_FEATURE_SWAP_EVENTS)) if (clutter_feature_available (CLUTTER_FEATURE_SWAP_EVENTS))
stage_cogl->pending_swaps++; stage_cogl->pending_swaps++;
CLUTTER_TIMER_START (_clutter_uprof_context, swapbuffers_timer);
cogl_onscreen_swap_buffers (stage_cogl->onscreen); cogl_onscreen_swap_buffers (stage_cogl->onscreen);
CLUTTER_TIMER_STOP (_clutter_uprof_context, swapbuffers_timer);
} }
/* reset the redraw clipping for the next paint... */ /* reset the redraw clipping for the next paint... */

31
clutter/gdk/clutter-master-clock-gdk.c
View File

@ -40,7 +40,6 @@
#include "clutter-stage-gdk.h" #include "clutter-stage-gdk.h"
#include "clutter-debug.h" #include "clutter-debug.h"
#include "clutter-private.h" #include "clutter-private.h"
#include "clutter-profile.h"
#include "clutter-stage-manager-private.h" #include "clutter-stage-manager-private.h"
#include "clutter-stage-private.h" #include "clutter-stage-private.h"
@ -139,19 +138,9 @@ master_clock_process_stage_events (ClutterMasterClockGdk *master_clock,
gint64 start = g_get_monotonic_time (); gint64 start = g_get_monotonic_time ();
#endif #endif
CLUTTER_STATIC_TIMER (master_event_process,
"Master Clock",
"Event Processing",
"The time spent processing events on all stages",
0);
CLUTTER_TIMER_START (_clutter_uprof_context, master_event_process);
/* Process queued events */ /* Process queued events */
_clutter_stage_process_queued_events (stage); _clutter_stage_process_queued_events (stage);
CLUTTER_TIMER_STOP (_clutter_uprof_context, master_event_process);
#ifdef CLUTTER_ENABLE_DEBUG #ifdef CLUTTER_ENABLE_DEBUG
if (_clutter_diagnostic_enabled ()) if (_clutter_diagnostic_enabled ())
clutter_warn_if_over_budget (master_clock, start, "Event processing"); clutter_warn_if_over_budget (master_clock, start, "Event processing");
@ -176,12 +165,6 @@ master_clock_advance_timelines (ClutterMasterClockGdk *master_clock)
gint64 start = g_get_monotonic_time (); gint64 start = g_get_monotonic_time ();
#endif #endif
CLUTTER_STATIC_TIMER (master_timeline_advance,
"Master Clock",
"Timelines Advancement",
"The time spent advancing all timelines",
0);
/* we protect ourselves from timelines being removed during /* we protect ourselves from timelines being removed during
* the advancement by other timelines by copying the list of * the advancement by other timelines by copying the list of
* timelines, taking a reference on them, iterating over the * timelines, taking a reference on them, iterating over the
@ -205,13 +188,9 @@ master_clock_advance_timelines (ClutterMasterClockGdk *master_clock)
timelines = g_slist_copy (master_clock->timelines); timelines = g_slist_copy (master_clock->timelines);
g_slist_foreach (timelines, (GFunc) g_object_ref, NULL); g_slist_foreach (timelines, (GFunc) g_object_ref, NULL);
CLUTTER_TIMER_START (_clutter_uprof_context, master_timeline_advance);
for (l = timelines; l != NULL; l = l->next) for (l = timelines; l != NULL; l = l->next)
_clutter_timeline_do_tick (l->data, master_clock->cur_tick / 1000); _clutter_timeline_do_tick (l->data, master_clock->cur_tick / 1000);
CLUTTER_TIMER_STOP (_clutter_uprof_context, master_timeline_advance);
g_slist_foreach (timelines, (GFunc) g_object_unref, NULL); g_slist_foreach (timelines, (GFunc) g_object_unref, NULL);
g_slist_free (timelines); g_slist_free (timelines);
@ -257,14 +236,6 @@ clutter_master_clock_gdk_update (GdkFrameClock *frame_clock,
{ {
ClutterStage *stage; ClutterStage *stage;
CLUTTER_STATIC_TIMER (master_dispatch_timer,
"Mainloop",
"Master Clock",
"Master clock dispatch",
0);
CLUTTER_TIMER_START (_clutter_uprof_context, master_dispatch_timer);
CLUTTER_NOTE (SCHEDULER, "Master clock [tick]"); CLUTTER_NOTE (SCHEDULER, "Master clock [tick]");
_clutter_threads_acquire_lock (); _clutter_threads_acquire_lock ();
@ -301,8 +272,6 @@ clutter_master_clock_gdk_update (GdkFrameClock *frame_clock,
master_clock->prev_tick = master_clock->cur_tick; master_clock->prev_tick = master_clock->cur_tick;
_clutter_threads_release_lock (); _clutter_threads_release_lock ();
CLUTTER_TIMER_STOP (_clutter_uprof_context, master_dispatch_timer);
} }
static void static void

45
configure.ac
View File

@ -143,7 +143,6 @@ m4_define([atk_req_version], [2.5.3])
m4_define([cairo_req_version], [1.14.0]) m4_define([cairo_req_version], [1.14.0])
m4_define([pango_req_version], [1.30]) m4_define([pango_req_version], [1.30])
m4_define([gi_req_version], [1.39.0]) m4_define([gi_req_version], [1.39.0])
m4_define([uprof_req_version], [0.3])
m4_define([gtk_doc_req_version], [1.20]) m4_define([gtk_doc_req_version], [1.20])
m4_define([xcomposite_req_version], [0.4]) m4_define([xcomposite_req_version], [0.4])
m4_define([gdk_req_version], [3.3.18]) m4_define([gdk_req_version], [3.3.18])
@ -157,7 +156,6 @@ AC_SUBST([ATK_REQ_VERSION], [atk_req_version])
AC_SUBST([CAIRO_REQ_VERSION], [cairo_req_version]) AC_SUBST([CAIRO_REQ_VERSION], [cairo_req_version])
AC_SUBST([PANGO_REQ_VERSION], [pango_req_version]) AC_SUBST([PANGO_REQ_VERSION], [pango_req_version])
AC_SUBST([GI_REQ_VERSION], [gi_req_version]) AC_SUBST([GI_REQ_VERSION], [gi_req_version])
AC_SUBST([UPROF_REQ_VERSION], [uprof_req_version])
AC_SUBST([GTK_DOC_REQ_VERSION], [gtk_doc_req_version]) AC_SUBST([GTK_DOC_REQ_VERSION], [gtk_doc_req_version])
AC_SUBST([XCOMPOSITE_REQ_VERSION], [xcomposite_req_version]) AC_SUBST([XCOMPOSITE_REQ_VERSION], [xcomposite_req_version])
AC_SUBST([GDK_REQ_VERSION], [gdk_req_version]) AC_SUBST([GDK_REQ_VERSION], [gdk_req_version])
@ -930,44 +928,6 @@ AS_CASE([$enable_deprecated],
AC_SUBST([CLUTTER_DEPRECATED_CFLAGS]) AC_SUBST([CLUTTER_DEPRECATED_CFLAGS])
dnl === Profiling =============================================================
m4_define([profile_default], [no])
AC_ARG_ENABLE(profile,
AS_HELP_STRING([--enable-profile=@<:@no/yes@:>@],
[Turn on profiling support. yes; All profiling probe points are compiled in and may be runtime enabled. no; No profiling support will built into clutter. @<:@default=no@:>@]),
[],
[enable_profile=profile_default])
AS_CASE([$enable_profile],
[yes],
[
AS_IF([test "x$GCC" = "xyes"],
[
PKG_CHECK_MODULES([PROFILE_DEP], [uprof-0.3])
CLUTTER_PROFILE_CFLAGS="-DCLUTTER_ENABLE_PROFILE $PROFILE_DEP_CFLAGS"
CLUTTER_PROFILE_LDFLAGS="$PROFILE_DEP_LIBS"
AS_IF([test "x$enable_debug" = "xyes"], [CLUTTER_PROFILE_CFLAGS+=" -DUPROF_DEBUG"])
],
[
AC_MSG_ERROR([--enable-profile is currently only supported if using GCC])
])
],
[no],
[
CLUTTER_PROFILE_CFLAGS=""
CLUTTER_PROFILE_LDFLAGS=""
],
[*], [AC_MSG_ERROR([Invalid value for --enable-profile])]
)
AM_CONDITIONAL(PROFILE, test "x$enable_profile" != "xno")
AC_SUBST(CLUTTER_PROFILE_CFLAGS)
AC_SUBST(CLUTTER_PROFILE_LDFLAGS)
dnl === Enable strict compiler flags ========================================== dnl === Enable strict compiler flags ==========================================
# use strict compiler flags only when building from git; the rules for # use strict compiler flags only when building from git; the rules for
@ -1043,8 +1003,8 @@ AS_IF([test "x$CLUTTER_BASE_PC_FILES_PRIVATE" = "x" && test "x$BACKEND_PC_FILES_
AC_SUBST(CLUTTER_REQUIRES) AC_SUBST(CLUTTER_REQUIRES)
AC_SUBST(CLUTTER_REQUIRES_PRIVATE) AC_SUBST(CLUTTER_REQUIRES_PRIVATE)
CLUTTER_CFLAGS="$FLAVOUR_CFLAGS $CLUTTER_DEPS_CFLAGS $CLUTTER_DEPS_PRIVATE_CFLAGS $CLUTTER_PROFILE_CFLAGS $GLIB_CFLAGS" CLUTTER_CFLAGS="$FLAVOUR_CFLAGS $CLUTTER_DEPS_CFLAGS $CLUTTER_DEPS_PRIVATE_CFLAGS $GLIB_CFLAGS"
CLUTTER_LIBS="$FLAVOUR_LIBS $CLUTTER_DEPS_LIBS $CLUTTER_DEPS_PRIVATE_LIBS $CLUTTER_PROFILE_LDFLAGS $GLIB_LIBS" CLUTTER_LIBS="$FLAVOUR_LIBS $CLUTTER_DEPS_LIBS $CLUTTER_DEPS_PRIVATE_LIBS $GLIB_LIBS"
AC_SUBST(CLUTTER_CFLAGS) AC_SUBST(CLUTTER_CFLAGS)
AC_SUBST(CLUTTER_LIBS) AC_SUBST(CLUTTER_LIBS)
@ -1272,7 +1232,6 @@ echo ""
echo " • Compiler options:" echo " • Compiler options:"
echo " Clutter debug level: ${enable_debug}" echo " Clutter debug level: ${enable_debug}"
echo " Compiler flags: ${CFLAGS} ${MAINTAINER_CFLAGS}" echo " Compiler flags: ${CFLAGS} ${MAINTAINER_CFLAGS}"
echo " Profiling enabled: ${enable_profile}"
echo " Enable coverage tests: ${use_gcov}" echo " Enable coverage tests: ${use_gcov}"
echo " Enable deprecated symbols: ${enable_deprecated}" echo " Enable deprecated symbols: ${enable_deprecated}"

1
doc/reference/clutter/Makefile.am
View File

@ -93,7 +93,6 @@ IGNORE_HFILES = \
clutter-paint-node-private.h \ clutter-paint-node-private.h \
clutter-paint-volume-private.h \ clutter-paint-volume-private.h \
clutter-private.h \ clutter-private.h \
clutter-profile.h \
clutter-script-private.h \ clutter-script-private.h \
clutter-settings-private.h \ clutter-settings-private.h \
clutter-stage-manager-private.h \ clutter-stage-manager-private.h \

3
tests/conform/Makefile.am
View File

@ -9,8 +9,7 @@ AM_CPPFLAGS = \
-I$(top_builddir) \ -I$(top_builddir) \
-DCOGL_DISABLE_DEPRECATION_WARNINGS \ -DCOGL_DISABLE_DEPRECATION_WARNINGS \
$(CLUTTER_DEPRECATED_CFLAGS) \ $(CLUTTER_DEPRECATED_CFLAGS) \
$(CLUTTER_DEBUG_CFLAGS) \ $(CLUTTER_DEBUG_CFLAGS)
$(CLUTTER_PROFILE_CFLAGS)
# Basic actor API # Basic actor API
actor_tests = \ actor_tests = \