diff options
| -rw-r--r-- | .SRCINFO | 8 | ||||
| -rw-r--r-- | 216.patch | 125 | ||||
| -rw-r--r-- | 318.patch | 420 | ||||
| -rw-r--r-- | PKGBUILD | 58 |
4 files changed, 591 insertions, 20 deletions
@@ -1,7 +1,7 @@ pkgbase = mutter-781835-workaround pkgdesc = A window manager for GNOME. This package reverts a commit which may causes performance problems for nvidia driver users. Some performance patches also included. pkgver = 3.30.2+7 - pkgrel = 7 + pkgrel = 8 url = https://gitlab.gnome.org/GNOME/mutter arch = x86_64 groups = gnome @@ -28,12 +28,14 @@ pkgbase = mutter-781835-workaround provides = mutter conflicts = mutter source = git+https://gitlab.gnome.org/GNOME/mutter.git#commit=bcd6103c44ff74ebffd1737b8e0f3a952b83bd54 - source = https://gitlab.gnome.org/vanvugt/mutter/commit/fc02b040f3b750b0513f812813351c09795950f6.patch + source = 216.patch + source = 318.patch source = https://gitlab.gnome.org/GNOME/mutter/merge_requests/347.patch source = startup-notification.patch source = revert.patch sha256sums = SKIP - sha256sums = dffa2ca19281b9fa5a81bf80bd46a8eae78325c7e1f8b2a25c33945aa7cc0903 + sha256sums = 1ae59343f3f5838babdfe1400962bb315d8b49189deb05bb516966b922cd26a5 + sha256sums = d4dcffa9c407e60e321670caaa44dcd6e2bfda7221d73ec4145a985c825a43b3 sha256sums = 1343ed3c21ca7ab4f179b864eae4b915b910406c3eb8259399973c29822f751c sha256sums = 00d5e77c94e83e1987cc443ed7c47303aa33367ce912b2f665bcd34f88890a17 sha256sums = 2d2e305e0a6cca087bb8164f81bdc0ae7a5ca8e9c13c81d7fd5252eb3563fc09 diff --git a/216.patch b/216.patch new file mode 100644 index 000000000000..43e53440fb57 --- /dev/null +++ b/216.patch @@ -0,0 +1,125 @@ +From ab03f010df7b78854433093030f08a81c059aa26 Mon Sep 17 00:00:00 2001 +From: Daniel van Vugt <daniel.van.vugt@canonical.com> +Date: Mon, 23 Jul 2018 16:28:56 +0800 +Subject: [PATCH] cogl-winsys-glx: Fix frame notification race/leak + +If a second `set_{sync,complete}_pending` was queued before the idle +handler had flushed the first then one of them would be forgotten. +It would stay queued forever and never emitted as a notification. + +This could happen repeatedly causing a slow leak. But worse still, +clutter-stage-cogl would then have pending_swaps permanently stuck above +zero preventing the presentation timing logic from being used. + +The problem was that CoglBool can only count to one pending notification, +so we just change that to an integer and count properly. +--- + cogl/cogl/winsys/cogl-winsys-glx.c | 58 +++++++++++++++--------------- + 1 file changed, 29 insertions(+), 29 deletions(-) + +diff --git a/cogl/cogl/winsys/cogl-winsys-glx.c b/cogl/cogl/winsys/cogl-winsys-glx.c +index 012c712bd..2cf6e95fc 100644 +--- a/cogl/cogl/winsys/cogl-winsys-glx.c ++++ b/cogl/cogl/winsys/cogl-winsys-glx.c +@@ -99,9 +99,9 @@ typedef struct _CoglOnscreenGLX + CoglOnscreenXlib _parent; + GLXDrawable glxwin; + uint32_t last_swap_vsync_counter; +- CoglBool pending_sync_notify; +- CoglBool pending_complete_notify; +- CoglBool pending_resize_notify; ++ uint32_t pending_sync_notify; ++ uint32_t pending_complete_notify; ++ uint32_t pending_resize_notify; + + GThread *swap_wait_thread; + GQueue *swap_wait_queue; +@@ -347,35 +347,35 @@ flush_pending_notifications_cb (void *data, + { + CoglOnscreen *onscreen = COGL_ONSCREEN (framebuffer); + CoglOnscreenGLX *glx_onscreen = onscreen->winsys; +- CoglBool pending_sync_notify = glx_onscreen->pending_sync_notify; +- CoglBool pending_complete_notify = glx_onscreen->pending_complete_notify; + +- /* If swap_region is called then notifying the sync event could +- * potentially immediately queue a subsequent pending notify so +- * we need to clear the flag before invoking the callback */ +- glx_onscreen->pending_sync_notify = FALSE; +- glx_onscreen->pending_complete_notify = FALSE; +- +- if (pending_sync_notify) ++ while (glx_onscreen->pending_sync_notify > 0 || ++ glx_onscreen->pending_complete_notify > 0 || ++ glx_onscreen->pending_resize_notify > 0) + { +- CoglFrameInfo *info = g_queue_peek_head (&onscreen->pending_frame_infos); +- +- _cogl_onscreen_notify_frame_sync (onscreen, info); +- } ++ if (glx_onscreen->pending_sync_notify > 0) ++ { ++ CoglFrameInfo *info = ++ g_queue_peek_head (&onscreen->pending_frame_infos); + +- if (pending_complete_notify) +- { +- CoglFrameInfo *info = g_queue_pop_head (&onscreen->pending_frame_infos); ++ _cogl_onscreen_notify_frame_sync (onscreen, info); ++ glx_onscreen->pending_sync_notify--; ++ } + +- _cogl_onscreen_notify_complete (onscreen, info); ++ if (glx_onscreen->pending_complete_notify > 0) ++ { ++ CoglFrameInfo *info = ++ g_queue_pop_head (&onscreen->pending_frame_infos); + +- cogl_object_unref (info); +- } ++ _cogl_onscreen_notify_complete (onscreen, info); ++ cogl_object_unref (info); ++ glx_onscreen->pending_complete_notify--; ++ } + +- if (glx_onscreen->pending_resize_notify) +- { +- _cogl_onscreen_notify_resize (onscreen); +- glx_onscreen->pending_resize_notify = FALSE; ++ if (glx_onscreen->pending_resize_notify > 0) ++ { ++ _cogl_onscreen_notify_resize (onscreen); ++ glx_onscreen->pending_resize_notify--; ++ } + } + } + } +@@ -417,7 +417,7 @@ set_sync_pending (CoglOnscreen *onscreen) + NULL); + } + +- glx_onscreen->pending_sync_notify = TRUE; ++ glx_onscreen->pending_sync_notify++; + } + + static void +@@ -440,7 +440,7 @@ set_complete_pending (CoglOnscreen *onscreen) + NULL); + } + +- glx_onscreen->pending_complete_notify = TRUE; ++ glx_onscreen->pending_complete_notify++; + } + + static void +@@ -533,7 +533,7 @@ notify_resize (CoglContext *context, + NULL); + } + +- glx_onscreen->pending_resize_notify = TRUE; ++ glx_onscreen->pending_resize_notify++; + + if (!xlib_onscreen->is_foreign_xwin) + { +-- +2.18.1 + diff --git a/318.patch b/318.patch new file mode 100644 index 000000000000..b59866f07a51 --- /dev/null +++ b/318.patch @@ -0,0 +1,420 @@ +From d20697ff5972b363679597372d1a98ff3074085c Mon Sep 17 00:00:00 2001 +From: Daniel van Vugt <daniel.van.vugt@canonical.com> +Date: Wed, 27 Jun 2018 17:19:27 +0800 +Subject: [PATCH 1/2] renderer-native: Add hardware presentation timing + +Add support for getting hardware presentation times from KMS (Wayland +sessions). Also implement cogl_get_clock_time which is required to compare +and judge the age of presentation timestamps. + +For single monitor systems this is straightforward. For multi-monitor +systems though we have to choose a display to sync to. The compositor +already partially solves this for us in the case of only one display +updating because it will only use the subset of monitors that are +changing. In the case of multiple monitors consuming the same frame +concurrently however, we choose the fastest one (in use at the time). +Note however that we also need !73 to land in order to fully realize +multiple monitors running at full speed. +--- + src/Makefile.am | 25 +++++++- + src/backends/native/meta-gpu-kms.c | 69 ++++++++++++++++++++-- + src/backends/native/meta-gpu-kms.h | 3 + + src/backends/native/meta-renderer-native.c | 38 +++++++++++- + src/meta-marshal.list | 1 + + 5 files changed, 128 insertions(+), 8 deletions(-) + create mode 100644 src/meta-marshal.list + +diff --git a/src/Makefile.am b/src/Makefile.am +index 811e2b86b..56d539836 100644 +--- a/src/Makefile.am ++++ b/src/Makefile.am +@@ -51,6 +51,8 @@ mutter_built_sources = \ + $(dbus_login1_built_sources) \ + meta/meta-enum-types.h \ + meta-enum-types.c \ ++ meta-marshal.c \ ++ meta-marshal.h \ + $(NULL) + + if HAVE_REMOTE_DESKTOP +@@ -677,6 +679,7 @@ EXTRA_DIST += \ + libmutter.pc.in \ + meta-enum-types.h.in \ + meta-enum-types.c.in \ ++ meta-marshal.list \ + org.freedesktop.login1.xml \ + org.gnome.Mutter.DisplayConfig.xml \ + org.gnome.Mutter.IdleMonitor.xml \ +@@ -690,7 +693,10 @@ BUILT_SOURCES = \ + $(libmutterinclude_built_headers) + + MUTTER_STAMP_FILES = stamp-meta-enum-types.h +-CLEANFILES += $(MUTTER_STAMP_FILES) ++CLEANFILES += \ ++ $(MUTTER_STAMP_FILES) \ ++ meta-marshal.c \ ++ meta-marshal.h + + meta/meta-enum-types.h: stamp-meta-enum-types.h Makefile + @true +@@ -786,3 +792,20 @@ endef + $(AM_V_GEN)$(WAYLAND_SCANNER) server-header $< $@ + %-server-protocol.h : $(WAYLAND_EGLSTREAM_DATADIR)/%.xml + $(AM_V_GEN)$(WAYLAND_SCANNER) server-header $< $@ ++ ++meta_marshal_opts = --prefix=meta_marshal --internal ++ ++meta-marshal.h: meta-marshal.list ++ $(AM_V_GEN)$(GLIB_GENMARSHAL) \ ++ --header \ ++ $(meta_marshal_opts) \ ++ --output=$@ \ ++ $< ++ ++meta-marshal.c: meta-marshal.list meta-marshal.h ++ $(AM_V_GEN)$(GLIB_GENMARSHAL) \ ++ --include-header=meta-marshal.h \ ++ $(meta_marshal_opts) \ ++ --body \ ++ --output=$@ \ ++ $< +diff --git a/src/backends/native/meta-gpu-kms.c b/src/backends/native/meta-gpu-kms.c +index c3c5d0d68..26c759031 100644 +--- a/src/backends/native/meta-gpu-kms.c ++++ b/src/backends/native/meta-gpu-kms.c +@@ -27,6 +27,7 @@ + #include <errno.h> + #include <poll.h> + #include <string.h> ++#include <time.h> + #include <xf86drm.h> + #include <xf86drmMode.h> + +@@ -51,6 +52,7 @@ typedef struct _MetaGpuKmsFlipClosureContainer + { + GClosure *flip_closure; + MetaGpuKms *gpu_kms; ++ MetaCrtc *crtc; + } MetaGpuKmsFlipClosureContainer; + + struct _MetaGpuKms +@@ -61,6 +63,8 @@ struct _MetaGpuKms + char *file_path; + GSource *source; + ++ clockid_t clock_id; ++ + drmModeConnector **connectors; + unsigned int n_connectors; + +@@ -165,18 +169,26 @@ meta_gpu_kms_apply_crtc_mode (MetaGpuKms *gpu_kms, + + static void + invoke_flip_closure (GClosure *flip_closure, +- MetaGpuKms *gpu_kms) ++ MetaGpuKms *gpu_kms, ++ MetaCrtc *crtc, ++ int64_t page_flip_time_ns) + { + GValue params[] = { + G_VALUE_INIT, +- G_VALUE_INIT ++ G_VALUE_INIT, ++ G_VALUE_INIT, ++ G_VALUE_INIT, + }; + + g_value_init (¶ms[0], G_TYPE_POINTER); + g_value_set_pointer (¶ms[0], flip_closure); + g_value_init (¶ms[1], G_TYPE_OBJECT); + g_value_set_object (¶ms[1], gpu_kms); +- g_closure_invoke (flip_closure, NULL, 2, params, NULL); ++ g_value_init (¶ms[2], G_TYPE_OBJECT); ++ g_value_set_object (¶ms[2], crtc); ++ g_value_init (¶ms[3], G_TYPE_INT64); ++ g_value_set_int64 (¶ms[3], page_flip_time_ns); ++ g_closure_invoke (flip_closure, NULL, 4, params, NULL); + g_closure_unref (flip_closure); + } + +@@ -216,6 +228,7 @@ meta_gpu_kms_is_crtc_active (MetaGpuKms *gpu_kms, + + MetaGpuKmsFlipClosureContainer * + meta_gpu_kms_wrap_flip_closure (MetaGpuKms *gpu_kms, ++ MetaCrtc *crtc, + GClosure *flip_closure) + { + MetaGpuKmsFlipClosureContainer *closure_container; +@@ -223,7 +236,8 @@ meta_gpu_kms_wrap_flip_closure (MetaGpuKms *gpu_kms, + closure_container = g_new0 (MetaGpuKmsFlipClosureContainer, 1); + *closure_container = (MetaGpuKmsFlipClosureContainer) { + .flip_closure = flip_closure, +- .gpu_kms = gpu_kms ++ .gpu_kms = gpu_kms, ++ .crtc = crtc + }; + + return closure_container; +@@ -263,6 +277,7 @@ meta_gpu_kms_flip_crtc (MetaGpuKms *gpu_kms, + int kms_fd = meta_gpu_kms_get_fd (gpu_kms); + + closure_container = meta_gpu_kms_wrap_flip_closure (gpu_kms, ++ crtc, + flip_closure); + + ret = drmModePageFlip (kms_fd, +@@ -296,6 +311,23 @@ meta_gpu_kms_flip_crtc (MetaGpuKms *gpu_kms, + return TRUE; + } + ++static int64_t ++timespec_to_nanoseconds (const struct timespec *ts) ++{ ++ const int64_t one_billion = 1000000000; ++ ++ return ((int64_t) ts->tv_sec) * one_billion + ts->tv_nsec; ++} ++ ++static int64_t ++timeval_to_nanoseconds (const struct timeval *tv) ++{ ++ int64_t usec = ((int64_t) tv->tv_sec) * G_USEC_PER_SEC + tv->tv_usec; ++ int64_t nsec = usec * 1000; ++ ++ return nsec; ++} ++ + static void + page_flip_handler (int fd, + unsigned int frame, +@@ -306,8 +338,12 @@ page_flip_handler (int fd, + MetaGpuKmsFlipClosureContainer *closure_container = user_data; + GClosure *flip_closure = closure_container->flip_closure; + MetaGpuKms *gpu_kms = closure_container->gpu_kms; ++ struct timeval page_flip_time = {sec, usec}; + +- invoke_flip_closure (flip_closure, gpu_kms); ++ invoke_flip_closure (flip_closure, ++ gpu_kms, ++ closure_container->crtc, ++ timeval_to_nanoseconds (&page_flip_time)); + meta_gpu_kms_flip_closure_container_free (closure_container); + } + +@@ -380,6 +416,17 @@ meta_gpu_kms_get_file_path (MetaGpuKms *gpu_kms) + return gpu_kms->file_path; + } + ++int64_t ++meta_gpu_kms_get_current_time_ns (MetaGpuKms *gpu_kms) ++{ ++ struct timespec ts; ++ ++ if (clock_gettime (gpu_kms->clock_id, &ts)) ++ return 0; ++ ++ return timespec_to_nanoseconds (&ts); ++} ++ + void + meta_gpu_kms_set_power_save_mode (MetaGpuKms *gpu_kms, + uint64_t state) +@@ -679,6 +726,17 @@ init_crtcs (MetaGpuKms *gpu_kms, + meta_gpu_take_crtcs (gpu, crtcs); + } + ++static void ++init_frame_clock (MetaGpuKms *gpu_kms) ++{ ++ uint64_t uses_monotonic; ++ ++ if (drmGetCap (gpu_kms->fd, DRM_CAP_TIMESTAMP_MONOTONIC, &uses_monotonic) != 0) ++ uses_monotonic = 0; ++ ++ gpu_kms->clock_id = uses_monotonic ? CLOCK_MONOTONIC : CLOCK_REALTIME; ++} ++ + static void + init_outputs (MetaGpuKms *gpu_kms, + MetaKmsResources *resources) +@@ -806,6 +864,7 @@ meta_gpu_kms_read_current (MetaGpu *gpu, + init_modes (gpu_kms, resources.resources); + init_crtcs (gpu_kms, &resources); + init_outputs (gpu_kms, &resources); ++ init_frame_clock (gpu_kms); + + meta_kms_resources_release (&resources); + +diff --git a/src/backends/native/meta-gpu-kms.h b/src/backends/native/meta-gpu-kms.h +index 5f77f191a..3e3f45c7e 100644 +--- a/src/backends/native/meta-gpu-kms.h ++++ b/src/backends/native/meta-gpu-kms.h +@@ -73,6 +73,8 @@ int meta_gpu_kms_get_fd (MetaGpuKms *gpu_kms); + + const char * meta_gpu_kms_get_file_path (MetaGpuKms *gpu_kms); + ++int64_t meta_gpu_kms_get_current_time_ns (MetaGpuKms *gpu_kms); ++ + void meta_gpu_kms_get_max_buffer_size (MetaGpuKms *gpu_kms, + int *max_width, + int *max_height); +@@ -89,6 +91,7 @@ gboolean meta_drm_mode_equal (const drmModeModeInfo *one, + float meta_calculate_drm_mode_refresh_rate (const drmModeModeInfo *mode); + + MetaGpuKmsFlipClosureContainer * meta_gpu_kms_wrap_flip_closure (MetaGpuKms *gpu_kms, ++ MetaCrtc *crtc, + GClosure *flip_closure); + + void meta_gpu_kms_flip_closure_container_free (MetaGpuKmsFlipClosureContainer *closure_container); +diff --git a/src/backends/native/meta-renderer-native.c b/src/backends/native/meta-renderer-native.c +index f58e6b3e0..b192c3641 100644 +--- a/src/backends/native/meta-renderer-native.c ++++ b/src/backends/native/meta-renderer-native.c +@@ -62,6 +62,7 @@ + #include "backends/native/meta-monitor-manager-kms.h" + #include "backends/native/meta-renderer-native.h" + #include "backends/native/meta-renderer-native-gles3.h" ++#include "meta-marshal.h" + #include "cogl/cogl.h" + #include "core/boxes-private.h" + +@@ -1159,6 +1160,8 @@ meta_onscreen_native_swap_drm_fb (CoglOnscreen *onscreen) + static void + on_crtc_flipped (GClosure *closure, + MetaGpuKms *gpu_kms, ++ MetaCrtc *crtc, ++ int64_t page_flip_time_ns, + MetaRendererView *view) + { + ClutterStageView *stage_view = CLUTTER_STAGE_VIEW (view); +@@ -1169,6 +1172,24 @@ on_crtc_flipped (GClosure *closure, + MetaOnscreenNative *onscreen_native = onscreen_egl->platform; + MetaRendererNative *renderer_native = onscreen_native->renderer_native; + MetaGpuKms *render_gpu = onscreen_native->render_gpu; ++ CoglFrameInfo *frame_info; ++ float refresh_rate; ++ ++ frame_info = g_queue_peek_tail (&onscreen->pending_frame_infos); ++ refresh_rate = crtc && crtc->current_mode ? ++ crtc->current_mode->refresh_rate : ++ 0.0f; ++ ++ /* Only keep the frame info for the fastest CRTC in use, which may not be ++ * the first one to complete a flip. By only telling the compositor about the ++ * fastest monitor(s) we direct it to produce new frames fast enough to ++ * satisfy all monitors. ++ */ ++ if (refresh_rate >= frame_info->refresh_rate) ++ { ++ frame_info->presentation_time = page_flip_time_ns; ++ frame_info->refresh_rate = refresh_rate; ++ } + + if (gpu_kms != render_gpu) + { +@@ -1299,7 +1320,9 @@ flip_egl_stream (MetaOnscreenNative *onscreen_native, + return FALSE; + + closure_container = +- meta_gpu_kms_wrap_flip_closure (onscreen_native->render_gpu, flip_closure); ++ meta_gpu_kms_wrap_flip_closure (onscreen_native->render_gpu, ++ NULL, ++ flip_closure); + + acquire_attribs = (EGLAttrib[]) { + EGL_DRM_FLIP_EVENT_DATA_NV, +@@ -1542,7 +1565,7 @@ meta_onscreen_native_flip_crtcs (CoglOnscreen *onscreen) + flip_closure = g_cclosure_new (G_CALLBACK (on_crtc_flipped), + g_object_ref (view), + (GClosureNotify) flip_closure_destroyed); +- g_closure_set_marshal (flip_closure, g_cclosure_marshal_VOID__OBJECT); ++ g_closure_set_marshal (flip_closure, meta_marshal_VOID__OBJECT_OBJECT_INT64); + + /* Either flip the CRTC's of the monitor info, if we are drawing just part + * of the stage, or all of the CRTC's if we are drawing the whole stage. +@@ -2687,6 +2710,15 @@ meta_renderer_native_create_offscreen (MetaRendererNative *renderer, + return fb; + } + ++static int64_t ++meta_renderer_native_get_clock_time (CoglContext *context) ++{ ++ CoglRenderer *cogl_renderer = cogl_context_get_renderer (context); ++ MetaGpuKms *gpu_kms = cogl_renderer->custom_winsys_user_data; ++ ++ return meta_gpu_kms_get_current_time_ns (gpu_kms); ++} ++ + static const CoglWinsysVtable * + get_native_cogl_winsys_vtable (CoglRenderer *cogl_renderer) + { +@@ -2715,6 +2747,8 @@ get_native_cogl_winsys_vtable (CoglRenderer *cogl_renderer) + vtable.onscreen_swap_buffers_with_damage = + meta_onscreen_native_swap_buffers_with_damage; + ++ vtable.context_get_clock_time = meta_renderer_native_get_clock_time; ++ + vtable_inited = TRUE; + } + +diff --git a/src/meta-marshal.list b/src/meta-marshal.list +new file mode 100644 +index 000000000..c1f4781d2 +--- /dev/null ++++ b/src/meta-marshal.list +@@ -0,0 +1 @@ ++VOID:OBJECT,OBJECT,INT64 +-- +2.18.1 + + +From 1b3109809167c17bfa8713ce906c95e66d2c042f Mon Sep 17 00:00:00 2001 +From: Daniel van Vugt <daniel.van.vugt@canonical.com> +Date: Tue, 10 Jul 2018 17:46:02 +0800 +Subject: [PATCH 2/2] renderer-native: Advertise _FEATURE_SWAP_THROTTLE + +Because it is implemented and always on. By advertising this fact +the master clock is able to sync to the native refresh rate instead +of always using the fallback of 60.00Hz. + +https://bugzilla.gnome.org/show_bug.cgi?id=781296 +--- + src/backends/native/meta-renderer-native.c | 15 +++++++++++++-- + 1 file changed, 13 insertions(+), 2 deletions(-) + +diff --git a/src/backends/native/meta-renderer-native.c b/src/backends/native/meta-renderer-native.c +index b192c3641..929e9ca90 100644 +--- a/src/backends/native/meta-renderer-native.c ++++ b/src/backends/native/meta-renderer-native.c +@@ -2005,6 +2005,13 @@ meta_renderer_native_init_egl_context (CoglContext *cogl_context, + COGL_WINSYS_FEATURE_MULTIPLE_ONSCREEN, + TRUE); + ++ /* COGL_WINSYS_FEATURE_SWAP_THROTTLE is always true for this renderer ++ * because we have the call to wait_for_pending_flips on every frame. ++ */ ++ COGL_FLAGS_SET (cogl_context->winsys_features, ++ COGL_WINSYS_FEATURE_SWAP_THROTTLE, ++ TRUE); ++ + #ifdef HAVE_EGL_DEVICE + if (renderer_gpu_data->mode == META_RENDERER_NATIVE_MODE_EGL_DEVICE) + COGL_FLAGS_SET (cogl_context->features, +@@ -2639,8 +2646,12 @@ meta_renderer_native_create_onscreen (MetaRendererNative *renderer_native, + } + + onscreen = cogl_onscreen_new (context, width, height); +- cogl_onscreen_set_swap_throttled (onscreen, +- _clutter_get_sync_to_vblank ()); ++ ++ /* We have wait_for_pending_flips hardcoded, so throttling always. */ ++ cogl_onscreen_set_swap_throttled (onscreen, TRUE); ++ if (!_clutter_get_sync_to_vblank ()) ++ g_warning ("Request to disable sync-to-vblank is being ignored. " ++ "MetaRendererNative does not support disabling it."); + + if (!cogl_framebuffer_allocate (COGL_FRAMEBUFFER (onscreen), error)) + { +-- +2.18.1 + @@ -5,10 +5,17 @@ # Patched package maintainer: Saren Arterius <saren@wtako.net> # Patch origin: https://gist.github.com/DeadMetaler/12622bf9415c1100f2d436ffbd6778c6 +### BUILD OPTIONS +# Set these variables to ANYTHING that is not null to enable them + +### Revert offending commit, recommanded to disable if not using NVIDIA +_revert=1 + + pkgname=mutter-781835-workaround _pkgname=mutter pkgver=3.30.2+7 -pkgrel=7 +pkgrel=8 pkgdesc="A window manager for GNOME. This package reverts a commit which may causes performance problems for nvidia driver users. Some performance patches also included." url="https://gitlab.gnome.org/GNOME/mutter" arch=(x86_64) @@ -22,12 +29,13 @@ conflicts=(mutter) groups=(gnome) _commit=bcd6103c44ff74ebffd1737b8e0f3a952b83bd54 # tags/3.30.2^0 source=("git+https://gitlab.gnome.org/GNOME/mutter.git#commit=$_commit" - https://gitlab.gnome.org/vanvugt/mutter/commit/fc02b040f3b750b0513f812813351c09795950f6.patch + 216.patch 318.patch https://gitlab.gnome.org/GNOME/mutter/merge_requests/347.patch startup-notification.patch revert.patch) sha256sums=('SKIP' - 'dffa2ca19281b9fa5a81bf80bd46a8eae78325c7e1f8b2a25c33945aa7cc0903' + '1ae59343f3f5838babdfe1400962bb315d8b49189deb05bb516966b922cd26a5' + 'd4dcffa9c407e60e321670caaa44dcd6e2bfda7221d73ec4145a985c825a43b3' '1343ed3c21ca7ab4f179b864eae4b915b910406c3eb8259399973c29822f751c' '00d5e77c94e83e1987cc443ed7c47303aa33367ce912b2f665bcd34f88890a17' '2d2e305e0a6cca087bb8164f81bdc0ae7a5ca8e9c13c81d7fd5252eb3563fc09') @@ -47,20 +55,15 @@ prepare() { git fetch vanvugt # clutter: Deliver events sooner when possible - # https://gitlab.gnome.org/GNOME/mutter/merge_requests/168/commits + # https://gitlab.gnome.org/GNOME/mutter/merge_requests/168 # Disabled as may cause stutter when using mouse with high polling rate # git cherry-pick 7782ed6e # clutter: Fix offscreen-effect painting of clones # https://gitlab.gnome.org/GNOME/mutter/merge_requests/117/commits - git cherry-pick --strategy=recursive -Xtheirs b1493354 || true + git cherry-pick 8655bc5d -Xtheirs || true git rm clutter/tests/conform/meson.build - git commit -m "fix" - - # Sync to the hardware refresh rate, not just 60.00Hz [performance] - # https://gitlab.gnome.org/GNOME/mutter/merge_requests/171/commits - git cherry-pick d20697ff - git cherry-pick 1b310980 + git commit -m "117" # Geometric (GPU-less) picking # https://gitlab.gnome.org/GNOME/mutter/merge_requests/189 @@ -68,21 +71,42 @@ prepare() { git add -A && git commit -m "347" # clutter-actor: Add detail to captured-event signal [performance] - # https://gitlab.gnome.org/GNOME/mutter/merge_requests/283/commits + # https://gitlab.gnome.org/GNOME/mutter/merge_requests/283 git cherry-pick 4a9a0d62 # clutter-stage-cogl: Reduce output latency and reduce missed frames too [performance] # https://gitlab.gnome.org/GNOME/mutter/merge_requests/281/commits - git cherry-pick 434460c5 - git cherry-pick 13efca15 + git cherry-pick fc8f80f0^..cfa6bf9d + + # Consolidate all frame throttling into clutter-stage-cogl [performance] + # https://gitlab.gnome.org/GNOME/mutter/merge_requests/363 + git cherry-pick 8c9a6dab^..dcad8363 -Xtheirs + + # clutter: Avoid redundant margin changes + # https://gitlab.gnome.org/GNOME/mutter/merge_requests/399 + git cherry-pick 94cd0246 + + # cursor-renderer-native: Floor the cursor position instead of rounding + # https://gitlab.gnome.org/GNOME/mutter/merge_requests/353/commits + git cherry-pick 8d514095 + + # cogl-winsys-glx: Fix frame notification race/leak [performance] + # https://gitlab.gnome.org/GNOME/mutter/merge_requests/216 + git cherry-pick 335993f7 + # ' # Commented multiline comment end, remove the # above if disabling the patches - # Revert offending commit, recommended to comment out the line below if not using NVIDIA - patch -Np1 -i ../revert.patch + # Revert offending commit + if [ -n "$_revert" ]; then + patch -Np1 -i ../revert.patch + fi # https://gitlab.gnome.org/GNOME/mutter/merge_requests/216 - git apply -3 ../fc02b040f3b750b0513f812813351c09795950f6.patch + git apply -3 ../216.patch + + # https://gitlab.gnome.org/GNOME/mutter/merge_requests/318 + git apply -3 ../318.patch # https://bugs.archlinux.org/task/51940 # As of 2018-05-08: Still needed, according to fmuellner |