sungmg/mutter-performance-source
1
0
Fork 0
Code Activity
mutter-performance-source/clutter/clutter-master-clock.c

742 lines
22 KiB
C
Raw Normal View History

Use a single master "clock" to drive timelines Currently, all timelines install a timeout inside the TimeoutPool they share. Every time the main loop spins, all the timeouts are updated. This, in turn, will usually lead to redraws being queued on the stages. This behaviour leads to the potential starvation of timelines and to excessive redraws. One lesson learned from the games developers is that the scenegraph should be prepared in its entirety before the GL paint sequence is initiated. This means making sure that every ::new-frame signal handler is called before clutter_redraw() is invoked. In order to do so a TimeoutPool is not enough: we need a master clock. The clock will be responsible for advancing all the active timelines created inside a scene, but only when the stage is being redrawn. The sequence is: + queue_redraw() is invoked on an actor and bubbles up to the stage + if no redraw() has already been scheduled, install an idle handler with a known priority + inside the idle handler: - advance the master clock, which will in turn advance every playing timeline by the amount of milliseconds elapsed since the last redraw; this will make every playing timeline emit the ::new-frame signal - queue a relayout - call the redraw() method of the backend This way we trade multiple timeouts with a single frame source that only runs if a timeline is playing and queues redraws on the various stages.
2009-03-21 20:39:32 +00:00
/*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Authored By: Emmanuele Bassi <ebassi@linux.intel.com>
*
* 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/>.
*/
/*
* SECTION:clutter-master-clock
* @short_description: The master clock for all animations
*
* The #ClutterMasterClock class is responsible for advancing all
* #ClutterTimelines when a stage is being redrawn. The master clock
* makes sure that the scenegraph is always integrally updated before
* painting it.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "clutter-master-clock.h"
#include "clutter-debug.h"
#include "clutter-private.h"
master-clock: Add profiling timers Use the newly-added profiling timers inside the master clock dispatch function to see how much time we spend: • in the whole function • in the event processing for each stage • in the timeline advancement
2010-01-14 12:28:07 +00:00
#include "clutter-profile.h"
Clean up clutter-private.h/6 Move all Actor private API to a separate file.
2010-10-21 11:16:05 +00:00
#include "clutter-stage-manager-private.h"
Clean up clutter-private.h/3 Move Stage private API to a separate header.
2010-10-21 10:29:09 +00:00
#include "clutter-stage-private.h"
Use a single master "clock" to drive timelines Currently, all timelines install a timeout inside the TimeoutPool they share. Every time the main loop spins, all the timeouts are updated. This, in turn, will usually lead to redraws being queued on the stages. This behaviour leads to the potential starvation of timelines and to excessive redraws. One lesson learned from the games developers is that the scenegraph should be prepared in its entirety before the GL paint sequence is initiated. This means making sure that every ::new-frame signal handler is called before clutter_redraw() is invoked. In order to do so a TimeoutPool is not enough: we need a master clock. The clock will be responsible for advancing all the active timelines created inside a scene, but only when the stage is being redrawn. The sequence is: + queue_redraw() is invoked on an actor and bubbles up to the stage + if no redraw() has already been scheduled, install an idle handler with a known priority + inside the idle handler: - advance the master clock, which will in turn advance every playing timeline by the amount of milliseconds elapsed since the last redraw; this will make every playing timeline emit the ::new-frame signal - queue a relayout - call the redraw() method of the backend This way we trade multiple timeouts with a single frame source that only runs if a timeline is playing and queues redraws on the various stages.
2009-03-21 20:39:32 +00:00
#define CLUTTER_MASTER_CLOCK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), CLUTTER_TYPE_MASTER_CLOCK, ClutterMasterClockClass))
#define CLUTTER_IS_MASTER_CLOCK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), CLUTTER_TYPE_MASTER_CLOCK))
#define CLUTTER_MASTER_CLASS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), CLUTTER_TYPE_MASTER_CLOCK, ClutterMasterClockClass))
master-clock: Add frame budget diagnostic messages Let's keep a budget of 16.6 milliseconds per frame, and reduce it by the amount of time spent in each phase of the frame processing. If any phase goes over the allocated budget then we use the diagnostic mode facilities to warn the app developer.
2012-03-06 13:50:10 +00:00
#ifdef CLUTTER_ENABLE_DEBUG
#define clutter_warn_if_over_budget(master_clock,start_time,section) G_STMT_START { \
gint64 __delta = g_get_monotonic_time () - start_time; \
gint64 __budget = master_clock->remaining_budget; \
if (__budget > 0 && __delta >= __budget) { \
_clutter_diagnostic_message ("%s took %" G_GINT64_FORMAT " microseconds " \
"over a budget of %" G_GINT64_FORMAT " microseconds", \
section, __delta, __budget); \
} } G_STMT_END
#else
#define clutter_warn_if_over_budget(master_clock,start_time,section)
#endif
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
typedef struct _ClutterClockSource ClutterClockSource;
Use a single master "clock" to drive timelines Currently, all timelines install a timeout inside the TimeoutPool they share. Every time the main loop spins, all the timeouts are updated. This, in turn, will usually lead to redraws being queued on the stages. This behaviour leads to the potential starvation of timelines and to excessive redraws. One lesson learned from the games developers is that the scenegraph should be prepared in its entirety before the GL paint sequence is initiated. This means making sure that every ::new-frame signal handler is called before clutter_redraw() is invoked. In order to do so a TimeoutPool is not enough: we need a master clock. The clock will be responsible for advancing all the active timelines created inside a scene, but only when the stage is being redrawn. The sequence is: + queue_redraw() is invoked on an actor and bubbles up to the stage + if no redraw() has already been scheduled, install an idle handler with a known priority + inside the idle handler: - advance the master clock, which will in turn advance every playing timeline by the amount of milliseconds elapsed since the last redraw; this will make every playing timeline emit the ::new-frame signal - queue a relayout - call the redraw() method of the backend This way we trade multiple timeouts with a single frame source that only runs if a timeline is playing and queues redraws on the various stages.
2009-03-21 20:39:32 +00:00
typedef struct _ClutterMasterClockClass ClutterMasterClockClass;
struct _ClutterMasterClock
{
GObject parent_instance;
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
/* the list of timelines handled by the clock */
Use a single master "clock" to drive timelines Currently, all timelines install a timeout inside the TimeoutPool they share. Every time the main loop spins, all the timeouts are updated. This, in turn, will usually lead to redraws being queued on the stages. This behaviour leads to the potential starvation of timelines and to excessive redraws. One lesson learned from the games developers is that the scenegraph should be prepared in its entirety before the GL paint sequence is initiated. This means making sure that every ::new-frame signal handler is called before clutter_redraw() is invoked. In order to do so a TimeoutPool is not enough: we need a master clock. The clock will be responsible for advancing all the active timelines created inside a scene, but only when the stage is being redrawn. The sequence is: + queue_redraw() is invoked on an actor and bubbles up to the stage + if no redraw() has already been scheduled, install an idle handler with a known priority + inside the idle handler: - advance the master clock, which will in turn advance every playing timeline by the amount of milliseconds elapsed since the last redraw; this will make every playing timeline emit the ::new-frame signal - queue a relayout - call the redraw() method of the backend This way we trade multiple timeouts with a single frame source that only runs if a timeline is playing and queues redraws on the various stages.
2009-03-21 20:39:32 +00:00
GSList *timelines;
Move away from GTimeVal GLib 2.28 will deprecate GTimeVal and related API in favour of standardizing on microseconds granularity for all time-based API. Clutter should switch too. All of the current users of GTimeVal convert to milliseconds when doing time operations, and use GTimeVal only as storage. This can effectively be replaced by a gint64. The Master Clock uses a microsecond resolution, except when interacting with the main loop itself, since the main loop has a millisecond resolution - at least until Ryan Lortie manages to switch that too to microseconds on Linux. The clutter_timeline_do_tick() function was erroneously not privatized, but it was still assumed to be private; we should just remove it from the public symbols.
2010-11-07 15:57:33 +00:00
/* the current state of the clock, in usecs */
gint64 cur_tick;
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
Move away from GTimeVal GLib 2.28 will deprecate GTimeVal and related API in favour of standardizing on microseconds granularity for all time-based API. Clutter should switch too. All of the current users of GTimeVal convert to milliseconds when doing time operations, and use GTimeVal only as storage. This can effectively be replaced by a gint64. The Master Clock uses a microsecond resolution, except when interacting with the main loop itself, since the main loop has a millisecond resolution - at least until Ryan Lortie manages to switch that too to microseconds on Linux. The clutter_timeline_do_tick() function was erroneously not privatized, but it was still assumed to be private; we should just remove it from the public symbols.
2010-11-07 15:57:33 +00:00
/* the previous state of the clock, in usecs, used to compute the delta */
gint64 prev_tick;
Use a single master "clock" to drive timelines Currently, all timelines install a timeout inside the TimeoutPool they share. Every time the main loop spins, all the timeouts are updated. This, in turn, will usually lead to redraws being queued on the stages. This behaviour leads to the potential starvation of timelines and to excessive redraws. One lesson learned from the games developers is that the scenegraph should be prepared in its entirety before the GL paint sequence is initiated. This means making sure that every ::new-frame signal handler is called before clutter_redraw() is invoked. In order to do so a TimeoutPool is not enough: we need a master clock. The clock will be responsible for advancing all the active timelines created inside a scene, but only when the stage is being redrawn. The sequence is: + queue_redraw() is invoked on an actor and bubbles up to the stage + if no redraw() has already been scheduled, install an idle handler with a known priority + inside the idle handler: - advance the master clock, which will in turn advance every playing timeline by the amount of milliseconds elapsed since the last redraw; this will make every playing timeline emit the ::new-frame signal - queue a relayout - call the redraw() method of the backend This way we trade multiple timeouts with a single frame source that only runs if a timeline is playing and queues redraws on the various stages.
2009-03-21 20:39:32 +00:00
master-clock: Add frame budget diagnostic messages Let's keep a budget of 16.6 milliseconds per frame, and reduce it by the amount of time spent in each phase of the frame processing. If any phase goes over the allocated budget then we use the diagnostic mode facilities to warn the app developer.
2012-03-06 13:50:10 +00:00
#ifdef CLUTTER_ENABLE_DEBUG
gint64 frame_budget;
gint64 remaining_budget;
#endif
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
/* an idle source, used by the Master Clock to queue
* a redraw on the stage and drive the animations
*/
GSource *source;
[master-clock] Throttle if no redraw was performed A flag in the master clock is now set whenever the dispatch caused an actual redraw of a stage. If this flag is not set during the prepare and check functions then it will resort to limiting the redraw attempts to the default frame rate as if vblank syncing was disabled. Otherwise if a timeline is running that does not cause the scene to change then it would busy-wait with 100% CPU until the next frame. This fix was suggested by Owen Taylor in: http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-10 14:50:27 +00:00
Move away from GTimeVal GLib 2.28 will deprecate GTimeVal and related API in favour of standardizing on microseconds granularity for all time-based API. Clutter should switch too. All of the current users of GTimeVal convert to milliseconds when doing time operations, and use GTimeVal only as storage. This can effectively be replaced by a gint64. The Master Clock uses a microsecond resolution, except when interacting with the main loop itself, since the main loop has a millisecond resolution - at least until Ryan Lortie manages to switch that too to microseconds on Linux. The clutter_timeline_do_tick() function was erroneously not privatized, but it was still assumed to be private; we should just remove it from the public symbols.
2010-11-07 15:57:33 +00:00
/* If the master clock is idle that means it has
glx backend: Adds support for GLX_INTEL_swap_event If your OpenGL driver supports GLX_INTEL_swap_event that means when glXSwapBuffers is called it returns immediatly and an XEvent is sent when the actual swap has finished. Clutter can use the events that notify swap completion as a means to throttle rendering in the master clock without blocking the CPU and so it should help improve the performance of CPU bound applications.
2009-11-12 20:37:01 +00:00
* fallen back to idle polling for timeline
* progressions and it may have been some time since
* the last real stage update.
*/
guint idle : 1;
ensure next iteration Added an internal clutter function, _clutter_master_clock_ensure_next_iteration that ensures another iteration of the master clock, can be called from repaint functions as well as other threads.
2009-07-09 19:03:01 +00:00
guint ensure_next_iteration : 1;
Use a single master "clock" to drive timelines Currently, all timelines install a timeout inside the TimeoutPool they share. Every time the main loop spins, all the timeouts are updated. This, in turn, will usually lead to redraws being queued on the stages. This behaviour leads to the potential starvation of timelines and to excessive redraws. One lesson learned from the games developers is that the scenegraph should be prepared in its entirety before the GL paint sequence is initiated. This means making sure that every ::new-frame signal handler is called before clutter_redraw() is invoked. In order to do so a TimeoutPool is not enough: we need a master clock. The clock will be responsible for advancing all the active timelines created inside a scene, but only when the stage is being redrawn. The sequence is: + queue_redraw() is invoked on an actor and bubbles up to the stage + if no redraw() has already been scheduled, install an idle handler with a known priority + inside the idle handler: - advance the master clock, which will in turn advance every playing timeline by the amount of milliseconds elapsed since the last redraw; this will make every playing timeline emit the ::new-frame signal - queue a relayout - call the redraw() method of the backend This way we trade multiple timeouts with a single frame source that only runs if a timeline is playing and queues redraws on the various stages.
2009-03-21 20:39:32 +00:00
};
struct _ClutterMasterClockClass
{
GObjectClass parent_class;
};
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
struct _ClutterClockSource
{
GSource source;
ClutterMasterClock *master_clock;
};
Use a single master "clock" to drive timelines Currently, all timelines install a timeout inside the TimeoutPool they share. Every time the main loop spins, all the timeouts are updated. This, in turn, will usually lead to redraws being queued on the stages. This behaviour leads to the potential starvation of timelines and to excessive redraws. One lesson learned from the games developers is that the scenegraph should be prepared in its entirety before the GL paint sequence is initiated. This means making sure that every ::new-frame signal handler is called before clutter_redraw() is invoked. In order to do so a TimeoutPool is not enough: we need a master clock. The clock will be responsible for advancing all the active timelines created inside a scene, but only when the stage is being redrawn. The sequence is: + queue_redraw() is invoked on an actor and bubbles up to the stage + if no redraw() has already been scheduled, install an idle handler with a known priority + inside the idle handler: - advance the master clock, which will in turn advance every playing timeline by the amount of milliseconds elapsed since the last redraw; this will make every playing timeline emit the ::new-frame signal - queue a relayout - call the redraw() method of the backend This way we trade multiple timeouts with a single frame source that only runs if a timeline is playing and queues redraws on the various stages.
2009-03-21 20:39:32 +00:00
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
static gboolean clutter_clock_prepare (GSource *source,
gint *timeout);
static gboolean clutter_clock_check (GSource *source);
static gboolean clutter_clock_dispatch (GSource *source,
GSourceFunc callback,
gpointer user_data);
static GSourceFuncs clock_funcs = {
clutter_clock_prepare,
clutter_clock_check,
clutter_clock_dispatch,
NULL
};
Mark internal symbol as private A bunch of private symbols have escaped into the SO; let's rectify this situation by using the '_' private prefix, or making them static as they should have been.
2012-02-09 18:40:03 +00:00
#define clutter_master_clock_get_type _clutter_master_clock_get_type
Use a single master "clock" to drive timelines Currently, all timelines install a timeout inside the TimeoutPool they share. Every time the main loop spins, all the timeouts are updated. This, in turn, will usually lead to redraws being queued on the stages. This behaviour leads to the potential starvation of timelines and to excessive redraws. One lesson learned from the games developers is that the scenegraph should be prepared in its entirety before the GL paint sequence is initiated. This means making sure that every ::new-frame signal handler is called before clutter_redraw() is invoked. In order to do so a TimeoutPool is not enough: we need a master clock. The clock will be responsible for advancing all the active timelines created inside a scene, but only when the stage is being redrawn. The sequence is: + queue_redraw() is invoked on an actor and bubbles up to the stage + if no redraw() has already been scheduled, install an idle handler with a known priority + inside the idle handler: - advance the master clock, which will in turn advance every playing timeline by the amount of milliseconds elapsed since the last redraw; this will make every playing timeline emit the ::new-frame signal - queue a relayout - call the redraw() method of the backend This way we trade multiple timeouts with a single frame source that only runs if a timeline is playing and queues redraws on the various stages.
2009-03-21 20:39:32 +00:00
G_DEFINE_TYPE (ClutterMasterClock, clutter_master_clock, G_TYPE_OBJECT);
[master clock] Handle Timeline::started signal correctly The "started" signal is sent first after the timeline has been set to the 'running' state. For this reason, checking if the clock has any running timelines running will always return true in the "started" signal handler: the timeline that sent the signal is running. What needs to be checked in the signal handler is if there are any timelines running other than the one that emitted the ::started signal, which we know is running anyway. This prevents frames from being lost at the beginning of an animation when a timeline is started after a quiescent period. Fixes bug: http://bugzilla.openedhand.com/show_bug.cgi?id=1617 Signed-off-by: Jonas Bonn <jonas@southpole.se> Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-05-29 13:25:19 +00:00
/*
Remove stage update idle and do updates from the master clock When a redraw is queued on a stage, simply set a flag; then in the check/prepare functions of the master clock source, check for stages that need redrawing. This avoids the complexity of having multiple competing sources at the same priority and makes the update ordering more reliable and understandable. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-06 22:22:51 +00:00
* master_clock_is_running:
[master clock] Handle Timeline::started signal correctly The "started" signal is sent first after the timeline has been set to the 'running' state. For this reason, checking if the clock has any running timelines running will always return true in the "started" signal handler: the timeline that sent the signal is running. What needs to be checked in the signal handler is if there are any timelines running other than the one that emitted the ::started signal, which we know is running anyway. This prevents frames from being lost at the beginning of an animation when a timeline is started after a quiescent period. Fixes bug: http://bugzilla.openedhand.com/show_bug.cgi?id=1617 Signed-off-by: Jonas Bonn <jonas@southpole.se> Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-05-29 13:25:19 +00:00
* @master_clock: a #ClutterMasterClock
*
Remove stage update idle and do updates from the master clock When a redraw is queued on a stage, simply set a flag; then in the check/prepare functions of the master clock source, check for stages that need redrawing. This avoids the complexity of having multiple competing sources at the same priority and makes the update ordering more reliable and understandable. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-06 22:22:51 +00:00
* Checks if we should currently be advancing timelines or redrawing
* stages.
[master clock] Handle Timeline::started signal correctly The "started" signal is sent first after the timeline has been set to the 'running' state. For this reason, checking if the clock has any running timelines running will always return true in the "started" signal handler: the timeline that sent the signal is running. What needs to be checked in the signal handler is if there are any timelines running other than the one that emitted the ::started signal, which we know is running anyway. This prevents frames from being lost at the beginning of an animation when a timeline is started after a quiescent period. Fixes bug: http://bugzilla.openedhand.com/show_bug.cgi?id=1617 Signed-off-by: Jonas Bonn <jonas@southpole.se> Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-05-29 13:25:19 +00:00
*
* Return value: %TRUE if the #ClutterMasterClock has at least
* one running timeline
*/
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
static gboolean
Remove stage update idle and do updates from the master clock When a redraw is queued on a stage, simply set a flag; then in the check/prepare functions of the master clock source, check for stages that need redrawing. This avoids the complexity of having multiple competing sources at the same priority and makes the update ordering more reliable and understandable. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-06 22:22:51 +00:00
master_clock_is_running (ClutterMasterClock *master_clock)
Use a single master "clock" to drive timelines Currently, all timelines install a timeout inside the TimeoutPool they share. Every time the main loop spins, all the timeouts are updated. This, in turn, will usually lead to redraws being queued on the stages. This behaviour leads to the potential starvation of timelines and to excessive redraws. One lesson learned from the games developers is that the scenegraph should be prepared in its entirety before the GL paint sequence is initiated. This means making sure that every ::new-frame signal handler is called before clutter_redraw() is invoked. In order to do so a TimeoutPool is not enough: we need a master clock. The clock will be responsible for advancing all the active timelines created inside a scene, but only when the stage is being redrawn. The sequence is: + queue_redraw() is invoked on an actor and bubbles up to the stage + if no redraw() has already been scheduled, install an idle handler with a known priority + inside the idle handler: - advance the master clock, which will in turn advance every playing timeline by the amount of milliseconds elapsed since the last redraw; this will make every playing timeline emit the ::new-frame signal - queue a relayout - call the redraw() method of the backend This way we trade multiple timeouts with a single frame source that only runs if a timeline is playing and queues redraws on the various stages.
2009-03-21 20:39:32 +00:00
{
Simplify timeout list handling for the master clock Instead of keeping a list of all timelines, and connecting to signals and weak notifies, simply keep a list of running timelines; this greatly simplifies both the book-keeping, and also determining if there are any running timelines. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-06 21:44:40 +00:00
ClutterStageManager *stage_manager = clutter_stage_manager_get_default ();
const GSList *stages, *l;
glx backend: Adds support for GLX_INTEL_swap_event If your OpenGL driver supports GLX_INTEL_swap_event that means when glXSwapBuffers is called it returns immediatly and an XEvent is sent when the actual swap has finished. Clutter can use the events that notify swap completion as a means to throttle rendering in the master clock without blocking the CPU and so it should help improve the performance of CPU bound applications.
2009-11-12 20:37:01 +00:00
stages = clutter_stage_manager_peek_stages (stage_manager);
Simplify timeout list handling for the master clock Instead of keeping a list of all timelines, and connecting to signals and weak notifies, simply keep a list of running timelines; this greatly simplifies both the book-keeping, and also determining if there are any running timelines. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-06 21:44:40 +00:00
if (master_clock->timelines)
return TRUE;
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
Remove stage update idle and do updates from the master clock When a redraw is queued on a stage, simply set a flag; then in the check/prepare functions of the master clock source, check for stages that need redrawing. This avoids the complexity of having multiple competing sources at the same priority and makes the update ordering more reliable and understandable. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-06 22:22:51 +00:00
for (l = stages; l; l = l->next)
stage: Add sanity checks for get_pending_swaps() The master clock might have a Stage during its destruction phase, without a StageWindow attached to it. If this happens and we try to dereference the StageWindow to get its class and call a virtual function we might experience some slight turbulence and... then... explode. http://bugzilla.openedhand.com/show_bug.cgi?id=1987
2010-02-15 12:04:50 +00:00
{
if (_clutter_stage_has_queued_events (l->data) ||
_clutter_stage_needs_update (l->data))
return TRUE;
}
Remove stage update idle and do updates from the master clock When a redraw is queued on a stage, simply set a flag; then in the check/prepare functions of the master clock source, check for stages that need redrawing. This avoids the complexity of having multiple competing sources at the same priority and makes the update ordering more reliable and understandable. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-06 22:22:51 +00:00
ensure next iteration Added an internal clutter function, _clutter_master_clock_ensure_next_iteration that ensures another iteration of the master clock, can be called from repaint functions as well as other threads.
2009-07-09 19:03:01 +00:00
if (master_clock->ensure_next_iteration)
{
master_clock->ensure_next_iteration = FALSE;
return TRUE;
}
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
return FALSE;
}
Add clutter_stage_set_sync_delay() New experimental API is added to allow changing the way that redraws are timed for a stage to include a "sync delay" - a period after the vertical blanking period where Clutter simply waits for updates. In detail, the algorithm is that when the master clock is restarted after drawing a frame (in the case where there are timelines running) or started fresh in response to a queued redraw or relayout, the start is scheduled at the next sync point (sync_delay ms after the predicted vblank period) rather than done immediately. https://bugzilla.gnome.org/show_bug.cgi?id=692901
2012-11-08 17:42:24 +00:00
static gint
master_clock_get_swap_wait_time (ClutterMasterClock *master_clock)
{
ClutterStageManager *stage_manager = clutter_stage_manager_get_default ();
const GSList *stages, *l;
gint64 min_update_time = -1;
stages = clutter_stage_manager_peek_stages (stage_manager);
for (l = stages; l != NULL; l = l->next)
{
gint64 update_time = _clutter_stage_get_update_time (l->data);
if (min_update_time == -1 ||
(update_time != -1 && update_time < min_update_time))
min_update_time = update_time;
}
if (min_update_time == -1)
{
return -1;
}
else
{
gint64 now = g_source_get_time (master_clock->source);
if (min_update_time < now)
{
return 0;
}
else
{
gint64 delay_us = min_update_time - now;
return (delay_us + 999) / 1000;
}
}
}
static void
master_clock_schedule_stage_updates (ClutterMasterClock *master_clock)
{
ClutterStageManager *stage_manager = clutter_stage_manager_get_default ();
const GSList *stages, *l;
stages = clutter_stage_manager_peek_stages (stage_manager);
for (l = stages; l != NULL; l = l->next)
_clutter_stage_schedule_update (l->data);
}
static GSList *
master_clock_list_ready_stages (ClutterMasterClock *master_clock)
{
ClutterStageManager *stage_manager = clutter_stage_manager_get_default ();
const GSList *stages, *l;
GSList *result;
stages = clutter_stage_manager_peek_stages (stage_manager);
result = NULL;
for (l = stages; l != NULL; l = l->next)
{
gint64 update_time = _clutter_stage_get_update_time (l->data);
/* If a stage has a swap-buffers pending we don't want to draw to it
* in case the driver may block the CPU while it waits for the next
* backbuffer to become available.
*
* TODO: We should be able to identify if we are running triple or N
* buffered and in these cases we can still draw if there is 1 swap
* pending so we can hopefully always be ready to swap for the next
* vblank and really match the vsync frequency.
*/
if (update_time != -1 && update_time <= master_clock->cur_tick)
result = g_slist_prepend (result, g_object_ref (l->data));
}
return g_slist_reverse (result);
}
static void
master_clock_reschedule_stage_updates (ClutterMasterClock *master_clock,
GSList *stages)
{
const GSList *l;
for (l = stages; l != NULL; l = l->next)
{
/* Clear the old update time */
_clutter_stage_clear_update_time (l->data);
/* And if there is still work to be done, schedule a new one */
if (master_clock->timelines ||
_clutter_stage_has_queued_events (l->data) ||
_clutter_stage_needs_update (l->data))
_clutter_stage_schedule_update (l->data);
}
}
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
/*
* master_clock_next_frame_delay:
* @master_clock: a #ClutterMasterClock
*
* Computes the number of delay before we need to draw the next frame.
*
* Return value: -1 if there is no next frame pending, otherwise the
* number of millseconds before the we need to draw the next frame
*/
static gint
master_clock_next_frame_delay (ClutterMasterClock *master_clock)
{
Move away from GTimeVal GLib 2.28 will deprecate GTimeVal and related API in favour of standardizing on microseconds granularity for all time-based API. Clutter should switch too. All of the current users of GTimeVal convert to milliseconds when doing time operations, and use GTimeVal only as storage. This can effectively be replaced by a gint64. The Master Clock uses a microsecond resolution, except when interacting with the main loop itself, since the main loop has a millisecond resolution - at least until Ryan Lortie manages to switch that too to microseconds on Linux. The clutter_timeline_do_tick() function was erroneously not privatized, but it was still assumed to be private; we should just remove it from the public symbols.
2010-11-07 15:57:33 +00:00
gint64 now, next;
Add clutter_stage_set_sync_delay() New experimental API is added to allow changing the way that redraws are timed for a stage to include a "sync delay" - a period after the vertical blanking period where Clutter simply waits for updates. In detail, the algorithm is that when the master clock is restarted after drawing a frame (in the case where there are timelines running) or started fresh in response to a queued redraw or relayout, the start is scheduled at the next sync point (sync_delay ms after the predicted vblank period) rather than done immediately. https://bugzilla.gnome.org/show_bug.cgi?id=692901
2012-11-08 17:42:24 +00:00
gint swap_delay;
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
if (!master_clock_is_running (master_clock))
return -1;
Add clutter_stage_set_sync_delay() New experimental API is added to allow changing the way that redraws are timed for a stage to include a "sync delay" - a period after the vertical blanking period where Clutter simply waits for updates. In detail, the algorithm is that when the master clock is restarted after drawing a frame (in the case where there are timelines running) or started fresh in response to a queued redraw or relayout, the start is scheduled at the next sync point (sync_delay ms after the predicted vblank period) rather than done immediately. https://bugzilla.gnome.org/show_bug.cgi?id=692901
2012-11-08 17:42:24 +00:00
/* If all of the stages are busy waiting for a swap-buffers to complete
* then we wait for one to be ready.. */
swap_delay = master_clock_get_swap_wait_time (master_clock);
if (swap_delay != 0)
return swap_delay;
glx backend: Adds support for GLX_INTEL_swap_event If your OpenGL driver supports GLX_INTEL_swap_event that means when glXSwapBuffers is called it returns immediatly and an XEvent is sent when the actual swap has finished. Clutter can use the events that notify swap completion as a means to throttle rendering in the master clock without blocking the CPU and so it should help improve the performance of CPU bound applications.
2009-11-12 20:37:01 +00:00
/* When we have sync-to-vblank, we count on swap-buffer requests (or
* swap-buffer-complete events if supported in the backend) to throttle our
* frame rate so no additional delay is needed to start the next frame.
*
* If the master-clock has become idle due to no timeline progression causing
* redraws then we can no longer rely on vblank synchronization because the
* last real stage update/redraw may have happened a long time ago and so we
* fallback to polling for timeline progressions every 1/frame_rate seconds.
*
* (NB: if there aren't even any timelines running then the master clock will
* be completely stopped in master_clock_is_running())
*/
[master-clock] Throttle if no redraw was performed A flag in the master clock is now set whenever the dispatch caused an actual redraw of a stage. If this flag is not set during the prepare and check functions then it will resort to limiting the redraw attempts to the default frame rate as if vblank syncing was disabled. Otherwise if a timeline is running that does not cause the scene to change then it would busy-wait with 100% CPU until the next frame. This fix was suggested by Owen Taylor in: http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-10 14:50:27 +00:00
if (clutter_feature_available (CLUTTER_FEATURE_SYNC_TO_VBLANK) &&
glx backend: Adds support for GLX_INTEL_swap_event If your OpenGL driver supports GLX_INTEL_swap_event that means when glXSwapBuffers is called it returns immediatly and an XEvent is sent when the actual swap has finished. Clutter can use the events that notify swap completion as a means to throttle rendering in the master clock without blocking the CPU and so it should help improve the performance of CPU bound applications.
2009-11-12 20:37:01 +00:00
!master_clock->idle)
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
{
Add more debug notes inside the master clock
2009-06-29 15:33:07 +00:00
CLUTTER_NOTE (SCHEDULER, "vblank available and updated stages");
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
return 0;
}
Move away from GTimeVal GLib 2.28 will deprecate GTimeVal and related API in favour of standardizing on microseconds granularity for all time-based API. Clutter should switch too. All of the current users of GTimeVal convert to milliseconds when doing time operations, and use GTimeVal only as storage. This can effectively be replaced by a gint64. The Master Clock uses a microsecond resolution, except when interacting with the main loop itself, since the main loop has a millisecond resolution - at least until Ryan Lortie manages to switch that too to microseconds on Linux. The clutter_timeline_do_tick() function was erroneously not privatized, but it was still assumed to be private; we should just remove it from the public symbols.
2010-11-07 15:57:33 +00:00
if (master_clock->prev_tick == 0)
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
{
/* If we weren't previously running, then draw the next frame
* immediately
*/
Add more debug notes inside the master clock
2009-06-29 15:33:07 +00:00
CLUTTER_NOTE (SCHEDULER, "draw the first frame immediately");
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
return 0;
}
Add more debug notes inside the master clock
2009-06-29 15:33:07 +00:00
/* Otherwise, wait at least 1/frame_rate seconds since we last
* started a frame
*/
Start using the monotonic API in GLib ≥ 2.27 Starting from the 2.27 cycle, GLib is exposing a monotonic clock with microseconds granularity throughout the time-based API. We can start using it, given that the old, non-monotonic version is going to be deprecated by the same cycle.
2010-11-07 16:20:51 +00:00
now = g_source_get_time (master_clock->source);
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
next = master_clock->prev_tick;
clutter-master-clock: Don't wait for a frame if time goes backwards If we aren't syncing to vblank or if the last dispatch didn't cause a redraw then the master clock will try to wait at least a small amount of time before dispatching again. However if time goes backwards then it would not do a dispatch until time catches up again. To fix this it know just runs a dispatch immediately if time goes backwards. This is related to Moblin bug #3839. There was a similar fix for this in 9dc012c07, however that only fixed the case where timelines wouldn't update. If there are no animations running then the master clock won't even try updating timelines until time catches up. http://bugzilla.o-hand.com/show_bug.cgi?id=1974
2010-02-05 21:56:31 +00:00
/* If time has gone backwards then there's no way of knowing how
long we should wait so let's just dispatch immediately */
Move away from GTimeVal GLib 2.28 will deprecate GTimeVal and related API in favour of standardizing on microseconds granularity for all time-based API. Clutter should switch too. All of the current users of GTimeVal convert to milliseconds when doing time operations, and use GTimeVal only as storage. This can effectively be replaced by a gint64. The Master Clock uses a microsecond resolution, except when interacting with the main loop itself, since the main loop has a millisecond resolution - at least until Ryan Lortie manages to switch that too to microseconds on Linux. The clutter_timeline_do_tick() function was erroneously not privatized, but it was still assumed to be private; we should just remove it from the public symbols.
2010-11-07 15:57:33 +00:00
if (now <= next)
clutter-master-clock: Don't wait for a frame if time goes backwards If we aren't syncing to vblank or if the last dispatch didn't cause a redraw then the master clock will try to wait at least a small amount of time before dispatching again. However if time goes backwards then it would not do a dispatch until time catches up again. To fix this it know just runs a dispatch immediately if time goes backwards. This is related to Moblin bug #3839. There was a similar fix for this in 9dc012c07, however that only fixed the case where timelines wouldn't update. If there are no animations running then the master clock won't even try updating timelines until time catches up. http://bugzilla.o-hand.com/show_bug.cgi?id=1974
2010-02-05 21:56:31 +00:00
{
CLUTTER_NOTE (SCHEDULER, "Time has gone backwards");
return 0;
}
Move away from GTimeVal GLib 2.28 will deprecate GTimeVal and related API in favour of standardizing on microseconds granularity for all time-based API. Clutter should switch too. All of the current users of GTimeVal convert to milliseconds when doing time operations, and use GTimeVal only as storage. This can effectively be replaced by a gint64. The Master Clock uses a microsecond resolution, except when interacting with the main loop itself, since the main loop has a millisecond resolution - at least until Ryan Lortie manages to switch that too to microseconds on Linux. The clutter_timeline_do_tick() function was erroneously not privatized, but it was still assumed to be private; we should just remove it from the public symbols.
2010-11-07 15:57:33 +00:00
next += (1000000L / clutter_get_default_frame_rate ());
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
Move away from GTimeVal GLib 2.28 will deprecate GTimeVal and related API in favour of standardizing on microseconds granularity for all time-based API. Clutter should switch too. All of the current users of GTimeVal convert to milliseconds when doing time operations, and use GTimeVal only as storage. This can effectively be replaced by a gint64. The Master Clock uses a microsecond resolution, except when interacting with the main loop itself, since the main loop has a millisecond resolution - at least until Ryan Lortie manages to switch that too to microseconds on Linux. The clutter_timeline_do_tick() function was erroneously not privatized, but it was still assumed to be private; we should just remove it from the public symbols.
2010-11-07 15:57:33 +00:00
if (next <= now)
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
{
Add more debug notes inside the master clock
2009-06-29 15:33:07 +00:00
CLUTTER_NOTE (SCHEDULER, "Less than %lu microsecs",
1000000L / (gulong) clutter_get_default_frame_rate ());
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
return 0;
}
else
{
Move away from GTimeVal GLib 2.28 will deprecate GTimeVal and related API in favour of standardizing on microseconds granularity for all time-based API. Clutter should switch too. All of the current users of GTimeVal convert to milliseconds when doing time operations, and use GTimeVal only as storage. This can effectively be replaced by a gint64. The Master Clock uses a microsecond resolution, except when interacting with the main loop itself, since the main loop has a millisecond resolution - at least until Ryan Lortie manages to switch that too to microseconds on Linux. The clutter_timeline_do_tick() function was erroneously not privatized, but it was still assumed to be private; we should just remove it from the public symbols.
2010-11-07 15:57:33 +00:00
CLUTTER_NOTE (SCHEDULER, "Waiting %" G_GINT64_FORMAT " msecs",
(next - now) / 1000);
Add more debug notes inside the master clock
2009-06-29 15:33:07 +00:00
Move away from GTimeVal GLib 2.28 will deprecate GTimeVal and related API in favour of standardizing on microseconds granularity for all time-based API. Clutter should switch too. All of the current users of GTimeVal convert to milliseconds when doing time operations, and use GTimeVal only as storage. This can effectively be replaced by a gint64. The Master Clock uses a microsecond resolution, except when interacting with the main loop itself, since the main loop has a millisecond resolution - at least until Ryan Lortie manages to switch that too to microseconds on Linux. The clutter_timeline_do_tick() function was erroneously not privatized, but it was still assumed to be private; we should just remove it from the public symbols.
2010-11-07 15:57:33 +00:00
return (next - now) / 1000;
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
}
}
master-clock: Clean up the frame processing Split out every phase into its own function, to ensure that the sequence of operation is clear and easy to follow.
2012-03-06 12:55:27 +00:00
static void
master_clock_process_events (ClutterMasterClock *master_clock,
GSList *stages)
{
GSList *l;
master-clock: Add frame budget diagnostic messages Let's keep a budget of 16.6 milliseconds per frame, and reduce it by the amount of time spent in each phase of the frame processing. If any phase goes over the allocated budget then we use the diagnostic mode facilities to warn the app developer.
2012-03-06 13:50:10 +00:00
#ifdef CLUTTER_ENABLE_DEBUG
gint64 start = g_get_monotonic_time ();
#endif
master-clock: Clean up the frame processing Split out every phase into its own function, to ensure that the sequence of operation is clear and easy to follow.
2012-03-06 12:55:27 +00:00
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 */
for (l = stages; l != NULL; l = l->next)
Add clutter_stage_set_sync_delay() New experimental API is added to allow changing the way that redraws are timed for a stage to include a "sync delay" - a period after the vertical blanking period where Clutter simply waits for updates. In detail, the algorithm is that when the master clock is restarted after drawing a frame (in the case where there are timelines running) or started fresh in response to a queued redraw or relayout, the start is scheduled at the next sync point (sync_delay ms after the predicted vblank period) rather than done immediately. https://bugzilla.gnome.org/show_bug.cgi?id=692901
2012-11-08 17:42:24 +00:00
_clutter_stage_process_queued_events (l->data);
master-clock: Clean up the frame processing Split out every phase into its own function, to ensure that the sequence of operation is clear and easy to follow.
2012-03-06 12:55:27 +00:00
CLUTTER_TIMER_STOP (_clutter_uprof_context, master_event_process);
master-clock: Add frame budget diagnostic messages Let's keep a budget of 16.6 milliseconds per frame, and reduce it by the amount of time spent in each phase of the frame processing. If any phase goes over the allocated budget then we use the diagnostic mode facilities to warn the app developer.
2012-03-06 13:50:10 +00:00
#ifdef CLUTTER_ENABLE_DEBUG
if (_clutter_diagnostic_enabled ())
clutter_warn_if_over_budget (master_clock, start, "Event processing");
master_clock->remaining_budget -= (g_get_monotonic_time () - start);
#endif
master-clock: Clean up the frame processing Split out every phase into its own function, to ensure that the sequence of operation is clear and easy to follow.
2012-03-06 12:55:27 +00:00
}
/*
* master_clock_advance_timelines:
* @master_clock: a #ClutterMasterClock
*
* Advances all the timelines held by the master clock. This function
* should be called before calling _clutter_stage_do_update() to
* make sure that all the timelines are advanced and the scene is updated.
*/
static void
master_clock_advance_timelines (ClutterMasterClock *master_clock)
{
GSList *timelines, *l;
master-clock: Add frame budget diagnostic messages Let's keep a budget of 16.6 milliseconds per frame, and reduce it by the amount of time spent in each phase of the frame processing. If any phase goes over the allocated budget then we use the diagnostic mode facilities to warn the app developer.
2012-03-06 13:50:10 +00:00
#ifdef CLUTTER_ENABLE_DEBUG
gint64 start = g_get_monotonic_time ();
#endif
master-clock: Clean up the frame processing Split out every phase into its own function, to ensure that the sequence of operation is clear and easy to follow.
2012-03-06 12:55:27 +00:00
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
* the advancement by other timelines by copying the list of
* timelines, taking a reference on them, iterating over the
* copied list and then releasing the reference.
*
* we cannot simply take a reference on the timelines and still
* use the list held by the master clock because the do_tick()
* might result in the creation of a new timeline, which gets
* added at the end of the list with no reference increase and
* thus gets disposed at the end of the iteration.
*
* this implies that a newly added timeline will not be advanced
* by this clock iteration, which is perfectly fine since we're
* in its first cycle.
*
* we also cannot steal the master clock timelines list because
* a timeline might be removed as the direct result of do_tick()
* and remove_timeline() would not find the timeline, failing
* and leaving a dangling pointer behind.
*/
timelines = g_slist_copy (master_clock->timelines);
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)
_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_free (timelines);
master-clock: Add frame budget diagnostic messages Let's keep a budget of 16.6 milliseconds per frame, and reduce it by the amount of time spent in each phase of the frame processing. If any phase goes over the allocated budget then we use the diagnostic mode facilities to warn the app developer.
2012-03-06 13:50:10 +00:00
#ifdef CLUTTER_ENABLE_DEBUG
if (_clutter_diagnostic_enabled ())
clutter_warn_if_over_budget (master_clock, start, "Animations");
master_clock->remaining_budget -= (g_get_monotonic_time () - start);
#endif
master-clock: Clean up the frame processing Split out every phase into its own function, to ensure that the sequence of operation is clear and easy to follow.
2012-03-06 12:55:27 +00:00
}
static gboolean
master_clock_update_stages (ClutterMasterClock *master_clock,
GSList *stages)
{
gboolean stages_updated = FALSE;
GSList *l;
master-clock: Add frame budget diagnostic messages Let's keep a budget of 16.6 milliseconds per frame, and reduce it by the amount of time spent in each phase of the frame processing. If any phase goes over the allocated budget then we use the diagnostic mode facilities to warn the app developer.
2012-03-06 13:50:10 +00:00
#ifdef CLUTTER_ENABLE_DEBUG
gint64 start = g_get_monotonic_time ();
#endif
master-clock: Clean up the frame processing Split out every phase into its own function, to ensure that the sequence of operation is clear and easy to follow.
2012-03-06 12:55:27 +00:00
_clutter_run_repaint_functions (CLUTTER_REPAINT_FLAGS_PRE_PAINT);
/* Update any stage that needs redraw/relayout after the clock
* is advanced.
*/
for (l = stages; l != NULL; l = l->next)
Add clutter_stage_set_sync_delay() New experimental API is added to allow changing the way that redraws are timed for a stage to include a "sync delay" - a period after the vertical blanking period where Clutter simply waits for updates. In detail, the algorithm is that when the master clock is restarted after drawing a frame (in the case where there are timelines running) or started fresh in response to a queued redraw or relayout, the start is scheduled at the next sync point (sync_delay ms after the predicted vblank period) rather than done immediately. https://bugzilla.gnome.org/show_bug.cgi?id=692901
2012-11-08 17:42:24 +00:00
stages_updated |= _clutter_stage_do_update (l->data);
master-clock: Clean up the frame processing Split out every phase into its own function, to ensure that the sequence of operation is clear and easy to follow.
2012-03-06 12:55:27 +00:00
_clutter_run_repaint_functions (CLUTTER_REPAINT_FLAGS_POST_PAINT);
master-clock: Add frame budget diagnostic messages Let's keep a budget of 16.6 milliseconds per frame, and reduce it by the amount of time spent in each phase of the frame processing. If any phase goes over the allocated budget then we use the diagnostic mode facilities to warn the app developer.
2012-03-06 13:50:10 +00:00
#ifdef CLUTTER_ENABLE_DEBUG
if (_clutter_diagnostic_enabled ())
clutter_warn_if_over_budget (master_clock, start, "Updating the stage");
master_clock->remaining_budget -= (g_get_monotonic_time () - start);
#endif
master-clock: Clean up the frame processing Split out every phase into its own function, to ensure that the sequence of operation is clear and easy to follow.
2012-03-06 12:55:27 +00:00
return stages_updated;
}
[master clock] Handle Timeline::started signal correctly The "started" signal is sent first after the timeline has been set to the 'running' state. For this reason, checking if the clock has any running timelines running will always return true in the "started" signal handler: the timeline that sent the signal is running. What needs to be checked in the signal handler is if there are any timelines running other than the one that emitted the ::started signal, which we know is running anyway. This prevents frames from being lost at the beginning of an animation when a timeline is started after a quiescent period. Fixes bug: http://bugzilla.openedhand.com/show_bug.cgi?id=1617 Signed-off-by: Jonas Bonn <jonas@southpole.se> Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-05-29 13:25:19 +00:00
/*
* clutter_clock_source_new:
* @master_clock: a #ClutterMasterClock for the source
*
* The #ClutterClockSource is an idle GSource that will queue a redraw
* if @master_clock has at least a running #ClutterTimeline. The redraw
* will cause @master_clock to advance all timelines, thus advancing all
* animations as well.
*
* Return value: the newly created #GSource
*/
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
static GSource *
clutter_clock_source_new (ClutterMasterClock *master_clock)
{
GSource *source = g_source_new (&clock_funcs, sizeof (ClutterClockSource));
ClutterClockSource *clock_source = (ClutterClockSource *) source;
g_source_set_name on custom sources (if available) Call g_source_set_name, if the versio of GLib is new enough. This aids debugging, using e.g. SystemTap. See https://bugzilla.gnome.org/show_bug.cgi?id=620511 for more information http://bugzilla.openedhand.com/show_bug.cgi?id=2151 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2010-06-04 03:34:09 +00:00
g_source_set_name (source, "Clutter master clock");
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
clock_source->master_clock = master_clock;
return source;
}
static gboolean
clutter_clock_prepare (GSource *source,
gint *timeout)
{
ClutterClockSource *clock_source = (ClutterClockSource *) source;
ClutterMasterClock *master_clock = clock_source->master_clock;
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
int delay;
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
Deprecate clutter_threads_enter()/leave() Acquiring the Clutter lock to mark critical sections is not portable, and not recommended to implement threaded applications with Clutter. The recommended pattern is to use worker threads, and schedule UI updates inside idle or timeout handlers within the main loop. We should enforce this pattern by deprecating the threads_enter()/leave() functions. For compatibility concerns, we need internal API to acquire the main lock during frame processing dispatch. https://bugzilla.gnome.org/show_bug.cgi?id=679450
2012-07-05 13:30:26 +00:00
_clutter_threads_acquire_lock ();
Add a CLUTTER_PAINT debug option to enable continous redrawing When testing the performance of an application, it's often useful to force it to continuously redraw instead of going idle to help measure the frame rate. This just adds a CLUTTER_PAINT=continuous-redraw which causes the master clock to queue a redraw on all of the stages just before it prepares its source. Reviewed-by: Robert Bragg <robert@linux.intel.com> Reviewed-by: Emmanuele Bassi <ebassi@linux.intel.com>
2011-09-23 14:12:44 +00:00
if (G_UNLIKELY (clutter_paint_debug_flags &
CLUTTER_DEBUG_CONTINUOUS_REDRAW))
{
ClutterStageManager *stage_manager = clutter_stage_manager_get_default ();
const GSList *stages, *l;
stages = clutter_stage_manager_peek_stages (stage_manager);
/* Queue a full redraw on all of the stages */
for (l = stages; l != NULL; l = l->next)
clutter_actor_queue_redraw (l->data);
}
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
delay = master_clock_next_frame_delay (master_clock);
Deprecate clutter_threads_enter()/leave() Acquiring the Clutter lock to mark critical sections is not portable, and not recommended to implement threaded applications with Clutter. The recommended pattern is to use worker threads, and schedule UI updates inside idle or timeout handlers within the main loop. We should enforce this pattern by deprecating the threads_enter()/leave() functions. For compatibility concerns, we need internal API to acquire the main lock during frame processing dispatch. https://bugzilla.gnome.org/show_bug.cgi?id=679450
2012-07-05 13:30:26 +00:00
_clutter_threads_release_lock ();
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
*timeout = delay;
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
return delay == 0;
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
}
static gboolean
clutter_clock_check (GSource *source)
{
ClutterClockSource *clock_source = (ClutterClockSource *) source;
ClutterMasterClock *master_clock = clock_source->master_clock;
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
int delay;
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
Deprecate clutter_threads_enter()/leave() Acquiring the Clutter lock to mark critical sections is not portable, and not recommended to implement threaded applications with Clutter. The recommended pattern is to use worker threads, and schedule UI updates inside idle or timeout handlers within the main loop. We should enforce this pattern by deprecating the threads_enter()/leave() functions. For compatibility concerns, we need internal API to acquire the main lock during frame processing dispatch. https://bugzilla.gnome.org/show_bug.cgi?id=679450
2012-07-05 13:30:26 +00:00
_clutter_threads_acquire_lock ();
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
delay = master_clock_next_frame_delay (master_clock);
Deprecate clutter_threads_enter()/leave() Acquiring the Clutter lock to mark critical sections is not portable, and not recommended to implement threaded applications with Clutter. The recommended pattern is to use worker threads, and schedule UI updates inside idle or timeout handlers within the main loop. We should enforce this pattern by deprecating the threads_enter()/leave() functions. For compatibility concerns, we need internal API to acquire the main lock during frame processing dispatch. https://bugzilla.gnome.org/show_bug.cgi?id=679450
2012-07-05 13:30:26 +00:00
_clutter_threads_release_lock ();
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
return delay == 0;
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
}
Use a single master "clock" to drive timelines Currently, all timelines install a timeout inside the TimeoutPool they share. Every time the main loop spins, all the timeouts are updated. This, in turn, will usually lead to redraws being queued on the stages. This behaviour leads to the potential starvation of timelines and to excessive redraws. One lesson learned from the games developers is that the scenegraph should be prepared in its entirety before the GL paint sequence is initiated. This means making sure that every ::new-frame signal handler is called before clutter_redraw() is invoked. In order to do so a TimeoutPool is not enough: we need a master clock. The clock will be responsible for advancing all the active timelines created inside a scene, but only when the stage is being redrawn. The sequence is: + queue_redraw() is invoked on an actor and bubbles up to the stage + if no redraw() has already been scheduled, install an idle handler with a known priority + inside the idle handler: - advance the master clock, which will in turn advance every playing timeline by the amount of milliseconds elapsed since the last redraw; this will make every playing timeline emit the ::new-frame signal - queue a relayout - call the redraw() method of the backend This way we trade multiple timeouts with a single frame source that only runs if a timeline is playing and queues redraws on the various stages.
2009-03-21 20:39:32 +00:00
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
static gboolean
clutter_clock_dispatch (GSource *source,
GSourceFunc callback,
gpointer user_data)
{
Remove stage update idle and do updates from the master clock When a redraw is queued on a stage, simply set a flag; then in the check/prepare functions of the master clock source, check for stages that need redrawing. This avoids the complexity of having multiple competing sources at the same priority and makes the update ordering more reliable and understandable. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-06 22:22:51 +00:00
ClutterClockSource *clock_source = (ClutterClockSource *) source;
ClutterMasterClock *master_clock = clock_source->master_clock;
glx backend: Adds support for GLX_INTEL_swap_event If your OpenGL driver supports GLX_INTEL_swap_event that means when glXSwapBuffers is called it returns immediatly and an XEvent is sent when the actual swap has finished. Clutter can use the events that notify swap completion as a means to throttle rendering in the master clock without blocking the CPU and so it should help improve the performance of CPU bound applications.
2009-11-12 20:37:01 +00:00
gboolean stages_updated = FALSE;
master-clock: Clean up the frame processing Split out every phase into its own function, to ensure that the sequence of operation is clear and easy to follow.
2012-03-06 12:55:27 +00:00
GSList *stages;
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
master-clock: Add profiling timers Use the newly-added profiling timers inside the master clock dispatch function to see how much time we spend: • in the whole function • in the event processing for each stage • in the timeline advancement
2010-01-14 12:28:07 +00:00
CLUTTER_STATIC_TIMER (master_dispatch_timer,
"Mainloop",
"Master Clock",
"Master clock dispatch",
0);
CLUTTER_TIMER_START (_clutter_uprof_context, master_dispatch_timer);
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
CLUTTER_NOTE (SCHEDULER, "Master clock [tick]");
Deprecate clutter_threads_enter()/leave() Acquiring the Clutter lock to mark critical sections is not portable, and not recommended to implement threaded applications with Clutter. The recommended pattern is to use worker threads, and schedule UI updates inside idle or timeout handlers within the main loop. We should enforce this pattern by deprecating the threads_enter()/leave() functions. For compatibility concerns, we need internal API to acquire the main lock during frame processing dispatch. https://bugzilla.gnome.org/show_bug.cgi?id=679450
2012-07-05 13:30:26 +00:00
_clutter_threads_acquire_lock ();
[master clock] Fix MT safety issues Fix MT issues when enabling threading in Clutter. Fixes bug: http://bugzilla.openedhand.com/show_bug.cgi?id=1655 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-18 21:53:46 +00:00
Move away from GTimeVal GLib 2.28 will deprecate GTimeVal and related API in favour of standardizing on microseconds granularity for all time-based API. Clutter should switch too. All of the current users of GTimeVal convert to milliseconds when doing time operations, and use GTimeVal only as storage. This can effectively be replaced by a gint64. The Master Clock uses a microsecond resolution, except when interacting with the main loop itself, since the main loop has a millisecond resolution - at least until Ryan Lortie manages to switch that too to microseconds on Linux. The clutter_timeline_do_tick() function was erroneously not privatized, but it was still assumed to be private; we should just remove it from the public symbols.
2010-11-07 15:57:33 +00:00
/* Get the time to use for this frame */
Start using the monotonic API in GLib ≥ 2.27 Starting from the 2.27 cycle, GLib is exposing a monotonic clock with microseconds granularity throughout the time-based API. We can start using it, given that the old, non-monotonic version is going to be deprecated by the same cycle.
2010-11-07 16:20:51 +00:00
master_clock->cur_tick = g_source_get_time (source);
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
master-clock: Add frame budget diagnostic messages Let's keep a budget of 16.6 milliseconds per frame, and reduce it by the amount of time spent in each phase of the frame processing. If any phase goes over the allocated budget then we use the diagnostic mode facilities to warn the app developer.
2012-03-06 13:50:10 +00:00
#ifdef CLUTTER_ENABLE_DEBUG
master_clock->remaining_budget = master_clock->frame_budget;
#endif
Compress events as part of the frame cycle Instead of trying to guess about which motion events are extraneous, queue up all events until we process a frame. This allows us to look ahead and reliably compress consecutive sequence of motion events. clutter-main.c: Feed received events to the stage for queueing. Remove old compression code. Remove clutter_get_motion_events_frequency() clutter_set_motion_events_frequency() clutter-stage.c: Keep a queue of pending events. clutter-master-clock.c: Add processng of queued events to the clock source dispatch function. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-06 23:10:41 +00:00
/* We need to protect ourselves against stages being destroyed during
Add clutter_stage_set_sync_delay() New experimental API is added to allow changing the way that redraws are timed for a stage to include a "sync delay" - a period after the vertical blanking period where Clutter simply waits for updates. In detail, the algorithm is that when the master clock is restarted after drawing a frame (in the case where there are timelines running) or started fresh in response to a queued redraw or relayout, the start is scheduled at the next sync point (sync_delay ms after the predicted vblank period) rather than done immediately. https://bugzilla.gnome.org/show_bug.cgi?id=692901
2012-11-08 17:42:24 +00:00
* event handling - master_clock_list_ready_stages() returns a
* list of referenced that we'll unref afterwards.
Compress events as part of the frame cycle Instead of trying to guess about which motion events are extraneous, queue up all events until we process a frame. This allows us to look ahead and reliably compress consecutive sequence of motion events. clutter-main.c: Feed received events to the stage for queueing. Remove old compression code. Remove clutter_get_motion_events_frequency() clutter_set_motion_events_frequency() clutter-stage.c: Keep a queue of pending events. clutter-master-clock.c: Add processng of queued events to the clock source dispatch function. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-06 23:10:41 +00:00
*/
Add clutter_stage_set_sync_delay() New experimental API is added to allow changing the way that redraws are timed for a stage to include a "sync delay" - a period after the vertical blanking period where Clutter simply waits for updates. In detail, the algorithm is that when the master clock is restarted after drawing a frame (in the case where there are timelines running) or started fresh in response to a queued redraw or relayout, the start is scheduled at the next sync point (sync_delay ms after the predicted vblank period) rather than done immediately. https://bugzilla.gnome.org/show_bug.cgi?id=692901
2012-11-08 17:42:24 +00:00
stages = master_clock_list_ready_stages (master_clock);
Compress events as part of the frame cycle Instead of trying to guess about which motion events are extraneous, queue up all events until we process a frame. This allows us to look ahead and reliably compress consecutive sequence of motion events. clutter-main.c: Feed received events to the stage for queueing. Remove old compression code. Remove clutter_get_motion_events_frequency() clutter_set_motion_events_frequency() clutter-stage.c: Keep a queue of pending events. clutter-master-clock.c: Add processng of queued events to the clock source dispatch function. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-06 23:10:41 +00:00
glx backend: Adds support for GLX_INTEL_swap_event If your OpenGL driver supports GLX_INTEL_swap_event that means when glXSwapBuffers is called it returns immediatly and an XEvent is sent when the actual swap has finished. Clutter can use the events that notify swap completion as a means to throttle rendering in the master clock without blocking the CPU and so it should help improve the performance of CPU bound applications.
2009-11-12 20:37:01 +00:00
master_clock->idle = FALSE;
[master-clock] Throttle if no redraw was performed A flag in the master clock is now set whenever the dispatch caused an actual redraw of a stage. If this flag is not set during the prepare and check functions then it will resort to limiting the redraw attempts to the default frame rate as if vblank syncing was disabled. Otherwise if a timeline is running that does not cause the scene to change then it would busy-wait with 100% CPU until the next frame. This fix was suggested by Owen Taylor in: http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-10 14:50:27 +00:00
master-clock: Clean up the frame processing Split out every phase into its own function, to ensure that the sequence of operation is clear and easy to follow.
2012-03-06 12:55:27 +00:00
/* Each frame is split into three separate phases: */
Remove stage update idle and do updates from the master clock When a redraw is queued on a stage, simply set a flag; then in the check/prepare functions of the master clock source, check for stages that need redrawing. This avoids the complexity of having multiple competing sources at the same priority and makes the update ordering more reliable and understandable. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-06 22:22:51 +00:00
master-clock: Clean up the frame processing Split out every phase into its own function, to ensure that the sequence of operation is clear and easy to follow.
2012-03-06 12:55:27 +00:00
/* 1. process all the events; each stage goes through its events queue
* and processes each event according to its type, then emits the
* various signals that are associated with the event
[master clock] Handle Timeline::started signal correctly The "started" signal is sent first after the timeline has been set to the 'running' state. For this reason, checking if the clock has any running timelines running will always return true in the "started" signal handler: the timeline that sent the signal is running. What needs to be checked in the signal handler is if there are any timelines running other than the one that emitted the ::started signal, which we know is running anyway. This prevents frames from being lost at the beginning of an animation when a timeline is started after a quiescent period. Fixes bug: http://bugzilla.openedhand.com/show_bug.cgi?id=1617 Signed-off-by: Jonas Bonn <jonas@southpole.se> Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-05-29 13:25:19 +00:00
*/
master-clock: Clean up the frame processing Split out every phase into its own function, to ensure that the sequence of operation is clear and easy to follow.
2012-03-06 12:55:27 +00:00
master_clock_process_events (master_clock, stages);
glx backend: Adds support for GLX_INTEL_swap_event If your OpenGL driver supports GLX_INTEL_swap_event that means when glXSwapBuffers is called it returns immediatly and an XEvent is sent when the actual swap has finished. Clutter can use the events that notify swap completion as a means to throttle rendering in the master clock without blocking the CPU and so it should help improve the performance of CPU bound applications.
2009-11-12 20:37:01 +00:00
master-clock: Clean up the frame processing Split out every phase into its own function, to ensure that the sequence of operation is clear and easy to follow.
2012-03-06 12:55:27 +00:00
/* 2. advance the timelines */
master_clock_advance_timelines (master_clock);
/* 3. relayout and redraw the stages */
stages_updated = master_clock_update_stages (master_clock, stages);
Improve repaint functions It is sometimes useful to be able to have better control on when a repaint function is called. Currently, all repaint functions are called prior to the stages update phase of the frame processing. We can introduce flags to represent the point in the frame update process in which we wish Clutter called the repaint function. As a bonus, we can also add a flag that causes adding a repaint function to spin the master clock.
2012-03-06 12:09:00 +00:00
glx backend: Adds support for GLX_INTEL_swap_event If your OpenGL driver supports GLX_INTEL_swap_event that means when glXSwapBuffers is called it returns immediatly and an XEvent is sent when the actual swap has finished. Clutter can use the events that notify swap completion as a means to throttle rendering in the master clock without blocking the CPU and so it should help improve the performance of CPU bound applications.
2009-11-12 20:37:01 +00:00
/* The master clock goes idle if no stages were updated and falls back
* to polling for timeline progressions... */
if (!stages_updated)
master_clock->idle = TRUE;
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
Add clutter_stage_set_sync_delay() New experimental API is added to allow changing the way that redraws are timed for a stage to include a "sync delay" - a period after the vertical blanking period where Clutter simply waits for updates. In detail, the algorithm is that when the master clock is restarted after drawing a frame (in the case where there are timelines running) or started fresh in response to a queued redraw or relayout, the start is scheduled at the next sync point (sync_delay ms after the predicted vblank period) rather than done immediately. https://bugzilla.gnome.org/show_bug.cgi?id=692901
2012-11-08 17:42:24 +00:00
master_clock_reschedule_stage_updates (master_clock, stages);
Move all picking-related operations inside InputDevice The InputDevice objects stores pointer coordinates, state, stage and the actor under the cursor, so if the current backend provides us with one attached to the Event structure then we want the InputDevice itself to update its state and give us the ClutterActor underneath the pointer's cursor.
2010-01-08 17:51:00 +00:00
g_slist_foreach (stages, (GFunc) g_object_unref, NULL);
Compress events as part of the frame cycle Instead of trying to guess about which motion events are extraneous, queue up all events until we process a frame. This allows us to look ahead and reliably compress consecutive sequence of motion events. clutter-main.c: Feed received events to the stage for queueing. Remove old compression code. Remove clutter_get_motion_events_frequency() clutter_set_motion_events_frequency() clutter-stage.c: Keep a queue of pending events. clutter-master-clock.c: Add processng of queued events to the clock source dispatch function. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-06 23:10:41 +00:00
g_slist_free (stages);
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
master_clock->prev_tick = master_clock->cur_tick;
Deprecate clutter_threads_enter()/leave() Acquiring the Clutter lock to mark critical sections is not portable, and not recommended to implement threaded applications with Clutter. The recommended pattern is to use worker threads, and schedule UI updates inside idle or timeout handlers within the main loop. We should enforce this pattern by deprecating the threads_enter()/leave() functions. For compatibility concerns, we need internal API to acquire the main lock during frame processing dispatch. https://bugzilla.gnome.org/show_bug.cgi?id=679450
2012-07-05 13:30:26 +00:00
_clutter_threads_release_lock ();
[master clock] Fix MT safety issues Fix MT issues when enabling threading in Clutter. Fixes bug: http://bugzilla.openedhand.com/show_bug.cgi?id=1655 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-18 21:53:46 +00:00
master-clock: Add profiling timers Use the newly-added profiling timers inside the master clock dispatch function to see how much time we spend: • in the whole function • in the event processing for each stage • in the timeline advancement
2010-01-14 12:28:07 +00:00
CLUTTER_TIMER_STOP (_clutter_uprof_context, master_dispatch_timer);
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
return TRUE;
}
Use a single master "clock" to drive timelines Currently, all timelines install a timeout inside the TimeoutPool they share. Every time the main loop spins, all the timeouts are updated. This, in turn, will usually lead to redraws being queued on the stages. This behaviour leads to the potential starvation of timelines and to excessive redraws. One lesson learned from the games developers is that the scenegraph should be prepared in its entirety before the GL paint sequence is initiated. This means making sure that every ::new-frame signal handler is called before clutter_redraw() is invoked. In order to do so a TimeoutPool is not enough: we need a master clock. The clock will be responsible for advancing all the active timelines created inside a scene, but only when the stage is being redrawn. The sequence is: + queue_redraw() is invoked on an actor and bubbles up to the stage + if no redraw() has already been scheduled, install an idle handler with a known priority + inside the idle handler: - advance the master clock, which will in turn advance every playing timeline by the amount of milliseconds elapsed since the last redraw; this will make every playing timeline emit the ::new-frame signal - queue a relayout - call the redraw() method of the backend This way we trade multiple timeouts with a single frame source that only runs if a timeline is playing and queues redraws on the various stages.
2009-03-21 20:39:32 +00:00
static void
clutter_master_clock_finalize (GObject *gobject)
{
ClutterMasterClock *master_clock = CLUTTER_MASTER_CLOCK (gobject);
g_slist_free (master_clock->timelines);
G_OBJECT_CLASS (clutter_master_clock_parent_class)->finalize (gobject);
}
static void
clutter_master_clock_class_init (ClutterMasterClockClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
gobject_class->finalize = clutter_master_clock_finalize;
}
static void
clutter_master_clock_init (ClutterMasterClock *self)
{
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
GSource *source;
source = clutter_clock_source_new (self);
self->source = source;
glx backend: Adds support for GLX_INTEL_swap_event If your OpenGL driver supports GLX_INTEL_swap_event that means when glXSwapBuffers is called it returns immediatly and an XEvent is sent when the actual swap has finished. Clutter can use the events that notify swap completion as a means to throttle rendering in the master clock without blocking the CPU and so it should help improve the performance of CPU bound applications.
2009-11-12 20:37:01 +00:00
self->idle = FALSE;
ensure next iteration Added an internal clutter function, _clutter_master_clock_ensure_next_iteration that ensures another iteration of the master clock, can be called from repaint functions as well as other threads.
2009-07-09 19:03:01 +00:00
self->ensure_next_iteration = FALSE;
[master-clock] Throttle if no redraw was performed A flag in the master clock is now set whenever the dispatch caused an actual redraw of a stage. If this flag is not set during the prepare and check functions then it will resort to limiting the redraw attempts to the default frame rate as if vblank syncing was disabled. Otherwise if a timeline is running that does not cause the scene to change then it would busy-wait with 100% CPU until the next frame. This fix was suggested by Owen Taylor in: http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-10 14:50:27 +00:00
clutter-master-clock.c: Set frame_budget conditionally The frame_budget member of ClutterMasterClock is only enabled when CLUTTER_ENABLE_DEBUG is enabled, so fix the build with this. Checked with Emmanuele Bassi on IRC.
2012-03-08 09:11:35 +00:00
#ifdef CLUTTER_ENABLE_DEBUG
master-clock: Add frame budget diagnostic messages Let's keep a budget of 16.6 milliseconds per frame, and reduce it by the amount of time spent in each phase of the frame processing. If any phase goes over the allocated budget then we use the diagnostic mode facilities to warn the app developer.
2012-03-06 13:50:10 +00:00
self->frame_budget = G_USEC_PER_SEC / 60;
clutter-master-clock.c: Set frame_budget conditionally The frame_budget member of ClutterMasterClock is only enabled when CLUTTER_ENABLE_DEBUG is enabled, so fix the build with this. Checked with Emmanuele Bassi on IRC.
2012-03-08 09:11:35 +00:00
#endif
master-clock: Add frame budget diagnostic messages Let's keep a budget of 16.6 milliseconds per frame, and reduce it by the amount of time spent in each phase of the frame processing. If any phase goes over the allocated budget then we use the diagnostic mode facilities to warn the app developer.
2012-03-06 13:50:10 +00:00
[clock] Rework the master clock The master clock is currently advanced using a frame source driven by the default frame rate. This breaks the sync to vblank because the vblanking rate could be different than 60 Hz -- or it might be completely disabled (e.g. with CLUTTER_VBLANK=none). We should be using the main loop to check if we have timelines playing, and if so queue a redraw on the stages we own. We should also prepare the subsequent frame at the end of the redraw process, so if there are new redraw we will have the scene already in place. This makes Clutter redraw at the maximum frame rate, which is limited by the vblanking frequency.
2009-05-07 18:07:21 +00:00
g_source_set_priority (source, CLUTTER_PRIORITY_REDRAW);
g_source_set_can_recurse (source, FALSE);
g_source_attach (source, NULL);
Use a single master "clock" to drive timelines Currently, all timelines install a timeout inside the TimeoutPool they share. Every time the main loop spins, all the timeouts are updated. This, in turn, will usually lead to redraws being queued on the stages. This behaviour leads to the potential starvation of timelines and to excessive redraws. One lesson learned from the games developers is that the scenegraph should be prepared in its entirety before the GL paint sequence is initiated. This means making sure that every ::new-frame signal handler is called before clutter_redraw() is invoked. In order to do so a TimeoutPool is not enough: we need a master clock. The clock will be responsible for advancing all the active timelines created inside a scene, but only when the stage is being redrawn. The sequence is: + queue_redraw() is invoked on an actor and bubbles up to the stage + if no redraw() has already been scheduled, install an idle handler with a known priority + inside the idle handler: - advance the master clock, which will in turn advance every playing timeline by the amount of milliseconds elapsed since the last redraw; this will make every playing timeline emit the ::new-frame signal - queue a relayout - call the redraw() method of the backend This way we trade multiple timeouts with a single frame source that only runs if a timeline is playing and queues redraws on the various stages.
2009-03-21 20:39:32 +00:00
}
/*
* _clutter_master_clock_get_default:
*
* Retrieves the default master clock. If this function has never
* been called before, the default master clock is created.
*
* Return value: the default master clock. The returned object is
* owned by Clutter and should not be modified or freed
*/
ClutterMasterClock *
_clutter_master_clock_get_default (void)
{
Store the master clock pointer in the main context Let's try and move all singletons into ClutterMainContext.
2011-11-14 17:04:14 +00:00
ClutterMainContext *context = _clutter_context_get_default ();
Use a single master "clock" to drive timelines Currently, all timelines install a timeout inside the TimeoutPool they share. Every time the main loop spins, all the timeouts are updated. This, in turn, will usually lead to redraws being queued on the stages. This behaviour leads to the potential starvation of timelines and to excessive redraws. One lesson learned from the games developers is that the scenegraph should be prepared in its entirety before the GL paint sequence is initiated. This means making sure that every ::new-frame signal handler is called before clutter_redraw() is invoked. In order to do so a TimeoutPool is not enough: we need a master clock. The clock will be responsible for advancing all the active timelines created inside a scene, but only when the stage is being redrawn. The sequence is: + queue_redraw() is invoked on an actor and bubbles up to the stage + if no redraw() has already been scheduled, install an idle handler with a known priority + inside the idle handler: - advance the master clock, which will in turn advance every playing timeline by the amount of milliseconds elapsed since the last redraw; this will make every playing timeline emit the ::new-frame signal - queue a relayout - call the redraw() method of the backend This way we trade multiple timeouts with a single frame source that only runs if a timeline is playing and queues redraws on the various stages.
2009-03-21 20:39:32 +00:00
Store the master clock pointer in the main context Let's try and move all singletons into ClutterMainContext.
2011-11-14 17:04:14 +00:00
if (G_UNLIKELY (context->master_clock == NULL))
context->master_clock = g_object_new (CLUTTER_TYPE_MASTER_CLOCK, NULL);
Use a single master "clock" to drive timelines Currently, all timelines install a timeout inside the TimeoutPool they share. Every time the main loop spins, all the timeouts are updated. This, in turn, will usually lead to redraws being queued on the stages. This behaviour leads to the potential starvation of timelines and to excessive redraws. One lesson learned from the games developers is that the scenegraph should be prepared in its entirety before the GL paint sequence is initiated. This means making sure that every ::new-frame signal handler is called before clutter_redraw() is invoked. In order to do so a TimeoutPool is not enough: we need a master clock. The clock will be responsible for advancing all the active timelines created inside a scene, but only when the stage is being redrawn. The sequence is: + queue_redraw() is invoked on an actor and bubbles up to the stage + if no redraw() has already been scheduled, install an idle handler with a known priority + inside the idle handler: - advance the master clock, which will in turn advance every playing timeline by the amount of milliseconds elapsed since the last redraw; this will make every playing timeline emit the ::new-frame signal - queue a relayout - call the redraw() method of the backend This way we trade multiple timeouts with a single frame source that only runs if a timeline is playing and queues redraws on the various stages.
2009-03-21 20:39:32 +00:00
Store the master clock pointer in the main context Let's try and move all singletons into ClutterMainContext.
2011-11-14 17:04:14 +00:00
return context->master_clock;
Use a single master "clock" to drive timelines Currently, all timelines install a timeout inside the TimeoutPool they share. Every time the main loop spins, all the timeouts are updated. This, in turn, will usually lead to redraws being queued on the stages. This behaviour leads to the potential starvation of timelines and to excessive redraws. One lesson learned from the games developers is that the scenegraph should be prepared in its entirety before the GL paint sequence is initiated. This means making sure that every ::new-frame signal handler is called before clutter_redraw() is invoked. In order to do so a TimeoutPool is not enough: we need a master clock. The clock will be responsible for advancing all the active timelines created inside a scene, but only when the stage is being redrawn. The sequence is: + queue_redraw() is invoked on an actor and bubbles up to the stage + if no redraw() has already been scheduled, install an idle handler with a known priority + inside the idle handler: - advance the master clock, which will in turn advance every playing timeline by the amount of milliseconds elapsed since the last redraw; this will make every playing timeline emit the ::new-frame signal - queue a relayout - call the redraw() method of the backend This way we trade multiple timeouts with a single frame source that only runs if a timeline is playing and queues redraws on the various stages.
2009-03-21 20:39:32 +00:00
}
/*
* _clutter_master_clock_add_timeline:
* @master_clock: a #ClutterMasterClock
* @timeline: a #ClutterTimeline
*
Simplify timeout list handling for the master clock Instead of keeping a list of all timelines, and connecting to signals and weak notifies, simply keep a list of running timelines; this greatly simplifies both the book-keeping, and also determining if there are any running timelines. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-06 21:44:40 +00:00
* Adds @timeline to the list of playing timelines held by the master
* clock.
Use a single master "clock" to drive timelines Currently, all timelines install a timeout inside the TimeoutPool they share. Every time the main loop spins, all the timeouts are updated. This, in turn, will usually lead to redraws being queued on the stages. This behaviour leads to the potential starvation of timelines and to excessive redraws. One lesson learned from the games developers is that the scenegraph should be prepared in its entirety before the GL paint sequence is initiated. This means making sure that every ::new-frame signal handler is called before clutter_redraw() is invoked. In order to do so a TimeoutPool is not enough: we need a master clock. The clock will be responsible for advancing all the active timelines created inside a scene, but only when the stage is being redrawn. The sequence is: + queue_redraw() is invoked on an actor and bubbles up to the stage + if no redraw() has already been scheduled, install an idle handler with a known priority + inside the idle handler: - advance the master clock, which will in turn advance every playing timeline by the amount of milliseconds elapsed since the last redraw; this will make every playing timeline emit the ::new-frame signal - queue a relayout - call the redraw() method of the backend This way we trade multiple timeouts with a single frame source that only runs if a timeline is playing and queues redraws on the various stages.
2009-03-21 20:39:32 +00:00
*/
void
_clutter_master_clock_add_timeline (ClutterMasterClock *master_clock,
ClutterTimeline *timeline)
{
Simplify timeout list handling for the master clock Instead of keeping a list of all timelines, and connecting to signals and weak notifies, simply keep a list of running timelines; this greatly simplifies both the book-keeping, and also determining if there are any running timelines. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-06 21:44:40 +00:00
gboolean is_first;
Use a single master "clock" to drive timelines Currently, all timelines install a timeout inside the TimeoutPool they share. Every time the main loop spins, all the timeouts are updated. This, in turn, will usually lead to redraws being queued on the stages. This behaviour leads to the potential starvation of timelines and to excessive redraws. One lesson learned from the games developers is that the scenegraph should be prepared in its entirety before the GL paint sequence is initiated. This means making sure that every ::new-frame signal handler is called before clutter_redraw() is invoked. In order to do so a TimeoutPool is not enough: we need a master clock. The clock will be responsible for advancing all the active timelines created inside a scene, but only when the stage is being redrawn. The sequence is: + queue_redraw() is invoked on an actor and bubbles up to the stage + if no redraw() has already been scheduled, install an idle handler with a known priority + inside the idle handler: - advance the master clock, which will in turn advance every playing timeline by the amount of milliseconds elapsed since the last redraw; this will make every playing timeline emit the ::new-frame signal - queue a relayout - call the redraw() method of the backend This way we trade multiple timeouts with a single frame source that only runs if a timeline is playing and queues redraws on the various stages.
2009-03-21 20:39:32 +00:00
if (g_slist_find (master_clock->timelines, timeline))
return;
Simplify timeout list handling for the master clock Instead of keeping a list of all timelines, and connecting to signals and weak notifies, simply keep a list of running timelines; this greatly simplifies both the book-keeping, and also determining if there are any running timelines. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-06 21:44:40 +00:00
is_first = master_clock->timelines == NULL;
Use a single master "clock" to drive timelines Currently, all timelines install a timeout inside the TimeoutPool they share. Every time the main loop spins, all the timeouts are updated. This, in turn, will usually lead to redraws being queued on the stages. This behaviour leads to the potential starvation of timelines and to excessive redraws. One lesson learned from the games developers is that the scenegraph should be prepared in its entirety before the GL paint sequence is initiated. This means making sure that every ::new-frame signal handler is called before clutter_redraw() is invoked. In order to do so a TimeoutPool is not enough: we need a master clock. The clock will be responsible for advancing all the active timelines created inside a scene, but only when the stage is being redrawn. The sequence is: + queue_redraw() is invoked on an actor and bubbles up to the stage + if no redraw() has already been scheduled, install an idle handler with a known priority + inside the idle handler: - advance the master clock, which will in turn advance every playing timeline by the amount of milliseconds elapsed since the last redraw; this will make every playing timeline emit the ::new-frame signal - queue a relayout - call the redraw() method of the backend This way we trade multiple timeouts with a single frame source that only runs if a timeline is playing and queues redraws on the various stages.
2009-03-21 20:39:32 +00:00
master_clock->timelines = g_slist_prepend (master_clock->timelines,
timeline);
Simplify timeout list handling for the master clock Instead of keeping a list of all timelines, and connecting to signals and weak notifies, simply keep a list of running timelines; this greatly simplifies both the book-keeping, and also determining if there are any running timelines. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-06 21:44:40 +00:00
if (is_first)
Add clutter_stage_set_sync_delay() New experimental API is added to allow changing the way that redraws are timed for a stage to include a "sync delay" - a period after the vertical blanking period where Clutter simply waits for updates. In detail, the algorithm is that when the master clock is restarted after drawing a frame (in the case where there are timelines running) or started fresh in response to a queued redraw or relayout, the start is scheduled at the next sync point (sync_delay ms after the predicted vblank period) rather than done immediately. https://bugzilla.gnome.org/show_bug.cgi?id=692901
2012-11-08 17:42:24 +00:00
{
master_clock_schedule_stage_updates (master_clock);
_clutter_master_clock_start_running (master_clock);
}
Use a single master "clock" to drive timelines Currently, all timelines install a timeout inside the TimeoutPool they share. Every time the main loop spins, all the timeouts are updated. This, in turn, will usually lead to redraws being queued on the stages. This behaviour leads to the potential starvation of timelines and to excessive redraws. One lesson learned from the games developers is that the scenegraph should be prepared in its entirety before the GL paint sequence is initiated. This means making sure that every ::new-frame signal handler is called before clutter_redraw() is invoked. In order to do so a TimeoutPool is not enough: we need a master clock. The clock will be responsible for advancing all the active timelines created inside a scene, but only when the stage is being redrawn. The sequence is: + queue_redraw() is invoked on an actor and bubbles up to the stage + if no redraw() has already been scheduled, install an idle handler with a known priority + inside the idle handler: - advance the master clock, which will in turn advance every playing timeline by the amount of milliseconds elapsed since the last redraw; this will make every playing timeline emit the ::new-frame signal - queue a relayout - call the redraw() method of the backend This way we trade multiple timeouts with a single frame source that only runs if a timeline is playing and queues redraws on the various stages.
2009-03-21 20:39:32 +00:00
}
/*
* _clutter_master_clock_remove_timeline:
* @master_clock: a #ClutterMasterClock
* @timeline: a #ClutterTimeline
*
Simplify timeout list handling for the master clock Instead of keeping a list of all timelines, and connecting to signals and weak notifies, simply keep a list of running timelines; this greatly simplifies both the book-keeping, and also determining if there are any running timelines. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-06 21:44:40 +00:00
* Removes @timeline from the list of playing timelines held by the
* master clock.
Use a single master "clock" to drive timelines Currently, all timelines install a timeout inside the TimeoutPool they share. Every time the main loop spins, all the timeouts are updated. This, in turn, will usually lead to redraws being queued on the stages. This behaviour leads to the potential starvation of timelines and to excessive redraws. One lesson learned from the games developers is that the scenegraph should be prepared in its entirety before the GL paint sequence is initiated. This means making sure that every ::new-frame signal handler is called before clutter_redraw() is invoked. In order to do so a TimeoutPool is not enough: we need a master clock. The clock will be responsible for advancing all the active timelines created inside a scene, but only when the stage is being redrawn. The sequence is: + queue_redraw() is invoked on an actor and bubbles up to the stage + if no redraw() has already been scheduled, install an idle handler with a known priority + inside the idle handler: - advance the master clock, which will in turn advance every playing timeline by the amount of milliseconds elapsed since the last redraw; this will make every playing timeline emit the ::new-frame signal - queue a relayout - call the redraw() method of the backend This way we trade multiple timeouts with a single frame source that only runs if a timeline is playing and queues redraws on the various stages.
2009-03-21 20:39:32 +00:00
*/
void
_clutter_master_clock_remove_timeline (ClutterMasterClock *master_clock,
ClutterTimeline *timeline)
{
master_clock->timelines = g_slist_remove (master_clock->timelines,
timeline);
Limit the frame rate when not syncing to VBLANK clutter-master-clock.c clutter-master-clock.h: When the SYNC_TO_VBLANK feature is not available, wait for 1/frame_rate seconds since the start of the last frame before drawing the next frame. Add _clutter_master_clock_start_running() to abstract the usage of g_main_context_wakeup() clutter-stage.c: Add _clutter_master_clock_start_running() clutter-main.c: Update docs for clutter_set_default_frame_rate() clutter_get_default_frame_rate() to no longer talk about timeline frame rates. test-text-perf.c test-text.c: Set a frame rate of 1000fps so that frame-rate limiting doesn't affect the result. http://bugzilla.openedhand.com/show_bug.cgi?id=1637 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-06-07 02:48:15 +00:00
}
/*
* _clutter_master_clock_start_running:
* @master_clock: a #ClutterMasterClock
*
* Called when we have events or redraws to process; if the clock
* is stopped, does the processing necessary to wake it up again.
*/
void
_clutter_master_clock_start_running (ClutterMasterClock *master_clock)
{
/* If called from a different thread, we need to wake up the
* main loop to start running the timelines
*/
g_main_context_wakeup (NULL);
Use a single master "clock" to drive timelines Currently, all timelines install a timeout inside the TimeoutPool they share. Every time the main loop spins, all the timeouts are updated. This, in turn, will usually lead to redraws being queued on the stages. This behaviour leads to the potential starvation of timelines and to excessive redraws. One lesson learned from the games developers is that the scenegraph should be prepared in its entirety before the GL paint sequence is initiated. This means making sure that every ::new-frame signal handler is called before clutter_redraw() is invoked. In order to do so a TimeoutPool is not enough: we need a master clock. The clock will be responsible for advancing all the active timelines created inside a scene, but only when the stage is being redrawn. The sequence is: + queue_redraw() is invoked on an actor and bubbles up to the stage + if no redraw() has already been scheduled, install an idle handler with a known priority + inside the idle handler: - advance the master clock, which will in turn advance every playing timeline by the amount of milliseconds elapsed since the last redraw; this will make every playing timeline emit the ::new-frame signal - queue a relayout - call the redraw() method of the backend This way we trade multiple timeouts with a single frame source that only runs if a timeline is playing and queues redraws on the various stages.
2009-03-21 20:39:32 +00:00
}
ensure next iteration Added an internal clutter function, _clutter_master_clock_ensure_next_iteration that ensures another iteration of the master clock, can be called from repaint functions as well as other threads.
2009-07-09 19:03:01 +00:00
/**
* _clutter_master_clock_ensure_next_iteration:
* @master_clock: a #ClutterMasterClock
*
* Ensures that the master clock will run at least one iteration
*/
void
_clutter_master_clock_ensure_next_iteration (ClutterMasterClock *master_clock)
{
g_return_if_fail (CLUTTER_IS_MASTER_CLOCK (master_clock));
master_clock->ensure_next_iteration = TRUE;
}
Copy permalink