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

wayland: Emit frame events in GSource after "empty" updates

Browse Source 
Under certain conditions a stage-view update does not trigger a kms
update.

In such cases we still want the next update to run within the same
refresh cycle, as otherwise we'd waste the remaining time in the
current one.
At the same time we currently use the `after-update` signal for Wayland
frame events, which again may result in more "empty" updates -
creating an unthrottled feedback loop. This can trigger excessive
load both in the compositor as well as in clients.

Introduce a new GSource that is dispatched once per refresh cycle at
maximum per stage view and use it to emit frame events. Do so by
computing the time from when on we can be sure that an update resulting
from a client commit would certainly get scheduled to the next refresh
cycle.

Note: this only works on the native backend. Given that chances are
small that we hit the corresponding issue on e.g. the nested backend,
stick to the previous behavior there for now.

Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2823>
This commit is contained in:
Robert Mader 2023-02-11 07:02:40 +01:00 committed by Marge Bot
parent 87b3843615
commit a7a7933e03
1 changed files with 208 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

246
src/wayland/meta-wayland.c
View File

@ -60,6 +60,7 @@
#endif
#ifdef HAVE_NATIVE_BACKEND
#include "backends/native/meta-frame-native.h"
#include "backends/native/meta-renderer-native.h"
#endif
@ -79,6 +80,7 @@ typedef struct _MetaWaylandCompositorPrivate
gboolean is_wayland_egl_display_bound;
MetaWaylandFilterManager *filter_manager;
GHashTable *frame_callback_sources;
} MetaWaylandCompositorPrivate;
G_DEFINE_TYPE_WITH_PRIVATE (MetaWaylandCompositor, meta_wayland_compositor,
@ -90,6 +92,15 @@ typedef struct
struct wl_display *display;
} WaylandEventSource;
typedef struct
{
GSource source;
MetaWaylandCompositor *compositor;
ClutterStageView *stage_view;
int64_t target_presentation_time_us;
} FrameCallbackSource;
static gboolean
wayland_event_source_prepare (GSource *base,
int *timeout)
@ -143,6 +154,199 @@ wayland_event_source_new (struct wl_display *display)
return &wayland_source->source;
}
static void
emit_frame_callbacks_for_stage_view (MetaWaylandCompositor *compositor,
ClutterStageView *stage_view)
{
GList *l;
int64_t now_us;
now_us = g_get_monotonic_time ();
l = compositor->frame_callback_surfaces;
while (l)
{
GList *l_cur = l;
MetaWaylandSurface *surface = l->data;
MetaSurfaceActor *actor;
MetaWaylandActorSurface *actor_surface;
l = l->next;
actor = meta_wayland_surface_get_actor (surface);
if (!actor)
continue;
if (!meta_surface_actor_wayland_is_view_primary (actor,
stage_view))
continue;
actor_surface = META_WAYLAND_ACTOR_SURFACE (surface->role);
meta_wayland_actor_surface_emit_frame_callbacks (actor_surface,
now_us / 1000);
compositor->frame_callback_surfaces =
g_list_delete_link (compositor->frame_callback_surfaces, l_cur);
}
}
static gboolean
frame_callback_source_dispatch (GSource *source,
GSourceFunc callback,
gpointer user_data)
{
FrameCallbackSource *frame_callback_source = (FrameCallbackSource *) source;
MetaWaylandCompositor *compositor = frame_callback_source->compositor;
ClutterStageView *stage_view = frame_callback_source->stage_view;
emit_frame_callbacks_for_stage_view (compositor, stage_view);
g_source_set_ready_time (source, -1);
return G_SOURCE_CONTINUE;
}
static void
frame_callback_source_finalize (GSource *source)
{
FrameCallbackSource *frame_callback_source = (FrameCallbackSource *) source;
g_signal_handlers_disconnect_by_data (frame_callback_source->stage_view,
source);
}
static GSourceFuncs frame_callback_source_funcs = {
.dispatch = frame_callback_source_dispatch,
.finalize = frame_callback_source_finalize,
};
static void
on_stage_view_destroy (ClutterStageView *stage_view,
GSource *source)
{
FrameCallbackSource *frame_callback_source = (FrameCallbackSource *) source;
MetaWaylandCompositor *compositor = frame_callback_source->compositor;
MetaWaylandCompositorPrivate *priv =
meta_wayland_compositor_get_instance_private (compositor);
g_hash_table_remove (priv->frame_callback_sources, stage_view);
}
static GSource*
frame_callback_source_new (MetaWaylandCompositor *compositor,
ClutterStageView *stage_view)
{
FrameCallbackSource *frame_callback_source;
g_autofree char *name = NULL;
GSource *source;
source = g_source_new (&frame_callback_source_funcs,
sizeof (FrameCallbackSource));
frame_callback_source = (FrameCallbackSource *) source;
name =
g_strdup_printf ("[mutter] Wayland frame callbacks for stage view (%p)",
stage_view);
g_source_set_name (source, name);
g_source_set_priority (source, CLUTTER_PRIORITY_REDRAW);
g_source_set_can_recurse (source, FALSE);
frame_callback_source->compositor = compositor;
frame_callback_source->stage_view = stage_view;
g_signal_connect (stage_view,
"destroy",
G_CALLBACK (on_stage_view_destroy),
source);
return &frame_callback_source->source;
}
static GSource*
ensure_source_for_stage_view (MetaWaylandCompositor *compositor,
ClutterStageView *stage_view)
{
MetaWaylandCompositorPrivate *priv =
meta_wayland_compositor_get_instance_private (compositor);
GSource *source;
source = g_hash_table_lookup (priv->frame_callback_sources, stage_view);
if (!source)
{
source = frame_callback_source_new (compositor, stage_view);
g_hash_table_insert (priv->frame_callback_sources, stage_view, source);
g_source_attach (source, NULL);
g_source_unref (source);
}
return source;
}
static void
on_after_update (ClutterStage *stage,
ClutterStageView *stage_view,
ClutterFrame *frame,
MetaWaylandCompositor *compositor)
{
#if defined(HAVE_NATIVE_BACKEND)
MetaContext *context = meta_wayland_compositor_get_context (compositor);
MetaBackend *backend = meta_context_get_backend (context);
MetaFrameNative *frame_native;
FrameCallbackSource *frame_callback_source;
GSource *source;
int64_t min_render_time_allowed_us;
if (!META_IS_BACKEND_NATIVE (backend))
{
emit_frame_callbacks_for_stage_view (compositor, stage_view);
return;
}
frame_native = meta_frame_native_from_frame (frame);
source = ensure_source_for_stage_view (compositor, stage_view);
frame_callback_source = (FrameCallbackSource *) source;
if (meta_frame_native_had_kms_update (frame_native) ||
!clutter_frame_get_min_render_time_allowed (frame,
&min_render_time_allowed_us))
{
g_source_set_ready_time (source, -1);
emit_frame_callbacks_for_stage_view (compositor, stage_view);
}
else
{
int64_t target_presentation_time_us;
int64_t source_ready_time_us;
if (!clutter_frame_get_target_presentation_time (frame,
&target_presentation_time_us))
target_presentation_time_us = 0;
if (g_source_get_ready_time (source) != -1 &&
frame_callback_source->target_presentation_time_us <
target_presentation_time_us)
emit_frame_callbacks_for_stage_view (compositor, stage_view);
source_ready_time_us = target_presentation_time_us -
min_render_time_allowed_us;
if (source_ready_time_us <= g_get_monotonic_time ())
{
g_source_set_ready_time (source, -1);
emit_frame_callbacks_for_stage_view (compositor, stage_view);
}
else
{
frame_callback_source->target_presentation_time_us =
target_presentation_time_us;
g_source_set_ready_time (source, source_ready_time_us);
}
}
#else
emit_frame_callbacks_for_stage_view (compositor, stage_view);
#endif
}
void
meta_wayland_compositor_set_input_focus (MetaWaylandCompositor *compositor,
MetaWindow *window)
@ -215,44 +419,6 @@ meta_wayland_compositor_update (MetaWaylandCompositor *compositor,
meta_wayland_seat_update (compositor->seat, event);
}
static void
on_after_update (ClutterStage *stage,
ClutterStageView *stage_view,
ClutterFrame *frame,
MetaWaylandCompositor *compositor)
{
GList *l;
int64_t now_us;
now_us = g_get_monotonic_time ();
l = compositor->frame_callback_surfaces;
while (l)
{
GList *l_cur = l;
MetaWaylandSurface *surface = l->data;
MetaSurfaceActor *actor;
MetaWaylandActorSurface *actor_surface;
l = l->next;
actor = meta_wayland_surface_get_actor (surface);
if (!actor)
continue;
if (!meta_surface_actor_wayland_is_view_primary (actor,
stage_view))
continue;
actor_surface = META_WAYLAND_ACTOR_SURFACE (surface->role);
meta_wayland_actor_surface_emit_frame_callbacks (actor_surface,
now_us / 1000);
compositor->frame_callback_surfaces =
g_list_delete_link (compositor->frame_callback_surfaces, l_cur);
}
}
static MetaWaylandOutput *
get_output_for_stage_view (MetaWaylandCompositor *compositor,
ClutterStageView *stage_view)
@ -477,6 +643,7 @@ meta_wayland_compositor_finalize (GObject *object)
g_clear_pointer (&compositor->seat, meta_wayland_seat_free);
g_clear_pointer (&priv->filter_manager, meta_wayland_filter_manager_free);
g_clear_pointer (&priv->frame_callback_sources, g_hash_table_destroy);
g_clear_pointer (&compositor->display_name, g_free);
g_clear_pointer (&compositor->wayland_display, wl_display_destroy);
@ -500,6 +667,9 @@ meta_wayland_compositor_init (MetaWaylandCompositor *compositor)
g_error ("Failed to create the global wl_display");
priv->filter_manager = meta_wayland_filter_manager_new (compositor);
priv->frame_callback_sources =
g_hash_table_new_full (NULL, NULL, NULL,
(GDestroyNotify) g_source_destroy);
}
static void